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

1016 issues found
Showing 1-25 of 1016 flagged pages
Azure Functions Develop Azure Functions using Visual Studio .../main/articles/azure-functions/functions-develop-vs.md
High Priority View Details →
Scanned: 2026-01-14 00:00
Reviewed by: LLM Analysis
Issues: 4 bias types
Detected Bias Types
🔧 Windows Tools Windows First Missing Linux Example Powershell Heavy
Summary
The documentation is heavily focused on Visual Studio 2022 and its integrated tools, which are primarily available on Windows. All examples and instructions assume the use of Visual Studio's GUI, with no mention of cross-platform alternatives like VS Code or CLI workflows. Package installation commands are shown only for PowerShell (Package Manager Console), and remote debugging is explicitly stated as supported only on Windows. There are no Linux/macOS-specific instructions, screenshots, or parity notes, making it difficult for non-Windows users to follow or adapt the guidance.
Recommendations
  • Add equivalent instructions for developing, testing, and publishing Azure Functions using VS Code and Azure Functions Core Tools, which are cross-platform.
  • Include CLI-based examples for project creation, binding addition, and package installation (e.g., dotnet CLI, func CLI), not just PowerShell/Package Manager Console.
  • Provide guidance for remote debugging on Linux/macOS, or clearly state limitations and suggest alternatives.
  • Ensure screenshots and UI instructions are supplemented with text-based or CLI alternatives.
  • Explicitly mention platform requirements and offer links to Linux/macOS documentation where available.
GitHub Create Pull Request
Azure Functions Develop Azure Functions using Visual Studio .../main/articles/azure-functions/functions-develop-vs.md
High Priority View Details →
Scanned: 2026-01-13 00:00
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
🔧 Windows Tools Windows First Missing Linux Example
Summary
The documentation is heavily focused on Visual Studio (Windows-only) workflows, with all examples and instructions assuming the use of Visual Studio 2022. There are no instructions or examples for Linux/macOS users, such as using VS Code, CLI, or cross-platform tools. Windows-specific tools and dialogs are referenced throughout, and remote debugging is explicitly stated as only supported on Windows. Linux/macOS users are left without guidance for completing the documented tasks.
Recommendations
  • Add equivalent instructions and examples for developing Azure Functions using VS Code and Azure Functions Core Tools on Linux/macOS.
  • Include CLI-based workflows for project creation, binding addition, and publishing, suitable for cross-platform environments.
  • Explicitly mention platform limitations and provide links to Linux/macOS guides where Visual Studio features are unavailable.
  • Reorder sections or provide pivots so that Windows and cross-platform instructions are equally prominent.
  • Clarify remote debugging limitations and offer alternative debugging strategies for Linux/macOS users.
GitHub Create Pull Request
Azure Functions Guide for running C# Azure Functions in an isolated worker process ...icles/azure-functions/dotnet-isolated-process-guide.md
High Priority View Details →
Scanned: 2026-01-12 00:00
Reviewed by: LLM Analysis
Issues: 4 bias types
Detected Bias Types
Windows First 🔧 Windows Tools Powershell Heavy Missing Linux Example
Summary
The documentation demonstrates a moderate Windows bias. Windows-specific tools (Visual Studio, PowerShell) are mentioned before or more prominently than their Linux equivalents. Many CLI examples and configuration instructions default to Windows terminology and commands, with Linux alternatives often relegated to tabs or secondary notes. Some deployment and debugging instructions are Windows-centric, and PowerShell is listed as a primary automation option. Linux-specific guidance is present but less visible, and Linux examples are sometimes missing or less detailed.
Recommendations
  • Ensure all CLI and configuration examples are provided for both Windows and Linux, with equal prominence.
  • Present Linux tools (e.g., bash, Azure CLI) alongside or before Windows tools (e.g., PowerShell), not as secondary options.
  • Add explicit Linux shell examples for all Azure CLI and deployment commands, including file paths and environment variable conventions.
  • Include Linux-specific troubleshooting and debugging guidance where Windows instructions are given.
  • Avoid listing Windows tools (Visual Studio, PowerShell) first in getting started and deployment sections; alternate or parallelize the order.
  • Where tabs are used for code/configuration, ensure Linux is always an option and not omitted.
  • Review all references to Windows-only features and clarify Linux alternatives or limitations.
