Azure Functions

711
Total Pages
610
Linux-Friendly Pages
101
Pages with Bias
14.2%
Bias Rate

Bias Trend Over Time

Pages with Bias Issues

233 issues found
Showing 176-200 of 233 flagged pages
Azure Functions Manage connections in Azure Functions ...ob/main/articles/azure-functions/manage-connections.md
Low Priority View Details →
Scanned: 2026-01-12 00:00
Reviewed by: LLM Analysis
Issues: 2 bias types
Detected Bias Types
Windows First Missing Linux Example
Summary
The documentation provides code examples and configuration guidance primarily for .NET (C#) and JavaScript, with a strong focus on .NET libraries and patterns (e.g., HttpClient, SqlClient, Entity Framework). It references configuration files and paths (like local.settings.json) that are cross-platform, but does not mention platform-specific tools or commands (such as PowerShell or Windows-only utilities). However, the ordering and emphasis on .NET examples, as well as the lack of explicit Linux/macOS-specific instructions or examples (e.g., environment variable setup, file paths, or troubleshooting steps for non-Windows environments), creates a subtle bias toward Windows and .NET users.
Recommendations
  • Add explicit Linux/macOS instructions for configuring environment variables and connection strings, including examples using bash/zsh.
  • Include notes on file path differences and permissions for local.settings.json on Linux/macOS.
  • Provide troubleshooting tips relevant to Linux/macOS environments (e.g., common issues with file permissions, service limits, or networking).
  • Ensure that examples for JavaScript and other languages mention cross-platform considerations, such as differences in process.env usage or agent configuration.
  • Consider adding a section or callout highlighting cross-platform compatibility and any platform-specific caveats.
GitHub Create Pull Request
Azure Functions Memory profiling of Python apps in Azure Functions ...es/azure-functions/python-memory-profiler-reference.md
Low Priority View Details →
Scanned: 2026-01-12 00:00
Reviewed by: LLM Analysis
Issues: 2 bias types
Detected Bias Types
Windows First Powershell Heavy
Summary
The documentation demonstrates minor Windows bias in the local development setup instructions. Windows PowerShell is mentioned first, and Windows-specific commands (e.g., 'py -m venv .venv', '.venv\Scripts\Activate.ps1') are presented before their Linux equivalents. However, Linux alternatives are provided for each step, and the rest of the documentation is platform-agnostic.
Recommendations
  • Present Linux and Windows instructions side-by-side or in tabs, rather than listing Windows first.
  • Use neutral phrasing such as 'Open a terminal (Windows PowerShell or Linux shell)' instead of 'Open a Windows PowerShell or any Linux shell as you prefer.'
  • Consider listing Linux/macOS commands first or equally to avoid perceived prioritization.
  • Explicitly mention macOS where Linux is referenced, as many users develop on macOS.
GitHub Create Pull Request
Azure Functions Troubleshoot Python function apps in Azure Functions ...n/articles/azure-functions/recover-python-functions.md
Low 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 demonstrates mild Windows bias in several areas. Windows/Powershell commands are often presented before their Linux equivalents, and Windows-specific tools or patterns (e.g., PowerShell, 'py' launcher) are referenced. Some troubleshooting steps and examples default to Windows-first instructions, with Linux/Unix alternatives provided but sometimes less prominently. There are also sections where only Windows/macOS development scenarios are discussed, with Linux parity implied but not always explicitly covered.
Recommendations
  • Present Linux/macOS and Windows examples side-by-side, or default to Linux first since Azure Functions Python runtime is Linux-based.
  • Ensure all command-line instructions include both Bash and PowerShell/Cmd variants, with equal prominence.
  • Avoid referencing Windows-specific tools (e.g., 'py' launcher, PowerShell) without Linux equivalents; use 'python3' as the default.
  • Explicitly mention Linux development scenarios where only Windows/macOS are referenced.
  • Clarify when instructions or troubleshooting steps differ for Linux vs. Windows/macOS, especially in deployment and package management sections.
GitHub Create Pull Request
Azure Functions Respond to database changes in Azure SQL Database using Azure Functions ...ure-functions/scenario-database-changes-azure-sqldb.md
Low Priority View Details →
Scanned: 2026-01-12 00:00
Reviewed by: LLM Analysis
Issues: 2 bias types
Detected Bias Types
Windows First Missing Linux Example
Summary
The documentation page demonstrates a mild Windows bias by consistently presenting instructions and examples using Visual Studio Code with Windows-centric keybindings (e.g., <kbd>F1</kbd>, <kbd>Ctrl</kbd>+click) and referencing features like the SQL Server (mssql) extension, which is available cross-platform but is most commonly used on Windows. There are no explicit Linux/macOS command-line examples, nor are alternative Linux-native tools (e.g., sqlcmd, Azure Data Studio) mentioned for interacting with Azure SQL Database. The documentation does acknowledge macOS in a few places (e.g., <kbd>Ctrl</kbd>+click on macOS), but overall, the flow assumes a Windows-like experience and omits Linux-specific guidance.
Recommendations
  • Add explicit instructions and examples for Linux/macOS users, such as using Azure Data Studio or sqlcmd for database interactions.
  • Include terminal-based steps for provisioning and connecting to Azure SQL Database, not just Visual Studio Code extension workflows.
  • Present cross-platform keybindings and clarify differences in UI/UX between Windows, Linux, and macOS environments.
  • Mention and link to Linux/macOS installation guides for required tools (azd, Azure Functions Core Tools, mssql extension, etc.).
  • Consider providing a section or callout for Linux/macOS users to ensure parity and reduce friction.
GitHub Create Pull Request
Azure Functions Respond to database changes in Azure Cosmos DB using Azure Functions ...-functions/scenario-database-changes-azure-cosmosdb.md
Low Priority View Details →
Scanned: 2026-01-12 00:00
Reviewed by: LLM Analysis
Issues: 2 bias types
Detected Bias Types
🔧 Windows Tools Windows First
Summary
The documentation page demonstrates minor Windows bias in several areas. Windows-specific tools and patterns (such as PowerShell's Set-ExecutionPolicy) are mentioned, and Windows instructions are often presented before or alongside Linux/macOS equivalents. There is also a troubleshooting note specifically for Windows users regarding the default terminal in Visual Studio Code. However, Linux/macOS instructions are present and generally complete, and most commands are cross-platform.
Recommendations
  • Ensure Linux/macOS instructions are presented before or alongside Windows instructions, not after.
  • Expand troubleshooting sections to include common Linux/macOS issues, not just Windows-specific ones.
  • Where possible, use cross-platform commands and avoid Windows-specific terminology (e.g., refer to 'terminal' rather than 'Windows command prompt').
  • Add explicit notes confirming parity of functionality and experience for Linux/macOS users.
  • Include links to Linux/macOS-specific documentation or resources, especially for setup and permissions.
GitHub Create Pull Request
Azure Functions Durable Functions publishing to Azure Event Grid ...unctions/durable/durable-functions-event-publishing.md
Low 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 exhibits mild Windows bias primarily through references to Windows-specific tools (Storage Emulator), listing Windows-centric options before Linux alternatives, and lacking explicit Linux/macOS instructions or examples for local development and storage emulation. While Azure CLI is cross-platform and used for most commands, the local development guidance and emulator references favor Windows users.
Recommendations
  • Explicitly mention and provide instructions for Linux/macOS users, especially regarding local Azure Storage emulation (e.g., highlight Azurite as the recommended emulator for all platforms, and provide installation steps for Linux/macOS).
  • Avoid referencing the legacy Storage Emulator (Windows-only) without clarifying its platform limitations; recommend Azurite as the default emulator.
  • Where PowerShell is mentioned as an alternative, clarify that Azure CLI is cross-platform and provide equivalent bash/zsh examples if relevant.
  • Ensure screenshots and portal instructions do not assume Windows UI conventions.
  • Add a section or note on how to run Durable Functions locally on Linux/macOS, including any platform-specific caveats.
GitHub Create Pull Request
Azure Functions Configure monitoring for Azure Functions .../main/articles/azure-functions/configure-monitoring.md
Low Priority View Details →
Scanned: 2026-01-12 00:00
Reviewed by: LLM Analysis
Issues: 2 bias types
Detected Bias Types
Powershell Heavy Windows First
Summary
The documentation provides both Azure CLI and PowerShell examples for overriding monitoring configuration, but PowerShell is presented as a primary option for v1.x, which is Windows-specific. There are no explicit Linux/macOS shell examples (e.g., Bash), and PowerShell is mentioned before alternatives. Additionally, a note clarifies that app settings containing periods are not supported on Linux in certain plans, but does not provide Linux-specific workarounds or examples. The documentation does not show exclusive use of Windows tools, but the presence and ordering of PowerShell examples and lack of Linux/macOS shell parity indicate a mild Windows bias.
Recommendations
  • Add Bash or shell script examples for overriding app settings, especially for Linux/macOS users.
  • Clarify Linux/macOS alternatives where PowerShell is suggested, and provide explicit instructions for those platforms.
  • Ensure that CLI examples are shown before or alongside PowerShell, not after.
  • Where platform-specific limitations exist (e.g., app settings with periods on Linux), provide clear Linux/macOS workarounds or guidance.
GitHub Create Pull Request
Azure Functions Build a scalable web API using Azure Functions ...functions/create-first-function-azure-developer-cli.md
Low Priority View Details →
Scanned: 2026-01-12 00:00
Reviewed by: LLM Analysis
Issues: 2 bias types
Detected Bias Types
Powershell Heavy Windows First
Summary
The documentation provides parity for most platforms and languages, but there is a mild Windows bias in some areas. PowerShell is included as a first-class language option, and Windows-specific instructions (Cmd, PowerShell) are given equal or greater prominence compared to Linux/macOS equivalents. In some command sections, Windows variants are listed before Linux/macOS, and PowerShell-specific instructions are detailed, which may create friction for Linux/macOS users unfamiliar with Windows tools.
Recommendations
  • Ensure Linux/macOS instructions are always presented first or equally alongside Windows instructions.
  • Where PowerShell is used, provide bash/zsh equivalents for Linux/macOS users.
  • Clarify which commands are cross-platform and which are Windows-only, especially in sections involving environment variable setting and activation of virtual environments.
  • Consider adding explicit notes or tables indicating platform compatibility for each command.
  • Reduce emphasis on PowerShell unless necessary for the language or task.
GitHub Create Pull Request
Azure Functions Durable Functions best practices and diagnostic tools ...s/durable/durable-functions-best-practice-reference.md
Low 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 PowerShell as a primary example when discussing language-specific performance settings, and by mentioning Visual Studio (a Windows-first IDE) before Visual Studio Code in the context of the Roslyn Analyzer. Diagnostic tooling references (e.g., Application Insights, Azure portal) are platform-neutral, but the language and tool examples tend to favor Windows environments, with limited explicit mention of Linux/macOS alternatives or parity.
Recommendations
  • Include Linux/macOS-specific examples and tooling references where applicable, such as Bash or shell script examples alongside PowerShell.
  • When mentioning IDEs, list Visual Studio Code (cross-platform) before Visual Studio, or clarify platform support for each.
  • Explicitly state that all diagnostic tools (Application Insights, Azure portal, Durable Functions Monitor) are accessible from Linux/macOS environments.
  • Add references to Linux/macOS package managers and setup instructions for SDKs and extensions.
  • Ensure parity in language runtime tuning examples (e.g., include Bash, zsh, or Linux-native configuration steps for Python/JavaScript).
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
Low 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 demonstrates mild Windows bias. Windows-specific tools (Visual Studio, PowerShell) are frequently mentioned and often listed before Linux equivalents. Some CLI examples use Windows-centric terminology or are shown with Windows as the default. Linux alternatives are present but sometimes appear after Windows instructions, and PowerShell is referenced more than Bash. In deployment and configuration sections, Windows settings and commands are described first or in more detail, while Linux instructions are sometimes less prominent or grouped separately. However, most core concepts and code samples are OS-neutral, and Linux/macOS users can generally complete all tasks.
Recommendations
  • Ensure all CLI and deployment instructions show both Windows and Linux/macOS examples side-by-side, or use tabs for parity.
  • List Linux tools and workflows (e.g., Bash, Azure CLI) before or alongside Windows/PowerShell equivalents, not after.
  • Avoid Windows-centric terminology (e.g., 'use PowerShell to...') unless also providing the Linux equivalent.
  • Explicitly state OS support and parity in relevant sections.
  • Add more Linux/macOS-specific troubleshooting and environment setup notes where appropriate.
GitHub Create Pull Request
Azure Functions Durable Functions packages .../azure-functions/durable/durable-functions-packages.md
Low Priority View Details →
Scanned: 2026-01-12 00:00
Reviewed by: LLM Analysis
Issues: 2 bias types
Detected Bias Types
Windows First Powershell Heavy
Summary
The documentation page presents .NET (which is historically Windows-centric) as the primary runtime, with detailed package instructions for .NET in-process and .NET isolated projects before mentioning other languages. PowerShell is also called out with a dedicated note and migration guide, while Linux/macOS-specific considerations or examples are not provided. However, SDKs for Node.js, Python, and Java are listed, and no Windows-only tools or instructions are present.
Recommendations
  • Add explicit notes or examples for Linux/macOS users, especially regarding package installation and project configuration.
  • Balance the order of language runtimes so that non-Windows-centric languages (Node.js, Python, Java) are not always listed after .NET.
  • Include any platform-specific caveats or instructions for Linux/macOS environments if they exist.
  • Provide parity in tips and migration guides for other languages, not just PowerShell.
GitHub Create Pull Request
Azure Functions Sub-orchestrations for Durable Functions - Azure ...ctions/durable/durable-functions-sub-orchestrations.md
Low 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 PowerShell examples and notes about PowerShell SDK support, which are primarily relevant to Windows users. PowerShell is presented as a first-class language alongside cross-platform options, and specific tooling (e.g., PowerShell SDK, PowerShell Gallery) is referenced. However, all major language examples (C#, JavaScript, Python, Java) are provided, and there are no critical sections that are Windows-only. The PowerShell-specific note and examples may create mild friction for Linux/macOS users, as PowerShell is less commonly used or installed by default on those platforms.
Recommendations
  • Clarify that PowerShell examples are optional and provide guidance for Linux/macOS users on installing PowerShell Core if desired.
  • Add Bash or shell script equivalents if relevant, or explicitly mention that PowerShell is not required for Linux/macOS users.
  • Reorder examples so that cross-platform languages (Python, JavaScript, Java) are shown before PowerShell, or randomize order to avoid implicit prioritization.
  • Where PowerShell SDK/tooling is mentioned, add a note about cross-platform compatibility or alternatives.
GitHub Create Pull Request
Azure Functions Quickstart: Create a Java Durable Functions app ...in/articles/azure-functions/durable/quickstart-java.md
Low 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 exhibits mild Windows bias. In the manual setup section, the Maven plugin configuration explicitly sets the runtime OS to 'windows' without mentioning Linux or macOS alternatives. In the Maven command section, PowerShell and Cmd examples are provided alongside Bash, with Windows shells shown after Bash but before Linux-specific notes. Visual Studio Code instructions are cross-platform, but screenshots and steps do not clarify Linux/macOS differences. There is no explicit mention of Linux/macOS-specific setup, nor guidance for using Azure Functions on those platforms. The Azure Functions Core Tools prerequisite is platform-agnostic, but the runtime configuration and examples lean toward Windows.
Recommendations
  • In the Maven plugin configuration, clarify that the <os>windows</os> setting is for Windows deployments and provide examples for Linux (e.g., <os>linux</os>) and macOS if supported.
  • Add explicit instructions or notes for Linux/macOS users, especially regarding file paths, shell commands, and environment setup.
  • Ensure screenshots and step-by-step instructions in the Visual Studio Code section mention any platform-specific differences.
  • Consider listing Bash (Linux/macOS) examples first, or equally with Windows shells, and clarify which commands are for which platforms.
  • Mention that Azure Functions Core Tools and Maven are cross-platform, and link to installation instructions for Linux/macOS.
GitHub Create Pull Request
Azure Functions Task hubs in Durable Functions - Azure ...azure-functions/durable/durable-functions-task-hubs.md
Low Priority View Details →
Scanned: 2026-01-12 00:00
Reviewed by: LLM Analysis
Issues: 2 bias types
Detected Bias Types
Powershell Heavy Windows First
Summary
The documentation provides code examples for multiple languages, including PowerShell, which is primarily a Windows-centric shell. PowerShell examples are given equal prominence to other languages, but there are no explicit Linux shell (e.g., Bash) examples or references to Linux-specific tools or patterns. However, the documentation does not mention Windows-only tools or patterns outside of PowerShell, nor does it prioritize Windows tools over Linux equivalents in other contexts. The severity of bias is low, as Linux/macOS users are not blocked from completing tasks, but the inclusion of PowerShell without Linux shell alternatives may create minor friction.
Recommendations
  • Add equivalent Bash or shell script examples alongside PowerShell to improve parity for Linux/macOS users.
  • Clarify that PowerShell examples can be run cross-platform (if true), or provide guidance for Linux/macOS users where differences exist.
  • Explicitly mention platform compatibility for code samples and tools where relevant.
  • Consider including references to Linux/macOS tools (e.g., Azure CLI usage in Bash) where applicable.
GitHub Create Pull Request
Azure Functions Quickstart: Create an app with Durable Task SDKs and Durable Task Scheduler ...ask-scheduler/quickstart-portable-durable-task-sdks.md
Low Priority View Details →
Scanned: 2026-01-12 00:00
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
Windows First Powershell Heavy Missing Linux Example
Summary
The documentation exhibits mild Windows bias in several areas. Powershell and Windows-specific instructions are provided in dedicated pivots, and in the Python section, Windows activation commands are shown before Linux equivalents. However, Linux/macOS instructions are present for all major steps, and Docker-based workflows are inherently cross-platform. No critical steps are Windows-only, but the ordering and prominence of Windows instructions may create minor friction for Linux/macOS users.
Recommendations
  • Present Linux/macOS and Windows instructions side-by-side or in a neutral order, rather than Windows-first.
  • Ensure all code blocks for environment setup (e.g., Python venv activation) include both Windows and Linux/macOS commands, and clarify platform differences.
  • Add explicit macOS instructions where relevant (e.g., Python venv activation, Docker installation).
  • Avoid using 'Powershell' as a primary pivot unless equivalent bash/zsh examples are provided.
  • Where possible, use platform-agnostic commands and tools, or clearly mark platform-specific steps.
GitHub Create Pull Request
Azure Functions Quickstart: Create a Python Durable Functions app ...es/azure-functions/durable/quickstart-python-vscode.md
Low Priority View Details →
Scanned: 2026-01-12 00:00
Reviewed by: LLM Analysis
Issues: 2 bias types
Detected Bias Types
Windows First Powershell Heavy
Summary
The documentation generally provides parity between Windows and Linux/macOS, especially in the virtual environment activation instructions, which are clearly separated by OS. However, there is a subtle Windows bias: the Windows/Powershell activation command is listed last, and the use of 'scripts' (Windows convention) rather than 'bin' (Linux/macOS convention) in the virtual environment folder is highlighted. Additionally, the documentation refers to using Visual Studio Code and its integrated terminal, which is cross-platform but may be more familiar to Windows users. No critical steps are Windows-only, and Linux/macOS users are given explicit instructions for all major commands.
Recommendations
  • List Linux/macOS commands first when presenting OS-specific instructions to avoid implicit prioritization of Windows.
  • Explicitly mention that Visual Studio Code and Azure Functions Core Tools are fully supported on Linux/macOS.
  • Add a note or section highlighting any platform-specific caveats (if any) for Linux/macOS users.
  • Ensure screenshots and examples occasionally show Linux/macOS environments to reinforce parity.
GitHub Create Pull Request
Azure Functions Tutorial: Add Azure OpenAI text completions to your functions in Visual Studio Code ...zure-functions/functions-add-openai-text-completion.md
Low 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 page demonstrates mild Windows bias. Visual Studio Code is cross-platform, but the tutorial assumes use of Azurite (which is available on all platforms but is often associated with Windows workflows), and the instructions for running the emulator and function app use command palette actions and keyboard shortcuts that are most familiar to Windows users. Powershell is included as a first-class language, and some steps (such as starting Azurite) use command palette instructions that may differ on Linux/macOS. There is no explicit mention of Linux/macOS-specific tools, nor are there examples of using Bash or other Linux-native shells. The order of language pivots and examples tends to favor Windows-centric workflows (C#, Powershell) before Linux-favored ones (Python, JavaScript).
Recommendations
  • Add explicit instructions or notes for Linux/macOS users, especially regarding starting Azurite and using keyboard shortcuts.
  • Include Bash or terminal command examples for starting Azurite and running/debugging the function app, alongside command palette instructions.
  • Ensure parity in language pivots by rotating or randomizing the order, or by grouping Windows and Linux/macOS languages equally.
  • Mention that all steps are cross-platform and highlight any platform-specific differences, such as keyboard shortcuts or file paths.
  • Add troubleshooting notes for common Linux/macOS issues (e.g., permissions, path differences).
GitHub Create Pull Request
Azure Functions Azure Database for MySQL Input Binding for Functions ...zure-functions/functions-bindings-azure-mysql-input.md
Low Priority View Details →
Scanned: 2026-01-12 00:00
Reviewed by: LLM Analysis
Issues: 2 bias types
Detected Bias Types
Powershell Heavy Windows First
Summary
The documentation provides extensive PowerShell examples, which are primarily relevant to Windows users. PowerShell is featured as a first-class language alongside Python, JavaScript/TypeScript, Java, and C#. There is no explicit mention of Linux/macOS equivalents for PowerShell, nor any guidance for users who do not have access to PowerShell. However, the core functionality (Azure Functions bindings for MySQL) is documented for all major languages, and the examples for Python, JavaScript/TypeScript, and Java are platform-agnostic. No Windows-specific tools or patterns are required for the main tasks, but the prominence of PowerShell may create friction for Linux/macOS users.
Recommendations
  • Clarify that PowerShell examples are primarily for Windows users and suggest alternatives for Linux/macOS (e.g., Bash, Python scripting).
  • Add notes or links for Linux/macOS users on how to achieve similar functionality using their native shells or scripting languages.
  • Consider providing Bash or shell script examples for common tasks where PowerShell is used.
  • Explicitly state cross-platform compatibility for all code samples, especially in sections where PowerShell is featured.
  • If PowerShell is required for any step, provide instructions for installing PowerShell Core on Linux/macOS, or alternatives.
GitHub Create Pull Request
Azure Functions Quickstart: Configure a storage provider by using Netherite ...ticles/azure-functions/durable/quickstart-netherite.md
Low Priority View Details →
Scanned: 2026-01-12 00:00
Reviewed by: LLM Analysis
Issues: 2 bias types
Detected Bias Types
🔧 Windows Tools Windows First
Summary
The documentation is generally cross-platform, but there are minor Windows biases. The section on local storage emulation specifically mentions Windows OS and recommends Azurite over the legacy Azure Storage Emulator, which is Windows-only. Additionally, instructions for ensuring 64-bit architecture in Azure Functions are presented for Windows first, with Linux noted as not needing this step. No PowerShell-heavy or Windows-only examples are present, and Linux/macOS users are not blocked from completing the quickstart.
Recommendations
  • Clarify that Azurite is cross-platform and provide installation instructions for Linux/macOS users.
  • Present architecture validation steps for Linux/macOS users (e.g., how to confirm 64-bit on those platforms, even if it's always 64-bit).
  • Avoid phrasing that assumes Windows as the default OS; explicitly mention Linux/macOS parity where relevant.
  • If screenshots or instructions differ for Linux/macOS, provide those alternatives.
GitHub Create Pull Request
Azure Functions Build a serverless workflow using Durable Functions - Azure Functions ...unctions/durable/scenario-build-serverless-workflow.md
Low 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 provides command examples for Windows-specific shells (PowerShell, Cmd) alongside bash, and references Windows tools (e.g., 'command prompt', 'py' launcher) in several places. Windows command examples are presented before Linux/macOS equivalents in some sections, and Windows-specific tooling is mentioned (e.g., 'py' launcher, Windows paths). However, Linux/macOS instructions are present and generally complete, so Linux users can follow along, albeit with minor friction.
Recommendations
  • Present Linux/macOS examples before or alongside Windows examples, especially in sections where Windows commands are currently listed first.
  • Clarify when a command is cross-platform or provide explicit instructions for both platforms in all relevant sections.
  • Avoid referencing Windows-specific tools (e.g., 'py' launcher, Windows paths) without noting Linux/macOS alternatives.
  • Where possible, use shell-agnostic commands or clearly separate platform-specific instructions.
  • Add explicit notes about differences in file paths, environment activation, and shell usage between platforms.
GitHub Create Pull Request
Azure Functions Event-driven Scaling in Azure Functions .../main/articles/azure-functions/event-driven-scaling.md
Low Priority View Details →
Scanned: 2026-01-12 00:00
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
Windows First Powershell Heavy Missing Linux Example
Summary
The documentation provides both Azure CLI and Azure PowerShell examples for configuring scale limits, but PowerShell is highlighted as a primary method alongside CLI. There is no mention of Bash or Linux-specific shell usage, nor are Linux/macOS-specific considerations discussed. Windows-specific behaviors (drain mode) are called out, but Linux/macOS equivalents are not addressed. The CLI examples are cross-platform, but the presence of PowerShell and Windows-only notes creates a subtle Windows bias.
Recommendations
  • Add explicit Bash examples for scale configuration alongside Azure CLI and PowerShell.
  • Clarify that Azure CLI commands work on Linux/macOS and provide any OS-specific notes if relevant.
  • When discussing behaviors (like drain mode), specify whether they apply to Linux/macOS apps or provide equivalent details.
  • Avoid listing PowerShell before CLI or provide parity for Linux/macOS shell scripting.
  • Include a section or note about Linux/macOS deployment and scaling nuances if any exist.
GitHub Create Pull Request
Azure Functions Durable Functions best practices and diagnostic tools ...s/durable/durable-functions-best-practice-reference.md
Low Priority View Details →
Scanned: 2026-01-11 06:20
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 (Visual Studio, PowerShell), listing PowerShell alongside other languages in performance tuning, and mentioning Visual Studio before Visual Studio Code. However, Linux/macOS users are not blocked from following the guidance, and most recommendations/tools are cross-platform or have equivalents.
Recommendations
  • When referencing IDEs, mention Visual Studio Code before or alongside Visual Studio, as VS Code is cross-platform.
  • For language-specific performance tuning, ensure Linux/macOS equivalents (e.g., Bash, shell scripts) are mentioned alongside PowerShell.
  • Explicitly state that all diagnostic tools (such as Application Insights, Durable Functions Monitor) are available on Linux/macOS.
  • Provide links or examples for Linux/macOS environments where relevant (e.g., package managers, shell commands).
GitHub Create Pull Request
Azure Functions Quickstart: Create a Python Durable Functions app ...es/azure-functions/durable/quickstart-python-vscode.md
Low Priority View Details →
Scanned: 2026-01-11 06:20
Reviewed by: LLM Analysis
Issues: 2 bias types
Detected Bias Types
Windows First Powershell Heavy
Summary
The documentation provides both Windows and Linux/macOS instructions for activating Python virtual environments, but Windows (PowerShell) instructions are listed last. The use of Visual Studio Code and its integrated tools is platform-neutral, but some minor bias is present in the order of examples and the explicit mention of PowerShell for Windows activation. No critical functionality is limited to Windows, and Linux/macOS users are given equivalent instructions.
Recommendations
  • Present activation commands for Linux, macOS, and Windows together in a single table or in parallel, rather than sequentially.
  • Avoid referring to Windows-specific shells (e.g., PowerShell) without mentioning common Linux/macOS shells (e.g., bash, zsh).
  • Where possible, show Linux/macOS examples first or at least alternate the order to avoid implicit prioritization.
  • Explicitly state that all steps are cross-platform and highlight any platform-specific differences up front.
GitHub Create Pull Request
Azure Functions Memory profiling of Python apps in Azure Functions ...es/azure-functions/python-memory-profiler-reference.md
Low Priority View Details →
Scanned: 2026-01-11 06:20
Reviewed by: LLM Analysis
Issues: 2 bias types
Detected Bias Types
Windows First Powershell Heavy
Summary
The documentation presents both Windows and Linux instructions for local development, but consistently lists Windows commands and tools first (e.g., PowerShell, 'py -m venv', '.venv\Scripts\Activate.ps1') before their Linux equivalents. This ordering and emphasis may subtly prioritize Windows users and workflows, even though Linux alternatives are provided.
Recommendations
  • Present Windows and Linux/macOS instructions side-by-side or in separate, clearly labeled sections/tabs.
  • Alternate the order of Windows and Linux examples to avoid implicit prioritization.
  • Explicitly mention macOS where Linux instructions apply, or provide macOS-specific commands if they differ.
  • Use generic Python commands (e.g., 'python -m venv .venv') where possible, or explain platform differences.
  • Clarify that Azure Functions Core Tools and memory-profiler work equally well on Linux/macOS.
GitHub Create Pull Request
Azure Functions Build a scalable web API using Azure Functions ...functions/create-first-function-azure-developer-cli.md
Low Priority View Details →
Scanned: 2026-01-11 06:20
Reviewed by: LLM Analysis
Issues: 2 bias types
Detected Bias Types
Windows First Powershell Heavy
Summary
The documentation provides examples and instructions for both Windows and Linux/macOS users, but there are several places where Windows-specific tools and patterns are presented first or with more detail. PowerShell is included as a primary language option, and Windows command-line instructions (Cmd, PowerShell) are often shown before or alongside bash equivalents. However, Linux/macOS users are generally able to follow along, and bash examples are present for most commands.
Recommendations
  • Ensure Linux/macOS instructions are presented before or alongside Windows instructions, especially in code blocks and tabbed sections.
  • Where PowerShell is used as a primary example, provide equivalent bash or shell scripts for Linux/macOS users.
  • Clarify when a command or tool is cross-platform, and avoid implying Windows is the default environment.
  • Review the order of tabbed instructions to avoid Windows-first bias, and consider defaulting to bash or cross-platform CLI examples.
  • Explicitly mention Linux/macOS compatibility for Azure Developer CLI and Azure Functions Core Tools in the prerequisites.
GitHub Create Pull Request
← Previous Page 8 of 10 Next →