Azure Functions

359
Total Pages
274
Linux-Friendly Pages
85
Pages with Bias
23.7%
Bias Rate

Bias Trend Over Time

Pages with Bias Issues (137)

https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-reference-python.md [View Details]
Scanned: 2025-07-17 00:00 • Page-level bias detected
▼

Page-Level Analysis

Windows First Windows Tools Powershell Heavy
Summary:
The documentation demonstrates a mild Windows bias, primarily in the way it presents development and publishing workflows. Windows terminology ("command prompt") is used alongside "terminal" without explicit mention of Linux or macOS. Remote build is recommended for Windows users, and local build is discouraged on Windows, but there is little explicit guidance for Linux users. The documentation references Visual Studio Code and Azure Functions Core Tools, which are cross-platform, but does not provide Linux-specific examples, terminal commands, or troubleshooting tips. There are no PowerShell-specific examples, but the overall pattern assumes a Windows-first perspective.
Recommendations:
  • Explicitly mention Linux and macOS in all references to 'terminal or command prompt', and provide example commands using bash/zsh where appropriate.
  • Include Linux-specific troubleshooting tips, such as file permission issues, case sensitivity, or common dependency installation problems.
  • When discussing publishing and build workflows, clarify which steps or recommendations apply to Linux, macOS, and Windows, and provide parity in guidance.
  • Add explicit examples of using Azure Functions Core Tools and CLI commands in a Linux shell environment.
  • Where folder structures are shown, use generic or Linux-style paths (e.g., forward slashes) or provide both Windows and Linux path examples.
  • Highlight any differences in behavior or requirements when developing and deploying from Linux/macOS versus Windows.
  • Consider including a section or callout for Linux/macOS users with tips or known issues.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/create-first-function-vs-code-node.md [View Details]
Scanned: 2025-07-17 00:00 • Page-level bias detected
▼

Page-Level Analysis

