Azure Functions
711
Total Pages
610
Linux-Friendly Pages
101
Pages with Bias
14.2%
Bias Rate
Bias Trend Over Time
Pages with Bias Issues
233 issues found
Showing 26-50 of 233 flagged pages
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/how-to-create-function-azure-cli.md
...es/azure-functions/how-to-create-function-azure-cli.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation shows some Windows bias, particularly in the ordering and selection of shell examples. In the Java section, command examples are provided for Bash, PowerShell, and Cmd, with Bash not always listed first. PowerShell and Cmd (Windows-specific shells) are given equal prominence to Bash, and in some cases, PowerShell is listed before Bash. There are also references to 'command prompt' and 'PowerShell' throughout, and no explicit Linux-specific instructions or troubleshooting. The use of Windows-style paths (e.g., _\src\main\java\com\fabrikam_) in Java examples further reinforces the bias. There are no explicit Linux/Mac-specific troubleshooting notes or guidance, and no mention of common Linux tools beyond jq and Azure CLI.
Recommendations
- Ensure Bash (Linux/macOS) examples are always listed first, with PowerShell and Cmd clearly marked as Windows-only.
- Where file paths are shown, provide both Windows (\) and POSIX (/) path examples, or use POSIX paths by default.
- Add explicit notes or troubleshooting for Linux/macOS users, especially around environment variables, permissions, and common issues.
- Review all references to 'command prompt' and clarify when it means Windows Command Prompt versus a generic terminal.
- Where possible, provide parity in shell scripting examples (e.g., Bash scripts for Linux/macOS, PowerShell for Windows) and highlight cross-platform commands.
- Mention Linux tools and patterns (e.g., use of export for environment variables, common text editors) where relevant.
Create Pull Request
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/how-to-create-function-vs-code.md
...cles/azure-functions/how-to-create-function-vs-code.md
High Priority
View Details →
Detected Bias Types
Windows Tools
Windows First
Powershell Heavy
Missing Linux Example
Summary
The documentation shows some Windows bias, primarily by referencing Windows tools and patterns, mentioning Windows-specific instructions before Linux equivalents, and focusing on PowerShell as a language. Some sections (e.g., troubleshooting) call out Windows-specific issues, and PowerShell is treated as a first-class language alongside cross-platform options. There are also places where Linux-specific instructions are less detailed or are presented after Windows instructions.
Recommendations
- Ensure all platform-specific instructions are presented in parallel, with equal detail for Windows, Linux, and macOS.
- Where PowerShell is referenced, clarify its cross-platform availability and provide Bash/zsh equivalents where appropriate.
- Avoid phrases like 'When running on Windows...' unless there is a true platform-specific difference; otherwise, clarify for all platforms.
- In troubleshooting and setup sections, include Linux/macOS-specific guidance (e.g., default shell issues, permissions) alongside Windows.
- For custom handler compilation, consider presenting Linux/macOS instructions before Windows, or group them equally.
- Add explicit Linux/macOS examples for any command-line or tool usage, not just Windows (e.g., for setting environment variables).
- Review all links and references to ensure they do not default to Windows-only documentation or installers.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/manage-connections.md
...ob/main/articles/azure-functions/manage-connections.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Windows Tools
Summary
The documentation page demonstrates a Windows/.NET bias by providing only .NET (C#) and JavaScript examples, with a heavy focus on .NET libraries and patterns (e.g., HttpClient, SqlClient, ADO.NET, Entity Framework). There are no examples or mentions of Linux-specific tools, patterns, or languages (such as Python or Java), nor are there any references to Linux-specific configuration or troubleshooting. The configuration file references (e.g., local.settings.json) are generic, but the overall guidance and code samples are Windows/.NET-centric.
Recommendations
- Add code examples for additional languages commonly used on Linux, such as Python and Java, especially for HTTP and database client usage.
- Include references to Linux-native tools, patterns, or configuration files where relevant (e.g., environment variables, .env files, or Linux-based troubleshooting steps).
- Ensure that any mention of configuration files or application settings includes Linux development workflows (e.g., using environment variables in bash, or settings for local development on Linux).
- Provide parity in code samples and explanations for both Windows/.NET and Linux/open-source stacks, making it clear that the guidance applies cross-platform.
- Mention and link to Linux-specific documentation or best practices where appropriate.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/ip-addresses.md
...ocs/blob/main/articles/azure-functions/ip-addresses.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Summary
The documentation page exhibits a mild Windows bias. It consistently presents Azure PowerShell examples alongside Azure CLI, and in some cases, PowerShell is given its own section. The only local utility mentioned for finding inbound IP addresses is 'nslookup', which is available on Windows by default but not always on Linux/macOS. There is no mention of Linux-specific tools (e.g., 'dig'), and the documentation does not clarify parity or differences for Linux/macOS users. The Azure portal and Resource Explorer are also Windows-centric in their presentation.
Recommendations
- Add Linux/macOS command-line examples (e.g., using 'dig' for DNS lookups) alongside or before 'nslookup'.
- Explicitly state that 'nslookup' is available on most platforms, but provide alternatives for Linux/macOS users.
- Where Azure PowerShell is shown, clarify that it is cross-platform, or provide Bash/Azure CLI equivalents first.
- Review all instructions to ensure that Linux and macOS users are equally supported and not implicitly deprioritized.
- Consider adding a note or tab for Linux/macOS users in sections where command-line utilities are referenced.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/machine-learning-pytorch.md
...n/articles/azure-functions/machine-learning-pytorch.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Summary
The documentation provides both Linux (bash) and Windows (PowerShell, Cmd) command examples in most sections, but Windows-specific tools and patterns are often mentioned first or more prominently. For example, the Python version check lists the Windows command ('py --version') after the Linux/macOS command, but the PowerShell and Cmd tabs are always present and sometimes precede bash. Windows-specific troubleshooting (e.g., long path errors and registry edits) is included, while Linux-specific troubleshooting is minimal. Visual Studio Code is recommended as the editor, which is cross-platform, but no mention is made of Linux-preferred editors. The use of 'py' (the Windows Python launcher) is shown in PowerShell/Cmd examples, while bash uses 'python'.
Recommendations
- Ensure that Linux (bash) examples are always presented first, or at least alternate the order with Windows examples.
- Provide Linux-specific troubleshooting tips where appropriate, such as common permission issues or package installation errors.
- Mention popular Linux editors (e.g., Vim, Emacs, Gedit) alongside Visual Studio Code to acknowledge Linux developer preferences.
- When referencing the Python launcher, clarify that 'py' is Windows-specific and 'python' is used on Linux/macOS.
- Include a note that all steps are equally supported on Linux, and highlight any platform-specific differences explicitly.
- Add Linux-specific error messages or solutions if any are common (e.g., missing dependencies, virtual environment activation issues).
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/migrate-dotnet-to-isolated-model.md
...es/azure-functions/migrate-dotnet-to-isolated-model.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows Tools
Missing Linux Example
Windows First
Summary
The documentation demonstrates a Windows bias by exclusively providing Azure PowerShell scripts for identifying function apps, without offering Bash/CLI or cross-platform alternatives. It references Visual Studio and VS Code for tooling and deployment, which are predominantly used on Windows, and does not mention Linux/macOS equivalents or workflows. There are no explicit Linux shell or Azure CLI examples, and the initial scripting guidance assumes a Windows/PowerShell environment.
Recommendations
- Provide equivalent Azure CLI (az) and/or Bash shell examples alongside PowerShell scripts for identifying and managing function apps, ensuring cross-platform accessibility.
- Explicitly mention that Azure CLI and Bash can be used on Linux/macOS, and provide links or references to relevant documentation.
- Include deployment and configuration instructions using cross-platform tools (e.g., Azure CLI, GitHub Actions, or VS Code on Linux/macOS) in addition to Visual Studio.
- When referencing editor or IDE settings, clarify how to perform these actions on Linux/macOS (e.g., VS Code settings on Linux, or alternatives to Visual Studio).
- Review all scripting and automation steps to ensure parity for Linux/macOS users, and add tabs or callouts for platform-specific instructions where necessary.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/migrate-version-3-version-4.md
...rticles/azure-functions/migrate-version-3-version-4.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows Tools
Windows First
Missing Linux Example
Summary
The documentation shows Windows bias by providing only a PowerShell script to identify function apps for migration, without any equivalent Bash or cross-platform CLI example. Windows/PowerShell tools are mentioned first and exclusively in key migration steps, and there is no mention of Linux-specific tools or instructions for this critical discovery step. This could hinder Linux/macOS users who do not use PowerShell.
Recommendations
- Provide equivalent Bash (Azure CLI) scripts alongside PowerShell for identifying function apps to migrate, ensuring cross-platform parity.
- When referencing scripts or tools, mention both Windows and Linux/macOS options, or clarify cross-platform compatibility.
- If PowerShell is required, explicitly note its availability on Linux/macOS and provide installation guidance or alternatives.
- Review other steps for similar bias and ensure all critical migration actions have both Windows and Linux/macOS instructions or examples.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/openapi-apim-integrate-visual-studio.md
...zure-functions/openapi-apim-integrate-visual-studio.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Windows Tools
Summary
The documentation is heavily focused on Windows and Visual Studio, with all instructions and examples tailored to the Windows platform. There are no mentions of Linux-compatible tools, editors, or workflows, and the publishing process explicitly targets 'Azure Function App (Windows)'. The use of Visual Studio and NuGet Package Manager Console (which is Windows-centric) further excludes Linux users. No alternative instructions for Linux or cross-platform development environments are provided.
Recommendations
- Add equivalent instructions for developing and deploying Azure Functions using cross-platform tools such as Visual Studio Code or the Azure Functions Core Tools CLI.
- Include Linux-specific setup steps, such as using dotnet CLI and VS Code for project creation, extension installation, and local testing.
- Provide examples of publishing to 'Azure Function App (Linux)' and clarify platform choices during deployment.
- Mention and demonstrate how to use the Azure Portal, Azure CLI, or GitHub Actions for deployment, which are platform-agnostic.
- Ensure all code and configuration steps are compatible with both Windows and Linux environments, and explicitly note any platform-specific differences.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/opentelemetry-howto.md
...b/main/articles/azure-functions/opentelemetry-howto.md
High Priority
View Details →
Detected Bias Types
Windows Tools
Powershell Heavy
Windows First
Summary
The documentation page demonstrates some Windows bias. It references Windows-specific tools and patterns, such as using the Windows command prompt (`cmd`) for .NET package installation and PowerShell for module installation. The PowerShell section provides explicit instructions using PowerShell commands and module management, while there are no equivalent Linux shell (bash) or cross-platform instructions for these steps. The .NET examples use `dotnet add package` commands, which are cross-platform, but the command prompt syntax (`cmd`) is used. There are no explicit Linux or bash shell examples, and the PowerShell section is detailed, reinforcing a Windows-centric approach. Additionally, the order of language pivots often places Windows-centric languages (C#, PowerShell) before others.
Recommendations
- Add explicit bash/zsh shell examples for package installation and module management, especially for .NET and PowerShell sections.
- Where PowerShell commands are shown, provide equivalent bash or cross-platform alternatives, or clarify when instructions are Windows-only.
- Use neutral or cross-platform shell prompts (e.g., $ for bash, > for PowerShell) and clarify which platforms each example applies to.
- Ensure Linux/macOS users are guided on how to install dependencies and configure their environments, especially for PowerShell and .NET scenarios.
- Review the order of language pivots to avoid consistently prioritizing Windows-centric languages.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/python-memory-profiler-reference.md
...es/azure-functions/python-memory-profiler-reference.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Summary
The documentation demonstrates a mild Windows bias. In the local development section, Windows PowerShell is mentioned first, and Windows-specific commands (e.g., 'py -m venv .venv', '.venv\Scripts\Activate.ps1') are presented before their Linux equivalents. The file path separator in the sample output uses backslashes (\), which is Windows-specific. There is also a slight emphasis on Windows tools and patterns, such as referencing PowerShell explicitly and using Windows-style paths in examples.
Recommendations
- Present Linux and Windows commands side-by-side or in parallel tabs, rather than listing Windows first.
- Use platform-agnostic language when referring to shells (e.g., 'terminal' instead of 'PowerShell or Linux shell').
- Show both Windows and Linux file paths in sample outputs, or clarify that the path format may differ by OS.
- Ensure that Linux (and macOS) users see their commands and patterns with equal prominence and clarity.
- Consider adding a table or section summarizing all platform-specific commands for quick reference.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/recover-python-functions.md
...n/articles/azure-functions/recover-python-functions.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation exhibits mild Windows bias in several areas. Windows tools and patterns (e.g., PowerShell commands, 'py' launcher, Windows-first instructions) are often mentioned before or alongside their Linux equivalents. Some examples and troubleshooting steps prioritize Windows commands or tools, and Linux-specific guidance is sometimes less detailed or omitted. There is also a tendency to reference Windows development environments and workflows (e.g., Visual Studio Code, pip freeze from Windows), with less emphasis on Linux-native approaches.
Recommendations
- Ensure that Linux and macOS examples are provided alongside Windows/PowerShell commands, and that they appear with equal prominence.
- When referencing command-line instructions (e.g., checking Python bitness, deleting directories), present Linux/Bash examples first or at least equally.
- Include explicit guidance for common Linux development workflows, such as using Linux package managers, Python environment management, and deployment from Linux systems.
- Avoid assuming Windows as the default local development environment; clarify cross-platform differences and best practices for Linux users.
- Where platform-specific issues are discussed (e.g., pip freeze, pywin32), provide actionable Linux alternatives and highlight Linux compatibility considerations.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/scenario-blob-storage-events.md
...ticles/azure-functions/scenario-blob-storage-events.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Summary
The documentation shows a moderate Windows bias. Visual Studio Code is the only editor mentioned, and the workflow is tightly coupled to its command palette and extensions. Windows-specific instructions and terminology (such as references to 'Cmd', 'func.exe', and PowerShell) are present. In the Python section, Windows instructions are split into 'Windows (bash)' and 'Windows (Cmd)', and the troubleshooting note specifically references Windows/WSL. The use of the Azurite emulator and Azure Functions Core Tools is cross-platform, but the documentation does not always clarify Linux/macOS equivalents or highlight parity. There are no explicit Linux-only tools or workflows, and Windows patterns are sometimes mentioned first or exclusively.
Recommendations
- Add explicit instructions and troubleshooting notes for Linux/macOS users where only Windows is mentioned (e.g., default terminal issues, process names).
- When listing platform-specific steps (such as activating Python virtual environments), present Linux/macOS instructions first or in parallel with Windows, not after.
- Where PowerShell is referenced, clarify if Bash/zsh equivalents exist and provide them.
- Mention and link to cross-platform alternatives for any Visual Studio Code extensions or features that may not be available or work identically on Linux/macOS.
- Avoid using Windows-specific process names (e.g., 'func.exe') in generic instructions; use platform-neutral terms.
- Include a short section or callout at the top clarifying that all steps are supported on Linux/macOS, and highlight any differences or limitations.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/scenario-database-changes-azure-cosmosdb.md
...-functions/scenario-database-changes-azure-cosmosdb.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Powershell Heavy
Summary
The documentation demonstrates a moderate Windows bias. Windows-specific tools and patterns (such as PowerShell commands and references to the Windows command prompt) are mentioned explicitly and sometimes before or more prominently than their Linux equivalents. There is a specific warning about not using WSL Bash as the default terminal on Windows, and the PowerShell execution policy command is provided for Windows, while Linux/macOS users are simply told to chmod scripts. The document also refers to stopping the 'func.exe' process, which is a Windows-specific executable name. Linux instructions are present but sometimes less detailed or secondary.
Recommendations
- Ensure Linux/macOS and Windows instructions are presented with equal prominence and detail, ideally side-by-side or in parallel tabs.
- Where PowerShell or Windows command prompt commands are given, provide equivalent Bash or shell commands for Linux/macOS users.
- Avoid Windows-specific terminology (e.g., 'func.exe') when cross-platform alternatives exist; use generic terms like 'func' or 'host process'.
- Add troubleshooting notes for Linux/macOS users, similar to the WSL Bash note for Windows.
- Review all examples and ensure that Linux/macOS users are not required to infer steps from Windows instructions.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/set-runtime-version.md
...b/main/articles/azure-functions/set-runtime-version.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation demonstrates a moderate Windows bias. Windows and PowerShell examples are consistently presented before Linux equivalents, and PowerShell is included as a first-class method for managing settings, while Linux-specific command-line tools (other than Azure CLI) are not mentioned. Some instructions (e.g., portal steps) are not clearly differentiated for Linux, and Linux users are sometimes directed to use Azure CLI exclusively, with no mention of Bash scripting or other Linux-native approaches. The documentation also references Visual Studio and .csproj files, which are primarily Windows-centric development tools, without Linux alternatives.
Recommendations
- Present Linux and Windows instructions in parallel, or alternate which platform appears first in each section.
- Include Bash or shell script examples for Linux users where PowerShell is provided for Windows.
- Clarify any differences in portal UI or workflow for Linux-hosted function apps.
- When referencing Visual Studio or .csproj, provide equivalent instructions for Linux-friendly tools (e.g., VS Code, command-line publishing).
- Explicitly state when a method (e.g., PowerShell) is not available for Linux, and suggest alternatives.
- Add more Linux-native context and troubleshooting tips, not just Azure CLI commands.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/storage-considerations.md
...ain/articles/azure-functions/storage-considerations.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation exhibits a moderate Windows bias. Windows-specific plans and behaviors are often mentioned first or exclusively (e.g., Consumption plan (Windows only)), and PowerShell is referenced as a supported language for managed dependencies without equivalent mention of Bash or other Linux scripting. In several sections, Windows deployment patterns and tools are described before their Linux equivalents, and some examples (such as log streaming and file share mounting) are more detailed for Windows or PowerShell. Linux-specific instructions are present but often isolated or less emphasized. There are also cases where Linux examples are missing or less comprehensive.
Recommendations
- Ensure that Linux and Windows instructions/examples are presented with equal prominence and detail throughout the documentation.
- When referencing PowerShell or Windows-specific features, provide equivalent Bash/CLI or Linux-native alternatives where possible.
- Avoid phrasing such as 'Windows only' without immediately clarifying Linux support or alternatives.
- Add Linux-specific troubleshooting and deployment guidance where only Windows is currently covered.
- For every PowerShell example, include a Bash/Azure CLI equivalent, especially in sections about mounting shares, configuring settings, or deploying apps.
- Review the order of presentation so that Linux and Windows are treated equally (e.g., do not always list Windows first).
Azure Functions
Azure Functions Core Tools reference
...cles/azure-functions/functions-core-tools-reference.md
Medium Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Summary
The documentation is generally cross-platform and describes Azure Functions Core Tools commands in an OS-agnostic way. However, there are several subtle biases: (1) Windows/Windows-specific issues are often mentioned first or exclusively, such as warnings about Python packaging on Windows and references to the creation of trusted certificates 'on your computer' (which is a Windows-centric pattern); (2) Some terminology and examples (e.g., .pfx certificates, trusted certificate creation, and references to the Microsoft Azure Storage Emulator) are more familiar to Windows users and may lack Linux/macOS equivalents or clarifications. There are no explicit PowerShell-heavy examples, but some Windows tools and patterns are referenced without always providing Linux/macOS alternatives.
Recommendations
- Wherever Windows-specific issues are mentioned (e.g., Python packaging), provide equivalent Linux/macOS guidance or clarify when the issue is Windows-only.
- When referencing tools like the Microsoft Azure Storage Emulator, add notes about the Linux/macOS alternatives (e.g., Azurite) and link to their documentation.
- When mentioning certificate generation or trusted certificate creation, clarify the behavior on Linux/macOS (e.g., how self-signed certificates are handled, or if user action is required).
- Ensure that all examples and warnings are explicitly cross-platform or provide platform-specific notes as needed.
- Consider adding a short section at the top clarifying that all commands are cross-platform unless otherwise noted, and link to any OS-specific setup guides.
Azure Functions
Quickstart: Create a Durable Functions app that uses the MSSQL storage provider
...n/articles/azure-functions/durable/quickstart-mssql.md
Medium Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows First
Missing Linux Example
Summary
The documentation demonstrates a notable Windows/PowerShell bias, especially in the local SQL Server setup section. All Docker setup commands are provided only in PowerShell, and there are no equivalent Bash or shell script examples for Linux/macOS users. The text references installing PowerShell on all platforms, but this is not the native or most common shell for Linux/macOS users. Additionally, the order and language of instructions frequently assume a Windows/PowerShell context first, with Linux alternatives as an afterthought or omitted.
Recommendations
- Provide equivalent Bash/shell script examples for Docker-based SQL Server setup, including database creation and validation, alongside the PowerShell examples.
- Explicitly show how to run the Docker and sqlcmd commands in a native Linux/macOS terminal (e.g., using bash variables and syntax).
- Clarify that PowerShell is not required on Linux/macOS and that all steps can be performed in Bash or zsh.
- When referencing tools or commands (e.g., Visual Studio Code, Docker), note any platform-specific differences or prerequisites.
- In all code blocks, provide both PowerShell and Bash versions where applicable, or use a more platform-agnostic approach.
Azure Functions
Deployment technologies in Azure Functions
...s/azure-functions/functions-deployment-technologies.md
Medium Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Summary
The documentation provides deployment guidance for Azure Functions across multiple platforms, but Windows-centric tools (Visual Studio, Azure CLI, references to Kudu/scm) are often mentioned first or exclusively in example lists. Linux-specific guidance is present, but Windows tools and terminology (e.g., Visual Studio, Kudu, 'Windows-only' deployment options) are prioritized or explained in greater detail. Some deployment technologies (FTPS, Local Git, Source Control) are noted as 'Windows-only' without Linux alternatives or workarounds being clearly described.
Recommendations
- Ensure Linux/macOS equivalents are always mentioned alongside Windows tools, especially in example lists and 'How to use it' sections.
- Provide explicit Linux/macOS command-line examples (e.g., Bash, Core Tools usage) where only Windows/PowerShell or Visual Studio are referenced.
- Clarify when a deployment method is Windows-only and offer alternative Linux/macOS approaches or links to relevant Linux documentation.
- Consider reordering example lists so that cross-platform tools (e.g., Azure Functions Core Tools, Azure CLI) are mentioned before Windows-specific tools.
- Add more detail on Linux-specific deployment behaviors and troubleshooting, especially for methods marked 'Windows-only'.
Azure Functions
Migrate C# app from in-process to isolated worker model
...es/azure-functions/migrate-dotnet-to-isolated-model.md
Medium Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows First
Summary
The documentation provides only Azure PowerShell scripts for identifying function apps to migrate, without offering equivalent Azure CLI or Bash examples. PowerShell is primarily used on Windows, and presenting it as the sole option creates friction for Linux/macOS users. Additionally, PowerShell instructions are given first and exclusively, reinforcing a Windows-first bias.
Recommendations
- Add Azure CLI (az) examples alongside PowerShell scripts for identifying function apps to migrate.
- Explicitly mention that either PowerShell or Azure CLI can be used, and provide guidance for both environments.
- Where possible, provide Bash shell script examples for steps that involve scripting or automation.
- Ensure that instructions for updating app settings, deploying, and managing slots reference cross-platform tools (e.g., Azure CLI, VS Code) in addition to Visual Studio and PowerShell.
Azure Functions
Migrate Consumption plan apps to Flex Consumption in Azure Functions
...unctions/migration/migrate-plan-consumption-to-flex.md
Medium Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Missing Linux Example
Summary
The documentation provides both Windows and Linux migration paths, but Windows/PowerShell/Azure CLI examples and instructions are often presented first or in more detail. Some migration steps and CLI commands are more thoroughly documented for Windows users, and certain sections (such as premigration tasks and manual migration) are Windows-centric, with Linux instructions sometimes relegated to pivots or less prominent sections. The Linux migration process is described as more automated, but the overall guidance and troubleshooting are more detailed for Windows users.
Recommendations
- Ensure Linux and Windows instructions/examples are presented with equal prominence and detail, ideally side-by-side or with clear pivots.
- Expand Linux-specific troubleshooting and manual migration steps to match the depth provided for Windows.
- Where CLI commands differ, provide explicit Linux and Windows variants in every relevant section.
- Add more Linux-specific examples for infrastructure-as-code (IaC) migration, troubleshooting, and rollback.
- Review the order of presentation so that Linux is not consistently secondary to Windows.
Azure Functions
Deployment technologies in Azure Functions
...s/azure-functions/functions-deployment-technologies.md
Medium Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Missing Linux Example
Summary
The documentation generally aims for cross-platform coverage, but there are subtle Windows biases. Windows-based deployment methods (such as source control, local Git, FTPS) are called out in the technology availability table before Linux equivalents, and some deployment instructions (e.g., remote build, zip deploy) mention Windows scenarios first or in more detail. There is a tendency to reference Visual Studio (Windows-only) and PowerShell/CLI tools before Linux-native workflows. Some Linux-specific deployment limitations are mentioned, but Linux examples and workflows are less detailed or presented after Windows ones.
Recommendations
- Ensure Linux deployment examples are given equal prominence and detail as Windows examples, especially for zip deploy and remote build.
- When listing deployment technologies, alternate or group by OS rather than listing Windows-first.
- Provide explicit Linux/macOS command-line examples where possible, not just generic Azure CLI or Visual Studio references.
- Clarify when a deployment method is cross-platform and provide links to Linux/macOS setup guides.
- Highlight Linux-specific tools and workflows (e.g., Oryx, Docker, bash scripts) alongside Windows tools.
Azure Functions
Azure Functions Core Tools reference
...cles/azure-functions/functions-core-tools-reference.md
Medium Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Missing Linux Example
Summary
The documentation for Azure Functions Core Tools is generally cross-platform, but several areas show Windows bias. Windows-specific issues (such as Python packaging problems on Windows) are called out, but Linux/macOS equivalents or best practices are not always equally emphasized. The 'managed-dependencies' option is noted as PowerShell-only, but Linux alternatives are not discussed. Some examples and notes (e.g., certificate creation for HTTPS) assume Windows defaults and do not clarify Linux/macOS differences. There is a lack of explicit Linux/macOS command-line examples, troubleshooting, or parity notes, especially for tasks like Docker usage, certificate management, and remote builds.
Recommendations
- Add explicit Linux/macOS command-line examples and troubleshooting notes for common tasks (e.g., Docker usage, certificate management, remote builds).
- Where Windows-specific issues are called out (e.g., Python packaging), provide Linux/macOS best practices and highlight differences.
- Clarify when options or behaviors differ on Linux/macOS (e.g., certificate creation for HTTPS, local encryption of settings).
- Ensure parity in examples and recommendations for PowerShell and other language runtimes, including Linux/macOS equivalents where applicable.
- Consider adding a section summarizing cross-platform considerations and linking to OS-specific guidance.
Azure Functions
Azure Functions networking options
...ticles/azure-functions/functions-networking-options.md
Medium Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation generally maintains platform neutrality, but there are several areas where Windows bias is evident. Hybrid Connections are explicitly Windows-only, and this is clearly stated. However, in the section on enabling dynamic scale monitoring for virtual network triggers, PowerShell and Azure CLI examples are provided, but the PowerShell example is shown after the CLI. There are no Linux/macOS-specific command examples or troubleshooting steps, and some subnet sizing recommendations mention Windows before Linux. The troubleshooting and automation sections reference Azure CLI and PowerShell, but do not mention Bash or Linux-specific tools. The overall impact is moderate, as Linux users can still complete most tasks, but may need to adapt instructions or seek additional guidance.
Recommendations
- Provide Linux/macOS-specific command examples where relevant, especially for automation and troubleshooting.
- When listing command-line examples, alternate or parallelize Azure CLI and PowerShell, and clarify cross-platform compatibility.
- In subnet sizing recommendations, present Windows and Linux requirements in parallel rather than listing Windows first.
- Add troubleshooting guidance for Linux/macOS environments where applicable.
- Explicitly note when a feature (like Hybrid Connections) is Windows-only, as is already done, and provide alternative solutions for Linux users if possible.
Azure Functions
Deployment technologies in Azure Functions
...s/azure-functions/functions-deployment-technologies.md
Medium Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Summary
The documentation generally covers both Windows and Linux deployment options for Azure Functions, but there is a subtle Windows bias. Windows-based deployment technologies (such as Kudu/SCM, source control, Local Git, FTPS) are mentioned as 'Windows-only' in several places, and examples or tool references (Visual Studio, Azure CLI) are often presented without explicit Linux alternatives or parity. In some sections, Windows deployment mechanisms are described first or in more detail, while Linux-specific instructions (such as required environment variables for remote build) are presented later or as exceptions. There are few direct Linux command-line examples, and some deployment methods (source control, Local Git, FTPS) are not available for Linux Consumption plan users, but this is a platform limitation rather than a documentation bias.
Recommendations
- Provide explicit Linux/macOS command-line examples alongside Windows/PowerShell ones, especially for Azure CLI and Core Tools usage.
- Clarify tool parity for Linux users (e.g., Visual Studio Code, Azure CLI, Core Tools) and highlight any differences in workflow or prerequisites.
- Where deployment methods are Windows-only due to platform limitations, clearly state this is a product constraint, not a documentation gap.
- Add more guidance for Linux users on alternative deployment strategies when Windows-only methods are unavailable (e.g., using zip deploy or containers).
- Consider reordering sections so that Linux and Windows deployment options are presented with equal prominence.
Azure Functions
Monitor executions in Azure Functions
.../main/articles/azure-functions/functions-monitoring.md
Medium Priority
View Details →
Detected Bias Types
Missing Linux Example
Windows Tools
Summary
The documentation is generally cross-platform and avoids Windows-specific bias in most sections. However, there are a few areas where Linux parity is lacking: performance counters are noted as unsupported on Linux, and the built-in log streaming method is unavailable for Linux Consumption plan apps. These limitations are mentioned, but no Linux alternatives or workarounds are provided. There is also a slight bias in referencing Windows-centric tools (App Service platform log streaming) without offering equivalent Linux guidance.
Recommendations
- For sections where features are unavailable on Linux (e.g., performance counters, built-in log streaming for Consumption plan), provide Linux-specific alternatives or workarounds, such as using Live Metrics Stream or exporting logs to external systems.
- Explicitly document differences in feature availability between Windows and Linux, and link to Linux-specific monitoring solutions where possible.
- Where a feature is Windows-only, offer guidance on how Linux users can achieve similar monitoring outcomes, even if via different tools.
- Consider adding example workflows for Linux users, especially for log streaming and performance monitoring.