GitHub Create Pull Request
Azure Functions App settings reference for Azure Functions ...ain/articles/azure-functions/functions-app-settings.md
High Priority View Details →
Scanned: 2026-01-12 00:00
Reviewed by: LLM Analysis
Issues: 4 bias types
Detected Bias Types
Windows First 🔧 Windows Tools Powershell Heavy Missing Linux Example
Summary
The documentation page exhibits mild Windows bias. Several settings and examples are Windows-specific or prioritize Windows terminology and tools. Windows-only settings (e.g., WEBSITE_NODE_DEFAULT_VERSION) are called out, and some examples use Windows path syntax (e.g., %HOME%\typescript). PowerShell-specific configuration is documented in detail, while equivalent Linux shell or cross-platform alternatives are not. In some cases, Windows behaviors are explained before Linux equivalents, and PowerShell is mentioned as a primary automation tool, with Azure CLI listed second. Linux-specific settings (e.g., linuxFxVersion) are present but not always given parity in examples or explanations. Some settings (e.g., WEBSITE_TIME_ZONE) do provide both Windows and Linux examples, but this is not consistent throughout.
Recommendations
  • Ensure all examples and settings provide both Windows and Linux equivalents, especially for environment variables, file paths, and tooling.
  • Where PowerShell is mentioned for automation, also provide Bash/Azure CLI examples and reference cross-platform scripting.
  • For settings that are OS-specific, clearly label them and provide guidance for both Windows and Linux users.
  • Review sample values for path-related settings to use Linux syntax (e.g., /home/typescript) alongside Windows syntax.
  • Expand documentation for Linux-specific tools and patterns, such as bash scripting, Linux file system paths, and Linux container deployment.
  • Where deprecated or legacy Windows settings are discussed, ensure Linux alternatives are equally highlighted.
GitHub Create Pull Request
Azure Functions host.json reference for Azure Functions 2.x ...b/main/articles/azure-functions/functions-host-json.md
High Priority View Details →
Scanned: 2026-01-12 00:00
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
Powershell Heavy 🔧 Windows Tools Windows First
Summary
The documentation page for Azure Functions host.json is generally cross-platform, but there are several instances of Windows bias. The managedDependency feature is described as PowerShell-only, with references to Windows-centric dependency management. The snapshotConfiguration section refers to environment variables like LOCALAPPDATA, APPDATA, and TEMP, which are Windows-specific, and the default temp folder path uses the Windows-style %TEMP% variable. Additionally, references to Kudu performance counters and the use of Windows-style environment variable conventions appear before any Linux equivalents. While Linux is mentioned (e.g., console log color suppression), examples and explanations tend to default to Windows tools and patterns.
Recommendations
  • Provide equivalent Linux/macOS environment variable references and default paths (e.g., $HOME/tmp, /tmp) alongside Windows examples in snapshotConfiguration and tempFolder settings.
  • Clarify managedDependency support for non-PowerShell languages and platforms, or explicitly state Linux/Unix alternatives if available.
  • Mention Kudu alternatives or clarify its availability on Linux-based hosting plans.
  • Ensure examples and explanations use cross-platform conventions (e.g., both %TEMP% and $TMPDIR), and avoid Windows-first ordering.
  • Add more explicit Linux/macOS usage notes, especially for file paths, environment variables, and dependency management.
GitHub Create Pull Request
Azure Functions Use Python and TensorFlow for machine learning in Azure ...ure-functions/functions-machine-learning-tensorflow.md
High Priority View Details →
Scanned: 2026-01-12 00:00
Reviewed by: LLM Analysis
Issues: 4 bias types
Detected Bias Types
Windows First Powershell Heavy 🔧 Windows Tools Missing Linux Example
Summary
The documentation provides command examples for Bash (Linux/macOS), PowerShell, and Cmd, but frequently lists Windows-specific tools and patterns first or equally, such as using 'py' instead of 'python', referencing Windows registry edits for long paths, and providing PowerShell/Cmd examples alongside Bash. The troubleshooting section focuses on Windows-specific errors and solutions, with less detail for Linux/macOS issues. Visual Studio Code is recommended as the editor, which is cross-platform but often associated with Windows. The Azure Functions Core Tools and Python virtual environment instructions are generally cross-platform, but Windows-specific commands and troubleshooting are given prominence.
Recommendations
  • Ensure Linux/macOS examples are presented first or equally, not after Windows/PowerShell/Cmd examples.
  • Expand troubleshooting sections to include common Linux/macOS errors and solutions, not just Windows-specific issues like long path registry edits.
  • When referencing commands, clarify platform-specific differences and avoid assuming Windows tools (e.g., 'py' command) are available on all platforms.
  • Include alternative editors or tools that are popular on Linux/macOS, or clarify cross-platform compatibility.
  • Explicitly mention any platform-specific limitations or requirements for Azure Functions Core Tools and Python environments.
  • Where possible, provide parity in depth and detail for both Windows and Linux/macOS instructions and troubleshooting.