Windows First
Summary:
The documentation is generally cross-platform and focuses on Visual Studio Code, which is available on Windows, macOS, and Linux. However, there is a subtle Windows bias in the troubleshooting section, where a specific issue and solution are called out for Windows users ('When running on Windows, make sure that the default terminal shell for Visual Studio Code isn't set to WSL Bash.') without mentioning equivalent Linux or macOS troubleshooting steps. No PowerShell-specific commands, Windows-only tools, or missing Linux examples are present, but the only OS-specific troubleshooting tip is for Windows, indicating a 'windows_first' bias.
Recommendations:
  • Add troubleshooting tips relevant to Linux and macOS users, such as common issues with permissions, shell configuration, or dependencies on those platforms.
  • Where OS-specific guidance is given (such as the WSL Bash note), provide parallel advice for Linux and macOS users, or clarify that the guidance is only relevant to Windows.
  • Explicitly state that all steps are applicable to Windows, Linux, and macOS unless otherwise noted, to reinforce cross-platform parity.
  • If possible, include a table or section summarizing any platform-specific considerations for all supported operating systems.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/durable/durable-task-scheduler/durable-task-scheduler-versioning.md [View Details]
Scanned: 2025-07-17 00:00 • Page-level bias detected
▼

Page-Level Analysis

Missing Linux Example
Summary:
The documentation does not provide any OS-specific examples, but it does include a 'powershell' pivot without a corresponding Linux shell (e.g., Bash) or CLI example. There are no explicit Windows tools or patterns, but the absence of Linux/Unix shell examples or references creates an implicit bias by omission.
Recommendations:
  • If a 'powershell' pivot is included, add a corresponding 'bash' or 'shell' pivot with equivalent Linux/Unix command-line examples.
  • Ensure that any CLI or scripting examples are provided for both Windows and Linux environments, or clarify when examples are OS-agnostic.
  • Review the documentation for any implicit assumptions about the user's operating system and explicitly mention cross-platform support where applicable.
  • If the feature is not available or behaves differently on Linux, state this clearly in the documentation.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-develop-local.md [View Details]
Scanned: 2025-07-17 00:00 • Page-level bias detected
▼

Page-Level Analysis

Windows First Windows Tools Powershell Heavy
Summary:
The documentation demonstrates a mild Windows bias. Visual Studio (Windows-only) is consistently listed first in environment tables, and Windows-specific tools like PowerShell and Visual Studio are highlighted before cross-platform or Linux-native alternatives. The HTTP test tools section lists PowerShell and Microsoft Edge (Windows-centric) before curl, which is more common on Linux. There are no explicit Linux-only examples or tools, and Linux is generally mentioned as 'also supported' rather than as a primary platform.
Recommendations:
  • In environment tables, alternate the order of Windows and cross-platform tools, or list cross-platform tools (like VS Code and CLI) first to emphasize parity.
  • In the HTTP test tools section, list curl and Bruno before PowerShell and Microsoft Edge, or group tools by platform.
  • Include explicit Linux/macOS terminal examples (e.g., bash commands) alongside or before Windows/Powershell examples.
  • Highlight Linux/macOS support more prominently, not just as a secondary note.
  • Where Visual Studio is mentioned, clarify that it is Windows-only and suggest equivalent Linux/macOS workflows (e.g., JetBrains Rider, VS Code, CLI).
  • Add a section or callout specifically for Linux/macOS users, summarizing recommended tools and workflows.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-reference-java.md [View Details]
Scanned: 2025-07-17 00:00 • Page-level bias detected
▼

Page-Level Analysis

Windows First Powershell Heavy Missing Linux Example
Summary:
The documentation generally aims for cross-platform parity, but there are subtle Windows biases. Command-line examples are consistently provided for both Bash (Linux/macOS) and Cmd (Windows), but the Windows/Cmd tabs are always listed after Bash, which is positive. However, there is a notable absence of explicit PowerShell examples, which is good, but the documentation refers to 'command prompt' (a Windows term) alongside 'terminal' in some places. Some sections, such as Java version support, list Windows before Linux, and the table for supported Java versions is headed 'Java versions (Windows)' before 'Java versions (Linux)'. There are no Linux-specific tools or troubleshooting steps, and the documentation does not mention Linux-specific differences or caveats. While the documentation is not overtly Windows-centric, it does not provide Linux-first or Linux-specific guidance, and some language and ordering choices subtly prioritize Windows.
Recommendations:
  • When referencing command-line development, use 'terminal' or 'shell' instead of 'command prompt' to avoid Windows-centric language.
  • In tables and lists, alternate the order of Windows and Linux, or use alphabetical order to avoid always listing Windows first.
  • Add Linux-specific troubleshooting tips or notes where relevant, especially for environment variables, file paths, or permissions.
  • Explicitly mention that all CLI and Maven commands work identically on Linux, macOS, and Windows, and highlight any OS-specific caveats.
  • Consider including PowerShell examples only if there are unique steps, and always provide Bash equivalents.
  • Where IDEs are mentioned, clarify that all are cross-platform (e.g., IntelliJ, Eclipse, VS Code) and that the experience is consistent across OSes.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-reference.md [View Details]
Scanned: 2025-07-17 00:00 • Page-level bias detected
▼

Page-Level Analysis

Windows First Windows Tools
Summary:
The documentation page demonstrates a mild Windows bias, primarily by listing Windows-centric tools (such as Visual Studio) before cross-platform or Linux-native alternatives, especially in the C# section. Visual Studio is consistently mentioned first, and there is no explicit mention of Linux-specific editors or shell environments (e.g., Bash, Linux terminal) in examples or tool recommendations. However, the documentation does provide cross-platform options like Visual Studio Code and Azure Functions Core Tools, and avoids exclusive use of PowerShell or Windows-only commands.
Recommendations:
  • Ensure that cross-platform tools (e.g., Visual Studio Code, Azure Functions Core Tools) are listed before or alongside Windows-specific tools like Visual Studio, especially in introductory and quickstart sections.
  • Explicitly mention Linux and macOS compatibility for all tools where applicable, and provide links to Linux/macOS installation guides.
  • Include examples or references to using the command line in Bash or other Linux shells, not just 'command prompt', to clarify cross-platform support.
  • Where PowerShell is referenced, also mention Bash or sh equivalents if relevant.
  • Consider adding a section or callout for Linux/macOS users to highlight any differences or tips for those environments.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/create-first-function-vs-code-node.md [View Details]
Scanned: 2025-07-16 00:00 • Page-level bias detected
▼

Page-Level Analysis

Windows First
Summary:
The documentation is generally cross-platform and focuses on Visual Studio Code, which is available on Windows, macOS, and Linux. However, there is a subtle Windows bias in the Troubleshooting section, where a Windows-specific issue (default terminal shell set to WSL Bash) is mentioned before any Linux/macOS-specific troubleshooting. No explicit Linux or macOS examples or troubleshooting tips are provided, and no Linux-specific tools or shell commands are referenced. The rest of the guide avoids platform-specific instructions, but the troubleshooting section assumes a Windows-first perspective.
Recommendations:
  • Add troubleshooting tips relevant to Linux and macOS users, such as common shell or permission issues.
  • When mentioning Windows-specific issues (e.g., WSL Bash), also mention potential equivalents or common issues on Linux/macOS.
  • Explicitly state that the instructions apply to all supported platforms, and provide clarifications if any steps differ on Linux or macOS.
  • Where possible, include screenshots or terminal output from both Windows and Linux/macOS environments to reinforce parity.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-develop-local.md [View Details]
Scanned: 2025-07-16 00:00 • Page-level bias detected
▼

Page-Level Analysis

Windows First Windows Tools
Summary:
The documentation demonstrates a mild Windows bias, primarily by listing Windows-centric tools (such as Visual Studio and PowerShell) before cross-platform or Linux-native alternatives, especially in the C# section. Visual Studio (Windows-only) is always listed first, and PowerShell is mentioned as an HTTP test tool before curl. However, the documentation does make efforts to mention Linux and macOS support, especially for Visual Studio Code and command-line tools. There are no outright missing Linux examples, but the ordering and tool emphasis favor Windows.
Recommendations:
  • In each language section, list cross-platform tools (such as Visual Studio Code and command-line/terminal) before Windows-only tools like Visual Studio.
  • In the HTTP test tools section, list curl (a ubiquitous Linux tool) before PowerShell and Microsoft Edge.
  • Where possible, provide explicit Linux/macOS command-line examples alongside or before Windows/PowerShell examples.
  • Clarify in tables and descriptions which tools are cross-platform and which are Windows-only, to help Linux users quickly identify their options.
  • Consider adding a dedicated section or callout for Linux/macOS development tips or common issues.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-reference-java.md [View Details]
Scanned: 2025-07-16 00:00 • Page-level bias detected
▼

Page-Level Analysis

Windows First Cmd Examples Powershell Heavy
Summary:
The documentation generally provides both Bash (Linux/macOS) and Cmd (Windows) examples for command-line operations, but Windows/Cmd examples are consistently presented alongside or immediately after Bash, sometimes with slightly more detail. There is a mild 'windows_first' bias in the order of presentation (e.g., Visual Studio Code and Windows-specific tools are often mentioned before Linux alternatives), and the inclusion of Cmd tabs and examples throughout. However, Linux is not neglected: Bash examples are present, and Linux-specific details (such as Java 21 support) are included. There are no sections that are Windows-only or that omit Linux equivalents, but the parity could be improved for a more neutral, cross-platform experience.
Recommendations:
  • Ensure that Bash (Linux/macOS) examples are always presented first, or alternate the order with Cmd examples to avoid implicit prioritization.
  • Wherever command-line examples are given, explicitly mention that Bash examples apply to Linux/macOS and Cmd to Windows, to clarify for users.
  • Add explicit references to Linux terminal environments (e.g., GNOME Terminal, Konsole) in the introductory sections, not just 'Terminal'.
  • In the 'Getting started' and 'Next steps' sections, include links or notes about Linux-specific development environments or workflows, if available.
  • Review the order of tool mentions (e.g., Visual Studio Code, IntelliJ, Eclipse) to ensure no implicit Windows preference.
  • Consider adding troubleshooting or environment setup notes specific to Linux (e.g., setting JAVA_HOME in .bashrc/.zshrc, common Linux JDK installation commands).
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-create-private-site-access.md [View Details]
Scanned: 2025-07-15 00:00 • Page-level bias detected
▼

Page-Level Analysis

Windows First Missing Linux Example
Summary:
The documentation demonstrates a Windows bias by exclusively guiding users to create a Windows Server virtual machine, with no mention of Linux alternatives or examples. All screenshots and instructions for VM creation are Windows-centric, and there are no parallel instructions or notes for deploying or accessing the environment using a Linux VM. This may lead Linux users to believe that only Windows is supported or recommended for this scenario.
Recommendations:
  • Provide parallel instructions and screenshots for creating a Linux-based virtual machine (e.g., Ubuntu Server) alongside the Windows Server steps.
  • Explicitly mention that either Windows or Linux VMs can be used for this scenario, and highlight any differences in setup or access.
  • Include examples or notes on how to connect to a Linux VM via SSH using Azure Bastion, in addition to RDP for Windows.
  • Ensure that any command-line or deployment steps (such as function deployment) include both Windows (PowerShell/Command Prompt) and Linux (Bash) examples where relevant.
  • Add a section or callout box clarifying OS-agnostic aspects of the tutorial, reassuring users that the process is not limited to Windows environments.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/create-first-function-vs-code-node.md [View Details]
Scanned: 2025-07-15 00:00 • Page-level bias detected
▼

Page-Level Analysis

Windows First
Summary:
The documentation is largely cross-platform and avoids explicit Windows or PowerShell bias in its main instructions, as it focuses on Visual Studio Code and the Azure Functions extension. However, in the Troubleshooting section, there is a Windows-first bias: the only OS-specific advice is for Windows users regarding the default terminal shell, with no equivalent troubleshooting guidance for Linux or macOS users. There are no PowerShell-specific commands, Windows-only tools, or missing Linux examples, but the troubleshooting advice implicitly prioritizes Windows scenarios.
Recommendations:
  • Add troubleshooting notes for Linux and macOS users, such as common issues with permissions, shell configuration, or dependencies on those platforms.
  • Where OS-specific advice is given (e.g., about the default terminal shell), provide equivalent guidance for Linux (e.g., bash/zsh issues) and macOS users.
  • Explicitly state that the instructions apply to all supported platforms, and clarify any steps that differ by OS.
  • Consider including a table or section listing any known OS-specific issues or differences in workflow.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-dotnet-class-library.md [View Details]
Scanned: 2025-07-15 00:00 • Page-level bias detected
▼

Page-Level Analysis

Windows First Powershell Heavy Windows Tools Missing Linux Example
Summary:
The documentation page exhibits a moderate Windows bias. Visual Studio (a Windows-centric IDE) is mentioned first and most frequently, with Visual Studio Code and command-line options listed after. Examples for installing packages are provided for Command Prompt and PowerShell, but there are no explicit Bash or Linux shell examples. The ReadyToRun publishing example uses a Windows runtime identifier (win-x86) without showing cross-platform equivalents. The section on Azure Functions Core Tools references the Windows installer (MSI) and Windows-specific paths, with no mention of Linux or macOS installation or file locations. There are no explicit Linux/macOS command-line or tooling examples, and Windows tools/patterns are referenced before or instead of cross-platform alternatives.
Recommendations:
  • Provide Bash/Linux/macOS equivalents for all command-line examples, including package installation and project setup.
  • Include cross-platform runtime identifiers (e.g., linux-x64, osx-x64) in ReadyToRun and publishing examples, or show a table of common options.
  • When listing development environments, alternate the order or explicitly state parity between Visual Studio, Visual Studio Code, and CLI, and provide equal depth of guidance for each.
  • Reference cross-platform installation instructions for Azure Functions Core Tools, including npm and manual installation for Linux/macOS, and mention relevant file paths for non-Windows systems.
  • Add explicit notes or callouts where behaviors or file locations differ between Windows and Linux/macOS.
  • Ensure all tooling and workflow sections mention and show examples for both Windows and Linux/macOS users.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/how-to-create-function-azure-cli.md [View Details]
Scanned: 2025-07-15 00:00 • Page-level bias detected
▼

Page-Level Analysis

Windows First Windows Tools
Summary:
The documentation generally maintains cross-platform parity, but there are subtle signs of Windows bias. In the Java section, command examples are given for Bash, PowerShell, and Cmd, with Bash listed first but Windows shells (PowerShell, Cmd) included explicitly. File paths in examples use backslashes (\), which are Windows-specific. The mention of 'command prompt' alongside 'terminal' may also suggest a Windows-first mindset. However, Linux tools like jq are mentioned, and most commands are cross-platform.
Recommendations:
  • Where multiple shell examples are provided, always list Bash (Linux/macOS) first, but ensure all platforms are equally represented.
  • Use forward slashes (/) in file paths or clarify when a path is platform-specific.
  • When referring to the command line, prefer 'terminal' over 'command prompt' unless specifically referring to Windows.
  • Ensure that all scripts and code snippets are tested and work on both Linux and Windows shells.
  • Explicitly mention Linux/macOS equivalents for any Windows-specific instructions or tools.
  • If referencing PowerShell, also mention Bash or zsh alternatives where appropriate.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-create-first-java-gradle.md [View Details]
Scanned: 2025-07-15 00:00 • Page-level bias detected
▼

Page-Level Analysis

Windows First
Summary:
The documentation specifies 'os = windows' as the default runtime in the Gradle configuration, without mentioning Linux or cross-platform alternatives. This may lead users to assume Windows is the primary or only supported OS, despite Java and Azure Functions supporting Linux. No PowerShell or Windows-specific command-line tools are used, and all shell commands are cross-platform (bash/curl/gradle). However, the lack of explicit Linux parity in the runtime configuration is a subtle Windows-first bias.
Recommendations:
  • Explicitly mention that both Windows and Linux are supported as runtime OS options in the Gradle configuration.
  • Show how to set 'os = linux' in the azurefunctions.runtime block, or provide a table comparing both options.
  • Add a note clarifying that the instructions and commands work on both Windows and Linux, and that the default 'os = windows' can be changed as needed.
  • If there are any platform-specific considerations (e.g., Java 21 only on Linux), highlight them in context and provide guidance for both platforms.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-develop-local.md [View Details]
Scanned: 2025-07-15 00:00 • Page-level bias detected
▼

Page-Level Analysis

Windows First Windows Tools Powershell Heavy
Summary:
The documentation demonstrates some Windows bias by listing Windows-centric tools (Visual Studio, PowerShell) prominently, often before cross-platform or Linux-native alternatives. Visual Studio (Windows-only) is always listed first for C#, and PowerShell is highlighted as an HTTP test tool before more universal tools like curl. While the documentation does mention Linux and macOS support and includes cross-platform tools (VS Code, Core Tools, curl), Windows tools and patterns are often given priority or more detailed coverage.
Recommendations:
  • When listing development environments, avoid always listing Visual Studio (Windows-only) first. Consider grouping cross-platform tools (VS Code, Core Tools) before Windows-only tools, or clearly marking platform exclusivity.
  • In tables and lists, alternate the order of tools or use alphabetical order to avoid implicit prioritization of Windows tools.
  • For HTTP test tools, list curl (ubiquitous on Linux/macOS) before PowerShell, or group tools by platform compatibility.
  • Where PowerShell is mentioned, also mention Bash or other Linux-native shells for parity.
  • Explicitly call out Linux/macOS-specific workflows or tips where relevant, not just in passing.
  • Ensure that all example commands and workflows are shown for both Windows and Linux (e.g., both PowerShell and Bash command lines where appropriate).
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/python-memory-profiler-reference.md [View Details]
Scanned: 2025-07-15 00:00 • Page-level bias detected
▼

Page-Level Analysis

Windows First Powershell Heavy
Summary:
The documentation demonstrates a mild Windows bias, particularly in the local development instructions. Windows PowerShell is mentioned first, and Windows-specific commands and paths are presented before their Linux equivalents. The use of 'py -m venv' (Windows) is shown before 'python3 -m venv' (Linux), and the activation command for PowerShell is listed before the Linux shell equivalent. However, Linux alternatives are present, and the documentation does not omit Linux instructions entirely.
Recommendations:
  • Present Windows and Linux instructions in parallel or in a tabbed format, rather than listing Windows first.
  • Use neutral language such as 'In Windows PowerShell, run: ... In Linux shell, run: ...' or provide both commands together.
  • Where file paths are shown (e.g., <ProjectRoot>\HttpTriggerAsync\__init__.py), also show the Linux path (<ProjectRoot>/HttpTriggerAsync/__init__.py).
  • Avoid phrases like 'Open a Windows PowerShell or any Linux shell as you prefer'—instead, use 'Open a terminal (Windows PowerShell or Linux shell)'.
  • Ensure that all examples, screenshots, and outputs are shown for both platforms where differences exist.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/create-first-function-azure-developer-cli.md [View Details]
Scanned: 2025-07-15 00:00 • Page-level bias detected
▼

Page-Level Analysis

Windows First Powershell Heavy Windows Tools
Summary:
The documentation generally aims for cross-platform parity, but there are subtle signs of Windows bias. Windows command-line environments (Cmd, PowerShell) are often mentioned explicitly and sometimes before Linux/bash equivalents. PowerShell is given a dedicated programming language pivot, and Windows-specific instructions (such as activating Python venvs) are provided in detail. There is also a tendency to refer to 'terminal or command prompt' rather than just 'terminal', and some examples use Windows-centric terminology or tools.
Recommendations:
  • Ensure that Linux/bash instructions are always presented before or alongside Windows/Cmd/PowerShell examples, not after.
  • Use neutral language such as 'terminal' instead of 'command prompt' unless specifically referring to Windows.
  • Where PowerShell is given as a primary example, ensure bash/zsh equivalents are equally prominent.
  • For all code snippets, provide both bash and Windows (Cmd/PowerShell) versions side-by-side, and make it clear which is which.
  • Review all references to tools and paths (e.g., file paths, activation commands) to ensure Linux and macOS users are not disadvantaged.
  • Consider adding explicit notes about cross-platform compatibility and any platform-specific caveats.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/dotnet-isolated-process-guide.md [View Details]
Scanned: 2025-07-15 00:00 • Page-level bias detected
▼

Page-Level Analysis

Windows First Windows Tools Powershell Heavy Missing Linux Example
Summary:
The documentation demonstrates a moderate Windows bias. Windows-specific tools and patterns (such as Visual Studio, PowerShell, and Windows-specific Azure CLI flags) are often mentioned before or instead of their Linux equivalents. Some instructions and examples are Windows-centric, and Linux-specific guidance is often relegated to secondary tabs or not provided with equal detail. There are also several places where only Windows commands or behaviors are described, or where Windows is the default context.
Recommendations:
  • Ensure that all CLI examples (especially for deployment, configuration, and debugging) are provided for both Windows and Linux, with Linux examples given equal prominence.
  • When listing tools or workflows (e.g., Visual Studio, Visual Studio Code, CLI, PowerShell), present cross-platform options first or in parallel, rather than defaulting to Windows-first ordering.
  • Where PowerShell is mentioned, also provide Bash or shell equivalents for Linux/macOS users.
  • In tables and lists, avoid putting Windows tools or instructions before Linux equivalents unless there is a technical reason.
  • For debugging and deployment, include explicit Linux instructions and troubleshooting steps, not just Windows/Visual Studio guidance.
  • Review all references to environment variables, file paths, and commands to ensure they are cross-platform or that both Windows and Linux formats are shown.
  • Where tabs are used for OS-specific content, ensure the Linux tab is as complete and detailed as the Windows tab.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/monitor-functions-reference.md [View Details]
Scanned: 2025-07-13 21:37 • Page-level bias detected
▼

Page-Level Analysis

Missing Linux Example Windows First
Summary:
The documentation page demonstrates bias by providing more complete metric support and examples for Windows-based Azure Functions hosting plans, while repeatedly noting missing or unsupported features for Linux plans. There are no Linux-specific examples or guidance, and Windows support is implicitly prioritized.
Recommendations:
  • Add Linux-specific examples and guidance for monitoring Azure Functions, including any available metrics or workarounds.
  • Clearly indicate feature parity status and provide timelines or alternatives for Linux users where metrics are not supported.
  • Where features are unsupported on Linux, suggest equivalent monitoring strategies (e.g., using Application Insights logs or custom metrics).
  • Ensure that documentation sections and tables are inclusive of both Windows and Linux, or provide separate, parallel sections for each platform.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/update-language-versions.md [View Details]
Scanned: 2025-07-13 21:37 • Page-level bias detected
▼

Page-Level Analysis

Windows First Missing Linux Example Windows Tools
Summary:
The documentation frequently presents Windows instructions and examples before Linux equivalents, and in some cases, Linux instructions are less detailed or have additional restrictions. There are also sections where only Windows-specific tools or paths are referenced, and Linux users are sometimes redirected or given less guidance.
Recommendations:
  • Ensure that Linux instructions and examples are presented alongside Windows, or in parallel, rather than after or as an afterthought.
  • Provide equally detailed Linux examples for all languages and scenarios, including local development and configuration steps.
  • Avoid language such as 'select the Windows tab' as the default; instead, present both OS options equally.
  • Where features are not available on Linux (e.g., Python on Windows), clearly explain alternatives or workarounds for Linux users.
  • Review all code samples and ensure that Linux command-line and file path conventions are included where relevant.
  • Where possible, use cross-platform tools and instructions (such as Azure CLI) as the primary example, and only provide OS-specific guidance when necessary.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/run-functions-from-deployment-package.md [View Details]
Scanned: 2025-07-13 21:37 • Page-level bias detected
▼

Page-Level Analysis

Windows First Windows Tools Powershell Heavy Missing Linux Example
Summary:
The documentation exhibits a Windows-first bias in several ways: Windows paths and deployment patterns are consistently mentioned before Linux equivalents, and Windows-specific folders (e.g., c:\home\data\SitePackages) are referenced throughout. There is a lack of Linux-specific command-line or shell examples, and no Linux-native tooling or deployment workflows are highlighted. The documentation assumes familiarity with Windows conventions and tools, with only minimal parity for Linux mentioned as afterthoughts.
Recommendations:
  • Present Linux and Windows instructions/examples side by side or in parallel sections, rather than always listing Windows first.
  • Include Linux-native command-line examples (e.g., bash, zip, scp, az CLI on Linux) for creating and deploying packages.
  • Reference Linux paths first or equally, and avoid assuming Windows as the default environment.
  • Highlight Linux-specific deployment considerations and tools (such as using Linux shells, permissions, or automation scripts).
  • Provide explicit Linux troubleshooting steps and examples, not just Windows-centric advice.
  • Where UI steps are described, mention any differences for Linux users (e.g., Azure CLI vs. Azure Portal).
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/openapi-apim-integrate-visual-studio.md [View Details]
Scanned: 2025-07-13 21:37 • Page-level bias detected
▼

Page-Level Analysis

Windows First Missing Linux Example Windows Tools Powershell Heavy
Summary:
The documentation is heavily biased toward Windows development environments, specifically Visual Studio on Windows. All instructions, UI references, and publishing steps assume the use of Visual Studio 2022, with no mention of cross-platform alternatives such as Visual Studio Code, Azure CLI, or command-line tools available on Linux/macOS. The publishing process explicitly targets 'Azure Function App (Windows)', and there are no examples or guidance for Linux users or those preferring non-Windows workflows.
Recommendations:
  • Provide alternative instructions for Linux/macOS users, such as using Visual Studio Code, Azure CLI, or the Azure Functions Core Tools.
  • Include command-line examples for project creation, dependency installation, and publishing that work on all platforms.
  • Mention and demonstrate how to use cross-platform editors (e.g., VS Code) and tools (e.g., dotnet CLI, func CLI) alongside or instead of Visual Studio.
  • Clarify that Azure Functions and API Management are cross-platform services, and show how to deploy to Linux-based Function Apps.
  • Reorder or parallelize instructions so that Windows and Linux/macOS workflows are presented equally, rather than Windows-first or Windows-only.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/manage-connections.md [View Details]
Scanned: 2025-07-13 21:37 • Page-level bias detected
▼

Page-Level Analysis

Windows First Missing Linux Example
Summary:
The documentation provides code examples and configuration guidance primarily for C# (.NET) and JavaScript, but when discussing configuration files and application settings, it references patterns and files (such as 'ConnectionStrings' in configuration files and 'local.settings.json') that are more familiar to Windows/.NET developers. There are no explicit Linux-specific examples, nor are there mentions of Linux-native tools or configuration patterns. The order of presentation also places .NET/C# examples before JavaScript, which may reinforce a Windows-first perspective.
Recommendations:
  • Include explicit Linux-oriented examples, such as referencing environment variables for connection strings, and demonstrate how to set these in Linux environments (e.g., using bash or export statements).
  • When discussing configuration files, clarify cross-platform applicability and provide Linux-specific guidance (e.g., how to set application settings via Azure CLI or environment variables in Linux containers).
  • Alternate the order of code examples or provide a neutral introduction to avoid reinforcing a Windows-first perspective.
  • Mention Linux-native tools or patterns where relevant, such as using environment variables or configuration management approaches common in Linux deployments.
  • Add a section or note on how to manage connections and configuration in Linux-based Azure Functions environments, including Docker/container scenarios.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/dotnet-isolated-process-guide.md [View Details]
Scanned: 2025-07-13 21:37 • Page-level bias detected
▼

Page-Level Analysis

Windows First Windows Tools Powershell Heavy Missing Linux Example
Summary:
The documentation demonstrates a moderate Windows bias. Windows-specific tools, commands, and configuration steps are often mentioned before their Linux equivalents, or Linux is only referenced as an afterthought. Several CLI examples and deployment instructions are presented with Windows as the default or primary context, and PowerShell is included as a recommended tool for resource creation. In some sections, Linux-specific instructions are present but less emphasized or appear after Windows instructions. There are also areas where only Windows or Visual Studio workflows are detailed, with less parity for Linux or cross-platform alternatives.
Recommendations:
  • Ensure all CLI and deployment examples are provided for both Windows and Linux equally, using cross-platform tools (e.g., Azure CLI) as the default.
  • When listing tools or methods (e.g., Visual Studio, PowerShell, Azure CLI), avoid listing Windows-specific options first; instead, present cross-platform options first or in parallel.
  • Where PowerShell is mentioned, always include Bash or shell equivalents for Linux users.
  • In sections discussing configuration or deployment, provide explicit Linux examples and highlight any differences or required steps for Linux environments.
  • Where Visual Studio is referenced, ensure Visual Studio Code (cross-platform) instructions are equally detailed and prominent.
  • Review all code snippets and command-line instructions to ensure they are not Windows-centric (e.g., avoid backslashes in paths, use environment-agnostic syntax).
  • Add a summary table or section at the start that clearly indicates which instructions apply to Windows, Linux, or both, and link to the relevant sections.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/recover-python-functions.md [View Details]
Scanned: 2025-07-13 21:37 • Page-level bias detected
▼

Page-Level Analysis

Windows First Powershell Heavy Windows Tools Missing Linux Example
Summary:
The documentation generally aims for cross-platform coverage, but there are several areas where Windows is prioritized or receives more detailed attention. Windows-specific tools and commands (such as PowerShell and 'py') are often mentioned before their Linux equivalents, and in some cases, Linux/Bash examples are less detailed or missing. There is also a tendency to reference Windows development environments and patterns (e.g., 'pip freeze' from Windows, Visual Studio Code with Windows settings) before or more prominently than Linux alternatives.
Recommendations:
  • Ensure that all command-line examples are provided for both Windows (PowerShell/CMD) and Linux (Bash), and present them in parallel or with equal prominence.
  • When referencing tools like 'py' (Windows Python launcher), also provide the equivalent Linux command ('python3') and clarify platform differences.
  • Avoid listing Windows commands or tools first by default; alternate the order or present both at the same time.
  • Expand on Linux-specific troubleshooting steps and examples, especially for common deployment and environment issues.
  • Where platform-specific behaviors are discussed (e.g., 'pip freeze' on Windows vs. Linux), provide explicit guidance for Linux users.
  • In sections referencing Visual Studio Code or other tools, clarify any platform-specific setup steps or differences for Linux users.
  • Audit for any missing Linux/Bash examples, especially in troubleshooting or mitigation steps, and add them to ensure parity.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/create-first-function-cli-typescript.md [View Details]
Scanned: 2025-07-13 21:37 • Page-level bias detected
▼

Page-Level Analysis

Windows First Powershell Heavy Windows Tools
Summary:
The documentation provides both Azure CLI and Azure PowerShell examples for creating Azure resources, but consistently lists PowerShell as an alternative to CLI, which is a Windows-centric tool. There are no explicit Linux shell or Bash-specific examples, and keyboard shortcuts (e.g., Ctrl+C) are presented in a Windows-centric way. The documentation assumes familiarity with Windows tools and patterns, and does not provide parity for Linux or macOS users beyond the CLI.
Recommendations:
  • Provide explicit Bash or shell command examples where appropriate, especially for common tasks like navigation or process termination.
  • List Azure CLI (cross-platform) examples first, and clarify that PowerShell is optional, not required.
  • Include notes or sections for Linux/macOS users, such as alternative keyboard shortcuts (e.g., Ctrl+C is universal, but confirmation prompts may differ).
  • Mention that all commands work on Linux/macOS unless otherwise stated, and highlight any OS-specific differences.
  • If referencing screenshots or terminal output, ensure they are not Windows-specific, or provide Linux/macOS equivalents.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/configure-encrypt-at-rest-using-cmk.md [View Details]
Scanned: 2025-07-13 21:37 • Page-level bias detected
▼

Page-Level Analysis

Windows Tools Missing Linux Example
Summary:
The documentation demonstrates a mild Windows bias by recommending Azure Storage Explorer (a GUI tool with a primary focus on Windows) for uploading files and generating SAS tokens, without mentioning command-line or cross-platform alternatives. The Storage Explorer link specifically references a Windows tab. No Linux-specific or cross-platform CLI examples are provided for these steps, and there is no mention of Linux file upload or SAS generation workflows. However, the main configuration and encryption steps use Azure CLI, which is cross-platform.
Recommendations:
  • Provide Azure CLI or PowerShell (cross-platform) commands for uploading files to Azure Storage and generating SAS tokens, in addition to or instead of relying on Azure Storage Explorer.
  • Explicitly mention that Azure Storage Explorer is available for Linux and macOS, or provide links to platform-specific instructions.
  • Include Linux/macOS-specific instructions or examples for all steps involving file operations, such as uploading deployment packages.
  • Avoid linking only to Windows-specific tabs or instructions; ensure parity in documentation for all supported platforms.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/create-first-function-cli-node.md [View Details]
Scanned: 2025-07-13 21:37 • Page-level bias detected
▼

Page-Level Analysis

Powershell Heavy Windows First
Summary:
The documentation provides both Azure CLI and Azure PowerShell examples for creating and managing Azure Functions, but does not explicitly mention or provide Linux/macOS-specific shell commands or considerations. PowerShell is highlighted as an alternative to Azure CLI, which may be less familiar or relevant to Linux users. The order of presentation (CLI first, then PowerShell) is reasonable, but the presence of PowerShell throughout and lack of explicit Linux/macOS guidance or troubleshooting may create a subtle Windows bias.
Recommendations:
  • Explicitly state that all Azure CLI commands work on Linux, macOS, and Windows, and provide any necessary shell-specific notes (e.g., quoting, environment variables).
  • Add a brief section or callout for Linux/macOS users, clarifying that PowerShell steps are optional and not required on those platforms.
  • Where PowerShell is mentioned, clarify its cross-platform availability, or provide bash/zsh equivalents if relevant.
  • Include troubleshooting tips or common issues for Linux/macOS environments (e.g., permissions, path issues) if applicable.
  • Consider adding a table or tabbed examples for 'Bash (Linux/macOS)' and 'PowerShell (Windows)' to make parity explicit.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/durable/durable-functions-code-constraints.md [View Details]
Scanned: 2025-07-13 21:37 • Page-level bias detected
▼

Page-Level Analysis

Powershell Heavy
Summary:
The documentation provides language-specific examples for C#, JavaScript, Python, PowerShell, and Java. While PowerShell is included as a first-class language, there is no explicit Windows bias in terms of tools, shell commands, or patterns that would exclude or disadvantage Linux users. However, the inclusion of PowerShell as a primary example language (rather than, for example, Bash or a Linux-native shell) may be seen as a subtle bias toward Windows environments, since PowerShell is more commonly associated with Windows, even though it is now cross-platform.
Recommendations:
  • Clarify that PowerShell examples are cross-platform and not Windows-specific, or provide equivalent Bash/shell script examples where relevant.
  • Explicitly mention that all code examples (including PowerShell) are intended to work on both Windows and Linux environments, or provide notes about any platform-specific considerations.
  • If possible, add a Bash or Linux shell scripting tab for parity with PowerShell, especially if scripting is a common use case for Durable Functions.
  • Continue to ensure that all tooling and patterns described are platform-agnostic, and avoid references to Windows-only tools or workflows.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/durable/durable-functions-sub-orchestrations.md [View Details]
Scanned: 2025-07-13 21:37 • Page-level bias detected
▼

Page-Level Analysis

Powershell Heavy Windows Tools Windows First
Summary:
The documentation includes a prominent PowerShell-specific note and provides PowerShell code samples alongside other languages. The only shell/CLI-specific mention is for PowerShell, with no equivalent mention of Bash or Linux-native scripting. The note about sub-orchestrations support in PowerShell references the PowerShell SDK and migration guide, but there is no similar guidance or context for Linux or Bash users. PowerShell is a Windows-centric tool, and its exclusive mention and support note indicate a Windows bias.
Recommendations:
  • Provide equivalent notes or guidance for Linux/Bash users if there are any platform-specific considerations for sub-orchestrations.
  • If PowerShell is mentioned as a supported shell, clarify support for Bash or other shells, or explicitly state if they are unsupported.
  • Consider including Bash or cross-platform shell examples or notes where PowerShell is referenced.
  • Ensure that CLI or scripting guidance is not exclusively tied to Windows tools, and mention cross-platform alternatives where possible.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-create-vnet.md [View Details]
Scanned: 2025-07-13 21:37 • Page-level bias detected
▼

Page-Level Analysis

Windows First Missing Linux Example
Summary:
The documentation page demonstrates a Windows-first bias by explicitly stating that the tutorial uses Windows and C#, and by instructing users to select Windows as the operating system in the setup steps. While it mentions that Linux is also supported, there are no Linux-specific instructions, examples, or screenshots. All configuration and deployment steps are described using the Azure Portal UI, with no command-line examples (such as Azure CLI, Bash, or PowerShell), but the default assumption is a Windows environment. There are no Linux-specific troubleshooting notes or guidance, and the runtime stack and deployment examples are focused on .NET/C# on Windows.
Recommendations:
  • Provide parallel instructions and screenshots for Linux users, including selecting Linux as the OS during Function App creation.
  • Include examples for other supported runtime stacks (e.g., Node.js, Python) and clarify any differences in networking or deployment for Linux-based Function Apps.
  • Add Azure CLI and/or Bash script examples for resource creation, configuration, and deployment, to support cross-platform and automation scenarios.
  • Explicitly call out any differences or considerations when using Linux, such as file system paths, supported features, or troubleshooting steps.
  • Ensure that language in the documentation does not default to Windows (e.g., 'This tutorial uses Windows but also works for Linux' could be reworded to be more neutral or to offer a choice at the start).
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/create-first-function-vs-code-node.md [View Details]
Scanned: 2025-07-13 21:37 • Page-level bias detected
▼

Page-Level Analysis

Windows First Windows Tools Missing Linux Example
Summary:
The documentation page generally avoids explicit Windows bias in its main instructions, focusing on Visual Studio Code and the Azure Functions extension, which are cross-platform. However, there is a subtle Windows bias in the troubleshooting section, where a solution specifically references Windows and WSL Bash without mentioning equivalent Linux or macOS scenarios. There are no explicit Linux/macOS command-line examples or troubleshooting steps, and the only shell-specific advice is Windows-centric. No PowerShell commands or Windows-only tools are shown, but the troubleshooting advice assumes a Windows environment.
Recommendations:
  • In the troubleshooting section, add equivalent advice for Linux and macOS users, such as ensuring the default terminal shell is compatible (e.g., Bash, Zsh, etc.), and clarify that the advice about WSL Bash is only relevant for Windows users using WSL.
  • Wherever troubleshooting or environment setup is discussed, explicitly mention that the instructions apply to all supported operating systems, and provide OS-specific notes where necessary.
  • If there are any platform-specific behaviors or requirements (such as permissions, path formats, or shell differences), include them for Linux and macOS as well as Windows.
  • Consider adding a short section or note confirming cross-platform compatibility and linking to platform-specific setup guides if available.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/create-first-function-cli-csharp.md [View Details]
Scanned: 2025-07-13 21:37 • Page-level bias detected
▼

Page-Level Analysis

Windows First Powershell Heavy
Summary:
The documentation provides both Azure CLI and Azure PowerShell examples for creating Azure resources, but PowerShell is mentioned alongside CLI as a primary tool, and the PowerShell example is given equal prominence. There are no explicit Linux-specific instructions or examples, and the use of PowerShell (which is traditionally associated with Windows, though now cross-platform) may suggest a Windows-centric approach. There are no examples of Linux-specific shells or tools, and no mention of platform-specific differences or considerations.
Recommendations:
  • Clearly indicate that both Azure CLI and PowerShell are cross-platform, but highlight that Azure CLI is often pre-installed or more common on Linux/macOS.
  • Provide explicit bash/zsh shell examples or notes for Linux/macOS users, especially for common tasks like environment variable setting or file navigation.
  • If PowerShell is shown, clarify that it is available on Linux/macOS, or provide alternative bash commands where appropriate.
  • Add a section or callout for Linux/macOS users, mentioning any platform-specific considerations (such as file paths, permissions, or installation steps).
  • Ensure that CLI examples are shown before PowerShell, as CLI is more universal across platforms.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/durable/durable-functions-isolated-create-first-csharp.md [View Details]
Scanned: 2025-07-13 21:37 • Page-level bias detected
▼

Page-Level Analysis

Windows First Windows Tools Missing Linux Example
Summary:
The documentation is heavily oriented toward Windows development environments, focusing exclusively on Visual Studio and Visual Studio Code workflows. All instructions, screenshots, and tool references assume the use of Windows tools and UI patterns (e.g., Visual Studio, Azurite extension, menu navigation). There is no mention of Linux or macOS-specific instructions, terminal commands, or alternative editors. The use of Azurite and Azure Functions Core Tools is described only in the context of Visual Studio/VS Code, with no CLI or cross-platform guidance. This results in a lack of parity for Linux users.
Recommendations:
  • Add a dedicated section or pivot for Linux/macOS users, outlining how to create, run, and debug Durable Functions apps using the .NET CLI and Azure Functions Core Tools from the terminal.
  • Provide explicit instructions for installing prerequisites (e.g., .NET SDK, Azure Functions Core Tools, Azurite) on Linux and macOS, including package manager commands (apt, yum, brew, etc.).
  • Include CLI-based project creation and management steps as alternatives to Visual Studio/VS Code UI workflows.
  • Show examples of running and debugging Durable Functions apps from the terminal, including how to use breakpoints with VS Code on Linux/macOS.
  • Mention any platform-specific considerations, such as file paths, permissions, or differences in emulator usage.
  • Ensure screenshots and instructions are not exclusively Windows-centric, or provide equivalent visuals for Linux/macOS environments.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/bring-dependency-to-functions.md [View Details]
Scanned: 2025-07-13 21:37 • Page-level bias detected
▼

Page-Level Analysis

Windows Tools Windows First Missing Linux Example
Summary:
The documentation demonstrates some Windows bias, particularly in the Java example where the ffmpeg path uses a Windows-style executable (ffmpeg.exe) and the guidance for setting the BASE_PATH is tailored to Azure's Linux file structure but does not mention Windows equivalents. Additionally, PowerShell is mentioned as an upload option, but Linux-native tools (like rsync, scp, or standard shell commands) are not referenced. The Python examples are more Linux-oriented, but there is a lack of parity in providing explicit Linux/Unix examples or guidance for Java users, and the documentation does not provide equivalent Windows instructions for file mounting or path handling.
Recommendations:
  • For Java examples, provide both Windows and Linux path examples for ffmpeg (e.g., ffmpeg.exe for Windows, ffmpeg for Linux) and clarify how to set BASE_PATH on both platforms.
  • When referencing upload options for Azure Files, mention Linux-native tools (e.g., azcopy, scp, rsync) alongside PowerShell and Azure CLI.
  • Explicitly state any platform-specific requirements or differences, such as file permissions (chmod) or path separators, for both Windows and Linux.
  • Where possible, include both Windows and Linux code/configuration snippets, or clearly indicate which platform each snippet targets.
  • Ensure that all steps (such as mounting file shares or setting environment variables) have instructions for both Windows and Linux development environments.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/durable/durable-task-scheduler/quickstart-portable-durable-task-sdks.md [View Details]
Scanned: 2025-07-13 21:37 • Page-level bias detected
▼

Page-Level Analysis

Windows First Powershell Heavy Windows Tools
Summary:
The documentation shows some Windows bias, particularly in the Python section where Windows-specific instructions (such as activating a virtual environment) are presented before Linux equivalents. There are also explicit 'Windows' and 'Linux' tabs, with Windows shown first. The presence of a dedicated PowerShell pivot (even though it is empty in this sample) and references to Docker Desktop (which is branded and Windows-centric, though available on Linux) further reinforce a Windows-first orientation. However, Linux instructions are present and correct, and bash commands are used throughout for cross-platform compatibility.
Recommendations:
  • Present Linux and Windows instructions side-by-side or in a neutral order (e.g., Linux first, or alphabetical).
  • Avoid always listing Windows instructions first in tabbed code blocks; consider making Linux the default or randomizing the order.
  • Where possible, use generic terms like 'Docker' instead of 'Docker Desktop' unless the desktop version is specifically required.
  • Ensure PowerShell pivots or examples are matched with Bash or shell equivalents for parity.
  • Explicitly state that all commands work on both Windows and Linux unless there are genuine platform-specific differences.
  • Consider adding a table or section at the top summarizing OS-specific steps for quick reference.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/durable/durable-functions-create-portal.md [View Details]
Scanned: 2025-07-13 21:37 • Page-level bias detected
▼

Page-Level Analysis

Windows Tools Windows First
Summary:
The documentation page demonstrates a Windows bias by exclusively referencing the Kudu console (which is Windows-centric in its UI and terminology) for package installation and file management. The instructions for running commands and uploading files are tailored to the Kudu interface, which is more familiar to Windows users. There are no alternative instructions for Linux-based workflows, such as using SSH, SCP, or Bash in the Azure Cloud Shell. Additionally, the use of 'CMD' in the Kudu console and the absence of Linux-native command-line examples or guidance further reinforce a Windows-first approach.
Recommendations:
  • Provide alternative instructions for Linux users, such as using Azure Cloud Shell (Bash) or SSH to interact with the function app's file system.
  • Include examples of using SCP or SFTP to upload files like package.json, in addition to the Kudu drag-and-drop method.
  • Clarify that Kudu is accessible from any OS, but explain the differences in command-line environments (CMD vs Bash) and provide Bash equivalents where appropriate.
  • Mention cross-platform tools and workflows explicitly, ensuring parity for both Windows and Linux users throughout the documentation.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/create-first-function-cli-java.md [View Details]
Scanned: 2025-07-13 21:37 • Page-level bias detected
▼

Page-Level Analysis

Windows First Windows Tools Powershell Heavy Missing Linux Example
Summary:
The documentation demonstrates a Windows-first bias in several ways: Windows is the default for deployment and hosting (with Linux as an afterthought), Windows-specific tools and patterns (PowerShell, Cmd) are given equal or greater prominence than Linux/Bash, and the default project configuration targets Windows. Linux alternatives are mentioned but often as side notes, and there is little to no discussion of Linux-specific considerations or troubleshooting.
Recommendations:
  • Present Linux and Windows options with equal prominence, e.g., list Bash/Linux examples before or alongside Windows/PowerShell/Cmd.
  • In the project configuration (pom.xml), do not default to Windows for 'runtime.os'; instead, explain both options and let the user choose.
  • Provide Linux-specific troubleshooting tips and highlight any differences in behavior or requirements (such as file permissions, environment variables, or supported Java versions).
  • Ensure that all command-line examples are available for Bash (Linux/macOS), PowerShell, and Cmd, and clarify which platforms each applies to.
  • Where Windows-specific tools or terminology are used (e.g., Ctrl+C, pressing 'y' to confirm), also mention the Linux/macOS equivalents.
  • Add a section or callout for Linux users, especially where the workflow or experience may differ (e.g., Java 21 support is Linux-only).
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/errors-diagnostics/diagnostic-events/azfd0001.md [View Details]
Scanned: 2025-07-13 21:37 • Page-level bias detected
▼

Page-Level Analysis

Missing Linux Example
Summary:
The documentation does not provide any platform-specific examples or instructions, but it also omits any mention of how to set the AzureWebJobsStorage app setting from Linux environments (e.g., using Azure CLI or bash), which could be helpful for non-Windows users.
Recommendations:
  • Add explicit examples for setting the AzureWebJobsStorage app setting using cross-platform tools such as Azure CLI or bash scripts.
  • If relevant, mention both Windows (e.g., PowerShell, Azure Portal) and Linux (e.g., bash, Azure CLI) methods for configuring app settings.
  • Ensure that links to further documentation include Linux-friendly instructions or note any platform-specific differences.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/errors-diagnostics/diagnostic-events/azfd0010.md [View Details]
Scanned: 2025-07-13 21:37 • Page-level bias detected
▼

Page-Level Analysis

Windows First Missing Linux Example
Summary:
The documentation page discusses a Linux-specific error but suggests 'running on Windows' as the only alternative for timezone support, without providing Linux workarounds or parity. No Linux-specific solutions or examples are offered.
Recommendations:
  • Provide Linux-compatible alternatives or workarounds for timezone configuration, if available.
  • Offer examples or references for handling timezones on Linux hosting plans (e.g., using UTC or application-level timezone handling).
  • Avoid suggesting Windows as the primary or only solution; instead, present both Windows and Linux options equally.
  • Clarify any platform limitations and guide users to cross-platform best practices.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-add-openai-text-completion.md [View Details]
Scanned: 2025-07-13 21:37 • Page-level bias detected
▼

Page-Level Analysis

Windows Tools Windows First Missing Linux Example
Summary:
The documentation page exhibits a moderate Windows bias, primarily through the exclusive mention of Windows-centric tools (such as Azurite emulator and Visual Studio Code commands) and a lack of explicit Linux/macOS instructions or terminal commands. While the language pivots cover multiple programming languages, there are no explicit examples or notes for Linux or macOS users regarding command-line differences, emulator usage, or environment-specific setup. The instructions for running and debugging functions assume a Visual Studio Code GUI workflow, which is more common on Windows, and do not provide CLI alternatives or mention cross-platform differences.
Recommendations:
  • Add explicit instructions or notes for Linux/macOS users, especially for installing and running Azurite, and clarify any differences in command-line usage or environment setup.
  • Provide CLI-based alternatives for steps currently described via Visual Studio Code GUI actions (e.g., creating functions, starting the emulator, running/debugging the app), and show equivalent Bash/zsh commands alongside PowerShell/Windows instructions.
  • Mention any OS-specific prerequisites or troubleshooting tips, such as permissions, path differences, or package manager commands for installing dependencies.
  • Ensure that all code snippets and setup steps are verified to work on Linux/macOS, and highlight any platform-specific considerations.
  • Where possible, use neutral, cross-platform language and tools, or clearly indicate when a step is Windows-specific.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/create-first-function-vs-code-other.md [View Details]
Scanned: 2025-07-13 21:37 • Page-level bias detected
▼

Page-Level Analysis

Windows First Windows Tools Powershell Heavy
Summary:
The documentation generally maintains cross-platform parity, but there are subtle biases towards Windows. Windows-specific instructions and file extensions (e.g., handler.exe) are mentioned before Linux equivalents in several places. Windows environment variable setting syntax is shown after Linux/macOS, but the distinction is made explicit. There are references to Windows-specific tools (e.g., .exe files, Windows command syntax), and the documentation sometimes refers to Windows patterns first (e.g., 'handler.exe' before 'handler'). However, Linux and macOS instructions are present and correct, and the main workflow is cross-platform.
Recommendations:
  • When referencing executable names, mention the Linux version ('handler') before the Windows version ('handler.exe'), or present both together (e.g., 'handler (handler.exe on Windows)').
  • In configuration file examples, use cross-platform language, such as 'handler' for Linux/macOS and 'handler.exe' for Windows, or provide both options explicitly.
  • Where environment variable setting is required, present Linux/macOS and Windows commands side by side, or use tabs for clarity.
  • Avoid using Windows-specific terminology or tools as the default; instead, use neutral or Linux-first language where possible.
  • Ensure all screenshots and code snippets are available for both Linux and Windows environments, or use generic screenshots that do not show OS-specific details.
  • Consider adding a summary table or section at the start that clearly states the parity and any OS-specific steps.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/errors-diagnostics/diagnostic-events/azfd0011.md [View Details]
Scanned: 2025-07-13 21:37 • Page-level bias detected
▼

Page-Level Analysis

Missing Linux Example
Summary:
The documentation does not provide any platform-specific examples or instructions, but it also does not mention Linux or cross-platform workflows. There are no Windows-specific tools or commands, but the lack of Linux (or general cross-platform) command-line examples or instructions may leave Linux users without clear guidance.
Recommendations:
  • Add explicit examples for setting the FUNCTIONS_WORKER_RUNTIME variable using both Windows (e.g., PowerShell, Azure CLI on Windows) and Linux (e.g., Bash, Azure CLI on Linux).
  • Include notes or sections that clarify how to update application settings on different platforms, such as Linux, macOS, and Windows.
  • Provide sample commands for editing local.settings.json using common cross-platform editors or command-line tools.
  • Ensure parity in troubleshooting steps and instructions for both Windows and Linux environments.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-add-output-binding-storage-queue-vs.md [View Details]
Scanned: 2025-07-13 21:37 • Page-level bias detected
▼

Page-Level Analysis

Windows First Missing Linux Example Powershell Heavy
Summary:
The documentation is heavily oriented towards Windows and Visual Studio users, with all instructions and UI references tailored to the Windows version of Visual Studio. There are no CLI or cross-platform instructions for Linux or macOS users, and all examples assume the use of Visual Studio's GUI and PowerShell/NuGet Package Manager Console, which are primarily Windows-centric. While Azure Storage Explorer is mentioned as cross-platform, the rest of the workflow does not address Linux or macOS development environments.
Recommendations:
  • Provide equivalent instructions for developing and running Azure Functions using cross-platform tools such as Visual Studio Code or the Azure Functions Core Tools CLI.
  • Include examples of how to install required NuGet packages using the dotnet CLI (e.g., 'dotnet add package ...'), which works on all platforms.
  • Add guidance for editing configuration files (like local.settings.json) manually or via CLI, rather than relying solely on Visual Studio UI dialogs.
  • Explicitly mention and link to Linux/macOS development guides where appropriate, or provide tabs for different OS instructions.
  • Clarify which steps are specific to Windows/Visual Studio and offer alternatives for Linux/macOS users.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-app-settings.md [View Details]
Scanned: 2025-07-13 21:37 • Page-level bias detected
▼

Page-Level Analysis

Windows First Windows Tools Powershell Heavy
Summary:
The documentation generally aims for cross-platform coverage, but there are several areas where Windows is prioritized or referenced before Linux. Some examples and settings are Windows-specific or use Windows-style paths (e.g., %HOME%\typescript), and PowerShell is given dedicated sections and examples. In a few cases, Windows tools or terminology are mentioned without always providing Linux equivalents or parity.
Recommendations:
  • Ensure that all examples using Windows-style paths (e.g., %HOME%\typescript) also include Linux equivalents (e.g., $HOME/typescript).
  • When referencing tools or commands (such as Azure PowerShell), always mention Azure CLI or other cross-platform alternatives alongside or before Windows-specific tools.
  • In lists or tables where both Windows and Linux are supported, present Linux examples first or at least equally, rather than defaulting to Windows.
  • For PowerShell-specific settings or features, provide equivalent guidance for other shells or languages where possible, or clearly indicate when a feature is Windows-only.
  • Audit for any settings or behaviors that are described as default or standard but are actually Windows-specific, and clarify Linux behavior in those cases.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/durable/durable-functions-webjobs-sdk.md [View Details]
Scanned: 2025-07-13 21:37 • Page-level bias detected
▼

Page-Level Analysis

Windows First Missing Linux Example Windows Tools Powershell Heavy
Summary:
The documentation page demonstrates a Windows bias by prioritizing Windows-specific tools and workflows (such as Visual Studio and the Windows Classic Desktop template), providing only PowerShell/NuGet Package Manager Console commands, referencing the Windows-only Azurite storage emulator, and omitting explicit Linux or cross-platform instructions or examples. There are no examples or guidance for Linux users regarding equivalent development environments, package installation, or running the sample project.
Recommendations:
  • Provide equivalent instructions for Linux users, including how to set up and run projects using Visual Studio Code or JetBrains Rider, and .NET CLI commands for project creation and package installation.
  • Include Bash/.NET CLI examples alongside PowerShell/Package Manager Console commands for installing NuGet packages.
  • Mention cross-platform alternatives to the Azurite storage emulator and clarify how to run it on Linux/macOS.
  • Avoid using 'Windows Classic Desktop' as the default project template; instead, recommend .NET Core/.NET 6+ console apps, which are cross-platform.
  • Explicitly state which steps are Windows-specific and provide corresponding Linux/macOS steps where possible.
  • Add a section or callouts for deploying and running WebJobs from non-Windows environments, including any prerequisites or differences.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/durable/quickstart-java.md [View Details]
Scanned: 2025-07-13 21:37 • Page-level bias detected
▼

Page-Level Analysis

Windows First Windows Tools Powershell Heavy
Summary:
The documentation demonstrates a moderate Windows bias. In the manual setup section, the Maven plugin configuration explicitly sets the runtime OS to 'windows' without mentioning Linux or cross-platform options. In the Maven command section, while Bash, PowerShell, and Cmd examples are provided, the order places Bash first, but Windows-specific shells (PowerShell, Cmd) are given equal prominence. Visual Studio Code instructions are cross-platform, but there is no mention of Linux-specific considerations or troubleshooting. The documentation references Azure Functions Core Tools, which is cross-platform, but does not clarify any Linux-specific installation or usage notes. There is no explicit Linux example or guidance, and the only OS explicitly mentioned in configuration is Windows.
Recommendations:
  • In the Maven plugin configuration, provide examples for both Windows and Linux runtimes, or clarify that 'os' can be set to 'linux' and explain when to use each.
  • Add a note or section about Linux/macOS installation and usage of Azure Functions Core Tools, including any known issues or differences.
  • Where PowerShell and Cmd examples are given, ensure that Bash (Linux/macOS) is always listed first and is the default in code tabs, or provide a clear cross-platform command.
  • Explicitly state that all steps work on Linux and macOS, and call out any differences or additional steps required.
  • Consider including troubleshooting tips or links for common Linux/macOS issues (e.g., permissions, path differences, case sensitivity).
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-bindings-openai-textcompletion-input.md [View Details]
Scanned: 2025-07-13 21:37 • Page-level bias detected
▼

Page-Level Analysis

Powershell Heavy
Summary:
The documentation provides language-specific examples for C#, Java, JavaScript, TypeScript, PowerShell, and Python. While PowerShell is included as a first-class language alongside others, there is no evidence of exclusive Windows bias: there are no Windows-only tools, no Windows-first ordering, and no missing Linux equivalents. However, the inclusion of PowerShell as a primary example language (rather than, for example, Bash or shell scripting) may be seen as a mild bias towards Windows environments, since PowerShell is most commonly associated with Windows, even though it is now cross-platform.
Recommendations:
  • Consider adding Bash or shell scripting examples, especially in sections where PowerShell is used, to provide parity for Linux users.
  • Explicitly note that PowerShell Core is cross-platform, or provide guidance for Linux/macOS users where PowerShell is referenced.
  • Ensure that any references to tools, file paths, or environment variables are platform-agnostic or provide both Windows and Linux/macOS variants.
  • If possible, include a section or note on how to use the binding in a Linux environment, or link to Linux-specific setup guides.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-bindings-web-pubsub-input.md [View Details]
Scanned: 2025-07-13 21:37 • Page-level bias detected
▼

Page-Level Analysis

Missing Linux Example
Summary:
The documentation provides code samples for C#, JavaScript, and Python, with explicit notes that PowerShell and Java samples are pending. There is no evidence of Windows-specific tools, PowerShell-heavy content, or Windows-first ordering. However, the Python examples assume a generic cross-platform environment but do not provide explicit Linux-specific instructions or terminal commands. There are no references to Windows-only tools or patterns, but the lack of Linux-specific guidance (such as bash commands or Linux environment notes) may leave Linux users without full parity.
Recommendations:
  • Add explicit Linux shell/terminal instructions where relevant, such as for creating folders or deploying functions.
  • Include notes or examples for running and testing Azure Functions on Linux (e.g., using Azure Functions Core Tools in bash).
  • Ensure parity in sample completeness for all supported languages, including PowerShell and Java, and clarify if any samples are Windows-only.
  • If any steps differ between Windows and Linux (such as file paths or environment variable syntax), document both variants.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-create-private-site-access.md [View Details]
Scanned: 2025-07-13 21:37 • Page-level bias detected
▼

Page-Level Analysis

Windows First Missing Linux Example
Summary:
The documentation demonstrates a Windows bias by exclusively instructing users to create a Windows Server virtual machine and providing only Windows-based setup and screenshots. There are no instructions or examples for creating or using a Linux-based VM, nor are there any Linux-specific considerations or command-line examples. The documentation assumes a Windows environment for the VM used to access the Azure Function, which may not reflect the needs or preferences of all users.
Recommendations:
  • Provide parallel instructions and screenshots for creating a Linux-based virtual machine (e.g., Ubuntu) alongside the Windows Server example.
  • Explicitly mention that either Windows or Linux VMs can be used for this scenario, and highlight any differences in setup or access.
  • Include examples of connecting to the VM using SSH (for Linux) as well as RDP (for Windows), and clarify how Azure Bastion supports both.
  • Where relevant, show command-line examples (e.g., using curl or wget on Linux) for invoking the Azure Function from within the VM.
  • Ensure that all steps, especially those involving the VM, are platform-agnostic or provide clear alternatives for both Windows and Linux users.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-deployment-technologies.md [View Details]
Scanned: 2025-07-13 21:37 • Page-level bias detected
▼

Page-Level Analysis

Windows First Windows Tools Missing Linux Example
Summary:
The documentation demonstrates a Windows-first bias in several areas: Windows-specific deployment methods (such as source control, Local Git, and FTPS) are called out as 'Windows-only' in the availability table, with no Linux equivalents or alternatives described. Explanations of remote build and deployment behaviors often start with Windows, providing more detail for Windows scenarios (e.g., Kudu/SCM site), and Linux instructions are less prominent or require additional manual configuration. There are also references to Visual Studio (a Windows-centric tool) before cross-platform or Linux-native tools, and some deployment methods (e.g., FTPS, Local Git) lack Linux-specific guidance or alternatives.
Recommendations:
  • Provide Linux equivalents or alternatives for deployment methods currently marked as 'Windows-only' (e.g., Source Control, Local Git, FTPS), or clearly state if no equivalent exists and suggest best practices for Linux users.
  • Ensure that deployment examples and instructions are given for both Windows and Linux platforms, ideally side-by-side or with equal prominence.
  • When listing tools, mention cross-platform options (e.g., Azure Functions Core Tools, VS Code) before Windows-specific tools (e.g., Visual Studio), or present them together.
  • Expand explanations for Linux deployment scenarios, including details on how to perform common tasks (such as remote build, trigger syncing, or storage configuration) on Linux.
  • Where a feature is not available on Linux, provide a rationale and suggest alternative workflows for Linux users.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-how-to-use-nat-gateway.md [View Details]
Scanned: 2025-07-13 21:37 • Page-level bias detected
▼

Page-Level Analysis

Windows First Missing Linux Example
Summary:
The documentation demonstrates a Windows bias by explicitly recommending Windows as the operating system for the function app and not providing equivalent guidance or examples for Linux. There are no Linux-specific instructions, notes, or parity checks, and the only runtime stack mentioned is .NET, which is often associated with Windows. No PowerShell or Windows command-line tools are used, but the absence of Linux parity is notable.
Recommendations:
  • Provide explicit instructions and notes for both Windows and Linux hosting options, including any differences in configuration or limitations.
  • Include examples for creating and configuring the function app on Linux, and clarify if any steps differ.
  • Mention runtime stack options that are cross-platform (e.g., Node.js, Python) and provide sample code or notes for those.
  • If there are platform-specific recommendations (such as for best experience), explain the rationale and provide alternatives for Linux users.
  • Ensure screenshots and UI instructions are not Windows-specific, or clarify if the experience is identical on Linux.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-develop-local.md [View Details]
Scanned: 2025-07-13 21:37 • Page-level bias detected
▼

Page-Level Analysis

Windows First Windows Tools
Summary:
The documentation page demonstrates mild Windows bias by listing Windows-centric tools (such as Visual Studio and PowerShell) before cross-platform or Linux-native alternatives, especially in the C# and HTTP test tools sections. Visual Studio (Windows-only) is presented as the primary environment for C#, with cross-platform options mentioned later. PowerShell is listed as an HTTP test tool before curl, which is more native to Linux. However, the page does provide parity in mentioning Linux and macOS support for Visual Studio Code and Core Tools, and does not omit Linux examples entirely.
Recommendations:
  • In C# sections, list Visual Studio Code and command-line/terminal options before Visual Studio, or group them together to avoid implying Windows-first development.
  • In HTTP test tools, list curl before PowerShell, as curl is more universal and native to Linux/macOS.
  • Wherever possible, provide explicit Linux/macOS command-line examples or screenshots alongside Windows ones.
  • Highlight cross-platform tools and workflows first, or equally, to reinforce Linux parity.
  • Explicitly mention Linux package managers (e.g., apt, yum, brew) for installing Core Tools and Azurite, not just npm or Windows installers.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/python-memory-profiler-reference.md [View Details]
Scanned: 2025-07-13 21:37 • Page-level bias detected
▼

Page-Level Analysis

Windows First Powershell Heavy
Summary:
The documentation demonstrates a mild Windows bias, particularly in the local development instructions. Windows PowerShell is mentioned first, and Windows-specific commands (such as 'py -m venv .venv' and '.venv\Scripts\Activate.ps1') are listed before their Linux equivalents. The file path separator in the memory profiler output example also uses Windows-style backslashes. However, Linux alternatives are present, and there are no exclusive Windows-only tools or missing Linux examples.
Recommendations:
  • Present Linux and Windows instructions in parallel (side-by-side tabs or clearly separated steps) rather than listing Windows first.
  • Use neutral or platform-agnostic language, e.g., 'Open a terminal' instead of 'Open a Windows PowerShell or any Linux shell as you prefer.'
  • When showing commands, either provide both Windows and Linux/Mac commands together, or use tabs for each OS.
  • In code or output examples, use platform-neutral paths (e.g., <ProjectRoot>/HttpTriggerAsync/__init__.py) or show both Windows and Linux path formats.
  • Ensure that all steps and tooling are equally accessible and clear for Linux users, not just as an afterthought.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-openapi-definition.md [View Details]
Scanned: 2025-07-13 21:37 • Page-level bias detected
▼

Page-Level Analysis

Windows First Missing Linux Example
Summary:
The documentation demonstrates a subtle Windows bias by referencing Visual Studio (a primarily Windows-based tool) for C# class library functions and omitting any mention of Linux-specific tools, workflows, or command-line examples. All instructions are given via the Azure Portal UI, with no CLI or cross-platform automation examples. There are no Linux or macOS-specific instructions, nor are there alternatives to Visual Studio for non-Windows users.
Recommendations:
  • Include examples using Azure CLI and/or Azure PowerShell for all major steps (creating API Management instance, importing functions, downloading OpenAPI definitions) to provide parity for Linux and macOS users.
  • Mention cross-platform IDEs or editors (such as VS Code) alongside Visual Studio, and provide links or instructions for using them with Azure Functions and API Management.
  • Explicitly state that the portal-based workflow is platform-agnostic, but offer command-line alternatives for users who prefer or require non-GUI workflows.
  • If referencing Visual Studio, also reference equivalent workflows for Linux/macOS users (e.g., using VS Code or CLI tools).
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-create-first-java-gradle.md [View Details]
Scanned: 2025-07-13 21:37 • Page-level bias detected
▼

Page-Level Analysis

Windows First Windows Tools
Summary:
The documentation demonstrates a subtle Windows bias by defaulting the Azure Functions runtime OS to 'windows' in the Gradle configuration example, without mentioning Linux as an alternative or providing guidance for Linux users. Additionally, the documentation refers to the Azure portal and Azure CLI, which are cross-platform, but the explicit configuration for 'windows' as the runtime OS may lead Linux users to believe Windows is preferred or required.
Recommendations:
  • In the Gradle configuration example, explicitly mention that 'os' can be set to 'linux' as well as 'windows', and provide an example or note for Linux users.
  • Add a short section or note explaining the implications of choosing 'windows' vs 'linux' for the runtime, especially since Java 21 is supported on Linux only.
  • Ensure parity in instructions and examples for both Windows and Linux environments, particularly in configuration files and deployment steps.
  • If there are any OS-specific steps (such as setting JAVA_HOME), provide both Windows and Linux/macOS command examples.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-scale.md [View Details]
Scanned: 2025-07-13 21:37 • Page-level bias detected
▼

Page-Level Analysis

Windows First Windows Tools
Summary:
The documentation generally presents Windows and Linux options in parallel, but there are subtle biases: Windows is often mentioned first in tables and explanations, and some links (such as App Service plan rates) point to Windows-specific resources. There is also a lack of Linux-specific troubleshooting or deployment examples, and some App Service pricing links default to Windows. However, the page does acknowledge Linux container support and Linux-only features where relevant.
Recommendations:
  • Alternate the order of Windows and Linux mentions in tables and explanations to avoid always listing Windows first.
  • Ensure pricing and feature links reference both Windows and Linux resources, or provide a clear choice.
  • Add Linux-specific troubleshooting and deployment examples or links, especially where behaviors differ.
  • Where Windows-only features or limitations are mentioned, provide equivalent Linux information or explicitly state the Linux alternative.
  • Review all references to App Service plans and ensure Linux options are equally visible and accessible.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-identity-based-connections-tutorial.md [View Details]
Scanned: 2025-07-13 21:37 • Page-level bias detected
▼

Page-Level Analysis

Windows First Missing Linux Example Windows Tools
Summary:
The documentation is heavily oriented toward Windows environments: it explicitly states support for C# class library functions on Windows, references Azure Files (default for Windows), and omits Linux-specific guidance or examples. There are no Linux or cross-platform command-line examples, and Linux-specific deployment patterns are only briefly mentioned in passing, without actionable steps.
Recommendations:
  • Clearly indicate Windows-specific limitations at the top and provide equivalent Linux guidance or note when features are unavailable.
  • Add parallel instructions and examples for Linux-based function apps, including how to handle storage and identity configuration on Linux.
  • Include CLI (az), Bash, or cross-platform scripting examples alongside or instead of portal-only instructions.
  • Discuss Linux-specific storage options and deployment patterns (e.g., how to handle AzureWebJobsStorage and Azure Files on Linux Consumption and Premium plans).
  • Where features differ (e.g., Azure Files not being default on Linux), explain the implications and provide alternatives.
  • Ensure that references to tools and patterns (such as ARM templates or portal steps) are not Windows-centric and clarify any OS-specific behaviors.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-versions.md [View Details]
Scanned: 2025-07-13 21:37 • Page-level bias detected
▼

Page-Level Analysis

Windows First Windows Tools Missing Linux Example
Summary:
The documentation page demonstrates a Windows bias by referencing Visual Studio and its project settings in detail, with no equivalent coverage for Linux-native development environments or tools. Visual Studio (a Windows tool) is discussed first and in depth, while Visual Studio Code and Azure Functions Core Tools (which are cross-platform) are mentioned only briefly and without Linux-specific guidance or examples. There are no explicit Linux command-line examples or instructions for Linux users, and the process of pinning to a minor version is said to differ between Windows and Linux, but only a link is provided with no Linux-specific explanation or example.
Recommendations:
  • Provide explicit Linux command-line examples for tasks such as changing runtime versions, pinning to minor versions, and local development.
  • Include parity in tooling instructions by offering equivalent steps for Linux-native environments (e.g., JetBrains Rider, VS Code on Linux, or CLI-only workflows) alongside Visual Studio instructions.
  • When mentioning differences between Windows and Linux (e.g., pinning to a minor version), include both sets of instructions or examples directly in the documentation.
  • Avoid presenting Windows tools or workflows first by default; consider parallel presentation or starting with cross-platform tools.
  • Add a section or callout specifically for Linux/macOS users to ensure their workflows are equally represented.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-identity-based-connections-tutorial-2.md [View Details]
Scanned: 2025-07-13 21:37 • Page-level bias detected
▼

Page-Level Analysis

Windows First Missing Linux Example Powershell Heavy
Summary:
The documentation is explicitly targeted at C# class library functions on Windows, with no mention of Linux or cross-platform support. All examples and instructions assume use of the Azure portal or .NET CLI, with no Linux-specific guidance or parity checks. There are no examples for Linux-based deployments or for using the Azure Functions Core Tools on Linux/macOS, and no mention of Bash or cross-platform shell commands.
Recommendations:
  • Clearly indicate at the beginning of the tutorial whether the steps are applicable to Linux and macOS, and provide equivalent instructions where possible.
  • Add Linux/macOS-specific examples for creating and deploying function apps, including using Bash shell commands and Azure CLI from non-Windows environments.
  • Include notes or sections for differences in environment variable configuration on Linux (e.g., case sensitivity, file paths, use of export in Bash).
  • Provide cross-platform guidance for local development, such as how to set up local.settings.json and assign roles using Azure CLI or Bash scripts.
  • If certain features are Windows-only, explicitly state the limitations and provide workarounds or alternatives for Linux users.
  • Ensure that all code and command-line examples are tested and valid on both Windows and Linux platforms.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-how-to-use-azure-function-app-settings.md [View Details]
Scanned: 2025-07-13 21:37 • Page-level bias detected
▼

Page-Level Analysis

Powershell Heavy Windows First Missing Linux Example Windows Tools
Summary:
The documentation demonstrates a Windows bias by consistently providing Azure PowerShell examples alongside Azure CLI, often before or with more detail than Linux-specific workflows. Several features and tools (such as Kudu, App Service Editor, and in-portal console) are described as available or fully functional only on Windows, with Linux support either missing, limited, or explicitly marked as unsupported. Migration steps and plan management are documented only for Windows, with Linux migration called out as unsupported or limited. There are also several places where Windows terminology and patterns are used by default, and Linux alternatives are not described or are marked as unavailable.
Recommendations:
  • Provide explicit Linux examples and workflows where possible, especially for command-line and deployment operations.
  • Clarify feature parity and limitations for Linux up front, and offer Linux-specific guidance or workarounds where features are missing.
  • Balance the use of PowerShell and CLI examples, and avoid presenting Windows tools or patterns first unless they are the only option.
  • Where features are Windows-only (such as Kudu, App Service Editor, or in-portal console), suggest alternative Linux-compatible tools or approaches.
  • For plan migration and management, document Linux-specific scenarios and clearly outline supported migration paths for Linux-hosted function apps.
  • Review screenshots and UI instructions to ensure they are relevant for both Windows and Linux users, or provide parallel guidance.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-machine-learning-tensorflow.md [View Details]
Scanned: 2025-07-13 21:37 • Page-level bias detected
▼

Page-Level Analysis

Windows First Powershell Heavy Windows Tools
Summary:
The documentation provides both Linux (bash) and Windows (PowerShell, Cmd) instructions for most steps, but consistently lists Windows-specific commands and tools (PowerShell, Cmd, 'py' launcher) before or alongside Linux equivalents. Some troubleshooting and environment setup guidance is Windows-specific, and Windows tools (e.g., registry edits, 'py' launcher) are mentioned without Linux/macOS parallels. There is a slight preference for Windows-first presentation and more detailed Windows troubleshooting.
Recommendations:
  • Alternate the order of platform-specific tabs or examples, sometimes listing bash/Linux first to avoid implicit prioritization of Windows.
  • Where Windows-specific troubleshooting is provided (e.g., registry edits for long paths), add equivalent Linux/macOS troubleshooting tips if applicable, or explicitly state when an issue is Windows-only.
  • When referencing tools like the 'py' launcher (Windows), clarify the equivalent commands for Linux/macOS (e.g., always show 'python3' or 'python' usage).
  • Ensure that all environment setup, activation, and troubleshooting steps are equally detailed for Linux/macOS as for Windows.
  • Consider adding a summary table of commands for all platforms at the end of each section for quick reference.
  • Review the order of platform-specific instructions to avoid always listing Windows first, which can reinforce a Windows-centric perspective.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-create-first-function-bicep.md [View Details]
Scanned: 2025-07-13 21:37 • Page-level bias detected
▼

Page-Level Analysis

Powershell Heavy Windows Tools Windows First
Summary:
The documentation provides both Azure CLI and Azure PowerShell instructions for deploying Bicep files, but the inclusion of Azure PowerShell (which is primarily a Windows-centric tool) alongside Azure CLI (which is cross-platform) introduces a Windows bias. PowerShell examples are given equal prominence to CLI, and the documentation refers to 'Azure PowerShell' as a primary deployment method, which may not be as relevant for Linux users. There are no Linux-specific shell (bash) examples or explicit mention of Linux environments, and PowerShell is presented as a first-class option rather than as an alternative for Windows users.
Recommendations:
  • Clearly indicate that Azure CLI is cross-platform and preferred for Linux/macOS users, while Azure PowerShell is primarily for Windows.
  • Add bash/zsh shell examples for common Linux workflows, especially for validation and cleanup steps.
  • If PowerShell is included, clarify its cross-platform availability but note its prevalence on Windows.
  • Consider reordering sections to present Azure CLI (or bash) before PowerShell, or group PowerShell as a Windows-specific alternative.
  • Explicitly mention Linux/macOS compatibility in the prerequisites and throughout the instructions.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/migrate-version-3-version-4.md [View Details]
Scanned: 2025-07-13 21:37 • Page-level bias detected
▼

Page-Level Analysis

Powershell Heavy Windows First Missing Linux Example
Summary:
The documentation page demonstrates a Windows bias by providing only a PowerShell script for identifying function apps to migrate, referencing Azure PowerShell as the primary tool for this task, and omitting equivalent Bash, Azure CLI, or Linux-native instructions. The initial migration steps and tooling recommendations (e.g., Visual Studio, PowerShell) are presented from a Windows-centric perspective, with no parity for Linux or cross-platform users in the core discovery and migration workflow.
Recommendations:
  • Provide equivalent Azure CLI and/or Bash script examples alongside the PowerShell script for identifying function apps to migrate, ensuring Linux and macOS users have clear guidance.
  • When referencing Azure PowerShell, also mention Azure CLI as an alternative, and provide links or examples for both.
  • Avoid language such as 'use the following PowerShell script' without offering a cross-platform alternative.
  • In sections discussing publishing or migration tooling (e.g., Visual Studio), mention and provide instructions for cross-platform tools such as VS Code, Azure CLI, or GitHub Actions.
  • Audit all code snippets and workflow steps to ensure Linux users are not required to adapt Windows-specific instructions on their own.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-premium-plan.md [View Details]
Scanned: 2025-07-13 21:37 • Page-level bias detected
▼

Page-Level Analysis

Windows First Powershell Heavy Missing Linux Example Windows Tools
Summary:
The documentation demonstrates a Windows bias in several ways: PowerShell examples are provided alongside Azure CLI throughout, but there are no explicit Linux shell (bash) or scripting examples. Migration between plans is only supported on Windows, with Linux migration explicitly unsupported. In several places, Windows is mentioned first (e.g., in region scale-out tables and migration), and Windows-specific tools (PowerShell) are given equal prominence to cross-platform tools (CLI), but Linux-native scripting or commands are not. There is also a lack of Linux-specific guidance or parity in some features.
Recommendations:
  • Provide bash or Linux shell script equivalents for all Azure PowerShell examples, or clarify that Azure CLI commands are cross-platform and sufficient.
  • When listing operating systems (e.g., in region tables, migration sections), alternate the order or explicitly address both equally, rather than defaulting to Windows-first.
  • For migration, clarify the roadmap or alternatives for Linux users, or provide a workaround if possible.
  • Include Linux-specific considerations or troubleshooting tips where relevant, especially in sections where Windows-specific behaviors or limitations are discussed.
  • Review all examples and ensure that Linux users are not left without guidance or are not required to use Windows tools for management tasks.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-core-tools-reference.md [View Details]
Scanned: 2025-07-13 21:37 • Page-level bias detected
▼

Page-Level Analysis

Windows First Windows Tools Powershell Heavy Missing Linux Example
Summary:
The documentation for Azure Functions Core Tools demonstrates a moderate Windows bias. The page references Windows-specific tools and patterns (such as func.exe and the use of .pfx certificates), and some features or instructions are described in a way that assumes a Windows environment. There is a lack of explicit Linux/macOS examples, and certain options (like certificate handling) are described in a way that is more familiar to Windows users. Additionally, PowerShell is mentioned as a supported runtime with special features, but there is little parity discussion for Linux shells or scripting environments.
Recommendations:
  • Provide explicit Linux/macOS command-line examples alongside or in place of Windows-centric ones.
  • Avoid referencing Windows-specific binaries (e.g., func.exe) in the title or introductory text; use cross-platform terminology (e.g., Azure Functions Core Tools CLI).
  • Where features are Windows-specific (such as .pfx certificate handling), clarify cross-platform support and provide equivalent instructions for Linux/macOS (e.g., using OpenSSL-generated certificates).
  • When mentioning PowerShell-specific features, also discuss parity or alternatives for Bash or other common Linux shells.
  • Ensure that any references to local emulators, encryption, or file paths include Linux/macOS equivalents.
  • Add notes or tables indicating OS support for each feature or command where relevant.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-run-local.md [View Details]
Scanned: 2025-07-13 21:37 • Page-level bias detected
▼

Page-Level Analysis

Windows First Windows Tools
Summary:
The documentation is largely cross-platform and provides examples for multiple programming languages, but there are subtle signs of Windows bias. In several places, Windows command line (cmd) examples are provided alongside Bash, and references to 'command prompt' or 'cmd' often precede 'terminal' or 'Bash'. The use of 'func.exe' and references to MSI installers for upgrades are Windows-specific. The documentation also mentions Azure PowerShell and Azure CLI as required tools for publishing, listing PowerShell (a Windows-first tool) before CLI. However, Linux and macOS users are not excluded, and Bash/cURL examples are present.
Recommendations:
  • When providing command examples, always present Bash (Linux/macOS) and Windows (cmd/PowerShell) examples in parallel, and avoid listing Windows examples first by default.
  • Use neutral terminology such as 'terminal' instead of 'command prompt' or 'cmd', or mention both equally.
  • Where 'func.exe' is referenced, clarify that on Linux/macOS the executable is 'func'.
  • When discussing required tools, list Azure CLI before Azure PowerShell, or mention both together without preference.
  • Explicitly note platform differences in installation and usage steps, and provide links or instructions for Linux/macOS where appropriate.
  • Ensure that all cross-platform tools (like cURL) are introduced with equal weight for Linux/macOS and Windows, and avoid implying Windows is the default environment.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-reference-python.md [View Details]
Scanned: 2025-07-13 21:37 • Page-level bias detected
▼

Page-Level Analysis

Windows First Windows Tools
Summary:
The documentation is generally cross-platform and Linux-friendly, with explicit statements that Python Functions run on Linux in Azure. However, there is a subtle Windows bias in the order and phrasing of some development and publishing guidance. Specifically, 'command prompt' is used as a synonym for 'terminal', and remote build is recommended 'when developing Python apps on Windows', with local build discouraged for Windows users. Visual Studio Code is emphasized, but that is cross-platform. There are no PowerShell-specific examples, and Linux is well-represented in hosting and deployment sections.
Recommendations:
  • Replace 'command prompt' with 'terminal' or 'shell' to avoid Windows-centric terminology. If both are meant, clarify with 'terminal (Linux/macOS) or command prompt (Windows)'.
  • When discussing remote vs. local build, explain the technical reasons for the recommendation, and provide equivalent Linux/macOS guidance, not just Windows.
  • Where possible, add explicit Linux/macOS CLI examples (e.g., bash/zsh) alongside any Windows-specific instructions.
  • Review all tool references (e.g., Visual Studio Code, Azure Functions Core Tools) to ensure installation and usage instructions are clear for both Windows and Linux users.
  • Consider adding a section or callout summarizing any platform-specific caveats for local development, so Linux users are equally informed.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/function-keys-how-to.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows First Powershell Heavy Missing Linux Example
Summary:
The documentation provides both Azure CLI (which is cross-platform) and Azure PowerShell examples for managing access keys, but the PowerShell examples are given equal prominence and detail, despite PowerShell being primarily associated with Windows. There are no explicit Linux/Bash-native script examples, and the CLI example notes that it must be modified to run in a Windows terminal, but does not provide a corresponding Linux/Bash example. There is also no mention of Linux-specific tools or workflows, and the PowerShell examples are more verbose and detailed than the CLI ones.
Recommendations:
  • Provide explicit Bash/Linux shell script examples alongside Azure CLI and PowerShell, especially for key management tasks.
  • Clarify that Azure CLI commands are cross-platform and provide any necessary modifications for both Windows and Linux shells.
  • Avoid giving PowerShell examples equal or greater prominence than CLI/Bash unless there is a Windows-specific feature being demonstrated.
  • Where PowerShell is used, consider providing a Bash equivalent for parity.
  • Explicitly mention that Azure CLI can be used on Linux, macOS, and Windows, and provide sample commands for each where syntax or environment differs.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-add-openai-text-completion.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows Tools Windows First Missing Linux Example
Summary:
The documentation demonstrates a moderate Windows bias. It assumes the use of Visual Studio Code and the Azurite storage emulator, both of which are cross-platform but have stronger adoption and easier setup on Windows. The instructions for starting Azurite and running the function app rely on VS Code's command palette and do not provide explicit CLI alternatives for Linux/macOS users. There are no explicit Linux/macOS shell commands or terminal instructions, and no mention of platform-specific differences or troubleshooting for non-Windows environments. The documentation also does not mention or link to Linux-native tools or workflows, such as using the Azure CLI directly in bash/zsh, or running Azurite from the command line outside VS Code.
Recommendations:
  • Add explicit instructions for starting Azurite from the command line (e.g., `npx azurite` or `azurite` if installed globally), and clarify that it works on Linux/macOS as well as Windows.
  • Provide alternative instructions for running and debugging the function app using the Azure Functions Core Tools CLI (`func start`) for users who may not use VS Code or prefer terminal workflows.
  • Include notes or links about installing prerequisites (such as .NET Core, Node.js, Python, Java) on Linux/macOS, not just Windows.
  • Explicitly mention that all tools and steps are cross-platform, and call out any platform-specific caveats or troubleshooting steps.
  • Where possible, provide bash/zsh shell command equivalents alongside any PowerShell or Windows-centric instructions.
  • Consider adding a 'Platform differences' or 'Linux/macOS notes' section to address any subtle differences in setup or usage.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-app-settings.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows First Windows Tools Powershell Heavy
Summary:
The documentation generally aims for cross-platform coverage, but there are subtle Windows biases. In several places, Windows-specific tools, settings, or patterns are mentioned before Linux equivalents, or are given more detailed explanations. Some settings and examples (such as environment variable delimiters, file paths, and PowerShell-specific settings) are Windows-centric or prioritize Windows terminology. PowerShell and Windows-specific configuration options are described in more detail than their Linux or cross-platform counterparts. In a few cases, Windows-only settings are called out, but Linux-only settings are less emphasized.
Recommendations:
  • Ensure that all examples and explanations are provided for both Windows and Linux, with equal detail and prominence.
  • When describing environment variable delimiters or file paths, always show both Windows and Linux syntax side by side.
  • For settings that are platform-specific (e.g., WEBSITE_NODE_DEFAULT_VERSION for Windows), provide a corresponding note or section for Linux, even if just to state the equivalent or that it is not applicable.
  • Avoid prioritizing Windows terminology or tools (such as Azure PowerShell) over cross-platform alternatives (like Azure CLI); mention both together or prefer cross-platform tools.
  • Where PowerShell-specific settings are described in detail, ensure similar coverage for Bash or other Linux-relevant scripting environments if applicable.
  • Review the order in which OS-specific information is presented, and alternate or balance Windows and Linux references to avoid implicit prioritization.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-add-output-binding-storage-queue-vs.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows First Missing Linux Example Windows Tools Powershell Heavy
Summary:
The documentation is heavily oriented towards Windows and Visual Studio users. All instructions and UI references are for Visual Studio, a Windows-first IDE, with no mention of cross-platform alternatives (such as VS Code or CLI). The use of Solution Explorer, Publish dialogs, and NuGet Package Manager Console (which is PowerShell-based) are all Windows-centric. There are no Linux/macOS-specific instructions or CLI-based alternatives provided, despite Azure Storage Explorer being cross-platform.
Recommendations:
  • Provide equivalent instructions for developing and running Azure Functions using cross-platform tools such as Visual Studio Code and the Azure Functions Core Tools CLI.
  • Include examples of how to install dependencies and manage app settings using command-line tools (e.g., dotnet CLI, func CLI) that work on Linux and macOS.
  • Reference cross-platform editors and workflows alongside Visual Studio, or link to relevant guides for non-Windows users.
  • Avoid assuming the use of Solution Explorer, Publish dialogs, or NuGet Package Manager Console; instead, offer alternative steps for users on other platforms.
  • Clearly indicate which steps are Windows-specific and provide parity for Linux/macOS users wherever possible.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-bindings-kafka-trigger.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Powershell Heavy
Summary:
The documentation provides language-specific examples for C#, JavaScript, PowerShell, Python, and Java. While most examples are language-focused and cross-platform, the inclusion of PowerShell as a primary language (alongside Python and JavaScript) may indicate a slight Windows bias, as PowerShell is traditionally associated with Windows environments, although it is now cross-platform. However, there are no explicit Windows-only tools, Windows-first ordering, or missing Linux examples. No Windows-specific commands, paths, or tools are mentioned, and all code samples are language-agnostic or cross-platform.
Recommendations:
  • Clarify that PowerShell examples are intended to be cross-platform (PowerShell Core), not Windows PowerShell, to avoid confusion.
  • Consider including bash or shell script examples for Linux users, especially if scripting is relevant for operational tasks.
  • Explicitly state in the introduction or relevant sections that all examples are intended to work on both Windows and Linux, unless otherwise noted.
  • If any operational steps (such as local development, deployment, or troubleshooting) are added in the future, ensure both Windows and Linux command-line instructions are provided.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-bindings-openai-textcompletion-input.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Powershell Heavy
Summary:
The documentation provides language-specific examples for C#, Java, JavaScript, TypeScript, PowerShell, and Python. While there is no overt Windows bias in the form of Windows-only tools or commands, the inclusion of PowerShell as a primary example language (with detailed configuration and code samples) can be seen as a subtle Windows bias, since PowerShell is most commonly associated with Windows environments. However, there are no missing Linux examples, and no Windows-specific tools or patterns are mentioned exclusively or prioritized before Linux equivalents.
Recommendations:
  • Clarify that PowerShell examples are cross-platform, as PowerShell Core runs on Linux and macOS as well as Windows.
  • Consider adding Bash or shell script examples if relevant for parity with PowerShell, especially in sections where scripting is demonstrated.
  • Explicitly mention that all code samples are platform-agnostic unless otherwise noted, to reassure Linux users.
  • If any setup, deployment, or CLI instructions are added in the future, ensure both Windows (PowerShell/CMD) and Linux (Bash) equivalents are provided.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/bring-dependency-to-functions.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows Tools Windows First Missing Linux Example
Summary:
The documentation demonstrates a Windows bias primarily in the Java example, where the ffmpeg path uses a Windows-style executable (ffmpeg.exe) and the instructions reference a Windows directory structure. There is no explicit Linux/Unix example for Java, and the use of .exe implies Windows as the default. In contrast, the Python examples and the file share mounting section are Linux-focused, but there is no parity in providing both Windows and Linux examples for all languages. Additionally, PowerShell is mentioned as an upload option, but not demonstrated, and Windows tools are referenced before Linux equivalents in some places.
Recommendations:
  • For Java, provide both Windows and Linux examples for accessing and executing dependencies, including paths and executable formats (e.g., ffmpeg.exe vs. ffmpeg).
  • Avoid using Windows-specific file extensions (like .exe) in cross-platform documentation unless both alternatives are shown.
  • Explicitly mention and demonstrate how to set up and use dependencies on both Windows and Linux environments for all supported languages.
  • When referencing upload tools (Azure CLI, PowerShell, Portal), provide example commands for both Windows (PowerShell/CMD) and Linux (Bash) environments.
  • Ensure that instructions and code snippets do not assume a default platform; clarify when steps or paths differ between Windows and Linux.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/configure-encrypt-at-rest-using-cmk.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows Tools Missing Linux Example Windows First
Summary:
The documentation demonstrates a moderate Windows bias. It references Azure Storage Explorer (a GUI tool with a primary focus on Windows) for uploading files and generating SAS tokens, and the link for generating SAS tokens is specifically tagged with '?tabs=windows'. There are no Linux-specific instructions or CLI alternatives for these steps, and no mention of Linux-native tools or workflows. The documentation assumes the use of Storage Explorer and does not provide parity for Linux users who may prefer CLI or cross-platform solutions.
Recommendations:
  • Provide explicit Azure CLI commands for uploading files to Azure Storage and generating SAS tokens, as these are cross-platform and suitable for Linux users.
  • Avoid linking to documentation with Windows-specific tabs or, if necessary, ensure Linux/macOS tabs are equally visible and referenced.
  • Mention and provide instructions for using Linux-native tools (e.g., azcopy, Azure CLI) for all storage operations.
  • Clarify that Azure Storage Explorer is available on Linux and macOS, or suggest alternatives if certain features are Windows-only.
  • Review all steps to ensure that Linux users can follow the workflow without needing to use Windows-specific tools or interfaces.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/configure-networking-how-to.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Missing Linux Example Windows Tools Windows First
Summary:
The documentation page demonstrates some Windows bias by only mentioning or providing examples with Windows-centric tools (such as AzCopy and Azure Storage Explorer), and by omitting any explicit Linux command-line or cross-platform alternatives for storage migration. There are no CLI or scripting examples (e.g., Bash, Azure CLI, PowerShell) for Linux users, and the tools referenced are more familiar or accessible to Windows users. The documentation also refers to UI navigation steps in the Azure portal, which are platform-agnostic, but the lack of command-line parity is notable.
Recommendations:
  • Add explicit Linux and cross-platform examples for copying storage data, such as using Azure CLI commands (az storage blob/file copy) or AzCopy examples with Bash.
  • Mention that AzCopy is available cross-platform and provide sample commands for both Windows (cmd/PowerShell) and Linux (Bash).
  • Include references to open-source or cross-platform tools for storage management, not just Azure Storage Explorer.
  • Where possible, provide both portal (UI) and CLI (Azure CLI, Bicep, ARM templates) instructions side-by-side, so users on any OS can follow along.
  • Clarify that all steps can be performed from any OS, and highlight any OS-specific prerequisites or differences.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/create-first-function-azure-developer-cli.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows First Powershell Heavy Windows Tools
Summary:
The documentation generally provides cross-platform instructions, but there are several areas where Windows and Windows-specific tools or patterns are prioritized or presented first. PowerShell is given its own programming language pivot, and in several command sections, Windows command-line (Cmd) and PowerShell examples are provided before or alongside bash/Linux equivalents. Some sections, such as virtual environment activation for Python, include multiple Windows-specific tabs (bash, Cmd), and PowerShell is treated as a first-class language option. There is also a tendency to refer to 'terminal or command prompt' generically, which can be ambiguous for Linux users.
Recommendations:
  • When presenting command examples, alternate the order of Windows and Linux/macOS instructions, or present Linux/macOS first where appropriate.
  • Ensure that all command-line instructions are clearly labeled for each platform, and avoid ambiguous terms like 'command prompt' or 'terminal' without specifying the OS.
  • For PowerShell, clarify cross-platform support and, where possible, provide bash/zsh equivalents for scripting tasks.
  • In sections where Windows-specific tools or patterns are mentioned (such as PowerShell or Cmd), ensure that Linux/macOS alternatives are equally visible and easy to follow.
  • Consider adding explicit Linux/macOS troubleshooting notes or common issues, especially for steps that may differ (e.g., file paths, environment variable syntax).
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/create-first-function-cli-csharp.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows First Powershell Heavy
Summary:
The documentation provides both Azure CLI and Azure PowerShell examples for creating Azure resources, but PowerShell is given equal prominence to CLI, which can be seen as a Windows-centric approach. There is no explicit Linux bias, but the inclusion of PowerShell as a primary tool and its parity with CLI may disadvantage Linux/macOS users, for whom PowerShell is less common. Additionally, the order of presentation sometimes puts PowerShell before or alongside CLI, rather than prioritizing cross-platform tools.
Recommendations:
  • Prioritize Azure CLI examples before PowerShell, as CLI is more universally available and familiar to Linux/macOS users.
  • Clearly indicate that PowerShell is optional and primarily for Windows users, while CLI is cross-platform.
  • If PowerShell is included, provide a brief note or link on how to install and use PowerShell on Linux/macOS, or clarify its intended audience.
  • Ensure that all steps and examples are fully cross-platform, and avoid assuming familiarity with Windows-specific tools or patterns.
  • Consider adding explicit Linux/macOS shell examples where relevant, especially for common tasks like navigation or environment setup.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/create-first-function-cli-node.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows First Powershell Heavy
Summary:
The documentation presents both Azure CLI and Azure PowerShell examples for creating the function app in Azure, but consistently lists Azure PowerShell (a Windows-centric tool) alongside or immediately after Azure CLI, without mentioning Linux-native alternatives or clarifying cross-platform compatibility. There are no explicit Linux shell (bash/zsh) or macOS-specific instructions, and PowerShell is given equal prominence to the CLI, which may suggest a Windows-oriented bias.
Recommendations:
  • Clearly state that Azure CLI commands work cross-platform (Windows, Linux, macOS), and consider listing CLI examples before PowerShell to emphasize platform neutrality.
  • Add explicit bash/zsh (Linux/macOS shell) command examples or notes where relevant, especially for steps involving environment variables, file paths, or shell-specific syntax.
  • Clarify in the prerequisites and tool installation sections that PowerShell is optional and primarily for Windows users, while Azure CLI is recommended for all platforms.
  • Where PowerShell is shown, consider providing a corresponding bash/zsh example or a note indicating that the CLI commands are suitable for Linux/macOS users.
  • Review included snippets and links to ensure they do not assume a Windows file system or shell environment.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/create-first-function-cli-typescript.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows First Powershell Heavy
Summary:
The documentation provides both Azure CLI and Azure PowerShell examples for creating the function app in Azure, but consistently lists Azure PowerShell after Azure CLI and does not mention or provide Linux-specific shell examples (e.g., bash/zsh). There is no explicit Windows-only tooling, but the presence of PowerShell as a first-class option and the lack of Linux-specific notes or troubleshooting tips suggest a mild Windows bias.
Recommendations:
  • Add explicit bash/zsh/Linux shell examples alongside Azure CLI and PowerShell, especially for common tasks such as file editing, environment variable management, or troubleshooting.
  • Include notes or troubleshooting tips relevant to Linux/macOS users (e.g., differences in using Ctrl+C, file permissions, or path formats).
  • Clarify that Azure CLI commands are cross-platform and, where relevant, provide example terminal prompts or screenshots from both Windows and Linux/macOS environments.
  • Consider providing parity in scripting examples, such as bash scripts for automation, not just PowerShell.
  • Review screenshots and instructions to ensure they are not Windows-centric (e.g., avoid only showing Windows terminal output).
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/create-first-function-vs-code-node.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows First Windows Tools Missing Linux Example
Summary:
The documentation page is generally cross-platform in intent, focusing on Visual Studio Code and Azure Functions, which are available on Windows, macOS, and Linux. However, there are subtle signs of Windows bias: troubleshooting advice specifically mentions Windows (e.g., WSL Bash), and there are no explicit Linux/macOS-specific instructions or examples. Windows-specific issues are called out, but Linux/macOS equivalents are not discussed, and no terminal or shell commands are shown for non-Windows users.
Recommendations:
  • Add troubleshooting steps relevant to Linux/macOS environments, such as common shell or permission issues.
  • Where Windows-specific advice is given (e.g., about WSL Bash), provide equivalent guidance for Linux/macOS users (e.g., default terminal shell issues, permissions, or path differences).
  • Include explicit notes or examples for Linux/macOS users, such as how to open the command palette or run commands in their environments.
  • Ensure that any references to tools or extensions clarify their cross-platform compatibility.
  • If possible, add screenshots or terminal snippets from both Windows and Linux/macOS to illustrate parity.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/create-first-function-vs-code-other.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows First Windows Tools Windows File Extensions
Summary:
The documentation generally provides cross-platform instructions, but there are subtle signs of Windows bias. Windows-specific file extensions (e.g., 'handler.exe') are mentioned before or alongside Linux equivalents. Windows environment variable setting commands are shown after Unix-style commands, but the Windows instructions are sometimes more explicit. The documentation refers to Windows-specific behaviors (such as changing 'defaultExecutablePath' to 'handler.exe' on Windows) and includes Windows command syntax (e.g., 'set GOOS=linux') in separate tabs, but does not provide PowerShell examples or prioritize Windows tools. Linux and macOS instructions are present and generally complete.
Recommendations:
  • When referring to executable names, mention the Linux version ('handler') first, or present both at the same time (e.g., 'handler (or handler.exe on Windows)').
  • Instruct users to set the 'defaultExecutablePath' to 'handler' by default, with a note for Windows users to use 'handler.exe' if needed.
  • Ensure that Linux/macOS instructions are always presented before Windows, or group them together to avoid the perception of Windows-first bias.
  • If possible, provide PowerShell equivalents for Windows commands, or clarify when to use Command Prompt vs. PowerShell.
  • Explicitly state that all examples are cross-platform unless otherwise noted, and highlight any platform-specific differences in a dedicated section.
  • Consider adding a table summarizing key platform differences (e.g., file extensions, environment variable syntax) for quick reference.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/create-first-function-cli-java.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows First Windows Tools Missing Linux Example
Summary:
The documentation demonstrates a subtle Windows bias. Windows is presented as the default or primary runtime for Azure Functions (e.g., in pom.xml examples and deployment defaults), and Linux support is mentioned only as an alternative. The configuration and deployment instructions focus on Windows first, with Linux-specific instructions relegated to notes or tips. There is also a lack of explicit Linux shell examples for some steps, and the use of Windows tools and patterns (such as PowerShell and Cmd) is given equal or more prominence than Linux/Bash, despite the cross-platform context.
Recommendations:
  • Present Linux and Windows options equally, e.g., by showing both 'runtime.os: windows' and 'runtime.os: linux' in configuration examples, or by defaulting to a cross-platform neutral value.
  • When describing deployment and configuration, avoid language that assumes Windows as the default; instead, clarify that both Windows and Linux are supported and highlight any differences up front.
  • Ensure that all command-line examples are provided for Bash (Linux/macOS), PowerShell, and Cmd, and that Bash is not treated as an afterthought.
  • Where platform-specific instructions are necessary (e.g., setting JAVA_HOME), provide explicit examples for both Windows and Linux.
  • Consider including a section or callout on developing and deploying on Linux, including any caveats or best practices.
  • Review and update the documentation to ensure Linux users are not required to infer steps from Windows-centric instructions.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/create-first-function-cli-python.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows First Powershell Heavy Windows Tools
Summary:
The documentation provides both Bash (Linux/macOS) and Windows (PowerShell, Cmd) examples for Python virtual environment setup, and both Azure CLI and Azure PowerShell examples for Azure resource creation. However, there is a slight Windows bias: PowerShell and Cmd are given equal prominence to Bash, and PowerShell is presented as a first-class alternative to Azure CLI throughout, despite Azure CLI being cross-platform. Windows-specific tools and patterns (PowerShell, Cmd, 'py' launcher) are mentioned alongside or before Linux equivalents, and some instructions (such as using 'py' instead of 'python') are more relevant to Windows users.
Recommendations:
  • Prioritize Bash (Linux/macOS) examples before PowerShell and Cmd, as Bash is the default shell on most non-Windows systems and is also available on Windows via WSL.
  • Clearly indicate which commands are for which platforms, and consider grouping Windows-specific instructions after cross-platform or Linux-first instructions.
  • Instruct users to use 'python' instead of 'py' for virtual environment creation, as 'py' is a Windows-specific launcher.
  • Emphasize Azure CLI as the primary, cross-platform tool for resource creation, and present PowerShell as an alternative for Windows users.
  • Add explicit notes or callouts for Linux/macOS users where necessary, especially for common issues (e.g., missing 'venv' package).
  • Consider providing a single, cross-platform command block for steps that are identical across platforms, reducing fragmentation and potential confusion.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/dedicated-plan.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows First Windows Tools
Summary:
The documentation page demonstrates a Windows bias by linking exclusively to the Windows-specific App Service pricing page and referencing the App Service plan primarily in the context of Windows hosting. There are no explicit Linux or cross-platform examples, and the terminology and links default to Windows-centric resources.
Recommendations:
  • Include links to both Windows and Linux App Service pricing pages, or clarify that the information applies to both platforms.
  • Explicitly mention Linux support for App Service plans and provide examples or notes where behavior may differ between Windows and Linux hosting.
  • Where relevant, reference both Windows and Linux tools or workflows for managing and scaling App Service plans.
  • Add clarifying statements or links for users deploying on Linux, especially regarding features like Always On and scaling.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/disable-function.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows First Powershell Heavy Missing Linux Example
Summary:
The documentation presents Azure PowerShell and Portal examples alongside Azure CLI, but does not provide any Linux- or bash-specific examples, nor does it mention Linux-native tools or workflows. PowerShell is given a dedicated section, and the CLI examples are generic but do not clarify Linux compatibility or provide bash-specific guidance. The Portal and PowerShell sections may imply a Windows-centric workflow, and the lack of explicit Linux shell examples or troubleshooting for Linux users (beyond a single note about hyphens in function names) suggests a Windows-first bias.
Recommendations:
  • Explicitly state that Azure CLI commands work cross-platform and, where relevant, provide bash/zsh shell examples (e.g., with export statements or Linux environment variable syntax).
  • Add a section or tab for bash/Linux shell users, especially for setting environment variables or editing local.settings.json using Linux tools.
  • Clarify that PowerShell examples are primarily for Windows users, and offer equivalent bash commands where possible.
  • Include troubleshooting or notes specific to Linux environments, such as file permissions or common shell differences.
  • Where PowerShell is mentioned, ensure parity by offering bash or sh alternatives, or at least referencing their use.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/dotnet-isolated-process-guide.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows First Windows Tools Powershell Heavy Missing Linux Example
Summary:
The documentation demonstrates a Windows-first bias in several areas. Windows-specific tools and configuration steps (such as Visual Studio, PowerShell, and Windows-specific Azure CLI commands) are mentioned before or more prominently than their Linux equivalents. Some deployment and configuration examples are provided only for Windows or with Windows as the primary example, with Linux alternatives appearing later or not at all. There are also references to Windows-specific concepts (e.g., .NET Framework, win-x86/win-x64) without always providing equivalent Linux guidance or parity in examples.
Recommendations:
  • Ensure all CLI and deployment examples are provided for both Windows and Linux, with Linux examples given equal prominence and order.
  • Where Visual Studio or PowerShell are mentioned, also mention and provide examples for cross-platform alternatives (e.g., Visual Studio Code, Bash, Azure CLI).
  • In tables and lists of options, avoid listing Windows tools or workflows first by default; alternate or group by platform.
  • When referencing runtime identifiers or build targets (e.g., win-x64), always include the Linux equivalents (e.g., linux-x64) in parallel.
  • For debugging and local development, provide explicit Linux instructions and troubleshooting steps, not just Windows/Visual Studio.
  • Add explicit notes or callouts where a feature or tool is Windows-only, and suggest Linux-compatible alternatives where possible.
  • Review all code snippets and ensure any shell commands (e.g., Azure CLI) are shown with both Windows (cmd/PowerShell) and Linux (bash) syntax where differences exist.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/event-driven-scaling.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows First Powershell Heavy
Summary:
The documentation generally avoids OS-specific bias, but in the 'Limit scale-out' section, both Azure CLI and Azure PowerShell examples are provided, with PowerShell given its own tab. In the 'Scale-in behaviors' section, a specific note is made for 'app running on Windows in a Consumption plan', with no equivalent mention for Linux. There are no Linux shell or bash examples, and the only OS-specific scenario called out is for Windows. This subtly prioritizes Windows and PowerShell users, and omits parity for Linux users.
Recommendations:
  • Add explicit bash/Linux shell examples alongside Azure CLI and PowerShell, especially for configuration changes.
  • When mentioning Windows-specific behaviors (such as drain mode), clarify whether there are differences for Linux, or state explicitly if there are none.
  • If PowerShell is given a dedicated example, consider providing equivalent bash scripting for Linux users.
  • Review all examples and notes to ensure Linux users are equally represented and not left to infer behavior or commands.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-bindings-web-pubsub-input.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Missing Linux Example
Summary:
The documentation does not display explicit Windows bias in terms of command-line examples, tools, or patterns. However, there is a lack of parity for PowerShell: while a placeholder for PowerShell examples is present, no actual PowerShell (or platform-specific) samples are provided. There are no references to Windows-only tools, nor are Windows-specific instructions or patterns prioritized over Linux equivalents. All code samples are cross-platform (C#, JavaScript, Python), and there is no mention of Windows-specific behaviors or requirements. However, the absence of any Linux- or bash-specific examples or notes, especially in sections where PowerShell is mentioned, may leave Linux users underserved.
Recommendations:
  • If PowerShell samples are to be included, ensure equivalent bash or shell script examples are also provided for Linux users.
  • Explicitly state that all code samples are cross-platform unless otherwise noted.
  • If any platform-specific setup or troubleshooting is required (e.g., for local development), provide both Windows and Linux instructions.
  • When mentioning PowerShell, clarify its cross-platform availability or provide alternatives for Linux (such as bash).
  • Consider adding a section or note on running these samples on Linux/macOS, including any necessary environment setup or differences.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-bindings-web-pubsub-output.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Missing Linux Example
Summary:
The documentation provides code examples for C# and JavaScript, but for Python and PowerShell, it states that complete samples are pending. There are no explicit Windows-specific tools, commands, or PowerShell-heavy content, nor is there a 'Windows-first' ordering. However, the lack of Linux-oriented or cross-platform examples (especially for Python, which is popular on Linux) indicates a bias by omission.
Recommendations:
  • Add complete Python and PowerShell code samples to achieve parity with C# and JavaScript.
  • Ensure that any future troubleshooting or setup instructions include both Windows and Linux command-line examples (e.g., Bash and PowerShell).
  • Explicitly mention cross-platform compatibility where relevant, and avoid assuming a Windows environment.
  • If referencing configuration files or environment variables, provide examples for both Windows (e.g., %ENV_VAR%) and Linux/macOS (e.g., $ENV_VAR) syntax.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-core-tools-reference.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows Tools Powershell Heavy Windows First Missing Linux Example
Summary:
The documentation exhibits subtle Windows bias. It references Windows-specific tools (e.g., func.exe), mentions PowerShell as a supported runtime with special features, and refers to Windows patterns (such as .pfx certificates and trusted certificate creation) without clarifying Linux/Mac equivalents. There are no explicit Linux or cross-platform shell examples, and some features (like log streaming) are noted as unsupported on Linux in certain plans, but without offering Linux alternatives or parity guidance.
Recommendations:
  • Provide explicit Linux/macOS shell examples (e.g., bash/zsh) alongside or instead of Windows/PowerShell commands.
  • Clarify cross-platform behavior for features like certificate creation, trusted certificates, and file paths (e.g., .pfx usage on Linux).
  • Avoid referencing Windows-specific tools (like func.exe) in the title/description; use cross-platform terms (e.g., Azure Functions Core Tools CLI).
  • For features not supported on Linux (e.g., log streaming in Consumption plan), offer alternative Linux-compatible workflows or clarify expected behavior.
  • Ensure all examples and instructions are validated on Linux/macOS and highlight any OS-specific differences or requirements.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-create-first-function-bicep.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Powershell Heavy Windows Tools Windows First
Summary:
The documentation provides deployment instructions using both Azure CLI and Azure PowerShell. While Azure CLI is cross-platform, Azure PowerShell is primarily a Windows-centric tool, and its inclusion as a first-class alternative (with full code samples for every language) indicates a Windows bias. There are no Linux-specific shell examples (e.g., Bash), and the PowerShell examples are given equal prominence to the CLI, which may confuse or disadvantage Linux users. Additionally, the documentation refers to saving files to your 'local computer' without clarifying cross-platform paths or shell conventions.
Recommendations:
  • Add explicit Bash shell examples for Linux/macOS users alongside Azure CLI commands, including file path conventions (e.g., ./main.bicep).
  • Clarify that Azure CLI commands work identically on Windows, Linux, and macOS, and recommend it as the primary cross-platform tool.
  • De-emphasize Azure PowerShell as a primary deployment method, or clearly label it as Windows-centric, with a note for Linux users about PowerShell Core availability.
  • Include notes or examples for common Linux/macOS shell environments where relevant (e.g., using export for environment variables, file permissions, etc.).
  • Ensure that any references to file paths or shell commands use cross-platform syntax or provide both Windows and Linux/macOS variants.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-create-first-java-gradle.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows First Windows Tools
Summary:
The documentation page exhibits a subtle Windows bias by specifying 'os = windows' as the default in the Gradle configuration block, without mentioning or providing guidance for Linux or macOS users. The runtime OS setting is presented as 'windows' without alternatives, and there is no discussion of cross-platform deployment or local development differences. While command-line examples use Bash and cURL (which are cross-platform), the documentation implicitly assumes Windows as the primary target environment.
Recommendations:
  • Explicitly mention that the 'os' property in the Gradle configuration can be set to 'linux', and provide an example or table showing possible values and their implications.
  • Add a note or section for Linux/macOS users, clarifying any differences in setup, deployment, or supported Java versions (e.g., Java 21 is Linux-only).
  • Ensure that screenshots, instructions, and references to the Azure portal or CLI are platform-neutral or include platform-specific notes where relevant.
  • Consider providing a sample build.gradle snippet for Linux users, or at least mention that the default 'windows' value can be changed.
  • Review the documentation for any other implicit assumptions (such as file paths or environment variable syntax) that may be Windows-specific, and provide cross-platform guidance.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-create-cosmos-db-triggered-function.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Missing Linux Example Windows Tools
Summary:
The documentation exclusively uses the Azure Portal (web UI) for all steps and does not provide any command-line examples. There are no references to Windows-specific tools or PowerShell, but also no mention of Linux or cross-platform CLI alternatives (such as Azure CLI or Azure Functions Core Tools). This omission results in a bias by not addressing users who prefer or require command-line or Linux-native workflows.
Recommendations:
  • Add parallel instructions using Azure CLI and Azure Functions Core Tools for each step, including Cosmos DB account creation, function app deployment, and trigger setup.
  • Include code snippets for creating and managing resources via CLI, making it clear these commands work on Linux, macOS, and Windows.
  • Explicitly mention that all portal-based steps can be performed from any OS, but provide links or references to CLI-based documentation for users on Linux or who prefer automation.
  • Where screenshots or UI steps are given, consider adding CLI equivalents in expandable sections or as alternative workflows.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-create-first-function-terraform.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows First Powershell Heavy
Summary:
The documentation provides both Azure CLI and Azure PowerShell examples for verifying results, but the PowerShell tab is present and the CLI examples use variable assignment syntax that is compatible with Bash (Linux/macOS) but not with Windows CMD. There are no explicit Windows-only tools, but PowerShell is a Windows-centric shell, and its inclusion as a primary tab can indicate a slight Windows bias. However, the main workflow (Terraform, Azure CLI) is cross-platform and the function app is explicitly stated to run on Linux.
Recommendations:
  • Clarify in the Azure CLI section that the examples are intended for Bash (Linux/macOS/WSL) and provide equivalent CMD syntax for Windows users.
  • Consider adding a note that Azure PowerShell is available cross-platform, but is most familiar to Windows users.
  • If possible, add a third tab for Windows CMD users, or clarify that PowerShell is the preferred shell for Windows.
  • Ensure that all shell commands are tested on both Linux/macOS and Windows environments, and document any differences.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-create-private-site-access.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows First Missing Linux Example
Summary:
The documentation exclusively uses Windows Server as the example operating system for the virtual machine, with no mention of Linux alternatives or instructions. All screenshots, instructions, and default choices are Windows-centric, and there are no parallel steps or notes for deploying or accessing the function app from a Linux VM. This creates a Windows-first impression and omits guidance for users preferring or requiring Linux environments.
Recommendations:
  • Include parallel instructions and screenshots for creating a Linux-based virtual machine (e.g., Ubuntu) alongside the Windows Server example.
  • Explicitly mention that either Windows or Linux VMs can be used for this scenario, and provide guidance for both.
  • Add notes or sections on how to connect to a Linux VM via Azure Bastion (using SSH), including any differences in browser-based access.
  • Ensure that any command-line or deployment steps (such as function deployment) include both Windows (PowerShell/Command Prompt) and Linux (Bash) examples where relevant.
  • Review all screenshots and UI instructions to ensure they are not exclusively Windows-focused, or provide Linux equivalents where the experience differs.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-create-maven-intellij.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows First Windows Tools Missing Linux Example
Summary:
The documentation shows a Windows bias in several ways: it references Windows-specific platforms first (e.g., 'Windows-Java 17'), omits explicit Linux/macOS instructions or screenshots, and does not provide any Linux-specific examples or terminal commands. The workflow assumes the user is on Windows or using Windows defaults, with no mention of Linux-specific steps or troubleshooting.
Recommendations:
  • Provide explicit instructions and screenshots for Linux/macOS users, especially for steps that may differ (e.g., setting JAVA_HOME, running Maven, or using Azure Functions Core Tools).
  • When listing platform options (such as during function app creation), mention Linux options alongside or before Windows, and clarify any differences (e.g., Java 21 support on Linux only).
  • Include terminal/command-line examples for Linux/macOS (e.g., using bash instead of only referencing GUI steps or Windows paths).
  • Add troubleshooting notes for common Linux/macOS issues (such as file permissions, environment variable setup, or dependency installation).
  • Ensure parity in all screenshots and instructions, so Linux/macOS users are not left to infer or adapt Windows-centric guidance.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-create-storage-queue-triggered-function.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Missing Linux Example Windows Tools
Summary:
The documentation page demonstrates a bias toward Windows by exclusively using Azure Portal (web UI) instructions, which are platform-agnostic but omit any command-line examples. There are no CLI-based instructions (such as Azure CLI, PowerShell, or Bash), which are important for Linux users and automation. Additionally, there is no mention of Linux-specific tools or workflows, nor are there any examples using Bash or Linux shell commands.
Recommendations:
  • Add parallel instructions using Azure CLI commands for all steps (creating the function app, queue, and adding messages), with example commands that work on Linux and macOS.
  • Include Bash shell examples for interacting with Azure Storage queues, such as using az storage queue create and az storage message put.
  • Explicitly mention that all steps can be performed from Linux, macOS, or Windows, and provide links to CLI documentation.
  • If PowerShell is mentioned in other related pages, ensure Bash/Linux equivalents are always provided and given equal prominence.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-create-vnet.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows First Missing Linux Example
Summary:
The documentation consistently presents Windows as the default or primary operating system for Azure Functions, with explicit statements such as 'This tutorial uses C# and Windows' and 'This tutorial uses Windows but also works for Linux.' However, there are no Linux-specific instructions, screenshots, or examples provided. All steps and guidance are oriented around the Azure Portal UI, which is cross-platform, but the language and defaults reinforce a Windows-centric approach. There are no CLI, PowerShell, or Bash examples, but the lack of Linux parity is evident in the absence of Linux-specific guidance or troubleshooting.
Recommendations:
  • Explicitly provide parallel instructions and examples for Linux users, including any differences in setup or behavior.
  • Where the tutorial states 'This tutorial uses Windows but also works for Linux,' add a section or callout with Linux-specific considerations or steps.
  • Include screenshots or CLI commands (e.g., Azure CLI, Bash) that demonstrate how to perform the same actions on Linux systems.
  • If there are no differences, explicitly state that the steps are identical for Linux, and provide confirmation or validation steps for Linux environments.
  • Consider alternating the order of mention (e.g., 'Windows or Linux') or providing a neutral phrasing to avoid reinforcing Windows as the default.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-create-your-first-function-visual-studio.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows First Missing Linux Example Windows Tools
Summary:
The documentation is heavily oriented toward Windows users by focusing exclusively on Visual Studio (the full IDE), which is only fully supported on Windows. All instructions, screenshots, and workflows assume the use of Visual Studio, with no equivalent steps or examples for Linux users. There are no CLI or cross-platform alternatives provided within the main content, and Linux users are only briefly redirected to a separate Visual Studio Code article. The use of Windows-specific tools and UI patterns (e.g., Visual Studio menus, File Explorer) further reinforces the Windows bias.
Recommendations:
  • Provide parallel instructions for Linux users using Visual Studio Code and the Azure Functions Core Tools CLI within this article, or clearly indicate cross-platform alternatives at each step.
  • Include CLI-based steps for creating, running, and deploying Azure Functions projects, which work on both Windows and Linux.
  • Add screenshots and examples from Linux environments (e.g., using terminal, file managers) where appropriate.
  • Clarify in the prerequisites and introduction that Visual Studio is only available on Windows, and offer a direct, prominent link to the cross-platform (VS Code/CLI) guide.
  • Where Azurite or other tools are mentioned, note their installation and usage on Linux.
  • Consider restructuring the article or providing tabs/sections for Windows (Visual Studio) and Linux/macOS (VS Code/CLI) users to ensure parity.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-how-to-github-actions.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows First Powershell Heavy
Summary:
The documentation generally provides parity between Windows and Linux, offering explicit tabs and templates for both platforms and most languages. However, there is a subtle Windows-first bias: Windows is consistently listed before Linux in tabbed sections, and PowerShell (a Windows-centric shell) is included as a primary language example, even though it's less common on Linux. There are no missing Linux examples, and Linux is acknowledged as the only supported OS for Python. No Windows-only tools or patterns are mandated, but the ordering and language focus suggest a mild preference for Windows.
Recommendations:
  • Alternate the order of Windows and Linux tabs or present Linux first in some sections to avoid implicit prioritization.
  • Where PowerShell is shown, also provide Bash or shell script equivalents, especially for cross-platform scenarios.
  • Explicitly state that all workflows and tools are supported equally on both Windows and Linux where applicable.
  • Consider including a general-purpose shell scripting example (Bash) alongside PowerShell to better serve Linux users.
  • Review language and screenshots to ensure equal representation of both OS environments.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-identity-based-connections-tutorial-2.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows First Missing Linux Example Powershell Heavy
Summary:
The documentation is strongly Windows-centric, explicitly stating support for C# class library functions on Windows only. There are no examples or instructions for Linux-based Azure Functions, nor for other operating systems. All code and deployment steps assume a Windows environment, and there is no mention of Linux-specific considerations or parity.
Recommendations:
  • Add explicit instructions and examples for deploying and running Azure Functions with identity-based connections on Linux-based hosting plans.
  • Clarify which steps are cross-platform and which are Windows-specific; provide alternative steps or notes for Linux users.
  • Include examples for other supported languages and platforms, or at least acknowledge their support and provide links to relevant documentation.
  • If certain features are not yet available on Linux, clearly state this and provide a roadmap or workaround if possible.
  • Ensure that CLI commands and file paths are presented in a cross-platform manner (e.g., use forward slashes or note both Windows and Linux path formats).
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-identity-based-connections-tutorial.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows First Missing Linux Example
Summary:
The documentation is primarily focused on Windows-based Azure Functions, as explicitly stated in the introduction. It only provides examples and instructions for C# class library functions on Windows, with no equivalent Linux or cross-platform guidance. There are also references to Azure Files as the default file system for Windows deployments, but no mention of Linux file system options or differences in deployment patterns. The tutorial does not provide Linux-specific steps or highlight any differences for Linux-based function apps.
Recommendations:
  • Explicitly state in the introduction whether the steps are applicable to Linux-based function apps, and if not, provide a parallel Linux tutorial or note the differences.
  • Include Linux-specific instructions and examples, especially for ARM template configuration, environment variable settings, and deployment considerations.
  • Discuss storage options and behaviors for Linux function apps, such as how Azure Files is not the default for Linux Consumption plans, and provide guidance for secret management in those scenarios.
  • Where platform-specific behaviors exist (e.g., the use of AzureWebJobsStorage__accountName in Linux Consumption), provide clear, step-by-step Linux examples.
  • Ensure parity in prerequisites and tooling, mentioning any Linux-compatible tools or SDKs required for the tutorial.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-deployment-technologies.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows First Windows Tools Missing Linux Example
Summary:
The documentation demonstrates a moderate Windows bias. Windows-based deployment options (such as source control, Local Git, and FTPS) are called out as 'Windows-only' in the technology availability table, while Linux equivalents are either less emphasized or described as limited. Windows-specific tools and patterns (e.g., Visual Studio, Kudu/SCM site) are mentioned first or in more detail, and some deployment methods (like source control and FTPS) are not available or are restricted on Linux. Linux-specific instructions are present but often secondary, and there are few Linux command-line or native tool examples.
Recommendations:
  • Provide Linux-first or Linux-parity examples for each deployment method, especially where Windows is called out as the default or primary platform.
  • Where deployment technologies are Windows-only, offer clear Linux alternatives or workarounds, and link to relevant Linux documentation.
  • Include more explicit Linux command-line examples (e.g., Bash, native Linux tools) alongside or before Windows/PowerShell/Visual Studio instructions.
  • Clarify any limitations or differences for Linux users up front, and avoid presenting Windows tools as the default unless truly universal.
  • Expand documentation on remote build and deployment for Linux, including troubleshooting and best practices.
  • Where possible, avoid using 'Windows-only' as a default and instead structure tables and sections to give Linux and Windows equal prominence.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-develop-local.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows First Windows Tools
Summary:
The documentation generally aims for cross-platform parity, but there is a subtle Windows bias. Visual Studio (Windows-only) is consistently listed first in C# sections, and Windows tools like PowerShell and Microsoft Edge Network Console are highlighted among HTTP test tools. Linux-specific tools or workflows are not given equal prominence or called out explicitly, and there are no Linux-first examples or mentions of Linux-specific editors or shells.
Recommendations:
  • Alternate the order of environment/tool listings so that Windows-only tools (e.g., Visual Studio) are not always listed first. For example, sometimes list Visual Studio Code or command-line options before Visual Studio.
  • Explicitly mention and provide examples for Linux/macOS shells (e.g., bash, zsh) where 'command prompt or terminal' is referenced, and clarify that these instructions apply equally to Linux/macOS.
  • In the HTTP test tools section, include Linux-native tools (e.g., httpie, wget) alongside curl, and avoid listing PowerShell or Microsoft Edge before cross-platform or Linux-native tools.
  • Where possible, add screenshots or example commands from Linux terminals in addition to Windows/PowerShell.
  • Call out any platform-specific differences or considerations, especially for file paths, environment variables, or tool installation steps.
  • Consider a dedicated section or callout for Linux/macOS users, especially in areas where the workflow or tooling may differ.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-develop-vs.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows First Missing Linux Example Windows Tools Powershell Heavy
Summary:
The documentation is heavily oriented toward Windows and Visual Studio on Windows. All instructions, screenshots, and workflows assume the use of Visual Studio 2022, which is only fully supported on Windows. There are no examples or guidance for developing Azure Functions using Visual Studio Code, .NET CLI, or other cross-platform tools. PowerShell is used in package installation examples, and Windows-specific UI elements and dialogs are referenced throughout. There is no mention of Linux or macOS development environments, nor are alternative workflows (such as using VS Code or CLI tools) provided.
Recommendations:
  • Add explicit guidance and examples for developing Azure Functions on Linux and macOS using Visual Studio Code and the .NET CLI.
  • Include CLI-based instructions for project creation, dependency management, and publishing, alongside Visual Studio UI steps.
  • Provide screenshots and workflow descriptions for cross-platform tools (e.g., VS Code, terminal) in addition to Visual Studio.
  • Replace or supplement PowerShell commands with equivalent Bash commands for Linux/macOS users.
  • Clearly indicate which steps or features are Windows/Visual Studio-specific, and offer alternatives where possible.
  • Reference the Azure Functions Core Tools and Azure CLI for tasks like local development, configuration, and deployment, with examples for all supported platforms.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-custom-handlers.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows First Windows Tools Missing Linux Example
Summary:
The documentation page demonstrates a Windows bias in several areas. File and executable naming conventions (e.g., 'handler.exe') are Windows-centric and appear before or instead of Linux equivalents. Example directory structures and configuration files consistently use Windows-style executable names, and there are no explicit Linux or macOS command-line or file examples. The documentation does not provide parity in showing how to configure or run custom handlers on Linux (e.g., using './handler' or without the '.exe' extension), nor does it mention Linux-specific tools or patterns.
Recommendations:
  • In all file and executable examples, show both Windows and Linux/macOS equivalents (e.g., 'handler.exe' for Windows, './handler' for Linux/macOS).
  • In directory structure diagrams, include both 'handler.exe' and 'handler' to illustrate cross-platform deployment.
  • In configuration file examples, clarify that 'defaultExecutablePath' should match the platform (e.g., 'handler.exe' on Windows, 'handler' on Linux/macOS).
  • Add explicit Linux/macOS command-line examples where relevant (e.g., how to build and run the handler on Linux).
  • Mention cross-platform considerations (such as file permissions on Linux, executable extensions, and case sensitivity) in relevant sections.
  • Where tools are referenced (such as Azure Functions Core Tools), clarify that they are available on all platforms and provide installation/use instructions for Linux/macOS as well as Windows.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-dotnet-class-library.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows First Powershell Heavy Windows Tools Missing Linux Example
Summary:
The documentation page demonstrates a Windows bias in several ways: Windows-specific tools and paths are mentioned before or instead of cross-platform or Linux equivalents (e.g., use of Windows MSI installer, %USERPROFILE% paths, win-x86 in ReadyToRun examples). Command-line installation and usage examples are provided for Windows (cmd, PowerShell) but not for Linux (bash, zsh). There is no mention of Linux-specific instructions or file paths, and the ReadyToRun publishing example only shows a Windows runtime identifier. The documentation does not provide parity for Linux or macOS users in terms of examples or tool usage.
Recommendations:
  • Add Linux/macOS equivalents for all Windows-specific instructions, such as file paths (e.g., use $HOME instead of %USERPROFILE%) and installation locations.
  • Include bash/zsh shell examples alongside cmd and PowerShell for package installation and CLI usage.
  • When discussing ReadyToRun or publishing, provide examples for Linux (e.g., linux-x64) and macOS runtime identifiers, not just win-x86.
  • When referencing installation of Azure Functions Core Tools, include Linux/macOS installation methods (e.g., apt, brew, manual download) and clarify any differences in behavior.
  • Ensure that all command-line and configuration examples are cross-platform or provide platform-specific tabs.
  • Review and update any references to Windows-only dependencies or tools to clarify cross-platform compatibility or alternatives.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-event-hub-cosmos-db.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows First Powershell Heavy
Summary:
The documentation provides both Bash (Linux/macOS) and Cmd (Windows) examples for all command-line steps, ensuring cross-platform coverage. However, in every case, the Windows (Cmd) examples are presented after the Bash examples, which may subtly prioritize Linux. There is no exclusive use of Windows tools (such as PowerShell), but the documentation does use Windows-specific command syntax (Cmd) alongside Bash. There are no missing Linux examples, and all tools used (Azure CLI, Maven, Azure Functions Core Tools) are cross-platform. There is no mention of PowerShell, only Cmd. The documentation is slightly 'powershell_heavy' in the sense that it uses Windows command prompt syntax, but not actual PowerShell. The bias is minimal and mostly in the order of presentation ('windows_first' bias would be present if Windows examples came first, but here Bash comes first).
Recommendations:
  • Consider presenting both Bash and Cmd examples side-by-side or in a tabbed interface (as is already done), but clarify that both are equally supported.
  • Explicitly mention that all tools and commands are cross-platform and supported on Windows, Linux, and macOS.
  • Optionally, include PowerShell examples for Windows users who prefer PowerShell over Cmd.
  • Ensure that any troubleshooting or environment setup steps (such as setting environment variables) include notes for both Bash and Windows (Cmd/PowerShell) users.
  • Continue to avoid referencing Windows-only tools or patterns unless a Linux/macOS equivalent is also provided.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-how-to-azure-devops.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows First Windows Tools Powershell Heavy
Summary:
The documentation demonstrates a moderate Windows bias. Windows-based build agents (vmImage: 'windows-latest') are used by default or appear first in C# and PowerShell examples, while Linux (ubuntu-latest) is used for JavaScript and Python. PowerShell is included as a first-class language, but there is no mention of Bash or Linux shell scripting for administrative tasks. Windows is the default appType for deployment, and Windows-specific notes and terminology (such as 'windows-latest', 'functionApp' for Windows, and PowerShell language support) are presented before or more prominently than Linux equivalents. However, Linux deployment and build examples are present and reasonably complete, especially for Python and JavaScript.
Recommendations:
  • For C# examples, provide both 'windows-latest' and 'ubuntu-latest' YAML build pipeline samples, or explain when to use each.
  • For PowerShell, clarify that it is Windows-only and consider providing Bash equivalents for administrative or scripting tasks.
  • In deployment sections, present Linux and Windows options side-by-side or in parallel tabs, rather than defaulting to Windows.
  • Explicitly mention Linux support for C# and PowerShell if available, or clarify platform limitations.
  • Where Windows is the default (e.g., appType), explain how to select Linux and highlight Linux as an equal option.
  • Add a summary table or section comparing Windows and Linux support for each language and deployment scenario.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-how-to-use-nat-gateway.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows First Missing Linux Example
Summary:
The documentation demonstrates a Windows bias by explicitly recommending Windows as the operating system for the function app and not providing equivalent guidance or examples for Linux. There are no Linux-specific instructions, notes, or parity checks, and the only runtime stack mentioned is .NET, which is often associated with Windows. No PowerShell or Windows command-line tools are shown, but the OS recommendation is clear and exclusive.
Recommendations:
  • Provide parallel instructions for creating the function app using Linux as the operating system, including any differences in configuration or limitations.
  • Add a note clarifying whether the steps and features (such as VNet Integration and NAT Gateway) are fully supported on Linux-based function apps, and link to relevant documentation.
  • If there are differences in the portal UI or required settings for Linux, include screenshots and step-by-step guidance for Linux users.
  • Mention other supported runtime stacks (e.g., Node.js, Python) and clarify if the tutorial is applicable to them, especially on Linux.
  • Avoid recommending Windows as the default unless there is a technical reason; if so, explain the reason and provide guidance for Linux users.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-identity-access-azure-sql-with-managed-identity.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows First Powershell Heavy Missing Linux Example
Summary:
The documentation demonstrates a Windows bias by referencing PowerShell and Azure portal workflows before mentioning CLI alternatives, and by omitting explicit Linux/macOS examples for key steps (such as enabling managed identity or connecting to SQL). The SQL connection example uses sqlcmd, which is available cross-platform, but there is no mention of Linux-specific considerations or alternative tools. The documentation also refers to the Azure portal and PowerShell as primary methods, with Azure CLI as an alternative, which may not be as familiar or accessible to Linux users.
Recommendations:
  • Provide explicit Linux/macOS command-line examples for all steps, including enabling managed identity and connecting to SQL.
  • When listing methods (Azure portal, PowerShell, Azure CLI), avoid listing Windows-centric tools (PowerShell) before cross-platform options (CLI), or present all options equally.
  • Include notes or tips for Linux/macOS users, such as installation instructions for sqlcmd or alternative tools (e.g., mssql-cli).
  • Ensure that all screenshots and UI instructions are supplemented with CLI equivalents for users who do not use the Azure portal.
  • Review language to avoid implying that PowerShell or the Azure portal are the default or preferred options.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-how-to-use-azure-function-app-settings.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows First Powershell Heavy Windows Tools Missing Linux Example
Summary:
The documentation demonstrates a Windows bias in several ways: Windows and PowerShell tools are consistently presented alongside or before Linux alternatives, and some features or instructions are only available or described for Windows environments. PowerShell examples are provided throughout, but Linux-specific shell or scripting examples are absent. Several advanced tools (like Kudu, App Service Editor, and in-portal console) are available only or primarily on Windows. Plan migration instructions are explicitly limited to Windows, with Linux migration described as unsupported or restricted. In some feature matrices, Linux support is marked as unavailable or not discussed, and Linux-specific workflows are not given equal coverage.
Recommendations:
  • Provide explicit Linux/bash shell examples alongside PowerShell for all CLI operations, especially for scripting and automation.
  • Clarify Linux support and limitations in all feature tables and sections, and offer workarounds or alternatives where features are Windows-only.
  • Where plan migration is not supported on Linux, explain the reasons and suggest alternative approaches or migration paths for Linux users.
  • Include Linux-specific instructions for using advanced tools (such as SSH-based console access) and clarify differences in tool availability.
  • Ensure that all screenshots and UI walkthroughs mention or show Linux options where relevant.
  • Add parity in documentation for local development and deployment workflows on Linux, including references to Linux-compatible tools and editors.
  • Where PowerShell is featured, provide equivalent bash or shell script snippets for Linux users.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-monitoring.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Missing Linux Example Windows Tools Windows First
Summary:
The documentation generally avoids overt Windows bias in code examples or commands, but there are subtle biases. There is a lack of Linux-specific examples or parity in feature descriptions. Some features (e.g., Performance Counters, built-in log streaming) are noted as unsupported or limited on Linux, but Linux alternatives or workarounds are not provided. The documentation references Windows-centric tools (App Service log streaming) without giving equal prominence to Linux workflows. In sections where feature limitations on Linux are mentioned, Linux is framed as the exception rather than being treated equally.
Recommendations:
  • Provide Linux-specific examples or explicit instructions for common monitoring and logging tasks, especially where features differ from Windows.
  • When describing features that are unavailable or limited on Linux (e.g., Performance Counters, built-in log streaming), offer alternative Linux-compatible solutions or workarounds.
  • Where possible, avoid framing Linux as a secondary or unsupported platform; instead, present both Windows and Linux capabilities side by side.
  • Include references to Linux-native tools or commands (such as using Azure CLI, Kudu, or SSH for log access on Linux) where appropriate.
  • Ensure that all feature tables and instructions clarify platform support and guide users to Linux-compatible workflows.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-machine-learning-tensorflow.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows First Powershell Heavy Windows Tools
Summary:
The documentation provides both Linux/macOS (bash) and Windows (PowerShell, Cmd) instructions for most steps, but Windows-specific tools and patterns are often mentioned first or in more detail. There are several places where Windows command patterns (such as 'py' launcher and registry edits) are emphasized, and troubleshooting advice is Windows-centric. The PowerShell and Cmd tabs are always present, sometimes before bash, and Windows-specific issues (like long path errors and registry changes) are discussed in depth, while Linux troubleshooting is minimal.
Recommendations:
  • Ensure that bash (Linux/macOS) instructions are presented first or at least equally with Windows instructions.
  • Provide Linux/macOS-specific troubleshooting advice where Windows-specific advice is given (e.g., discuss common Linux pip/venv issues, permissions, or path problems).
  • When mentioning tools like the 'py' launcher or registry edits, offer equivalent Linux/macOS context or explicitly state that these are Windows-only concerns.
  • Balance the depth of troubleshooting guidance for both platforms, including common Linux/macOS errors and their resolutions.
  • Where possible, use cross-platform commands or highlight differences clearly, rather than defaulting to Windows-first patterns.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-scale.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows First Windows Tools
Summary:
The documentation generally maintains parity between Linux and Windows, but there is a subtle Windows bias in the ordering and references. Windows is often listed first in tables and explanations, and some links (such as App Service plan pricing) default to Windows. There are no explicit Linux command-line or deployment examples, but also no Windows/Powershell examples, so the bias is mostly in ordering and framing rather than in example content.
Recommendations:
  • Alternate the order in which Windows and Linux are presented in tables and explanations, or use alphabetical order to avoid implicit prioritization.
  • Where pricing or documentation links are provided, ensure both Linux and Windows options are equally visible and accessible.
  • Add explicit Linux-focused examples or notes where relevant, especially in sections discussing deployment, scaling, or troubleshooting.
  • Clarify when features are Linux-only or Windows-only, and provide guidance for users of both platforms.
  • Review terminology to ensure that neither platform is implied as the default or primary option.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-networking-options.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows First Missing Linux Example Windows Tools
Summary:
The documentation generally covers networking options for Azure Functions in a cross-platform manner, but there are notable areas of Windows bias. The 'Hybrid Connections' feature is only available for Windows, with Linux explicitly not supported. In the 'Virtual network triggers' section, CLI, PowerShell, and portal instructions are provided, but there is a heavier emphasis on PowerShell (a Windows-centric tool) and no Linux-specific scripting examples. Additionally, subnet sizing guidance is given for both Windows and Linux, but Windows is mentioned first and in more detail. There are no Linux shell (bash) command examples for automation or configuration, and Windows tools like PowerShell are referenced without Linux alternatives.
Recommendations:
  • Where PowerShell examples are given, provide equivalent bash/Azure CLI examples for Linux users.
  • In automation sections, ensure that Linux-friendly tools (e.g., bash scripts, Azure CLI) are presented alongside or before Windows tools.
  • In feature descriptions (such as Hybrid Connections), clearly state Linux limitations early and suggest alternative solutions for Linux users if available.
  • When giving subnet sizing or configuration guidance, present Linux and Windows information in parallel, not with Windows first.
  • Add explicit Linux testing and troubleshooting guidance, especially for scenarios where portal or Windows tools are referenced.
  • Review all screenshots and UI instructions to ensure they are not Windows-specific or clarify if the experience is the same on Linux.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-premium-plan.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Powershell Heavy Windows First Missing Linux Example Windows Tools
Summary:
The documentation page for Azure Functions Premium plan demonstrates several forms of Windows bias. PowerShell is presented as a primary automation tool alongside Azure CLI, with detailed PowerShell examples provided throughout. Migration guidance is only available for Windows, with Linux explicitly unsupported. There are no Linux-specific command-line or scripting examples (e.g., Bash, shell scripts), and Windows terminology and tools (such as PowerShell and Windows migration) are mentioned before or instead of Linux equivalents. Some features are only available or described for Windows, with Linux limitations noted but not explained or worked around.
Recommendations:
  • Provide Linux-specific migration guidance or clearly state feature parity plans for Linux.
  • Include Bash/shell script examples alongside PowerShell for all CLI operations.
  • Ensure that Linux and Windows are given equal prominence in feature descriptions, tables, and examples.
  • Where features are Windows-only, offer alternative approaches or workarounds for Linux users, or link to relevant Linux documentation.
  • Explicitly mention any differences in portal experience for Linux users, if applicable.
  • Review and update region/scale-out tables and feature lists to clarify Linux support and limitations, and provide context or alternatives where Linux is not supported.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-infrastructure-as-code.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows First Powershell Heavy
Summary:
The documentation generally provides parity between Windows and Linux, with explicit sections and code samples for both platforms throughout. However, there is a recurring pattern of presenting Windows examples and terminology before Linux equivalents (windows_first). Additionally, PowerShell is highlighted as a primary deployment method, with detailed PowerShell scripts and references, while Linux-native shell (bash) or cross-platform CLI examples are less emphasized (powershell_heavy). There are no significant omissions of Linux examples, but the ordering and tool emphasis may subtly prioritize Windows users.
Recommendations:
  • Alternate the order of Windows and Linux examples, or present Linux examples first in some sections to balance visibility.
  • Where PowerShell is shown, also provide equivalent bash/Azure CLI scripts for Linux/macOS users, especially in deployment and validation sections.
  • In lists of deployment options, avoid always listing PowerShell before CLI or portal; consider grouping by cross-platform tools first.
  • Explicitly state that all examples are cross-platform unless otherwise noted, and highlight any platform-specific differences up front.
  • Ensure that all referenced sample repositories and templates include both Windows and Linux variants, and link to both equally.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-reference-java.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows First Powershell Heavy Missing Linux Example
Summary:
The documentation generally provides both Bash and Windows CMD examples for command-line operations, but consistently lists Windows (CMD) examples after Bash. There is no exclusive use of Windows tools or PowerShell, but the documentation does not provide PowerShell-specific examples, which is a common Windows scripting environment. The documentation does not provide Linux-specific troubleshooting steps, nor does it highlight Linux-specific tools or patterns. In some tables (e.g., Java version support), Windows is listed before Linux, which may subtly reinforce a Windows-first perspective. However, overall, the documentation is relatively balanced, but could improve Linux parity by including more Linux-specific notes and examples.
Recommendations:
  • Add PowerShell examples alongside Bash and CMD, or clarify when PowerShell is supported.
  • Where relevant, provide Linux-specific troubleshooting steps or notes (e.g., file permissions, environment variable differences).
  • In tables and lists, alternate the order of Windows and Linux, or present them alphabetically to avoid implicit prioritization.
  • Include explicit mentions of Linux tools or patterns (e.g., using systemd for local development, or Linux-specific environment configuration).
  • Highlight any differences in behavior or setup between Windows and Linux environments, especially for local development and deployment.
  • Ensure all command-line examples are tested and work as expected on both Windows and Linux shells.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-scenario-database-table-cleanup.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows First Missing Linux Example Windows Tools Powershell Heavy
Summary:
The documentation page demonstrates a strong Windows bias by exclusively using Visual Studio (a Windows-centric IDE) for all steps, referencing Windows-specific UI and workflows, and omitting any Linux or cross-platform alternatives. There are no examples or instructions for using Linux or command-line tools (such as Azure CLI, VS Code, or cross-platform editors), and all tooling and screenshots are from the Windows ecosystem. The workflow assumes the user is on Windows and does not mention Linux or macOS at any point.
Recommendations:
  • Add parallel instructions for Linux and macOS users, including how to use VS Code or the Azure CLI to create and manage Azure Functions projects.
  • Provide examples for setting app settings and connection strings using Azure CLI or the Azure portal, not just through Visual Studio.
  • Include instructions for installing and managing NuGet packages using the dotnet CLI, which is cross-platform.
  • Mention and show how to run and debug Azure Functions locally using Azure Functions Core Tools on Linux/macOS.
  • Ensure screenshots and UI references are not exclusively Visual Studio/Windows-centric, or provide alternatives.
  • Explicitly state that the workflow is possible on non-Windows platforms and link to relevant cross-platform documentation.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/ip-addresses.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows First Powershell Heavy Missing Linux Example
Summary:
The documentation provides command-line examples for Azure CLI and Azure PowerShell, but does not offer Linux-specific shell examples (e.g., Bash scripts or curl commands) where relevant. In sections where multiple tooling options are shown, Azure PowerShell (a Windows-centric tool) is given equal prominence to Azure CLI, and in some cases, appears before or alongside CLI without clarifying cross-platform applicability. There are no explicit Linux-only or macOS-specific instructions, and no mention of platform differences in using tools like nslookup or Azure CLI. This may create a perception of Windows bias and insufficient Linux parity.
Recommendations:
  • Add explicit Bash/shell examples where appropriate, especially for common tasks (e.g., using curl/jq to parse JSON, or Bash scripting for automation).
  • Clarify that Azure CLI commands are cross-platform and can be run on Linux, macOS, and Windows, while Azure PowerShell is primarily a Windows tool but also available cross-platform.
  • When listing multiple tooling options, present Azure CLI (the most cross-platform tool) before PowerShell, or clearly indicate which tools are recommended for which platforms.
  • Include notes or callouts for any platform-specific differences in command usage or output.
  • Where possible, provide examples of using native Linux tools (e.g., dig as an alternative to nslookup) and mention their installation if not present by default.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-run-local.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows First Windows Tools Powershell Heavy
Summary:
The documentation generally aims for cross-platform parity, but there are subtle signs of Windows bias. Windows command-line tools (cmd, PowerShell) are mentioned alongside or before Linux equivalents, and some instructions or examples reference Windows-specific tools or patterns. The requirement for Azure PowerShell or Azure CLI is presented without noting Linux-specific package managers or shell environments. The cURL examples do include both Bash and Windows cmd, but Windows is often mentioned first or with extra detail. Some references (such as func.exe) use Windows-style naming. There is also a dedicated PowerShell programming language pivot, which may reinforce a Windows-centric view.
Recommendations:
  • Ensure all command-line examples are presented in both Bash (Linux/macOS) and Windows cmd/PowerShell, and alternate the order in which they are shown.
  • Avoid using Windows-specific executable names (like func.exe) in generic instructions; use 'func' unless specifically discussing Windows.
  • When referencing required tools (Azure CLI, PowerShell), clarify that both are cross-platform and provide Linux/macOS installation links or notes.
  • Explicitly mention Linux/macOS where appropriate, especially when discussing terminals, shells, or environment setup.
  • Consider adding a Linux/macOS-specific troubleshooting or tips section, similar to the PowerShell pivot.
  • Review for subtle language that assumes a Windows environment (e.g., 'command prompt'), and use more neutral terms like 'terminal'.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/monitor-functions-reference.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Missing Linux Example Windows First
Summary:
The documentation page exhibits a bias toward Windows by explicitly noting that certain metrics are not supported or available for Linux plans, without providing Linux alternatives or guidance. Additionally, the documentation often describes features and metrics in the context of Windows or general App Service plans, with Linux-specific limitations mentioned as exceptions rather than being treated equally or first.
Recommendations:
  • Provide equivalent Linux examples or guidance where metrics or features are not supported, including workarounds or alternative monitoring strategies for Linux-based Azure Functions.
  • Clearly indicate feature parity (or lack thereof) in a dedicated section, and link to up-to-date tracking or roadmap items for Linux support.
  • Where features are unavailable on Linux, suggest best practices or third-party tools that Linux users can leverage for similar monitoring needs.
  • Avoid presenting Windows/App Service plan features as the default; instead, structure documentation to address both Windows and Linux scenarios equally, or lead with Linux where possible to balance historical bias.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/manage-connections.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows First Missing Linux Example
Summary:
The documentation provides code examples and configuration guidance primarily for C# (.NET) and JavaScript, but when discussing configuration files and connection strings, it references patterns and file names (such as 'local.settings.json' and 'Application settings') that are more familiar to Windows/Azure Portal users. There are no explicit Linux or cross-platform command-line examples (e.g., Bash, Linux environment variables), and the documentation does not mention Linux-specific tools or patterns for managing environment variables or configuration. The .NET examples dominate, and there is no mention of Linux shell usage or parity in configuration management.
Recommendations:
  • Include Linux/Bash shell examples for setting environment variables and managing configuration, especially for local development and deployment scenarios.
  • When referencing configuration files (like 'local.settings.json'), clarify how these are used or mapped in Linux environments, including deployment via CLI or containers.
  • Provide parity in code and configuration examples for both Windows and Linux environments, such as showing how to set connection strings using Azure CLI or environment variables in Bash.
  • Mention cross-platform tools (e.g., Azure CLI) and provide examples for both PowerShell (Windows) and Bash (Linux/macOS) where relevant.
  • Avoid assuming the reader is using Windows or the Azure Portal for configuration; explicitly address both Windows and Linux workflows.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/migrate-dotnet-to-isolated-model.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Powershell Heavy Windows Tools Missing Linux Example
Summary:
The documentation page demonstrates a Windows bias primarily by providing only Azure PowerShell scripts for identifying function apps, with no equivalent Bash, Azure CLI, or Linux-native instructions. References to Visual Studio (a Windows-centric tool) are present, and there is no mention of cross-platform alternatives for publishing or managing Azure Functions. The documentation assumes the use of Windows tooling and does not address Linux/macOS users or provide parity in examples or instructions.
Recommendations:
  • Provide equivalent Azure CLI (az) commands and Bash scripts for identifying and managing function apps, alongside PowerShell examples.
  • Explicitly mention and provide instructions for using cross-platform tools such as Visual Studio Code and Azure CLI for publishing and managing Azure Functions.
  • Where Visual Studio is referenced, add guidance for Linux/macOS users, such as using VS Code or command-line deployment methods.
  • Audit the documentation for other Windows-specific assumptions (e.g., file paths, environment variables) and ensure cross-platform compatibility is addressed.
  • Add a section or callouts clarifying that all steps can be performed on Linux/macOS, and link to relevant cross-platform tooling documentation.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/machine-learning-pytorch.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows First Powershell Heavy Windows Tools Missing Linux Example
Summary:
The documentation provides examples for Bash (Linux/macOS), PowerShell, and Cmd, but there are several indications of Windows bias. Windows-specific tools and patterns (like 'py' launcher, registry edits, and long path issues) are mentioned prominently, sometimes before or in more detail than their Linux equivalents. Troubleshooting tips focus on Windows-specific errors, and some commands (e.g., activating virtual environments) use Windows-first or Windows-specific syntax. Linux troubleshooting is minimal or absent.
Recommendations:
  • Ensure that Linux/macOS commands and troubleshooting steps are given equal prominence and detail as Windows examples.
  • When mentioning issues like long path errors, also include common Linux/macOS installation issues (e.g., permissions, missing packages, or path length limits on certain filesystems).
  • In prerequisite checks, mention both Linux/macOS and Windows commands together, or list Linux/macOS first in some sections to balance the order.
  • Provide Linux/macOS-specific troubleshooting tips, such as dealing with missing dependencies, permissions, or virtual environment activation issues.
  • Where Windows registry edits are mentioned, clarify that these are Windows-only and suggest analogous checks or solutions for Linux/macOS if applicable.
  • Review all code tabs to ensure that Bash (Linux/macOS) is always present and accurate, and that it is not treated as secondary to Windows shells.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/migrate-version-3-version-4.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Powershell Heavy Windows First Missing Linux Example
Summary:
The documentation page demonstrates a Windows bias primarily by providing only a PowerShell script to identify function apps to migrate, with no equivalent Bash, Azure CLI, or Linux-native example. The initial migration workflow references Azure PowerShell and Visual Studio (a Windows-centric tool) without mentioning cross-platform alternatives. There are no explicit Linux or Bash shell instructions for common tasks, and the only scripting example is PowerShell, which is less common on Linux. This can make the guide less accessible to users on Linux or macOS.
Recommendations:
  • Provide equivalent Bash and/or Azure CLI scripts alongside the PowerShell example for identifying function apps to migrate.
  • When referencing tools like Visual Studio, also mention cross-platform alternatives such as Visual Studio Code with Azure Functions extensions, or the Azure CLI for deployment.
  • Ensure that all scripting and command-line instructions are available in both Windows (PowerShell) and Linux/macOS (Bash/Azure CLI) formats.
  • Explicitly state that the migration process can be performed on Linux/macOS, and link to relevant cross-platform tooling documentation.
  • Review the documentation for other subtle Windows-first patterns (such as terminology or tool recommendations) and ensure Linux parity in all sections.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/openapi-apim-integrate-visual-studio.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows First Missing Linux Example Windows Tools Powershell Heavy
Summary:
The documentation is heavily biased towards Windows and Visual Studio on Windows. All instructions and examples assume the use of Visual Studio 2022, a Windows-only IDE, and reference Windows-specific publishing targets (e.g., Azure Function App (Windows)). There are no instructions or examples for Linux users, such as using VS Code, the Azure CLI, or cross-platform .NET tools. The use of the Package Manager Console (PowerShell-based) and NuGet commands is also presented in a way that assumes a Windows environment. No Linux or cross-platform alternatives are mentioned or prioritized.
Recommendations:
  • Provide equivalent instructions for Linux users, such as using Visual Studio Code or JetBrains Rider with the Azure Functions extension.
  • Include examples using the Azure CLI and/or Azure Functions Core Tools for project creation, extension installation, and deployment, which work cross-platform.
  • Show how to install NuGet packages using the dotnet CLI (e.g., 'dotnet add package ...'), which is cross-platform, instead of only using the Package Manager Console.
  • When describing publishing, include steps for deploying from Linux/macOS using the Azure CLI or GitHub Actions.
  • Avoid specifying 'Azure Function App (Windows)' as the only deployment target; mention Linux-based hosting plans and how to select them.
  • Add a 'Prerequisites' section for Linux/macOS, listing required tools and setup steps.
  • Where possible, use neutral terminology (e.g., 'terminal' instead of 'console') and avoid assuming the reader is using Windows.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/python-memory-profiler-reference.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows First Powershell Heavy Windows Tools
Summary:
The documentation demonstrates a Windows-first bias in several areas. In the instructions for setting up a Python virtual environment, Windows PowerShell is mentioned first, and the Windows-specific command (`py -m venv .venv`) is listed before the Linux equivalent. The activation command for the virtual environment also lists the Windows path and PowerShell command before the Linux shell alternative. Additionally, file paths in output examples use Windows-style backslashes (e.g., `<ProjectRoot>\HttpTriggerAsync\__init__.py`), and there is a general assumption of familiarity with Windows tools and conventions throughout the guide.
Recommendations:
  • Present Linux and Windows instructions side-by-side or in parallel, rather than listing Windows first.
  • Use neutral or platform-agnostic language where possible (e.g., 'Open a terminal' instead of 'Open a Windows PowerShell or any Linux shell as you prefer').
  • Show both Windows and Linux commands together, or use tabbed sections for each OS.
  • Include Linux-style file paths in output examples, or provide both Windows and Linux variants.
  • Explicitly mention macOS where relevant, as it often shares commands with Linux.
  • Avoid assuming the use of Windows-specific tools or shells unless the guide is explicitly for Windows users.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/storage-considerations.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows First Powershell Heavy Missing Linux Example
Summary:
The documentation demonstrates some Windows bias. In several sections, Windows-specific plans and settings are mentioned before Linux equivalents, and PowerShell examples are provided alongside Azure CLI, but there is a lack of Linux shell (bash) or cross-platform scripting examples. Some features and limitations are described in terms of their Windows applicability first, and Linux-specific guidance is sometimes relegated to later sections or notes. There are also areas where Linux-specific instructions or parity are missing or less detailed.
Recommendations:
  • Provide Linux (bash) command-line examples alongside PowerShell, especially in sections about mounting file shares and configuring app settings.
  • When describing features or limitations, present both Windows and Linux information together, or clarify applicability in a parallel structure (e.g., 'On Windows... On Linux...').
  • Ensure that all settings and deployment options are explained for both Windows and Linux hosting plans, including any differences in behavior or support.
  • Add more explicit Linux-focused troubleshooting and configuration guidance, particularly for storage and deployment scenarios.
  • Where features are Windows-only or Linux-only, clearly label them and provide alternative recommendations for the other platform.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/migrate-version-1-version-4.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Powershell Heavy Windows Tools Missing Linux Example
Summary:
The documentation provides only a PowerShell script to identify function apps for migration, with no equivalent Bash, Azure CLI, or Linux-native instructions. The use of PowerShell and references to Visual Studio (a primarily Windows tool) suggest a Windows-centric approach. There are no Linux or cross-platform command-line examples for key migration steps, which may hinder users on Linux or macOS.
Recommendations:
  • Provide equivalent Azure CLI or Bash scripts alongside PowerShell examples for identifying function apps and other automation steps.
  • Explicitly mention cross-platform tools (e.g., Azure CLI, VS Code) and provide instructions for their use where appropriate.
  • Ensure that all code and command-line examples are available for both Windows and Linux/macOS environments.
  • Where Visual Studio is referenced, also mention Visual Studio Code and/or CLI-based deployment options for non-Windows users.
  • Add a note clarifying that PowerShell Core is available cross-platform, but still provide native Bash/Azure CLI alternatives for Linux users.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/run-functions-from-deployment-package.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows First Windows Tools Powershell Heavy Missing Linux Example
Summary:
The documentation page exhibits a Windows-first bias in several areas: Windows paths and terminology are consistently mentioned before Linux equivalents, and some deployment instructions and troubleshooting notes reference Windows-specific tools or behaviors (e.g., MSDeploy, c:\ paths) without providing Linux-specific alternatives or examples. There are no explicit Linux command-line or shell examples, and the documentation assumes familiarity with Windows conventions. Linux deployment nuances are mentioned, but not with the same level of detail or parity as Windows.
Recommendations:
  • Alternate the order of Windows and Linux references throughout the documentation, or present Linux examples first in some sections.
  • Provide explicit Linux shell (bash) command examples alongside any Windows/Powershell commands or references.
  • Include Linux-specific troubleshooting steps and tool recommendations (e.g., alternatives to MSDeploy or Windows file paths).
  • Clarify any differences in deployment workflows or behaviors between Windows and Linux, and ensure both are covered equally.
  • Where file paths are mentioned, use a neutral format or present both Windows and Linux paths together, not always with Windows first.
  • Add examples of using Linux-native tools (such as az CLI, curl, or scp) for uploading and managing deployment packages.
  • Ensure that all features and settings are explained with Linux parity, including any limitations or best practices specific to Linux environments.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/update-language-versions.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows First Missing Linux Example Windows Tools
Summary:
The documentation page demonstrates a 'Windows-first' bias in several areas: Windows instructions and examples are consistently presented before Linux equivalents, especially in the stack configuration update sections. Some language/platform combinations (e.g., Python on Windows) are explicitly unsupported, but the documentation does not always provide Linux alternatives in those cases. Additionally, the use of Azure portal and Azure CLI is mostly platform-agnostic, but the CLI examples for updating stack versions are more detailed for Windows, and Linux-specific details are sometimes relegated to notes or require extra navigation. There is also an implicit bias in the structure, where Windows is the default or primary path, and Linux is secondary.
Recommendations:
  • Present Windows and Linux instructions/examples in parallel or with equal prominence, rather than always listing Windows first.
  • Where a language/platform combination is unsupported (e.g., Python on Windows), provide a direct Linux example or link, rather than just instructing the user to switch tabs.
  • Ensure that CLI examples for Linux are as detailed and explicit as those for Windows, including full command examples for all supported languages.
  • Where limitations exist (e.g., Linux Consumption plan restrictions), provide clear alternative steps or workarounds for Linux users.
  • Consider a structure where the user selects their OS first, then sees language-specific instructions, to avoid implicit prioritization of Windows.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/recover-python-functions.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows First Powershell Heavy Windows Tools Missing Linux Example
Summary:
The documentation demonstrates a mild Windows bias in several areas: Windows commands and tools (such as PowerShell and 'py') are often mentioned before or in more detail than their Linux equivalents. Some instructions and examples are Windows-centric or lack parity in Linux-specific guidance. While Linux is acknowledged as the Azure Functions runtime environment, and some Unix-like examples are present, the documentation could better balance platform representation, especially in command-line instructions and troubleshooting steps.
Recommendations:
  • Ensure all command-line examples are provided for both Windows (PowerShell/CMD) and Linux/macOS (Bash), and present them in parallel or with equal prominence.
  • When referencing tools like 'py' (Windows Python launcher), also mention 'python3' for Linux/macOS, and clarify which platforms each applies to.
  • Avoid listing Windows commands or tools first by default; alternate the order or present both together.
  • Where platform-specific issues are discussed (e.g., pywin32), provide equivalent Linux/macOS troubleshooting steps or explicitly state if none exist.
  • Expand on Linux-native tools and workflows (e.g., using Bash, Linux file paths, package managers) where relevant.
  • Audit all sections for missing Linux/macOS examples, especially in deployment, troubleshooting, and environment setup instructions.
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/set-runtime-version.md [View Details]
Scanned: 2025-07-08 04:23 • Page-level bias detected
▼

Page-Level Analysis

Windows First Powershell Heavy Windows Tools Missing Linux Example
Summary:
The documentation exhibits a mild Windows bias. PowerShell examples and references to Visual Studio are present, and PowerShell is given as a first-class scripting option alongside Azure CLI. While the article uses platform pivots to separate Windows and Linux content, some sections (such as PowerShell commands and Visual Studio notes) are only present for Windows, with no Linux equivalents or alternatives. Additionally, the documentation sometimes presents Windows-specific tools and workflows (e.g., .csproj editing, Visual Studio dialogs) without Linux or cross-platform alternatives, and PowerShell is presented as a primary automation tool, which is less common on Linux.
Recommendations:
  • Where PowerShell examples are given, provide equivalent Bash or shell script examples for Linux users.
  • When referencing Visual Studio or .csproj file edits, mention cross-platform alternatives such as Visual Studio Code or editing project files manually.
  • Ensure that all automation and scripting examples are available in both PowerShell and Bash/shell script formats, or clearly indicate which platforms each example applies to.
  • Where possible, avoid presenting Windows tools or workflows before Linux equivalents; instead, present both options together or in parallel.
  • Add more explicit guidance for Linux users in sections where only Windows-specific instructions or tools are currently described.