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 451-475 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 demonstrates a moderate Windows bias. Windows-specific tools and patterns (such as Visual Studio, PowerShell, and Windows-specific Azure CLI flags) are often mentioned before or instead of their Linux equivalents. Some instructions and examples are Windows-centric, and Linux-specific guidance is often relegated to secondary tabs or not provided with equal detail. There are also several places where only Windows commands or behaviors are described, or where Windows is the default context.
Recommendations
- Ensure that all CLI examples (especially for deployment, configuration, and debugging) are provided for both Windows and Linux, with Linux examples given equal prominence.
- When listing tools or workflows (e.g., Visual Studio, Visual Studio Code, CLI, PowerShell), present cross-platform options first or in parallel, rather than defaulting to Windows-first ordering.
- Where PowerShell is mentioned, also provide Bash or shell equivalents for Linux/macOS users.
- In tables and lists, avoid putting Windows tools or instructions before Linux equivalents unless there is a technical reason.
- For debugging and deployment, include explicit Linux instructions and troubleshooting steps, not just Windows/Visual Studio guidance.
- Review all references to environment variables, file paths, and commands to ensure they are cross-platform or that both Windows and Linux formats are shown.
- Where tabs are used for OS-specific content, ensure the Linux tab is as complete and detailed as the Windows tab.
Create Pull Request
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 frequently presents Windows instructions and examples before Linux equivalents, and in some cases, Linux instructions are less detailed or have additional restrictions. There are also sections where only Windows-specific tools or paths are referenced, and Linux users are sometimes redirected or given less guidance.
Recommendations
- Ensure that Linux instructions and examples are presented alongside Windows, or in parallel, rather than after or as an afterthought.
- Provide equally detailed Linux examples for all languages and scenarios, including local development and configuration steps.
- Avoid language such as 'select the Windows tab' as the default; instead, present both OS options equally.
- Where features are not available on Linux (e.g., Python on Windows), clearly explain alternatives or workarounds for Linux users.
- Review all code samples and ensure that Linux command-line and file path conventions are included where relevant.
- Where possible, use cross-platform tools and instructions (such as Azure CLI) as the primary example, and only provide OS-specific guidance when necessary.
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 exhibits a Windows-first bias in several ways: Windows paths and deployment patterns are consistently mentioned before Linux equivalents, and Windows-specific folders (e.g., c:\home\data\SitePackages) are referenced throughout. There is a lack of Linux-specific command-line or shell examples, and no Linux-native tooling or deployment workflows are highlighted. The documentation assumes familiarity with Windows conventions and tools, with only minimal parity for Linux mentioned as afterthoughts.
Recommendations
- Present Linux and Windows instructions/examples side by side or in parallel sections, rather than always listing Windows first.
- Include Linux-native command-line examples (e.g., bash, zip, scp, az CLI on Linux) for creating and deploying packages.
- Reference Linux paths first or equally, and avoid assuming Windows as the default environment.
- Highlight Linux-specific deployment considerations and tools (such as using Linux shells, permissions, or automation scripts).
- Provide explicit Linux troubleshooting steps and examples, not just Windows-centric advice.
- Where UI steps are described, mention any differences for Linux users (e.g., Azure CLI vs. Azure Portal).
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 toward Windows development environments, specifically Visual Studio on Windows. All instructions, UI references, and publishing steps assume the use of Visual Studio 2022, with no mention of cross-platform alternatives such as Visual Studio Code, Azure CLI, or command-line tools available on Linux/macOS. The publishing process explicitly targets 'Azure Function App (Windows)', and there are no examples or guidance for Linux users or those preferring non-Windows workflows.
Recommendations
- Provide alternative instructions for Linux/macOS users, such as using Visual Studio Code, Azure CLI, or the Azure Functions Core Tools.
- Include command-line examples for project creation, dependency installation, and publishing that work on all platforms.
- Mention and demonstrate how to use cross-platform editors (e.g., VS Code) and tools (e.g., dotnet CLI, func CLI) alongside or instead of Visual Studio.
- Clarify that Azure Functions and API Management are cross-platform services, and show how to deploy to Linux-based Function Apps.
- Reorder or parallelize instructions so that Windows and Linux/macOS workflows are presented equally, rather than Windows-first or Windows-only.
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, commands, and configuration steps are often mentioned before their Linux equivalents, or Linux is only referenced as an afterthought. Several CLI examples and deployment instructions are presented with Windows as the default or primary context, and PowerShell is included as a recommended tool for resource creation. In some sections, Linux-specific instructions are present but less emphasized or appear after Windows instructions. There are also areas where only Windows or Visual Studio workflows are detailed, with less parity for Linux or cross-platform alternatives.
Recommendations
- Ensure all CLI and deployment examples are provided for both Windows and Linux equally, using cross-platform tools (e.g., Azure CLI) as the default.
- When listing tools or methods (e.g., Visual Studio, PowerShell, Azure CLI), avoid listing Windows-specific options first; instead, present cross-platform options first or in parallel.
- Where PowerShell is mentioned, always include Bash or shell equivalents for Linux users.
- In sections discussing configuration or deployment, provide explicit Linux examples and highlight any differences or required steps for Linux environments.
- Where Visual Studio is referenced, ensure Visual Studio Code (cross-platform) instructions are equally detailed and prominent.
- Review all code snippets and command-line instructions to ensure they are not Windows-centric (e.g., avoid backslashes in paths, use environment-agnostic syntax).
- Add a summary table or section at the start that clearly indicates which instructions apply to Windows, Linux, or both, and link to the relevant sections.
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 generally aims for cross-platform coverage, but there are several areas where Windows is prioritized or receives more detailed attention. Windows-specific tools and commands (such as PowerShell and 'py') are often mentioned before their Linux equivalents, and in some cases, Linux/Bash examples are less detailed or missing. There is also a tendency to reference Windows development environments and patterns (e.g., 'pip freeze' from Windows, Visual Studio Code with Windows settings) before or more prominently than Linux alternatives.
Recommendations
- Ensure that all command-line examples are provided for both Windows (PowerShell/CMD) and Linux (Bash), and present them in parallel or with equal prominence.
- When referencing tools like 'py' (Windows Python launcher), also provide the equivalent Linux command ('python3') and clarify platform differences.
- Avoid listing Windows commands or tools first by default; alternate the order or present both at the same time.
- Expand on Linux-specific troubleshooting steps and examples, especially for common deployment and environment issues.
- Where platform-specific behaviors are discussed (e.g., 'pip freeze' on Windows vs. Linux), provide explicit guidance for Linux users.
- In sections referencing Visual Studio Code or other tools, clarify any platform-specific setup steps or differences for Linux users.
- Audit for any missing Linux/Bash examples, especially in troubleshooting or mitigation steps, and add them to ensure parity.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/create-first-function-cli-typescript.md
...zure-functions/create-first-function-cli-typescript.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Summary
The documentation provides both Azure CLI and Azure PowerShell examples for creating Azure resources, but consistently lists PowerShell as an alternative to CLI, which is a Windows-centric tool. There are no explicit Linux shell or Bash-specific examples, and keyboard shortcuts (e.g., Ctrl+C) are presented in a Windows-centric way. The documentation assumes familiarity with Windows tools and patterns, and does not provide parity for Linux or macOS users beyond the CLI.
Recommendations
- Provide explicit Bash or shell command examples where appropriate, especially for common tasks like navigation or process termination.
- List Azure CLI (cross-platform) examples first, and clarify that PowerShell is optional, not required.
- Include notes or sections for Linux/macOS users, such as alternative keyboard shortcuts (e.g., Ctrl+C is universal, but confirmation prompts may differ).
- Mention that all commands work on Linux/macOS unless otherwise stated, and highlight any OS-specific differences.
- If referencing screenshots or terminal output, ensure they are not Windows-specific, or provide Linux/macOS equivalents.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/durable/durable-functions-sub-orchestrations.md
...ctions/durable/durable-functions-sub-orchestrations.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows Tools
Windows First
Summary
The documentation includes a prominent PowerShell-specific note and provides PowerShell code samples alongside other languages. The only shell/CLI-specific mention is for PowerShell, with no equivalent mention of Bash or Linux-native scripting. The note about sub-orchestrations support in PowerShell references the PowerShell SDK and migration guide, but there is no similar guidance or context for Linux or Bash users. PowerShell is a Windows-centric tool, and its exclusive mention and support note indicate a Windows bias.
Recommendations
- Provide equivalent notes or guidance for Linux/Bash users if there are any platform-specific considerations for sub-orchestrations.
- If PowerShell is mentioned as a supported shell, clarify support for Bash or other shells, or explicitly state if they are unsupported.
- Consider including Bash or cross-platform shell examples or notes where PowerShell is referenced.
- Ensure that CLI or scripting guidance is not exclusively tied to Windows tools, and mention cross-platform alternatives where possible.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/create-first-function-vs-code-node.md
.../azure-functions/create-first-function-vs-code-node.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation page generally avoids explicit Windows bias in its main instructions, focusing on Visual Studio Code and the Azure Functions extension, which are cross-platform. However, there is a subtle Windows bias in the troubleshooting section, where a solution specifically references Windows and WSL Bash without mentioning equivalent Linux or macOS scenarios. There are no explicit Linux/macOS command-line examples or troubleshooting steps, and the only shell-specific advice is Windows-centric. No PowerShell commands or Windows-only tools are shown, but the troubleshooting advice assumes a Windows environment.
Recommendations
- In the troubleshooting section, add equivalent advice for Linux and macOS users, such as ensuring the default terminal shell is compatible (e.g., Bash, Zsh, etc.), and clarify that the advice about WSL Bash is only relevant for Windows users using WSL.
- Wherever troubleshooting or environment setup is discussed, explicitly mention that the instructions apply to all supported operating systems, and provide OS-specific notes where necessary.
- If there are any platform-specific behaviors or requirements (such as permissions, path formats, or shell differences), include them for Linux and macOS as well as Windows.
- Consider adding a short section or note confirming cross-platform compatibility and linking to platform-specific setup guides if available.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/durable/durable-functions-isolated-create-first-csharp.md
...able/durable-functions-isolated-create-first-csharp.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation is heavily oriented toward Windows development environments, focusing exclusively on Visual Studio and Visual Studio Code workflows. All instructions, screenshots, and tool references assume the use of Windows tools and UI patterns (e.g., Visual Studio, Azurite extension, menu navigation). There is no mention of Linux or macOS-specific instructions, terminal commands, or alternative editors. The use of Azurite and Azure Functions Core Tools is described only in the context of Visual Studio/VS Code, with no CLI or cross-platform guidance. This results in a lack of parity for Linux users.
Recommendations
- Add a dedicated section or pivot for Linux/macOS users, outlining how to create, run, and debug Durable Functions apps using the .NET CLI and Azure Functions Core Tools from the terminal.
- Provide explicit instructions for installing prerequisites (e.g., .NET SDK, Azure Functions Core Tools, Azurite) on Linux and macOS, including package manager commands (apt, yum, brew, etc.).
- Include CLI-based project creation and management steps as alternatives to Visual Studio/VS Code UI workflows.
- Show examples of running and debugging Durable Functions apps from the terminal, including how to use breakpoints with VS Code on Linux/macOS.
- Mention any platform-specific considerations, such as file paths, permissions, or differences in emulator usage.
- Ensure screenshots and instructions are not exclusively Windows-centric, or provide equivalent visuals for Linux/macOS environments.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/bring-dependency-to-functions.md
...icles/azure-functions/bring-dependency-to-functions.md
High Priority
View Details →
Detected Bias Types
Windows Tools
Windows First
Missing Linux Example
Summary
The documentation demonstrates some Windows bias, particularly in the Java example where the ffmpeg path uses a Windows-style executable (ffmpeg.exe) and the guidance for setting the BASE_PATH is tailored to Azure's Linux file structure but does not mention Windows equivalents. Additionally, PowerShell is mentioned as an upload option, but Linux-native tools (like rsync, scp, or standard shell commands) are not referenced. The Python examples are more Linux-oriented, but there is a lack of parity in providing explicit Linux/Unix examples or guidance for Java users, and the documentation does not provide equivalent Windows instructions for file mounting or path handling.
Recommendations
- For Java examples, provide both Windows and Linux path examples for ffmpeg (e.g., ffmpeg.exe for Windows, ffmpeg for Linux) and clarify how to set BASE_PATH on both platforms.
- When referencing upload options for Azure Files, mention Linux-native tools (e.g., azcopy, scp, rsync) alongside PowerShell and Azure CLI.
- Explicitly state any platform-specific requirements or differences, such as file permissions (chmod) or path separators, for both Windows and Linux.
- Where possible, include both Windows and Linux code/configuration snippets, or clearly indicate which platform each snippet targets.
- Ensure that all steps (such as mounting file shares or setting environment variables) have instructions for both Windows and Linux development environments.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/durable/durable-task-scheduler/quickstart-portable-durable-task-sdks.md
...ask-scheduler/quickstart-portable-durable-task-sdks.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Summary
The documentation shows some Windows bias, particularly in the Python section where Windows-specific instructions (such as activating a virtual environment) are presented before Linux equivalents. There are also explicit 'Windows' and 'Linux' tabs, with Windows shown first. The presence of a dedicated PowerShell pivot (even though it is empty in this sample) and references to Docker Desktop (which is branded and Windows-centric, though available on Linux) further reinforce a Windows-first orientation. However, Linux instructions are present and correct, and bash commands are used throughout for cross-platform compatibility.
Recommendations
- Present Linux and Windows instructions side-by-side or in a neutral order (e.g., Linux first, or alphabetical).
- Avoid always listing Windows instructions first in tabbed code blocks; consider making Linux the default or randomizing the order.
- Where possible, use generic terms like 'Docker' instead of 'Docker Desktop' unless the desktop version is specifically required.
- Ensure PowerShell pivots or examples are matched with Bash or shell equivalents for parity.
- Explicitly state that all commands work on both Windows and Linux unless there are genuine platform-specific differences.
- Consider adding a table or section at the top summarizing OS-specific steps for quick reference.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/create-first-function-cli-java.md
...cles/azure-functions/create-first-function-cli-java.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Powershell Heavy
Missing Linux Example
Summary
The documentation demonstrates a Windows-first bias in several ways: Windows is the default for deployment and hosting (with Linux as an afterthought), Windows-specific tools and patterns (PowerShell, Cmd) are given equal or greater prominence than Linux/Bash, and the default project configuration targets Windows. Linux alternatives are mentioned but often as side notes, and there is little to no discussion of Linux-specific considerations or troubleshooting.
Recommendations
- Present Linux and Windows options with equal prominence, e.g., list Bash/Linux examples before or alongside Windows/PowerShell/Cmd.
- In the project configuration (pom.xml), do not default to Windows for 'runtime.os'; instead, explain both options and let the user choose.
- Provide Linux-specific troubleshooting tips and highlight any differences in behavior or requirements (such as file permissions, environment variables, or supported Java versions).
- Ensure that all command-line examples are available for Bash (Linux/macOS), PowerShell, and Cmd, and clarify which platforms each applies to.
- Where Windows-specific tools or terminology are used (e.g., Ctrl+C, pressing 'y' to confirm), also mention the Linux/macOS equivalents.
- Add a section or callout for Linux users, especially where the workflow or experience may differ (e.g., Java 21 support is Linux-only).
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 Tools
Windows First
Missing Linux Example
Summary
The documentation page exhibits a moderate Windows bias, primarily through the exclusive mention of Windows-centric tools (such as Azurite emulator and Visual Studio Code commands) and a lack of explicit Linux/macOS instructions or terminal commands. While the language pivots cover multiple programming languages, there are no explicit examples or notes for Linux or macOS users regarding command-line differences, emulator usage, or environment-specific setup. The instructions for running and debugging functions assume a Visual Studio Code GUI workflow, which is more common on Windows, and do not provide CLI alternatives or mention cross-platform differences.
Recommendations
- Add explicit instructions or notes for Linux/macOS users, especially for installing and running Azurite, and clarify any differences in command-line usage or environment setup.
- Provide CLI-based alternatives for steps currently described via Visual Studio Code GUI actions (e.g., creating functions, starting the emulator, running/debugging the app), and show equivalent Bash/zsh commands alongside PowerShell/Windows instructions.
- Mention any OS-specific prerequisites or troubleshooting tips, such as permissions, path differences, or package manager commands for installing dependencies.
- Ensure that all code snippets and setup steps are verified to work on Linux/macOS, and highlight any platform-specific considerations.
- Where possible, use neutral, cross-platform language and tools, or clearly indicate when a step is Windows-specific.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/create-first-function-vs-code-other.md
...azure-functions/create-first-function-vs-code-other.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Powershell Heavy
Summary
The documentation generally maintains cross-platform parity, but there are subtle biases towards Windows. Windows-specific instructions and file extensions (e.g., handler.exe) are mentioned before Linux equivalents in several places. Windows environment variable setting syntax is shown after Linux/macOS, but the distinction is made explicit. There are references to Windows-specific tools (e.g., .exe files, Windows command syntax), and the documentation sometimes refers to Windows patterns first (e.g., 'handler.exe' before 'handler'). However, Linux and macOS instructions are present and correct, and the main workflow is cross-platform.
Recommendations
- When referencing executable names, mention the Linux version ('handler') before the Windows version ('handler.exe'), or present both together (e.g., 'handler (handler.exe on Windows)').
- In configuration file examples, use cross-platform language, such as 'handler' for Linux/macOS and 'handler.exe' for Windows, or provide both options explicitly.
- Where environment variable setting is required, present Linux/macOS and Windows commands side by side, or use tabs for clarity.
- Avoid using Windows-specific terminology or tools as the default; instead, use neutral or Linux-first language where possible.
- Ensure all screenshots and code snippets are available for both Linux and Windows environments, or use generic screenshots that do not show OS-specific details.
- Consider adding a summary table or section at the start that clearly states the parity and any OS-specific steps.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-add-output-binding-storage-queue-vs.md
...tions/functions-add-output-binding-storage-queue-vs.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Powershell Heavy
Summary
The documentation is heavily oriented towards Windows and Visual Studio users, with all instructions and UI references tailored to the Windows version of Visual Studio. There are no CLI or cross-platform instructions for Linux or macOS users, and all examples assume the use of Visual Studio's GUI and PowerShell/NuGet Package Manager Console, which are primarily Windows-centric. While Azure Storage Explorer is mentioned as cross-platform, the rest of the workflow does not address Linux or macOS development environments.
Recommendations
- Provide equivalent instructions for developing and running Azure Functions using cross-platform tools such as Visual Studio Code or the Azure Functions Core Tools CLI.
- Include examples of how to install required NuGet packages using the dotnet CLI (e.g., 'dotnet add package ...'), which works on all platforms.
- Add guidance for editing configuration files (like local.settings.json) manually or via CLI, rather than relying solely on Visual Studio UI dialogs.
- Explicitly mention and link to Linux/macOS development guides where appropriate, or provide tabs for different OS instructions.
- Clarify which steps are specific to Windows/Visual Studio and offer alternatives for Linux/macOS users.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-app-settings.md
...ain/articles/azure-functions/functions-app-settings.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Powershell Heavy
Summary
The documentation generally aims for cross-platform coverage, but there are several areas where Windows is prioritized or referenced before Linux. Some examples and settings are Windows-specific or use Windows-style paths (e.g., %HOME%\typescript), and PowerShell is given dedicated sections and examples. In a few cases, Windows tools or terminology are mentioned without always providing Linux equivalents or parity.
Recommendations
- Ensure that all examples using Windows-style paths (e.g., %HOME%\typescript) also include Linux equivalents (e.g., $HOME/typescript).
- When referencing tools or commands (such as Azure PowerShell), always mention Azure CLI or other cross-platform alternatives alongside or before Windows-specific tools.
- In lists or tables where both Windows and Linux are supported, present Linux examples first or at least equally, rather than defaulting to Windows.
- For PowerShell-specific settings or features, provide equivalent guidance for other shells or languages where possible, or clearly indicate when a feature is Windows-only.
- Audit for any settings or behaviors that are described as default or standard but are actually Windows-specific, and clarify Linux behavior in those cases.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/durable/durable-functions-webjobs-sdk.md
...ure-functions/durable/durable-functions-webjobs-sdk.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Windows Tools
Powershell Heavy
Summary
The documentation page demonstrates a Windows bias by prioritizing Windows-specific tools and workflows (such as Visual Studio and the Windows Classic Desktop template), providing only PowerShell/NuGet Package Manager Console commands, referencing the Windows-only Azurite storage emulator, and omitting explicit Linux or cross-platform instructions or examples. There are no examples or guidance for Linux users regarding equivalent development environments, package installation, or running the sample project.
Recommendations
- Provide equivalent instructions for Linux users, including how to set up and run projects using Visual Studio Code or JetBrains Rider, and .NET CLI commands for project creation and package installation.
- Include Bash/.NET CLI examples alongside PowerShell/Package Manager Console commands for installing NuGet packages.
- Mention cross-platform alternatives to the Azurite storage emulator and clarify how to run it on Linux/macOS.
- Avoid using 'Windows Classic Desktop' as the default project template; instead, recommend .NET Core/.NET 6+ console apps, which are cross-platform.
- Explicitly state which steps are Windows-specific and provide corresponding Linux/macOS steps where possible.
- Add a section or callouts for deploying and running WebJobs from non-Windows environments, including any prerequisites or differences.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/durable/quickstart-java.md
...in/articles/azure-functions/durable/quickstart-java.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Powershell Heavy
Summary
The documentation demonstrates a moderate Windows bias. In the manual setup section, the Maven plugin configuration explicitly sets the runtime OS to 'windows' without mentioning Linux or cross-platform options. In the Maven command section, while Bash, PowerShell, and Cmd examples are provided, the order places Bash first, but Windows-specific shells (PowerShell, Cmd) are given equal prominence. Visual Studio Code instructions are cross-platform, but there is no mention of Linux-specific considerations or troubleshooting. The documentation references Azure Functions Core Tools, which is cross-platform, but does not clarify any Linux-specific installation or usage notes. There is no explicit Linux example or guidance, and the only OS explicitly mentioned in configuration is Windows.
Recommendations
- In the Maven plugin configuration, provide examples for both Windows and Linux runtimes, or clarify that 'os' can be set to 'linux' and explain when to use each.
- Add a note or section about Linux/macOS installation and usage of Azure Functions Core Tools, including any known issues or differences.
- Where PowerShell and Cmd examples are given, ensure that Bash (Linux/macOS) is always listed first and is the default in code tabs, or provide a clear cross-platform command.
- Explicitly state that all steps work on Linux and macOS, and call out any differences or additional steps required.
- Consider including troubleshooting tips or links for common Linux/macOS issues (e.g., permissions, path differences, case sensitivity).
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-deployment-technologies.md
...s/azure-functions/functions-deployment-technologies.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation demonstrates a Windows-first bias in several areas: Windows-specific deployment methods (such as source control, Local Git, and FTPS) are called out as 'Windows-only' in the availability table, with no Linux equivalents or alternatives described. Explanations of remote build and deployment behaviors often start with Windows, providing more detail for Windows scenarios (e.g., Kudu/SCM site), and Linux instructions are less prominent or require additional manual configuration. There are also references to Visual Studio (a Windows-centric tool) before cross-platform or Linux-native tools, and some deployment methods (e.g., FTPS, Local Git) lack Linux-specific guidance or alternatives.
Recommendations
- Provide Linux equivalents or alternatives for deployment methods currently marked as 'Windows-only' (e.g., Source Control, Local Git, FTPS), or clearly state if no equivalent exists and suggest best practices for Linux users.
- Ensure that deployment examples and instructions are given for both Windows and Linux platforms, ideally side-by-side or with equal prominence.
- When listing tools, mention cross-platform options (e.g., Azure Functions Core Tools, VS Code) before Windows-specific tools (e.g., Visual Studio), or present them together.
- Expand explanations for Linux deployment scenarios, including details on how to perform common tasks (such as remote build, trigger syncing, or storage configuration) on Linux.
- Where a feature is not available on Linux, provide a rationale and suggest alternative workflows for Linux users.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-identity-based-connections-tutorial.md
...tions/functions-identity-based-connections-tutorial.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Windows Tools
Summary
The documentation is heavily oriented toward Windows environments: it explicitly states support for C# class library functions on Windows, references Azure Files (default for Windows), and omits Linux-specific guidance or examples. There are no Linux or cross-platform command-line examples, and Linux-specific deployment patterns are only briefly mentioned in passing, without actionable steps.
Recommendations
- Clearly indicate Windows-specific limitations at the top and provide equivalent Linux guidance or note when features are unavailable.
- Add parallel instructions and examples for Linux-based function apps, including how to handle storage and identity configuration on Linux.
- Include CLI (az), Bash, or cross-platform scripting examples alongside or instead of portal-only instructions.
- Discuss Linux-specific storage options and deployment patterns (e.g., how to handle AzureWebJobsStorage and Azure Files on Linux Consumption and Premium plans).
- Where features differ (e.g., Azure Files not being default on Linux), explain the implications and provide alternatives.
- Ensure that references to tools and patterns (such as ARM templates or portal steps) are not Windows-centric and clarify any OS-specific behaviors.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-versions.md
...ob/main/articles/azure-functions/functions-versions.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation page demonstrates a Windows bias by referencing Visual Studio and its project settings in detail, with no equivalent coverage for Linux-native development environments or tools. Visual Studio (a Windows tool) is discussed first and in depth, while Visual Studio Code and Azure Functions Core Tools (which are cross-platform) are mentioned only briefly and without Linux-specific guidance or examples. There are no explicit Linux command-line examples or instructions for Linux users, and the process of pinning to a minor version is said to differ between Windows and Linux, but only a link is provided with no Linux-specific explanation or example.
Recommendations
- Provide explicit Linux command-line examples for tasks such as changing runtime versions, pinning to minor versions, and local development.
- Include parity in tooling instructions by offering equivalent steps for Linux-native environments (e.g., JetBrains Rider, VS Code on Linux, or CLI-only workflows) alongside Visual Studio instructions.
- When mentioning differences between Windows and Linux (e.g., pinning to a minor version), include both sets of instructions or examples directly in the documentation.
- Avoid presenting Windows tools or workflows first by default; consider parallel presentation or starting with cross-platform tools.
- Add a section or callout specifically for Linux/macOS users to ensure their workflows are equally represented.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-identity-based-connections-tutorial-2.md
...ons/functions-identity-based-connections-tutorial-2.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Powershell Heavy
Summary
The documentation is explicitly targeted at C# class library functions on Windows, with no mention of Linux or cross-platform support. All examples and instructions assume use of the Azure portal or .NET CLI, with no Linux-specific guidance or parity checks. There are no examples for Linux-based deployments or for using the Azure Functions Core Tools on Linux/macOS, and no mention of Bash or cross-platform shell commands.
Recommendations
- Clearly indicate at the beginning of the tutorial whether the steps are applicable to Linux and macOS, and provide equivalent instructions where possible.
- Add Linux/macOS-specific examples for creating and deploying function apps, including using Bash shell commands and Azure CLI from non-Windows environments.
- Include notes or sections for differences in environment variable configuration on Linux (e.g., case sensitivity, file paths, use of export in Bash).
- Provide cross-platform guidance for local development, such as how to set up local.settings.json and assign roles using Azure CLI or Bash scripts.
- If certain features are Windows-only, explicitly state the limitations and provide workarounds or alternatives for Linux users.
- Ensure that all code and command-line examples are tested and valid on both Windows and Linux platforms.
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
Powershell Heavy
Windows First
Missing Linux Example
Windows Tools
Summary
The documentation demonstrates a Windows bias by consistently providing Azure PowerShell examples alongside Azure CLI, often before or with more detail than Linux-specific workflows. Several features and tools (such as Kudu, App Service Editor, and in-portal console) are described as available or fully functional only on Windows, with Linux support either missing, limited, or explicitly marked as unsupported. Migration steps and plan management are documented only for Windows, with Linux migration called out as unsupported or limited. There are also several places where Windows terminology and patterns are used by default, and Linux alternatives are not described or are marked as unavailable.
Recommendations
- Provide explicit Linux examples and workflows where possible, especially for command-line and deployment operations.
- Clarify feature parity and limitations for Linux up front, and offer Linux-specific guidance or workarounds where features are missing.
- Balance the use of PowerShell and CLI examples, and avoid presenting Windows tools or patterns first unless they are the only option.
- Where features are Windows-only (such as Kudu, App Service Editor, or in-portal console), suggest alternative Linux-compatible tools or approaches.
- For plan migration and management, document Linux-specific scenarios and clearly outline supported migration paths for Linux-hosted function apps.
- Review screenshots and UI instructions to ensure they are relevant for both Windows and Linux users, or provide parallel guidance.
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 (bash) and Windows (PowerShell, Cmd) instructions for most steps, but consistently lists Windows-specific commands and tools (PowerShell, Cmd, 'py' launcher) before or alongside Linux equivalents. Some troubleshooting and environment setup guidance is Windows-specific, and Windows tools (e.g., registry edits, 'py' launcher) are mentioned without Linux/macOS parallels. There is a slight preference for Windows-first presentation and more detailed Windows troubleshooting.
Recommendations
- Alternate the order of platform-specific tabs or examples, sometimes listing bash/Linux first to avoid implicit prioritization of Windows.
- Where Windows-specific troubleshooting is provided (e.g., registry edits for long paths), add equivalent Linux/macOS troubleshooting tips if applicable, or explicitly state when an issue is Windows-only.
- When referencing tools like the 'py' launcher (Windows), clarify the equivalent commands for Linux/macOS (e.g., always show 'python3' or 'python' usage).
- Ensure that all environment setup, activation, and troubleshooting steps are equally detailed for Linux/macOS as for Windows.
- Consider adding a summary table of commands for all platforms at the end of each section for quick reference.
- Review the order of platform-specific instructions to avoid always listing Windows first, which can reinforce a Windows-centric perspective.