GitHub Create Pull Request
Azure Functions Deployment technologies in Azure Functions ...s/azure-functions/functions-deployment-technologies.md
High Priority View Details →
Scanned: 2026-01-12 00:00
Reviewed by: LLM Analysis
Issues: 4 bias types
Detected Bias Types
Windows First Missing Linux Example 🔧 Windows Tools Powershell Heavy
Summary
The documentation page demonstrates a Windows bias in several ways: Windows-based deployment methods (such as Visual Studio and FTPS) are mentioned first and more frequently, with Linux-specific methods often described as exceptions or limitations. Several deployment technologies are marked as 'Windows-only' or default to Windows, while Linux equivalents are less emphasized or require additional configuration. Examples and tool references (Visual Studio, FTPS, Local Git) are predominantly Windows-centric, and Linux deployment scenarios are often described in terms of their constraints or as alternatives rather than primary options.
Recommendations
  • Provide Linux-specific deployment examples and workflows alongside Windows ones, ensuring parity in detail and clarity.
  • When listing deployment methods, avoid listing Windows tools (Visual Studio, FTPS, Local Git) first; instead, present cross-platform tools (Azure CLI, Core Tools) before platform-specific ones.
  • Explicitly mention Linux equivalents for all deployment technologies, including any required configuration steps, and provide sample commands or scripts for Linux environments.
  • Clarify which deployment methods are cross-platform and which are platform-specific, and ensure that Linux options are not described only in terms of limitations.
  • Include references to Linux-native tools and environments (e.g., Bash, Linux file system paths) in examples and instructions.
  • Balance the use of screenshots and walkthroughs between Windows and Linux environments, or use generic/neutral representations where possible.
GitHub Create Pull Request
Azure Functions Create a function in Azure from the command line ...es/azure-functions/how-to-create-function-azure-cli.md
High Priority View Details →
Scanned: 2026-01-12 00:00
Reviewed by: LLM Analysis
Issues: 4 bias types
Detected Bias Types
Windows First Powershell Heavy 🔧 Windows Tools Missing Linux Example
Summary
The documentation page exhibits mild Windows bias. In several places, Windows-specific tools and patterns (such as PowerShell and Cmd) are presented alongside Bash, but Windows shells are listed first. The Java section provides examples for Bash, PowerShell, and Cmd, but Bash is not consistently prioritized. There is mention of setting JAVA_HOME, which is relevant for both platforms, but the example paths and instructions are not platform-neutral. The documentation refers to 'terminal or command prompt' generically, but does not provide explicit Linux-specific instructions or troubleshooting. There are no explicit examples of Linux-specific tools (e.g., shell scripts, environment variable export patterns), and the use of 'console' as a code block type is ambiguous. The inclusion of jq and Azure CLI is platform-neutral, but the overall pattern leans toward Windows-first presentation.
Recommendations
  • Ensure Bash (Linux/macOS) examples are listed before or alongside Windows (PowerShell/Cmd) examples, especially in multi-tab sections.
  • Explicitly mention Linux/macOS terminals and provide troubleshooting or setup notes for those platforms.
  • When referencing environment variables (e.g., JAVA_HOME), provide both Windows (set) and Linux/macOS (export) syntax.
  • Use platform-neutral terminology (e.g., 'terminal' instead of 'command prompt') and clarify any platform-specific steps.
  • Add explicit Linux/macOS shell script examples where appropriate, and clarify any differences in file paths or permissions.
  • Review included snippets (INCLUDE blocks) to ensure they do not assume Windows tooling or patterns.
GitHub Create Pull Request
Azure Functions Migrate apps from Azure Functions version 1.x to 4.x ...rticles/azure-functions/migrate-version-1-version-4.md
High Priority View Details →
Scanned: 2026-01-12 00:00
Reviewed by: LLM Analysis
Issues: 4 bias types
Detected Bias Types
Powershell Heavy 🔧 Windows Tools Windows First Missing Linux Example
Summary
The documentation page exhibits Windows bias primarily through its use of PowerShell scripts for key migration steps, such as identifying function apps to migrate. These examples are presented without equivalent Bash, Azure CLI, or Linux-native alternatives. The documentation references Windows-centric tools (PowerShell, Visual Studio) and patterns (Cloud Shell with PowerShell), and does not provide Linux-first or cross-platform instructions for these steps. This may hinder Linux users or those who prefer Bash/Azure CLI workflows.
Recommendations
  • Provide equivalent Bash and Azure CLI examples for identifying function apps to migrate, alongside PowerShell.
  • Explicitly mention cross-platform alternatives for all command-line instructions, including how to perform steps on Linux/macOS.
  • Include references to Linux-native tools and workflows (e.g., VS Code, Azure CLI) where Visual Studio or PowerShell are mentioned.
  • Ensure that all code snippets and instructions are platform-agnostic or have clear alternatives for non-Windows environments.
  • Add a section or callout clarifying platform compatibility for all tools and scripts, and link to relevant cross-platform documentation.
