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 326-350 of 1023 flagged pages
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/dotnet-isolated-process-guide.md
...icles/azure-functions/dotnet-isolated-process-guide.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Powershell Heavy
Missing Linux Example
Summary
The documentation exhibits a mild Windows bias. Windows-specific tools, settings, and instructions are often mentioned before or more prominently than their Linux equivalents. Some sections provide only Windows or PowerShell examples, or list Windows tooling before Linux/CLI alternatives. Linux-specific instructions are present but sometimes secondary or less detailed. There are also places where Linux examples or parity could be improved, especially regarding deployment, configuration, and debugging.
Recommendations
- Ensure that all CLI and deployment instructions are presented with both Windows (PowerShell/CMD) and Linux (Bash/CLI) examples, or use cross-platform Azure CLI examples by default.
- When listing tooling or setup methods (e.g., Visual Studio, VS Code, CLI), avoid always listing Windows-first; alternate the order or group by platform.
- Where PowerShell is mentioned, provide equivalent Bash or shell commands for Linux users.
- In sections discussing configuration (e.g., environment variables, app settings), explicitly show both Windows and Linux syntax or reference platform-agnostic approaches.
- For debugging and local development, include Linux-specific guidance and troubleshooting steps, not just Visual Studio/Windows workflows.
- In performance and deployment optimization sections (e.g., ReadyToRun, runtime identifiers), ensure Linux instructions are as detailed as Windows, including explicit Linux examples for project files and CLI commands.
- Review all code snippets and ensure any that are platform-specific are clearly labeled, and that Linux alternatives are provided where relevant.
- Consider adding a parity checklist to ensure future documentation updates maintain equal coverage for Linux and Windows scenarios.
Create Pull Request
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 aims for cross-platform parity, but there are subtle signs of Windows bias. Command-line examples are consistently split between Bash and Cmd, but Windows (Cmd) examples are always presented alongside or immediately after Bash, sometimes with more detailed context. There are no PowerShell-specific examples, but the presence of Windows command prompt (Cmd) examples throughout, and the explicit mention of 'command prompt' in getting started sections, may suggest a Windows-first mindset. There are no Linux-specific troubleshooting or environment notes, and some sections (such as environment variable configuration) assume familiarity with Windows conventions. No Linux-specific tools or shell environments (e.g., zsh, fish) are mentioned, and there are no explicit Linux troubleshooting steps or caveats.
Recommendations
- Ensure that Bash examples are always presented first, and clarify that Bash commands work on Linux, macOS, and Windows (with WSL or Git Bash).
- Add explicit notes or sections for Linux users, such as common locations for JAVA_HOME, shell profile configuration, or troubleshooting tips for Linux environments.
- Where 'command prompt' is mentioned, also mention 'terminal' or 'shell' to be inclusive of Linux/macOS users.
- Include Linux-specific troubleshooting steps or caveats where relevant (e.g., file permissions, case sensitivity, environment variable export syntax).
- Consider referencing cross-platform shells (e.g., zsh, fish) or tools (e.g., SDKMAN for Java version management) where appropriate.
- Review all examples and ensure parity in detail and context between Bash and Cmd sections.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/dotnet-isolated-process-guide.md
...icles/azure-functions/dotnet-isolated-process-guide.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation exhibits a mild Windows bias. In several places, Windows-specific tools or settings are mentioned before their Linux equivalents (e.g., ReadyToRun runtime identifiers, deployment requirements, and preview .NET version configuration). Some instructions and examples are Windows-centric or list Windows first, and there are references to Visual Studio (a Windows-first tool) without always providing parity for Linux/VS Code. In a few cases, Linux-specific instructions are less detailed or missing, and Azure PowerShell (primarily used on Windows) is listed as a deployment option without equivalent emphasis on Bash or Linux-native scripting.
Recommendations
- Ensure that all CLI and deployment instructions are provided for both Windows and Linux, with equal detail and prominence.
- When listing tools or options (e.g., Visual Studio, PowerShell), always include Linux-friendly alternatives (e.g., VS Code, Bash scripts, Azure CLI) and avoid listing Windows tools first by default.
- For configuration tables or code snippets (e.g., ReadyToRun, deployment requirements), present Linux and Windows options side-by-side or in parallel tabs, not with Windows first.
- When referencing PowerShell, also provide Bash/Azure CLI equivalents and highlight cross-platform approaches.
- Review all sections for parity in debugging, deployment, and project setup instructions, ensuring Linux users have clear, direct guidance.
- Explicitly mention if a feature or tool is Windows-only, and suggest Linux alternatives where possible.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-add-openai-text-completion.md
...zure-functions/functions-add-openai-text-completion.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Windows Tools
Summary
The documentation demonstrates a Windows bias by exclusively referencing Visual Studio Code and Azurite usage patterns that are most familiar to Windows users. Instructions for starting Azurite and running the function app use the Visual Studio Code command palette (F1) and function keys (F5), which are more commonly associated with Windows environments. There are no explicit instructions or terminal commands for starting Azurite or running/debugging the function app from a Linux or macOS terminal. Additionally, there is no mention of Linux-specific tools or alternative workflows, and the use of 'local.settings.json' and 'UseDevelopmentStorage=true' assumes a development pattern typical of Windows setups.
Recommendations
- Add explicit instructions for starting Azurite and running/debugging the function app from the terminal (e.g., using `azurite` and `func start` commands), which are platform-agnostic and especially relevant for Linux/macOS users.
- Include notes or callouts for Linux/macOS users regarding any differences in keyboard shortcuts or command palette access in Visual Studio Code.
- Mention and provide examples for using actual Azure Storage accounts as an alternative to Azurite, and clarify any platform-specific considerations.
- Ensure all steps that reference file paths, commands, or tools are verified to work on Linux/macOS and provide alternative instructions if necessary.
- Consider adding a prerequisites section that explicitly lists supported platforms and any platform-specific setup steps.
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
Powershell Heavy
Windows Tools
Summary
The documentation demonstrates a moderate Windows bias. Windows-based examples and tools are often presented first, especially for .NET/C# and PowerShell. The default agent image for C# and PowerShell is 'windows-latest', and PowerShell is only shown with Windows agents. While Linux (ubuntu-latest) is used for JavaScript and Python, and Linux deployment is covered, the structure and ordering of examples generally prioritize Windows. There is also a lack of parity in PowerShell examples for Linux, and the documentation assumes Windows as the default for several tasks.
Recommendations
- For C#/.NET examples, provide both 'windows-latest' and 'ubuntu-latest' YAML samples, or clarify cross-platform compatibility.
- For PowerShell, clarify if Linux agents are supported and provide examples for Linux if available (e.g., using pwsh on Ubuntu agents).
- When listing deployment options, present Windows and Linux options side-by-side or in parallel tabs, rather than defaulting to Windows.
- Explicitly mention when a feature or task is Windows-only or Linux-only, and provide guidance for the other OS where possible.
- In introductory and summary sections, avoid language that assumes Windows as the default; instead, state that both Windows and Linux are supported and highlight any differences up front.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-add-openai-text-completion.md
...zure-functions/functions-add-openai-text-completion.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation demonstrates a moderate Windows bias. It assumes the use of Visual Studio Code and Azurite (which are cross-platform), but key steps and tooling are presented in a way that prioritizes or assumes Windows environments. For example, instructions for starting Azurite and running/debugging the function app use Visual Studio Code commands and function keys (e.g., F5, Ctrl+C) without mentioning terminal alternatives or Linux/macOS-specific workflows. There are no explicit Linux/macOS shell commands or troubleshooting notes for non-Windows users. The documentation also references Core Tools and Azurite without clarifying installation or usage differences across platforms.
Recommendations
- Provide explicit instructions or notes for Linux/macOS users, including alternative commands for starting Azurite and running/debugging the function app (e.g., using terminal commands like `func start` or `azurite` in bash/zsh).
- Clarify that Visual Studio Code, Azurite, and Azure Functions Core Tools are cross-platform, and provide installation links or steps for Linux/macOS.
- When referencing keyboard shortcuts (e.g., F5, Ctrl+C), add notes about how these may differ on macOS (e.g., Cmd+C instead of Ctrl+C) or how to perform the same actions in the terminal.
- Include troubleshooting tips or common issues for Linux/macOS environments, such as permissions, path differences, or dependency installation.
- Ensure that all code and configuration examples (such as file paths, environment variables, and CLI commands) are valid for both Windows and Linux/macOS users.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/dotnet-isolated-process-guide.md
...icles/azure-functions/dotnet-isolated-process-guide.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation exhibits a mild Windows bias. In several places, Windows-specific tools, settings, and instructions are mentioned before their Linux equivalents, or Linux guidance is less detailed. Some CLI and deployment examples focus on Windows or mention Windows-specific options first. There are also areas where Linux-specific instructions are less prominent or absent, such as ReadyToRun guidance and debugging steps.
Recommendations
- Ensure all CLI and deployment instructions are provided for both Windows and Linux, with equal detail and prominence.
- When listing platform-specific settings (e.g., netFrameworkVersion for Windows, linuxFxVersion for Linux), present them together or in parallel tabbed sections, not with Windows first.
- For performance and publishing guidance (e.g., ReadyToRun, runtime identifiers), include explicit Linux examples and clarify any differences or limitations.
- In debugging and development sections, provide Linux-specific instructions and troubleshooting steps, not just Windows/Visual Studio workflows.
- When referencing tools (e.g., Azure CLI, PowerShell), ensure Linux and cross-platform tools are given equal or greater prominence compared to Windows-only tools.
- Review all code and command snippets to ensure parity between Windows and Linux, including file paths, environment variables, and shell syntax.
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 provides both Bash and Windows CMD examples for most CLI operations, but consistently lists Windows CMD tabs after Bash. However, there is a subtle bias in that some sections (such as the initial project scaffolding and logging) present Bash and CMD examples, but do not mention Linux-specific tools or patterns beyond Bash. There are no explicit PowerShell examples, but the presence of CMD and Bash only may leave out users of other shells (e.g., zsh, fish) or those on macOS. The documentation does not provide Linux-specific troubleshooting, nor does it mention any Linux-specific behaviors or differences. The Java version support table lists Windows before Linux, and the default Java version is described in terms of the Maven archetype, which is platform-agnostic. Overall, the bias is mild, but there is a slight preference for Windows-first ordering and a lack of Linux-specific guidance.
Recommendations
- Ensure that all CLI examples explicitly mention compatibility with Linux/macOS as well as Windows, and consider including a note about shell compatibility (e.g., Bash, zsh, fish).
- Wherever possible, add Linux/macOS-specific troubleshooting tips or notes, especially for environment variables, file paths, and permissions.
- In tables and lists, alternate or randomize the order of Windows and Linux to avoid always listing Windows first.
- If there are any differences in behavior or requirements between Windows and Linux (e.g., file system case sensitivity, path separators), call these out explicitly.
- Consider adding a section or appendix summarizing any known Linux/macOS-specific issues or best practices for Java Azure Functions development.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/dotnet-isolated-process-guide.md
...icles/azure-functions/dotnet-isolated-process-guide.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Powershell Heavy
Missing Linux Example
Summary
The documentation page demonstrates a mild Windows bias. While it does mention both Windows and Linux in several places, Windows-specific tools, patterns, and configuration steps are often mentioned first or in more detail. Some examples and instructions are Windows-centric (e.g., PowerShell, Visual Studio), and Linux equivalents are less prominent or missing. Azure CLI is included, but PowerShell is also highlighted as a primary method. In performance and deployment sections, Windows is often listed before Linux, and some ReadyToRun and debugging instructions are more detailed for Windows. Linux-specific nuances are not always equally explained.
Recommendations
- Ensure all command-line examples are provided for both Windows (PowerShell/CMD) and Linux (Bash), with clear tabs or sections for each.
- When listing tools or deployment methods (e.g., Visual Studio, PowerShell), mention cross-platform options (like VS Code, Azure CLI) first or equally.
- In performance and deployment sections, present Windows and Linux instructions in parallel, with equal detail and prominence.
- Add Linux-specific examples and troubleshooting steps, especially for advanced scenarios like ReadyToRun, debugging, and deployment.
- Review all references to Windows tools (e.g., PowerShell) and ensure Linux alternatives are provided and easy to find.
- Where possible, use Azure CLI as the default for scripting/deployment, as it is cross-platform, and supplement with PowerShell only as an alternative.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-add-openai-text-completion.md
...zure-functions/functions-add-openai-text-completion.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation demonstrates a mild Windows bias. It assumes the use of Visual Studio Code and the Azurite storage emulator, both of which are cross-platform, but the instructions for starting Azurite ('Azurite: Start' in VS Code) and running/debugging the function app ('F5', 'Ctrl+C') are presented in a way that aligns more closely with Windows workflows. There are no explicit Linux/macOS terminal commands or alternative instructions for starting Azurite or running the function app outside of VS Code. Additionally, there are no references to Linux-specific tools or shell commands, and the documentation does not mention or show parity for Linux users in steps that could be performed via CLI or terminal, such as managing local.settings.json or starting/stopping the emulator. Powershell is included as a language pivot, but not favored in the main instructions.
Recommendations
- Include explicit instructions or notes for Linux/macOS users, such as how to start Azurite from the terminal (e.g., 'npx azurite' or 'azurite' command) and how to run/debug the function app using the Azure Functions Core Tools CLI.
- When referencing keyboard shortcuts (e.g., F5, Ctrl+C), clarify if these are cross-platform or provide alternatives for macOS/Linux (e.g., Cmd+F5, etc.).
- Add examples or notes for editing configuration files (like local.settings.json) using common Linux/macOS editors (e.g., nano, vim) or command-line tools.
- Where possible, provide CLI commands (bash/zsh) for steps that can be performed outside of Visual Studio Code, such as installing dependencies or running the function locally.
- Explicitly state that all tools and steps are cross-platform, and link to platform-specific installation or usage guides for Azurite, Azure Functions Core Tools, and other dependencies.
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 demonstrates a mild Windows bias by frequently presenting Windows (cmd) examples alongside Bash, and sometimes listing Windows-specific instructions or terminology first. While Bash examples are provided for most CLI commands, there is a consistent pattern of giving equal or slightly prioritized attention to Windows command prompt (cmd) usage, which may not be necessary for a Java developer audience that is often cross-platform. There are no explicit Linux-only instructions or tools, and some sections (such as environment variable setup) do not clarify differences between Windows and Linux environments. There is also a lack of explicit Linux troubleshooting or environment-specific guidance, and no mention of Linux-native editors or shells beyond Bash.
Recommendations
- Wherever command-line examples are given, consider listing Bash (Linux/macOS) examples first, as these are more universally applicable for Java developers.
- Reduce the prominence of Windows cmd examples, or move them to expandable sections to avoid cluttering the main flow for cross-platform users.
- Add explicit notes or troubleshooting tips for Linux environments, such as file permissions, case sensitivity, or common issues with environment variables.
- Include references to Linux-native editors (e.g., Vim, Emacs, Nano) in addition to IDEs, or at least acknowledge their use in terminal-based workflows.
- Ensure that all instructions for setting environment variables, file paths, and permissions are cross-platform, with clear distinctions where necessary.
- Provide parity in troubleshooting and setup guidance for both Windows and Linux, especially in sections dealing with local development, environment variables, and deployment.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/dotnet-isolated-process-guide.md
...icles/azure-functions/dotnet-isolated-process-guide.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Powershell Heavy
Missing Linux Example
Summary
The documentation demonstrates a moderate Windows bias. Windows-specific tools and configuration steps (such as Visual Studio, PowerShell, and Windows runtime identifiers) are often mentioned first or in more detail than their Linux equivalents. Some CLI examples and deployment instructions are Windows-centric, and Linux alternatives are sometimes only briefly referenced or relegated to tabs. There are also places where Linux-specific examples or troubleshooting steps are missing or less emphasized, especially around deployment, debugging, and performance optimization.
Recommendations
- Ensure that all CLI and deployment examples are provided for both Windows and Linux, with equal detail and prominence.
- When listing tools or configuration steps, present cross-platform options (e.g., Azure CLI, Visual Studio Code) before or alongside Windows-only tools (e.g., Visual Studio, PowerShell).
- Include Linux-specific troubleshooting and debugging instructions, especially for scenarios like remote debugging and ReadyToRun publishing.
- Where platform-specific tabs are used, ensure both Windows and Linux tabs are present and equally detailed.
- Explicitly mention any differences in behavior or requirements between Windows and Linux throughout the document, not just in isolated sections.
- Provide parity in example commands (e.g., az CLI, dotnet publish) and clarify any OS-specific flags or considerations.
- Review all references to project file settings (like RuntimeIdentifier) and ensure Linux values are always included alongside Windows values.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-reference-python.md
...articles/azure-functions/functions-reference-python.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Powershell Heavy
Summary
The documentation is generally cross-platform and Linux-focused for hosting, but there are subtle Windows biases. Windows terminology ('command prompt'), Windows-first phrasing, and recommendations for remote build when 'developing Python apps on Windows' are present. Visual Studio Code is emphasized, but that's cross-platform. There is a lack of explicit Linux shell (bash) examples, and some folder structure examples use Windows-style command prompt blocks. The documentation does not provide PowerShell-specific commands, but it does use 'command prompt' and 'cmd' block types, which are Windows-centric. However, Linux is clearly the primary supported platform for hosting, and this is stated.
Recommendations
- Replace 'command prompt' and 'cmd' code block types with 'terminal' or 'shell', and use bash syntax for examples where appropriate.
- When listing development options, mention Linux/macOS terminals explicitly alongside Windows command prompt.
- Provide explicit bash/zsh shell command examples in addition to or instead of Windows command prompt/cmd examples.
- Avoid Windows-first phrasing such as 'Use remote build when you're developing Python apps on Windows'; instead, clarify platform-agnostic recommendations.
- Where folder structures are shown, use neutral formatting or provide both Windows and Linux/macOS examples if paths or commands differ.
- Consider adding a section or callout for Linux/macOS users if there are any platform-specific steps or tips.
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 aims for cross-platform parity but exhibits subtle Windows bias. Command-line examples are consistently provided for both Bash (Linux/macOS) and Cmd (Windows), but the Windows/Cmd examples are always presented after Bash, which is a positive sign. However, there is a lack of explicit PowerShell examples, but the use of 'command prompt' and 'Cmd' tabs may implicitly favor Windows users. Some references, such as 'command prompt' and 'open a new command prompt, Bash, or Terminal session,' prioritize Windows terminology or list it first. There are no Linux-specific tools or troubleshooting sections, and some instructions (e.g., setting JAVA_HOME) do not clarify platform-specific differences. IDE guidance includes both Windows- and Linux-friendly tools, but there is a slight tendency to mention Windows-first patterns.
Recommendations
- Add explicit PowerShell examples or clarify that Bash examples are for Linux/macOS and Cmd for Windows, and consider including PowerShell where relevant.
- When referencing terminals, use neutral phrasing such as 'terminal or command prompt' and avoid listing 'command prompt' first.
- Include Linux-specific troubleshooting tips, such as setting JAVA_HOME on Linux, file permissions, or common issues with Maven on Linux.
- Ensure that all environment variable and path examples are shown for both Windows and Linux (e.g., JAVA_HOME path formats).
- Where possible, provide parity in tool recommendations, such as mentioning Linux package managers for JDK installation.
- Review the order of presentation in tables and lists to ensure Linux is not always listed after Windows.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/migration/migrate-plan-consumption-to-flex.md
...unctions/migration/migrate-plan-consumption-to-flex.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Summary
The documentation provides both Linux and Windows instructions for most steps, but there is a slight Windows bias in the ordering and presentation. Windows examples and tools (such as PowerShell and Windows-specific storage/file share instructions) are sometimes presented before or more prominently than their Linux equivalents. Some CLI scripts assume a Windows shell environment, and there is heavier use of Windows terminology and tools (e.g., references to Azure Files, Windows environment variables, and PowerShell-style scripting). However, Linux parity is generally good, with dedicated Linux tabs and instructions throughout.
Recommendations
- Ensure Linux and Windows instructions are always presented in parallel, with neither consistently preceding the other.
- Where possible, provide Bash and PowerShell script examples side-by-side, or clarify which shell is assumed.
- Avoid Windows-centric terminology when describing cross-platform features (e.g., refer to 'file shares' generically, not just 'Azure Files').
- Explicitly mention required tools for both platforms (e.g., jq for Linux, PowerShell equivalents for Windows).
- Audit all CLI scripts for shell compatibility and provide both Bash and PowerShell variants where needed.
- Review and balance the use of screenshots or UI references from both Windows and Linux environments.
- Highlight any platform-specific limitations or differences up front, so users can quickly identify relevant sections.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/dotnet-isolated-process-guide.md
...icles/azure-functions/dotnet-isolated-process-guide.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Powershell Heavy
Missing Linux Example
Summary
The documentation demonstrates a moderate Windows bias. Windows-specific tools, settings, and instructions are often mentioned before or more prominently than their Linux equivalents. Some sections provide only Windows-oriented examples (e.g., ReadyToRun, checking 32/64-bit status), or use Windows-centric terminology and commands. While Linux is mentioned and supported, parity in examples and guidance is inconsistent, and some Linux-specific details are relegated to secondary tabs or footnotes.
Recommendations
- Ensure all CLI and configuration examples are provided for both Windows and Linux, with equal prominence and detail.
- When referencing tools (e.g., Azure CLI, PowerShell), always provide both Windows and Linux command variants, or clarify cross-platform compatibility.
- Avoid listing Windows methods or tools first by default; alternate order or present both together.
- Expand ReadyToRun and deployment sections to include explicit Linux examples (e.g., dotnet publish --runtime linux-x64, project file snippets for Linux).
- Where tabs are used for OS-specific instructions, ensure both tabs are equally detailed and easy to find.
- Explicitly mention any differences or limitations for Linux users up front, rather than as footnotes.
- Audit for any references to Visual Studio or PowerShell that lack corresponding VS Code or Bash/Linux alternatives, and add them where missing.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-reference-python.md
...articles/azure-functions/functions-reference-python.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Powershell Heavy
Summary
The documentation page is generally cross-platform and Linux-friendly, but there are subtle signs of Windows bias. In several places, Windows terminology ("command prompt") is used before or instead of Linux/Unix equivalents ("terminal"), and some folder structure examples use Windows-style command prompt code blocks. The remote build workflow is recommended specifically for Windows users, and local build is discouraged for Windows, but not for Linux. There is also mention of the Python standard library being installed with Python on Windows, while on Unix-based systems it's described as provided by package collections, which may imply a more complex experience on Linux. However, there are no outright missing Linux examples, and Linux hosting is clearly the default for Python on Azure Functions.
Recommendations
- Use neutral, cross-platform terminology such as 'terminal' or 'shell' instead of 'command prompt' or 'cmd', or mention both (e.g., 'terminal or command prompt').
- When showing folder structures, use generic code blocks or 'tree' command output, or provide both Windows and Unix-style examples.
- Clarify that both Windows and Linux users can use the Azure Functions Core Tools and provide any OS-specific instructions as needed.
- When discussing package management or the Python standard library, avoid implying that Linux is more complex; instead, provide clear, parallel instructions for both platforms.
- If recommending remote build for Windows, also state the recommended approach for Linux/Mac users for parity.
- Explicitly mention Linux/Mac equivalents for any Windows-specific tools or paths, and ensure all CLI commands work on both platforms.
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
Windows Tools
Summary
The documentation generally maintains cross-platform parity, but there are subtle signs of Windows bias. In several places, Windows command-line examples (Cmd) are presented alongside Bash, but Cmd is often listed second, which is good. However, the documentation refers to 'command prompt' and 'terminal' together, which can be confusing. There is also a reliance on Azure CLI, which is cross-platform, but some terminology and example structures (e.g., 'command prompt', 'cmd') are more familiar to Windows users. No Linux-specific tools or shell environments (like zsh or fish) are mentioned, and there are no explicit Linux troubleshooting notes or examples. The documentation does not provide PowerShell-specific examples, which is positive, but it also does not highlight Linux-first workflows or tools.
Recommendations
- Ensure that all references to 'command prompt' or 'cmd' are paired with clear references to 'terminal' or 'shell' for Linux/macOS users.
- Wherever command examples are given, consider listing Bash (Linux/macOS) before Cmd (Windows) to reinforce Linux parity.
- Add explicit notes or tips for Linux users where file paths, environment variables, or permissions may differ from Windows.
- Include troubleshooting tips or common issues for Linux environments, such as case sensitivity or shell differences.
- Consider mentioning or linking to Linux-specific tools or workflows (e.g., using zsh, fish, or Linux package managers for JDK installation).
- Review all language to ensure that Windows terminology does not dominate, and that Linux/macOS users feel equally addressed.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/dotnet-isolated-process-guide.md
...icles/azure-functions/dotnet-isolated-process-guide.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation demonstrates a moderate Windows bias. In several sections, Windows-specific tools, settings, and commands are mentioned before or more prominently than their Linux equivalents. Some examples, such as checking or setting the 32-bit/64-bit worker process, are shown only for Windows or are presented with Windows first. In deployment and debugging sections, Visual Studio (a Windows-centric tool) is emphasized, and Linux-specific guidance is less detailed or deferred. There are also places where Linux-specific examples or clarifications are missing or less visible.
Recommendations
- Ensure that all CLI commands and configuration examples are provided for both Windows and Linux, with equal prominence and clarity.
- When referencing tools like Visual Studio, also mention and provide equivalent instructions for cross-platform alternatives such as Visual Studio Code or JetBrains Rider.
- In tables or lists where both Windows and Linux options exist, present them in parallel or in alphabetical order, rather than Windows first.
- For deployment, debugging, and performance optimization sections, include explicit Linux examples and troubleshooting steps, not just Windows-focused guidance.
- Review all references to settings (e.g., netFrameworkVersion, linuxFxVersion) to ensure both Windows and Linux are equally covered, and that Linux-specific requirements are not only in footnotes or secondary tabs.
- Where PowerShell or Windows-specific commands are mentioned, provide Bash or Linux shell equivalents.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-reference-python.md
...articles/azure-functions/functions-reference-python.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Powershell Heavy
Summary
The documentation generally maintains good cross-platform parity, but there are subtle signs of Windows bias. In several places, Windows terminology ("command prompt") is used alongside or before more neutral terms ("terminal"). Visual Studio Code is highlighted as the primary editor, which is cross-platform but often associated with Windows. The publishing workflow recommends remote build for users developing on Windows, and local build is discouraged for Windows users. There is also a reference to the Python standard library being installed with Python on Windows, while on Unix-based systems it's provided by package collections, which may suggest a Windows-centric perspective. However, most code examples, commands, and folder structures are platform-neutral, and Linux hosting is clearly stated as the only supported production environment for Python on Azure Functions.
Recommendations
- Use platform-neutral terms such as "terminal" or "shell" instead of "command prompt" unless specifically referring to Windows.
- When listing development environments or tools, present cross-platform options first or equally (e.g., "Terminal or command prompt" before "Visual Studio Code" or vice versa, but clarify both are cross-platform).
- Clarify that Visual Studio Code is available on all major platforms, not just Windows.
- In the package management and publishing sections, provide explicit Linux/macOS command-line examples where appropriate (e.g., bash/zsh), and clarify any platform-specific differences.
- When referencing the Python standard library, note that it is included in all official Python distributions, regardless of OS, to avoid implying Windows is the default.
- If mentioning Windows-specific behaviors or recommendations (such as remote build), provide equivalent guidance for Linux/macOS users.
- Ensure that all instructions, especially for local development and deployment, are equally clear for Linux/macOS users (e.g., mention bash/zsh shells, Homebrew, etc., if relevant).
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
Windows Tools
Summary
The documentation demonstrates a mild Windows bias. While it provides both Bash and Windows Command Prompt (Cmd) examples for Maven and Azure CLI commands, the structure consistently presents Windows (Cmd) examples immediately after Bash, sometimes with more prominence. There is also a notable emphasis on Visual Studio Code and other Microsoft-centric tools, which are more commonly associated with Windows environments. However, Linux is represented in the OS support tables, and Bash examples are present throughout. There are no exclusive PowerShell-only instructions, but the documentation does not mention Linux-specific tools or patterns (e.g., native Linux package managers, shell scripting, or troubleshooting).
Recommendations
- Present Bash (Linux/macOS) examples before Windows (Cmd) examples to reflect the prevalence of Linux in Java development.
- Include explicit references to Linux/macOS Terminal in all command-line instructions, not just 'Terminal' or 'command prompt'.
- Add troubleshooting or setup notes for common Linux/macOS issues (e.g., setting JAVA_HOME, file permissions).
- Mention Linux-native editors (e.g., Vim, Emacs) or tools where appropriate, or at least acknowledge their use.
- Ensure parity in tool recommendations by highlighting cross-platform tools and workflows, not just Microsoft-centric ones.
- Where OS-specific instructions are needed, provide equal detail for Linux/macOS and Windows.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/dotnet-isolated-process-guide.md
...icles/azure-functions/dotnet-isolated-process-guide.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Powershell Heavy
Missing Linux Example
Summary
The documentation demonstrates a moderate Windows bias. Windows-specific tools and configuration steps are often mentioned before or more prominently than their Linux equivalents. In several sections, Windows commands, settings, and tools (such as Visual Studio, PowerShell, and Windows-specific Azure CLI flags) are listed first or exclusively, while Linux alternatives are mentioned later or in less detail. Some deployment and configuration examples focus on Windows, with Linux instructions provided as secondary or in separate tabs. There is also a lack of explicit Linux shell or scripting examples, and PowerShell is referenced as a primary automation tool.
Recommendations
- Ensure that all command-line examples are provided for both Windows (PowerShell/CMD) and Linux (Bash), ideally side-by-side or in tabs.
- When listing tools or methods (e.g., Visual Studio, Visual Studio Code, Azure CLI, PowerShell), avoid always listing Windows-specific tools first; alternate the order or group by platform.
- Provide Linux-specific instructions and examples wherever Windows-specific ones are given (e.g., for setting environment variables, publishing, or debugging).
- Include Bash/Azure CLI examples for common tasks, not just PowerShell or Visual Studio workflows.
- Clarify when a tool or feature is Windows-only, and suggest Linux alternatives where possible.
- Review and update deployment and configuration sections to ensure Linux parity, including explicit references to Linux containers, shell commands, and file paths.
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 strives 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 second, which is a positive. However, there is a slight overemphasis on Windows in some areas: references to 'command prompt' (a Windows term) in getting started, and the use of 'cmd' tabs (rather than 'powershell' or 'terminal') for Windows. There are no explicit Linux-only examples or Linux-specific troubleshooting, and some terminology (e.g., 'command prompt') may be confusing for Linux users. IDE instructions include both Windows- and Linux-friendly tools, but the initial mention of 'command prompt' before 'terminal' could be improved. No Windows-only tools are recommended, but the parity of examples could be more explicit.
Recommendations
- Replace 'command prompt' with 'terminal' or 'shell' in all cross-platform contexts, or use 'command prompt/terminal' to be inclusive.
- Wherever command-line examples are given, ensure the Bash (Linux/macOS) tab is listed first, and clarify that Cmd is for Windows.
- Add explicit notes or troubleshooting tips for Linux users where OS-specific issues may arise (e.g., file permissions, environment variable syntax).
- Consider including a short section or callout on Linux/macOS prerequisites or common issues, to balance the implicit Windows focus.
- Where possible, use 'terminal' as the default term and only specify 'command prompt' or 'Cmd' when referring to Windows-specific instructions.
- If possible, add at least one Linux/macOS-specific example or tip (e.g., setting JAVA_HOME in .bashrc) to demonstrate parity.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/dotnet-isolated-process-guide.md
...icles/azure-functions/dotnet-isolated-process-guide.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation page demonstrates a mild Windows bias. In several sections, Windows-specific tools, settings, and commands are mentioned before their Linux equivalents or without Linux parity. For example, in the ReadyToRun section, Windows runtime identifiers and Visual Studio publishing instructions are detailed before Linux, and the Visual Studio workflow is described in more depth than Linux alternatives. Some CLI commands and configuration steps are shown for Windows first, and the use of Visual Studio (a Windows-centric tool) is emphasized in deployment and debugging sections. While Linux is mentioned and supported, Linux-specific examples and workflows are less prominent or are referenced as secondary options.
Recommendations
- Ensure that all CLI and configuration instructions are presented for both Windows and Linux, ideally side-by-side or with equal prominence.
- Provide Linux-specific examples and workflows (e.g., using VS Code, Azure CLI, or other cross-platform tools) wherever Visual Studio or Windows PowerShell is mentioned.
- When listing tools or deployment methods, alternate the order or present Linux and Windows options together, rather than defaulting to Windows first.
- Expand on Linux container deployment and debugging workflows to match the detail provided for Windows/Visual Studio.
- Where possible, include explicit Linux shell commands and terminal output, not just Azure CLI or Visual Studio instructions.
- Audit for any references to Windows-only features or settings and clarify their Linux equivalents or note if not applicable.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/function-keys-how-to.md
.../main/articles/azure-functions/function-keys-how-to.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Missing Linux Example
Summary
The documentation provides both Azure CLI and Azure PowerShell examples for managing access keys, but the PowerShell examples are detailed and prominent, and there is no explicit mention or example for Linux shell scripting or Bash outside of Azure CLI. The CLI examples are stated to run in Azure Cloud Shell (Bash), but there is a note that they must be modified to run in a Windows terminal, suggesting a Windows-first perspective. No Linux-specific tools or shell script examples are provided, and PowerShell is presented as a primary scripting method.
Recommendations
- Add explicit Bash or shell script examples for key management tasks, especially for scenarios where scripting is needed outside of Azure CLI.
- Clarify that Azure CLI commands work natively on Linux, macOS, and Windows, and provide any necessary notes for cross-platform usage.
- Balance the prominence of PowerShell and CLI examples by ensuring that Linux/Bash scripting is equally represented, especially for automation scenarios.
- Where PowerShell scripts are provided, offer equivalent Bash scripts for users who may not use PowerShell.
- Avoid language that implies Windows is the default or primary environment (e.g., 'You must modify it to run in a Windows terminal'), and instead provide parallel guidance for both Windows and Linux users.