Azure Functions
385
Total Pages
248
Linux-Friendly Pages
137
Pages with Bias
35.6%
Bias Rate
Bias Trend Over Time
Pages with Bias Issues
1023 issues found
Showing 501-525 of 1023 flagged pages
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-custom-handlers.md
.../articles/azure-functions/functions-custom-handlers.md
High Priority
View Details →
Detected Bias Types
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.
Create Pull Request
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-dotnet-class-library.md
...cles/azure-functions/functions-dotnet-class-library.md
High Priority
View Details →
Detected Bias Types
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.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-how-to-azure-devops.md
...icles/azure-functions/functions-how-to-azure-devops.md
High Priority
View Details →
Detected Bias Types
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.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-identity-access-azure-sql-with-managed-identity.md
...ctions-identity-access-azure-sql-with-managed-identity.md
High Priority
View Details →
Detected Bias Types
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.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-how-to-use-azure-function-app-settings.md
...ns/functions-how-to-use-azure-function-app-settings.md
High Priority
View Details →
Detected Bias Types
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.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-monitoring.md
.../main/articles/azure-functions/functions-monitoring.md
High Priority
View Details →
Detected Bias Types
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.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-machine-learning-tensorflow.md
...ure-functions/functions-machine-learning-tensorflow.md
High Priority
View Details →
Detected Bias Types
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.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-networking-options.md
...ticles/azure-functions/functions-networking-options.md
High Priority
View Details →
Detected Bias Types
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.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-premium-plan.md
...ain/articles/azure-functions/functions-premium-plan.md
High Priority
View Details →
Detected Bias Types
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.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-reference-java.md
...n/articles/azure-functions/functions-reference-java.md
High Priority
View Details →
Detected Bias Types
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.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-scenario-database-table-cleanup.md
...functions/functions-scenario-database-table-cleanup.md
High Priority
View Details →
Detected Bias Types
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.
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
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.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-run-local.md
...b/main/articles/azure-functions/functions-run-local.md
High Priority
View Details →
Detected Bias Types
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'.
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
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.
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
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.
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 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.
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
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.
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 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.
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
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.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/migrate-version-1-version-4.md
...rticles/azure-functions/migrate-version-1-version-4.md
High Priority
View Details →
Detected Bias Types
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.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/run-functions-from-deployment-package.md
...ure-functions/run-functions-from-deployment-package.md
High Priority
View Details →
Detected Bias Types
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.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/update-language-versions.md
...n/articles/azure-functions/update-language-versions.md
High Priority
View Details →
Detected Bias Types
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.
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 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.
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 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.
Azure Functions
Guide for running C# Azure Functions in an isolated worker process
...icles/azure-functions/dotnet-isolated-process-guide.md
Medium Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Powershell Heavy
Missing Linux Example
Summary
The documentation generally aims for cross-platform parity, but there are several areas where Windows and Windows tooling are mentioned first or exclusively, and Linux-specific guidance is less prominent or missing. Windows/PowerShell commands are sometimes shown before their Linux equivalents, and some instructions (such as for ReadyToRun, checking process bitness, and certain deployment steps) focus on Windows scenarios or tools, with Linux alternatives only mentioned later or not at all. Azure PowerShell is listed as a primary resource creation method, while Bash/Azure CLI is not always given equal prominence. Some minor friction exists for Linux/macOS users, though most tasks are still possible.
Recommendations
- When listing resource creation or deployment methods, always mention cross-platform tools (Azure CLI, Bash) before or alongside Windows-specific tools (PowerShell, Visual Studio).
- For all CLI commands, provide both Windows (PowerShell/CMD) and Linux/macOS (Bash) syntax/examples where differences exist.
- In sections like ReadyToRun, ensure Linux build and deployment instructions are as detailed and prominent as Windows instructions.
- Where PowerShell is referenced, add equivalent Bash/Azure CLI examples and clarify platform applicability.
- In troubleshooting and configuration, explicitly call out any platform-specific differences and provide guidance for both Windows and Linux/macOS users.
- Review the order of presentation in tables and lists to avoid always listing Windows/PowerShell/Visual Studio first unless there is a technical reason.