GitHub Create Pull Request
Azure Functions Azure Functions language stack support policy ...in/articles/azure-functions/language-support-policy.md
High Priority View Details →
Scanned: 2026-01-12 00:00
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
🔧 Windows Tools Powershell Heavy Windows First
Summary
The documentation page demonstrates mild Windows bias. It lists Azure PowerShell as a primary method for checking runtime versions alongside Azure CLI and portal, and includes a dedicated resource section for PowerShell as a supported language. There is no explicit mention of Linux-specific tools (e.g., Bash, shell scripts), and the ordering of runtime inspection methods puts PowerShell on equal footing with CLI and portal, which may be interpreted as Windows-centric. No Linux-specific examples or tools are provided.
Recommendations
  • Add explicit examples and instructions for Linux users, such as using Bash or shell scripting to interact with Azure Functions.
  • Clarify cross-platform parity by mentioning that Azure CLI is available on both Windows and Linux, and provide Linux-specific usage notes where relevant.
  • Include references to Linux-native tools or environments (e.g., bash, zsh, or other shells) in sections discussing runtime inspection and configuration.
  • Ensure that PowerShell is not presented as the default or primary method unless justified by user base data; otherwise, present CLI and portal first, with PowerShell as an alternative.
  • Consider adding a section or FAQ entry addressing cross-platform support and best practices for both Windows and Linux users.
GitHub Create Pull Request
Azure Functions Build a custom remote MCP server using Azure Functions ...s/azure-functions/scenario-custom-remote-mcp-server.md
High Priority View Details →
Scanned: 2026-01-12 00:00
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
🔧 Windows Tools Windows First Powershell Heavy
Summary
The documentation demonstrates mild Windows bias, primarily in the deployment and configuration steps. Windows-specific tools and patterns (such as PowerShell scripts and references to Windows command line) are presented alongside, but often before, Linux/macOS equivalents. The documentation also references PowerShell and Windows-specific installation instructions in the prerequisites, and the Windows tab for deployment scripts uses PowerShell, which may be less familiar to Linux users. However, Linux/macOS instructions are present and reasonably complete, and most examples are cross-platform.
Recommendations
  • Ensure Linux/macOS instructions are always presented first or equally alongside Windows instructions, rather than after.
  • Where possible, use shell-agnostic commands (e.g., bash scripts) as the primary example, with PowerShell as an alternative.
  • Avoid referencing Windows-specific installation instructions or tools unless absolutely necessary; provide parity for Linux (e.g., installation steps for PowerShell on Linux if referenced).
  • Explicitly state cross-platform compatibility for all tools and commands, and clarify any platform-specific differences.
  • Consider including troubleshooting notes for common Linux/macOS issues (e.g., environment variable handling, shell differences).
GitHub Create Pull Request
Azure Functions Bring dependencies and third-party libraries to Azure Functions ...icles/azure-functions/bring-dependency-to-functions.md
High Priority View Details →
Scanned: 2026-01-12 00:00
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
🔧 Windows Tools Windows First Missing Linux Example
Summary
The documentation demonstrates Windows bias in several ways: Java examples use Windows-style paths and reference ffmpeg.exe, with no mention of Linux equivalents or cross-platform considerations. The Java section instructs users to use a Windows-specific executable and path format, and does not provide Linux alternatives or guidance. PowerShell is mentioned as an upload option for Azure Files, but Linux-native tools (e.g., scp, rsync) are not referenced. The Python section does mention chmod for Linux, but overall, Windows tools and patterns are presented first or exclusively, especially in Java examples.
Recommendations
  • Provide Linux-specific examples for Java, including use of ffmpeg (not ffmpeg.exe) and Linux-style paths.
  • Explicitly mention cross-platform considerations in all code samples, such as path separators and executable file extensions.
  • Include Linux-native upload tools (e.g., scp, rsync, sftp) as alternatives to PowerShell for uploading files to Azure Files.
  • Add notes or code samples showing how to set executable permissions on Linux for Java (e.g., using chmod in deployment scripts).
  • Ensure that documentation sections do not assume Windows as the default environment, and present Linux options equally or first where appropriate.
GitHub Create Pull Request
Azure Functions Configure monitoring for Azure Functions .../main/articles/azure-functions/configure-monitoring.md
High Priority View Details →
Scanned: 2026-01-12 00:00
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
Powershell Heavy 🔧 Windows Tools Windows First
Summary
The documentation page demonstrates moderate Windows bias. Command-line examples for overriding monitoring configuration are provided for both Azure CLI and PowerShell, but PowerShell is featured as a primary scripting option, which is Windows-specific. There is no mention of Linux shell equivalents (e.g., Bash), and PowerShell is presented before any Linux alternatives. Additionally, references to Visual Studio and Windows-centric tooling appear without equal emphasis on Linux-native tools or workflows. While Azure CLI is cross-platform, the lack of explicit Bash or Linux shell examples and the prioritization of PowerShell and Visual Studio contribute to a Windows-first orientation.
Recommendations
  • Add Bash shell examples alongside PowerShell for all command-line instructions, especially for overriding app settings.
  • Explicitly mention that Azure CLI commands can be run on Linux, macOS, and Windows, and provide sample Bash syntax (e.g., export, az commands) where appropriate.
  • Include references to Linux-native editors (e.g., VS Code on Linux, vim, nano) and workflows in sections discussing Visual Studio or Windows-centric tools.
  • Ensure that instructions for managing app settings in the Azure portal clarify any Linux-specific caveats (such as the note about periods in app settings on Linux plans), and provide alternative Linux-friendly approaches.
  • Where PowerShell is used, clarify its availability on Linux and macOS, or offer alternative shell scripting examples.
GitHub Create Pull Request
Azure Functions Build a scalable web API using Azure Functions ...functions/create-first-function-azure-developer-cli.md
High Priority View Details →
Scanned: 2026-01-12 00:00
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
Windows First Powershell Heavy 🔧 Windows Tools
Summary
The documentation provides examples and instructions for multiple programming languages and platforms, but there is a noticeable Windows bias in several areas. Windows-specific command shells (Cmd, PowerShell) are given dedicated sections, sometimes before Linux equivalents. PowerShell is treated as a first-class language option, and Windows command patterns (e.g., .venv\scripts\activate, for /f loops) are included. Linux instructions are present, but Windows tools and patterns are often mentioned first or with more detail.
Recommendations
  • Ensure Linux/macOS instructions are presented before or alongside Windows instructions, especially in tabbed command sections.
  • Provide parity in shell examples: include bash/zsh instructions for all relevant commands, not just Python virtual environments.
  • Avoid Windows-centric terminology like 'command prompt' as the default; use 'terminal' or clarify both.
  • For PowerShell, clarify cross-platform usage and provide equivalent bash/zsh scripts where possible.
  • Review all code and command examples to ensure Linux users are not required to infer or adapt Windows-specific instructions.
  • Explicitly mention platform compatibility for tools like Azure Developer CLI and Azure Functions Core Tools, and link to platform-specific installation guides.
GitHub Create Pull Request
Azure Functions How to disable functions in Azure Functions ...blob/main/articles/azure-functions/disable-function.md
High Priority View Details →
Scanned: 2026-01-12 00:00
Reviewed by: LLM Analysis
Issues: 4 bias types
Detected Bias Types
Windows First Powershell Heavy Missing Linux Example 🔧 Windows Tools
Summary
The documentation presents Windows-centric tools and workflows (Azure PowerShell, portal UI) before or alongside cross-platform options (Azure CLI), with PowerShell examples given equal prominence to CLI. There is no mention of Linux-specific shell usage (e.g., Bash), nor are there examples tailored for Linux environments. The only explicit Linux consideration is a limitation note, not a parity feature or example.
Recommendations
  • Add explicit Bash or shell examples for Linux users, especially for Azure CLI commands.
  • Clarify that Azure CLI is cross-platform and highlight its use for Linux/macOS users.
  • Reorder examples to present Azure CLI before PowerShell, or group them by platform.
  • Include notes or examples for managing app settings using Linux-native tools or scripts.
  • Address Linux-specific workflows, such as using environment variables or configuration files in Linux deployments.
  • Expand the 'Considerations' section to include best practices and caveats for Linux environments, not just limitations.
GitHub Create Pull Request
Azure Functions Bindings for Durable Functions - Azure .../azure-functions/durable/durable-functions-bindings.md
High Priority View Details →
Scanned: 2026-01-12 00:00
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
🔧 Windows Tools Powershell Heavy Windows First
Summary
The documentation provides extensive PowerShell examples and references to Windows-specific tools and configuration patterns (such as function.json and run.ps1), especially in the PowerShell sections. These examples and configuration instructions are tailored to Windows environments and do not mention Linux alternatives or cross-platform considerations. The documentation also introduces PowerShell before Python in some places and does not clarify platform differences, which may implicitly prioritize Windows usage.
Recommendations
  • Add explicit notes about PowerShell support on Linux and provide bash or shell script equivalents where possible.
  • Clarify that function.json and run.ps1 patterns are not exclusive to Windows and describe how to use them on Linux/macOS.
  • Include cross-platform CLI examples (e.g., Azure CLI, bash) alongside PowerShell for orchestration and activity triggers.
  • Ensure that examples and configuration instructions do not assume a Windows environment and mention any platform-specific limitations.
  • Where PowerShell is used, add links or references to Linux-compatible shells and scripting approaches for Azure Functions.
GitHub Create Pull Request
Azure Functions Durable Functions best practices and diagnostic tools ...s/durable/durable-functions-best-practice-reference.md
High Priority View Details →
Scanned: 2026-01-12 00:00
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
🔧 Windows Tools Powershell Heavy Windows First
Summary
The documentation page demonstrates mild Windows bias by referencing Windows-centric tools and patterns, such as PowerShell and Visual Studio, more prominently than Linux alternatives. Examples include listing PowerShell as a primary language for concurrency tuning, referencing Visual Studio and Visual Studio Code for Roslyn Analyzer usage, and mentioning Application Insights (which is often used in Windows-centric environments) without highlighting Linux-friendly diagnostic alternatives. There are no explicit Linux examples or mentions of Linux-specific tools, and Windows tools are often listed before or instead of Linux equivalents.
Recommendations
  • Provide explicit Linux examples for diagnostic and development workflows, such as using Bash or Linux-native editors (e.g., Vim, Emacs) for code analysis.
  • Mention cross-platform alternatives to PowerShell, such as Bash scripts, when discussing performance and concurrency settings.
  • Reference Linux-compatible monitoring and logging tools (e.g., Azure CLI, Kusto queries from Linux terminals) alongside Application Insights.
  • Clarify that Visual Studio Code is cross-platform and suggest Linux installation instructions or alternatives for Roslyn Analyzer usage.
  • Add links or notes about using Durable Functions on Linux-based Azure Function hosts, including any platform-specific considerations.
GitHub Create Pull Request
Azure Functions Configure Durable Functions app with managed identity ...urable/durable-functions-configure-managed-identity.md
High Priority View Details →
Scanned: 2026-01-12 00:00
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
Windows First Missing Linux Example 🔧 Windows Tools
Summary
The documentation page demonstrates a Windows bias by referencing Windows-centric tools and workflows (such as Visual Studio, Visual Studio Code, and Azure CLI) exclusively or first, without mentioning Linux equivalents or providing Linux-specific instructions. The local development section assumes use of Microsoft developer tools and does not address Linux authentication contexts or alternative editors. There are no explicit Linux examples or instructions for configuring Durable Functions with managed identity on Linux environments.
Recommendations
  • Include explicit instructions and examples for Linux environments, such as authentication via Linux shell, use of open-source editors (e.g., VS Code on Linux, Vim), and Linux-specific Azure CLI usage.
  • Mention Linux developer credential sources (e.g., Azure CLI on Linux, environment variables, service principals) alongside Windows/Visual Studio contexts.
  • Provide screenshots and walkthroughs using Linux terminals and file systems where appropriate.
  • Clarify that Azurite and Durable Functions are cross-platform, and provide setup instructions for Linux and macOS.
  • Add a note or section on differences or considerations when developing and deploying from Linux systems.
GitHub Create Pull Request
Azure Functions Durable Functions publishing to Azure Event Grid ...unctions/durable/durable-functions-event-publishing.md
High Priority View Details →
Scanned: 2026-01-12 00:00
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
🔧 Windows Tools Windows First Missing Linux Example
Summary
The documentation page shows evidence of Windows bias primarily through references to Windows-specific tools (such as the Storage Emulator), and by mentioning Windows-centric options (PowerShell, Storage Emulator) before or instead of Linux equivalents. There are no explicit Linux or cross-platform alternatives provided for the Storage Emulator, and PowerShell is referenced as an alternative to Azure CLI without any mention of Bash or Linux shell scripting. The instructions for local development and debugging assume the use of the Storage Emulator, which is only available on Windows, and do not mention Azurite's cross-platform capabilities or provide Linux setup instructions.
Recommendations
  • Replace references to the Storage Emulator with Azurite, and provide explicit instructions for installing and running Azurite on Linux and macOS.
  • When mentioning PowerShell, also mention Bash or other Linux-native scripting options, and provide equivalent examples if relevant.
  • Ensure all CLI examples are explicitly cross-platform (e.g., Azure CLI), and clarify that they work on Linux, macOS, and Windows.
  • Add a section or callout for Linux/macOS users, including any differences in setup, especially for local development and storage emulation.
  • Review screenshots and UI instructions to ensure they are not Windows-specific, or provide alternatives for Linux/macOS users where applicable.
GitHub Create Pull Request
Azure Functions Orchestration versioning in Durable Functions - Azure .../durable/durable-functions-orchestration-versioning.md
High Priority View Details →
Scanned: 2026-01-12 00:00
Reviewed by: LLM Analysis
Issues: 4 bias types
Detected Bias Types
Powershell Heavy Windows First 🔧 Windows Tools Missing Linux Example
Summary
The documentation provides language-specific examples, including PowerShell, which is primarily a Windows-centric technology. PowerShell examples are given equal prominence alongside Linux-friendly languages (Python, JavaScript), and PowerShell-specific SDKs and patterns are mentioned throughout. There are no explicit Linux shell (bash, sh) examples or references to Linux-native tools or deployment patterns. The documentation assumes PowerShell as the default shell for scripting, which may disadvantage Linux users who commonly use bash/zsh. Additionally, Windows/PowerShell terminology and tooling are referenced before or instead of Linux equivalents (e.g., no bash example for orchestration triggers or activity calls).
Recommendations
  • Add bash or shell script examples for orchestration triggers and activity calls, especially in sections where PowerShell is demonstrated.
  • Include references to Linux-native tools and deployment patterns (e.g., Azure CLI usage from bash, Linux service management).
  • Clarify that PowerShell examples are primarily for Windows users and provide equivalent Linux shell examples for parity.
  • Where SDKs or tooling are Windows-specific (e.g., PowerShell SDK), mention Linux alternatives or note platform limitations.
  • Consider reordering examples so that Linux-friendly languages (Python, JavaScript) are presented before PowerShell, or alternate the order to avoid implicit prioritization.
GitHub Create Pull Request
Azure Functions How to run Durable Functions as WebJobs - Azure ...ure-functions/durable/durable-functions-webjobs-sdk.md
High Priority View Details →
Scanned: 2026-01-12 00:00
Reviewed by: LLM Analysis
Issues: 4 bias types
Detected Bias Types
Windows First Missing Linux Example Powershell Heavy 🔧 Windows Tools
Summary
The documentation page demonstrates a strong Windows bias. It consistently presents Windows-centric development patterns, such as using Visual Studio (Windows-only) and the Windows Classic Desktop project template as the primary workflow. All code/package installation examples use PowerShell commands, with no mention of Linux equivalents (e.g., bash, dotnet CLI, or cross-platform editors). The Azurite storage emulator is referenced without clarifying cross-platform usage, and there are no instructions for running or deploying WebJobs from Linux or macOS environments. Linux tools, editors, and workflows are either omitted or mentioned only as alternatives, with caveats.
Recommendations
  • Provide equivalent instructions for Linux/macOS environments, including using Visual Studio Code and the dotnet CLI for project creation and package management.
  • Include bash or shell commands for installing NuGet packages, alongside PowerShell examples.
  • Clarify that Azurite is cross-platform and provide installation/running instructions for Linux/macOS.
  • Offer guidance for running and deploying WebJobs from Linux/macOS, including any platform-specific considerations.
  • Present cross-platform workflows first or in parallel, rather than defaulting to Windows/Visual Studio.
  • Explicitly mention any limitations or differences when using Linux/macOS, and provide workarounds or alternatives.
GitHub Create Pull Request
Azure Functions Sub-orchestrations for Durable Functions - Azure ...ctions/durable/durable-functions-sub-orchestrations.md
High Priority View Details →
Scanned: 2026-01-12 00:00
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
Powershell Heavy 🔧 Windows Tools Windows First
Summary
The documentation page includes a prominent PowerShell-specific note and full PowerShell code examples alongside other languages. PowerShell is a Windows-centric tool, and its inclusion (with a dedicated SDK note and example) may signal a Windows bias. The note about PowerShell SDK appears before any mention of Linux or cross-platform equivalents, and there is no mention of Bash, Linux shell, or cross-platform scripting alternatives. There is no explicit Linux example or reference to Linux-specific tooling or patterns.
Recommendations
  • Add a note clarifying PowerShell support on Linux and macOS, or mention cross-platform alternatives where relevant.
  • Include Bash or other Linux shell examples if scripting is discussed, or clarify that Durable Functions are cross-platform and provide guidance for Linux users.
  • Balance the introductory notes by mentioning both Windows and Linux environments, especially when discussing SDKs or tooling.
  • If PowerShell is shown, consider also showing Bash or Python CLI equivalents for orchestration management tasks.
  • Explicitly state platform compatibility for all SDKs and tools referenced, and link to documentation for Linux/macOS usage where available.
GitHub Create Pull Request
Azure Functions Versioning in Durable Functions - Azure ...zure-functions/durable/durable-functions-versioning.md
High Priority View Details →
Scanned: 2026-01-12 00:00
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
Powershell Heavy Windows First Missing Linux Example
Summary
The documentation page demonstrates a Windows bias by providing code examples in C#, PowerShell, and Java, with PowerShell being a Windows-centric shell language. There are no examples for Linux-native shells (such as Bash), nor are Linux-specific tools or deployment patterns mentioned. Windows/PowerShell examples are presented alongside C# and Java, but Linux alternatives are absent, and deployment guidance references Azure App Service deployment slots (which are more familiar to Windows users) without mentioning Linux-specific deployment workflows or CLI tools.
Recommendations
  • Add Bash or other Linux shell examples for orchestration logic, especially for users running Durable Functions on Linux.
  • Include references to Linux-native tools and deployment patterns, such as Azure CLI commands for deployment and queue management.
  • Explicitly mention Linux support and parity in deployment slot guidance, including any differences or considerations for Linux-based Azure Functions.
  • Provide links or sections on managing Durable Functions storage and queues using Linux tools (e.g., Azure CLI, azcopy) in addition to Windows-centric approaches.
  • Ensure that examples and instructions are platform-neutral or provide parallel guidance for both Windows and Linux environments.
GitHub Create Pull Request
Azure Functions Choosing an orchestration framework ...rable-task-scheduler/choose-orchestration-framework.md
High Priority View Details →
Scanned: 2026-01-12 00:00
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
🔧 Windows Tools Powershell Heavy Windows First
Summary
The documentation page demonstrates mild Windows bias. PowerShell is listed as a first-class language for Durable Functions quickstarts, with a dedicated link, while Linux-specific shells (e.g., Bash) are not mentioned. The quickstart and sample tables list PowerShell alongside .NET, Python, JavaScript/TypeScript, and Java, but do not provide parity for Linux-native scripting languages or tools. There is also a tendency to mention Windows-centric technologies (PowerShell, MSSQL) before Linux alternatives, and no explicit mention of Linux development environments or shell usage.
Recommendations
  • Add Linux/Bash shell examples and quickstarts alongside PowerShell for Durable Functions.
  • Explicitly mention Linux development environments and workflows (e.g., VS Code on Linux, Bash terminal usage).
  • Include parity for Linux-native tools and scripting languages in quickstart/sample tables.
  • Avoid listing Windows-centric technologies (PowerShell, MSSQL) before Linux alternatives; present them in parallel or with equal prominence.
  • Clarify that Durable Functions and SDKs are cross-platform and provide guidance for Linux users.
GitHub Create Pull Request
Azure Functions Quickstart: Create a Java Durable Functions app ...in/articles/azure-functions/durable/quickstart-java.md
High Priority View Details →
Scanned: 2026-01-12 00:00
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
Windows First 🔧 Windows Tools Powershell Heavy
Summary
The documentation demonstrates some Windows bias. In the manual setup section, the default runtime OS in the Maven plugin configuration is set to 'windows', with no mention of Linux alternatives. In the Maven command section, examples for Bash, PowerShell, and Cmd are provided, but PowerShell and Cmd (Windows shells) are listed after Bash, which is positive, but their inclusion may reinforce Windows-centric workflows. Visual Studio Code instructions are cross-platform, but there is no explicit mention of Linux-specific considerations or parity in deployment/runtime configuration. The use of Azure Functions Core Tools is cross-platform, but the documentation does not clarify Linux support or provide Linux-specific troubleshooting or configuration notes.
Recommendations
  • Explicitly mention Linux support in all relevant sections, especially in runtime configuration (e.g., show how to set <os>linux</os> in the Maven plugin).
  • Provide Linux-specific examples or troubleshooting notes where appropriate, such as file paths, permissions, or shell commands.
  • Balance shell examples by including zsh or other common Linux shells, and clarify that Bash commands work on Linux/macOS.
  • In the Maven plugin configuration, show both Windows and Linux runtime options, or default to a neutral value.
  • Add a note about Azure Functions Core Tools being cross-platform and provide installation instructions for Linux.
  • Ensure that any references to tools or workflows (e.g., Visual Studio Code) clarify their cross-platform nature and provide links to Linux/macOS setup guides.
GitHub Create Pull Request
← Previous Page 1 of 41 Next →