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 926-950 of 1023 flagged pages
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-14 00:00
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
Windows First Powershell Heavy Missing Linux Example
Summary
The documentation demonstrates a mild Windows bias in the local development setup instructions. Windows PowerShell is mentioned first, and Windows-specific commands (such as 'py -m venv .venv' and '.venv\Scripts\Activate.ps1') are shown before their Linux equivalents. The Linux shell and commands are mentioned, but always second. No Linux/macOS-specific troubleshooting or examples are provided, and screenshots use Windows paths. However, most steps are cross-platform and Linux instructions are present.
Recommendations
  • Present Linux/macOS and Windows instructions side-by-side or in tabs, rather than listing Windows first.
  • Include explicit macOS instructions (e.g., for activating virtual environments).
  • Use neutral path formats in code samples and screenshots, or provide both Windows and Linux/macOS examples.
  • Add troubleshooting notes for common Linux/macOS issues (e.g., permissions, shell differences).
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-14 00:00
Reviewed by: LLM Analysis
Issues: 2 bias types
Detected Bias Types
Windows First Powershell Heavy
Summary
The documentation generally provides parity for Linux/macOS and Windows users, with most commands shown in a cross-platform manner and explicit tabs for Linux/macOS and Windows. However, there are some subtle signs of Windows bias: Windows command line options (Cmd, PowerShell) are often shown before Linux/macOS equivalents, and PowerShell is included as a primary programming language pivot, which may not be as relevant for Linux/macOS users. In the Python virtual environment section, Windows bash is shown before Windows Cmd, and Linux/macOS is listed first, which is good. In the function invocation section, bash is shown first, but Windows Cmd and PowerShell are given detailed attention. Overall, Linux/macOS users can complete all tasks, but Windows tools and patterns are slightly more prominent.
Recommendations
  • Ensure Linux/macOS examples are always presented first or equally alongside Windows examples.
  • Where PowerShell is used, clarify its cross-platform availability or provide bash/zsh equivalents if relevant.
  • Explicitly mention that all CLI commands work on Linux/macOS unless otherwise noted.
  • Consider adding a note about using Azure Functions Core Tools and azd on Linux/macOS, including any platform-specific caveats.
  • Review the order of tabs and pivots to avoid implicit prioritization of Windows tools.
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-14 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, primarily through the mention of PowerShell as a language with specific performance tuning guidance and the focus on Windows-centric tools like Visual Studio and Visual Studio Code for Roslyn Analyzer integration. Additionally, Windows tools and patterns (e.g., PowerShell, Visual Studio) are mentioned before or more prominently than Linux/macOS alternatives, and there is no explicit mention of Linux/macOS-specific diagnostic tools or workflows.
Recommendations
  • Include Linux/macOS equivalents for diagnostic and development tools, such as instructions for using VS Code on Linux/macOS, or alternative editors.
  • Provide examples or references for shell scripting (e.g., Bash) alongside PowerShell where relevant.
  • Clarify that all tools and SDKs are cross-platform when applicable, and highlight any platform-specific limitations or features.
  • Add explicit guidance for Linux/macOS users on configuring and monitoring Durable Functions, especially for performance tuning and diagnostics.
GitHub Create Pull Request
Azure Functions Durable entities - Azure Functions .../azure-functions/durable/durable-functions-entities.md
Low Priority View Details →
Scanned: 2026-01-14 00:00
Reviewed by: LLM Analysis
Issues: 2 bias types
Detected Bias Types
Windows First Missing Linux Example
Summary
The documentation page for Durable Entities in Azure Functions is primarily focused on .NET (C#) examples, which are platform-agnostic but historically associated with Windows development. There is no explicit mention of Windows-only tools, PowerShell, or Windows-specific patterns. However, the page does not provide any Linux/macOS-specific instructions, nor does it address cross-platform development concerns (such as differences in local development, deployment, or tooling between Windows and Linux/macOS). All code samples are in C#, JavaScript, and Python, which are cross-platform, but the .NET focus and lack of Linux/macOS parity in examples or troubleshooting can create friction for non-Windows users.
Recommendations
  • Add explicit notes or sections on cross-platform development, including any differences in local development, deployment, or debugging between Windows and Linux/macOS.
  • Include troubleshooting tips for Linux/macOS users, especially for .NET isolated worker scenarios.
  • Ensure that any referenced tooling (such as Azure Functions Core Tools) is demonstrated on both Windows and Linux/macOS, if relevant.
  • If there are platform-specific limitations (e.g., file system, environment variables, dependencies), document these clearly.
  • Provide parity in example ordering (rotate which language appears first, or clarify that examples are platform-neutral).
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-14 00:00
Reviewed by: LLM Analysis
Issues: 1 bias type
Detected Bias Types
Powershell Heavy
Summary
The documentation provides a PowerShell-specific note and full PowerShell code examples alongside other languages, but does not exhibit Windows bias in terms of prioritizing Windows tools, patterns, or examples over Linux/macOS equivalents. All code samples are language-based and platform-agnostic, except for the PowerShell sections, which are inherently more relevant to Windows users.
Recommendations
  • Clarify in the PowerShell note whether the standalone SDK is cross-platform or Windows-only, and provide explicit guidance for Linux/macOS users if PowerShell is supported on those platforms.
  • If PowerShell examples are included, consider mentioning cross-platform compatibility or alternatives for Linux/macOS users.
  • Ensure that any platform-specific caveats (such as SDK support) are clearly marked for all platforms, not just Windows/PowerShell.
GitHub Create Pull Request
Azure Functions Durable Functions packages .../azure-functions/durable/durable-functions-packages.md
Low Priority View Details →
Scanned: 2026-01-14 00:00
Reviewed by: LLM Analysis
Issues: 2 bias types
Detected Bias Types
Windows First Powershell Heavy
Summary
The documentation page lists .NET and PowerShell (Windows-centric technologies) first and in greater detail, with explicit package references and configuration notes. Linux/macOS-friendly languages (Node.js, Python, Java) are grouped together and described more briefly. PowerShell is given a dedicated note and migration guidance, while Bash or Linux-specific tools are not mentioned. There are no explicit Linux/macOS examples or parity notes.
Recommendations
  • Provide equal detail and configuration guidance for Node.js, Python, and Java SDKs, including example package installation commands for Linux/macOS environments.
  • Add notes or examples for Linux/macOS users, such as using Bash, zsh, or other shells for installation and configuration.
  • Ensure that PowerShell-specific notes are balanced with equivalent guidance for Linux/macOS users.
  • Consider listing language runtimes in alphabetical order or grouping by platform neutrality to avoid Windows-first perception.
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-14 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 technology. PowerShell is given equal prominence alongside C#, JavaScript, Python, and Java, but there are no corresponding Linux shell (e.g., Bash) examples. Additionally, PowerShell examples may implicitly suggest a Windows-first approach, as Linux users are less likely to use PowerShell for Azure Functions development. However, the rest of the documentation avoids explicit references to Windows-only tools or patterns, and most configuration and management instructions are platform-neutral.
Recommendations
  • Add Linux shell (Bash) examples for orchestration triggers and activity calls, if supported by Durable Functions.
  • Clarify in the PowerShell sections that PowerShell Core is cross-platform, or provide guidance for Linux/macOS users.
  • Consider listing examples in an order that does not imply Windows-first (e.g., start with C#, then Python, JavaScript, Java, PowerShell).
  • Explicitly mention platform compatibility for all code samples and tools.
  • If PowerShell is not commonly used on Linux/macOS for Azure Functions, consider marking it as optional or providing alternative Linux-native scripting examples.
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-14 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 Windows Cmd examples are provided alongside Bash, but Bash is listed first. Visual Studio Code instructions are cross-platform, but screenshots and instructions do not clarify Linux/macOS specifics. Azure Functions Core Tools are referenced generically, but no Linux/macOS installation or troubleshooting notes are given.
Recommendations
  • In the Maven plugin configuration, clarify that the <os>windows</os> setting can be changed to 'linux' or 'mac' for non-Windows deployments, and provide example configurations for those platforms.
  • Add explicit installation instructions and troubleshooting notes for Azure Functions Core Tools on Linux/macOS.
  • Ensure screenshots and step-by-step instructions in the Visual Studio Code section mention any platform-specific differences (e.g., keyboard shortcuts, folder dialogs).
  • Provide parity in command-line examples by including Bash, PowerShell, and Cmd equally, and clarify which are for which platforms.
  • Add a note or section on deploying to Linux-based hosting plans in Azure.
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-14 00:00
Reviewed by: LLM Analysis
Issues: 2 bias types
Detected Bias Types
🔧 Windows Tools Windows First
Summary
The documentation generally maintains cross-platform parity, but there is a minor Windows bias in the section discussing local storage emulation, where Windows-specific tools (Azurite and the deprecated Azure Storage Emulator) are mentioned. Additionally, the instructions for ensuring 64-bit architecture are presented for Windows first, with Linux noted as an exception.
Recommendations
  • Explicitly mention how to use Azurite on Linux/macOS and provide installation/usage instructions or links for those platforms.
  • Clarify that Azurite is cross-platform and provide guidance for Linux/macOS users in the local storage emulation section.
  • When discussing platform-specific settings (like 64-bit architecture), present Linux/macOS information first or in parallel, rather than as an afterthought.
  • Include screenshots or examples from Linux/macOS environments where relevant, not only Windows/Azure Portal.
  • Ensure that any CLI commands or configuration steps are validated for Linux/macOS environments and note any differences.
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-14 00:00
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
🔧 Windows Tools Windows Examples Windows Shell Tabs
Summary
The documentation provides command-line instructions for all major platforms (Linux/macOS, Windows Bash, Windows Cmd, PowerShell) in relevant sections, especially for Python virtual environment activation and Azure Functions invocation. Windows-specific shells (Cmd, PowerShell) are given their own tabs, and Windows tools/commands (such as 'py' launcher, backslash paths) are included. However, Linux/macOS instructions are present and not omitted, and the overall flow does not prioritize Windows over Linux/macOS. No critical steps are Windows-only.
Recommendations
  • Consider listing Linux/macOS instructions before Windows instructions in tabbed sections to avoid implicit Windows-first bias.
  • Clarify when Windows-specific tools (e.g., 'py' launcher) are required and offer alternatives for Linux/macOS users.
  • Ensure all command examples are tested and accurate for both Linux/macOS and Windows environments.
  • Where possible, provide generic cross-platform commands before platform-specific variants.
  • Explicitly mention that all steps are supported on Linux/macOS, and highlight any differences or caveats.
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-14 00:00
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
Windows First Powershell Heavy Missing Linux Example
Summary
The documentation page demonstrates mild Windows bias. While most of the content is platform-neutral, the only explicit OS distinction is in the 'Scale-in behaviors' section, which references Windows specifically for drain mode defaults. In the 'Limit scale-out' section, both Azure CLI and Azure PowerShell examples are provided, but no Linux/macOS-specific shell examples (e.g., Bash) are shown, and PowerShell is highlighted as an alternative to CLI. There are no references to Windows-only tools, but the order and presence of PowerShell examples may create minor friction for Linux/macOS users.
Recommendations
  • Clarify whether scale-in behaviors and drain mode apply to Linux-hosted function apps, and provide equivalent information for non-Windows platforms.
  • Add explicit Bash or shell script examples for configuration tasks, especially in sections where PowerShell is shown.
  • When mentioning OS-specific behaviors (e.g., Windows drain mode), include a note on Linux/macOS parity or differences.
  • Ensure that examples and instructions are platform-agnostic or provide parity for all major platforms.
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-14 00:00
Reviewed by: LLM Analysis
Issues: 2 bias types
Detected Bias Types
Windows First Powershell Heavy
Summary
The documentation page is generally cross-platform, with pivots for C#, Python, and Java, and instructions for both Windows and Linux. However, there is mild Windows bias: Windows-specific instructions (such as activating Python virtual environments) are shown before Linux equivalents, and there is a dedicated Powershell pivot, whereas there is no explicit Bash or Linux shell pivot. No critical steps are Windows-only, and Docker-based workflows are inherently cross-platform.
Recommendations
  • Present Linux/macOS instructions before or alongside Windows instructions, rather than after.
  • Add a Bash/Linux shell pivot or examples where Powershell is shown, to ensure parity.
  • Ensure all screenshots and code samples are available for Linux/macOS environments.
  • If a Powershell pivot is present, consider adding a Bash or generic shell pivot for symmetry.
  • Explicitly mention that all Docker commands work on Linux/macOS, and clarify any OS-specific differences.
GitHub Create Pull Request
Azure Functions App settings reference for Azure Functions ...ain/articles/azure-functions/functions-app-settings.md
Low Priority View Details →
Scanned: 2026-01-14 00:00
Reviewed by: LLM Analysis
Issues: 4 bias types
Detected Bias Types
🔧 Windows Tools Windows First Powershell Heavy Missing Linux Example
Summary
The documentation page is generally cross-platform, but there are several instances of Windows bias. Some settings and examples are Windows-specific or presented with Windows-first patterns. PowerShell is referenced heavily, and certain settings (e.g., WEBSITE_NODE_DEFAULT_VERSION) are explicitly Windows-only. Some examples use Windows-style paths (e.g., %HOME%\typescript) without Linux equivalents. In a few cases, Linux alternatives are mentioned but not given equal detail or placement. There are also recommendations to use Azure PowerShell and CLI, but PowerShell is mentioned first. Overall, Linux/macOS users may experience minor friction but can complete all tasks.
Recommendations
  • For every Windows-specific setting or example, provide the Linux/macOS equivalent side-by-side or in parallel tables.
  • Where Windows tools (e.g., PowerShell) are mentioned, ensure Azure CLI is given equal prominence and examples.
  • Avoid Windows-first ordering in lists and tables; alternate or group by OS.
  • Replace Windows-style paths (e.g., %HOME%\typescript) with cross-platform examples, or show both Windows and Linux/macOS versions.
  • Explicitly call out OS applicability for each setting, especially where behavior differs.
  • Where settings are Windows-only, provide clear guidance for Linux/macOS users (e.g., alternatives, not applicable).
GitHub Create Pull Request
Azure Functions Model context protocol bindings for Azure Functions ...ain/articles/azure-functions/functions-bindings-mcp.md
Low Priority View Details →
Scanned: 2026-01-14 00:00
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
Windows First Powershell Heavy 🔧 Windows Tools
Summary
The documentation page demonstrates a mild Windows bias. The only example for retrieving the system key uses the Azure CLI, which is cross-platform, but the included note references PowerShell specifically. There is no mention of Linux/macOS-specific workflows or tools, and Windows-centric terminology (such as references to Visual Studio Code, which is cross-platform but often associated with Windows) appears first. No Linux/macOS shell examples (e.g., bash) are provided for common tasks, and no explicit mention is made of Linux-specific considerations for running Azure Functions locally.
Recommendations
  • Provide explicit bash/zsh examples for retrieving function keys, alongside Azure CLI and PowerShell.
  • Clarify that Azure Functions Core Tools and Azure CLI are cross-platform, and provide installation/usage notes for Linux/macOS.
  • Avoid referencing PowerShell in notes unless alternatives are also given.
  • Add troubleshooting or environment notes for Linux/macOS users running Azure Functions locally.
GitHub Create Pull Request
Azure Functions Develop and run Azure Functions locally ...in/articles/azure-functions/functions-develop-local.md
Low Priority View Details →
Scanned: 2026-01-14 00:00
Reviewed by: LLM Analysis
Issues: 2 bias types
Detected Bias Types
Windows First 🔧 Windows Tools
Summary
The documentation page shows mild Windows bias, primarily by listing Visual Studio (Windows-only) as the first and most detailed development environment for C# and referencing Windows-centric tools like PowerShell and Visual Studio/Edge in the HTTP test tools section. However, Linux and macOS are mentioned as supported platforms for most environments, and alternatives like Visual Studio Code, command line, and curl are included. There are no critical sections that are Windows-only, but Windows tools and patterns are often mentioned first or more prominently.
Recommendations
  • List cross-platform tools (e.g., Visual Studio Code, command line) before Windows-only tools like Visual Studio in environment tables and examples.
  • Ensure parity in example depth and detail for Linux/macOS workflows, especially for C# development (e.g., highlight .NET CLI and VS Code workflows for C# as much as Visual Studio).
  • When mentioning HTTP test tools, list cross-platform tools (curl, Bruno, REST Client) before Windows-specific tools (PowerShell, Edge).
  • Add explicit Linux/macOS setup notes or troubleshooting tips where relevant, especially for Core Tools and Azurite.
  • Consider including screenshots or walkthroughs for Linux/macOS environments alongside Windows/Visual Studio examples.
GitHub Create Pull Request
Azure Functions Use GitHub Actions to make code updates in Azure Functions ...les/azure-functions/functions-how-to-github-actions.md
Low Priority View Details →
Scanned: 2026-01-14 00:00
Reviewed by: LLM Analysis
Issues: 1 bias type
Detected Bias Types
Windows First
Summary
The documentation provides both Windows and Linux examples for all supported languages and deployment scenarios, with clear tabs for each. However, Windows examples and instructions are consistently presented before Linux equivalents throughout the page, including in template links and code samples. This ordering may subtly reinforce a Windows-centric perspective, even though Linux parity is maintained.
Recommendations
  • Alternate the order of Windows and Linux examples or present them side-by-side to avoid implicit prioritization.
  • Explicitly state that both Windows and Linux are fully supported and that users should select the appropriate tab for their environment.
  • For languages not supported on Windows (e.g., Python), clarify Linux is required, as is already done.
  • Consider a short introductory note emphasizing cross-platform support and parity.
GitHub Create Pull Request
Azure Functions Automate function app resource deployment to Azure ...es/azure-functions/functions-infrastructure-as-code.md
Low Priority View Details →
Scanned: 2026-01-14 00:00
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
Windows First Windows Examples Shown Powershell Heavy
Summary
The documentation provides both Windows and Linux examples for most resource definitions (Bicep/ARM), but consistently lists Windows examples before Linux, and sometimes gives more context or links for Windows. In deployment instructions, PowerShell is emphasized alongside Azure CLI, but Linux shell equivalents (e.g., Bash scripts) are not shown. There are no critical Windows-only sections, but the ordering and example selection subtly favor Windows users.
Recommendations
  • Alternate the order of Windows and Linux examples, or present Linux examples first in some sections.
  • Where PowerShell is shown, provide equivalent Bash/Azure CLI scripts for Linux/macOS users.
  • Explicitly mention Linux/macOS compatibility in deployment steps and validation instructions.
  • Ensure all referenced sample templates have Linux equivalents, and link to them equally.
  • Add a summary table or section clarifying OS parity and any differences in deployment workflow.
GitHub Create Pull Request
Azure Functions Develop Azure Functions locally using Core Tools ...b/main/articles/azure-functions/functions-run-local.md
Low Priority View Details →
Scanned: 2026-01-14 00:00
Reviewed by: LLM Analysis
Issues: 4 bias types
Detected Bias Types
🔧 Windows Tools Windows First Powershell Heavy Windows Examples
Summary
The documentation page generally provides cross-platform instructions for developing Azure Functions locally using Core Tools, but there are several subtle signs of Windows bias. Windows-specific tools (PowerShell, cmd) are mentioned alongside or before Linux equivalents, and some examples are shown for both Bash and Windows command line, with Windows syntax sometimes appearing first. The use of terms like 'command prompt' and references to func.exe also reflect Windows-centric language. The installation and usage instructions for Azure CLI and Azure PowerShell are presented together, but Linux-specific alternatives (e.g., bash scripts) are not highlighted. The cURL tool is described as being available by default on Linux and newer Windows, but the Windows installation is called out separately, suggesting a Windows-first audience. PowerShell is given its own programming language pivot, which may reinforce the Windows focus.
Recommendations
  • Ensure all examples are shown for both Linux/macOS and Windows, with equal prominence and ordering.
  • Use neutral terminology such as 'terminal' or 'shell' instead of 'command prompt' and avoid references to func.exe unless platform-specific.
  • Highlight Linux/macOS installation and usage patterns for Azure CLI and other tools, and provide bash/zsh script examples where appropriate.
  • When showing command examples, alternate the order or group them by platform rather than always showing Windows first.
  • Clarify that Core Tools and related workflows are fully supported on Linux/macOS, and link to platform-specific installation guides.
  • Consider adding troubleshooting notes for common Linux/macOS issues (e.g., permissions, path, npm installation).
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
Low Priority View Details →
Scanned: 2026-01-14 00:00
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
Windows First Powershell Heavy 🔧 Windows Tools
Summary
The documentation demonstrates mild Windows bias, especially in the Java section, where command examples are given for Bash, PowerShell, and Cmd, with Windows shells (PowerShell, Cmd) listed after Bash but still included. The file path example for reviewing generated code uses Windows-style backslashes (\src\main\java\com\fabrikam), and instructions reference 'command prompt' (a Windows term) alongside 'terminal'. However, most commands are cross-platform and use Azure CLI and func tools, which work on Linux/macOS. There are no critical sections that are Windows-only, but Windows terminology and examples are present throughout.
Recommendations
  • Use platform-neutral terminology like 'terminal' instead of 'command prompt' throughout.
  • When showing file paths, use POSIX-style (forward slashes) or clarify both formats for cross-platform clarity.
  • In tabbed command examples, consider listing Bash first and clarify that PowerShell/Cmd are for Windows users.
  • Add explicit notes or examples for Linux/macOS where Windows-specific instructions or terminology appear.
  • Ensure all referenced tools (Azure CLI, func, jq) are confirmed to work on Linux/macOS and provide installation links for those platforms.
GitHub Create Pull Request
Azure Functions Guidance for developing Azure Functions ...b/main/articles/azure-functions/functions-reference.md
Low Priority View Details →
Scanned: 2026-01-14 00:00
Reviewed by: LLM Analysis
Issues: 2 bias types
Detected Bias Types
Windows First 🔧 Windows Tools
Summary
The documentation shows a mild Windows bias, primarily by listing Windows-centric tools (Visual Studio) first in several sections and mentioning them before cross-platform alternatives. Visual Studio, a Windows-only IDE, is highlighted as a primary option for C# and deployment, while Linux/macOS equivalents (VS Code, CLI) are listed after. However, most examples and tooling are cross-platform, and Linux users can complete all tasks described.
Recommendations
  • List cross-platform tools (VS Code, Azure CLI) before or alongside Windows-only tools like Visual Studio, especially in quickstart and deployment sections.
  • Explicitly mention OS compatibility for each tool, e.g., 'Visual Studio (Windows only)', 'VS Code (Windows, Linux, macOS)'.
  • Provide Linux/macOS-specific notes or examples where relevant (e.g., command-line instructions, local development).
  • Ensure that all language pivots include parity in tool recommendations and example ordering.
GitHub Create Pull Request
Azure Functions Deploy a PyTorch model as an Azure Functions application ...n/articles/azure-functions/machine-learning-pytorch.md
Low Priority View Details →
Scanned: 2026-01-14 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 Windows-specific tools and patterns are often mentioned first or exclusively. Windows commands (py, copy, .venv\scripts\activate) are shown alongside Bash equivalents, but Windows error handling (long path registry fix) is described in detail, while Linux/macOS troubleshooting is minimal. The use of Visual Studio Code is suggested, which is cross-platform, but Windows-centric instructions (e.g., registry edits) are prioritized. Some commands (py) are Windows-only, and the documentation sometimes refers to Windows command patterns before Linux/macOS alternatives.
Recommendations
  • Ensure Linux/macOS troubleshooting is as detailed as Windows (e.g., common pip/venv issues on Linux).
  • Present Bash (Linux/macOS) examples before Windows examples to avoid implicit prioritization.
  • Include Linux/macOS-specific error messages and solutions, not just Windows registry fixes.
  • Clarify when commands/tools are platform-specific (e.g., py vs python).
  • Balance the depth of platform-specific guidance, especially in troubleshooting sections.
GitHub Create Pull Request
Azure Functions IP addresses in Azure Functions ...ocs/blob/main/articles/azure-functions/ip-addresses.md
Low Priority View Details →
Scanned: 2026-01-14 00:00
Reviewed by: LLM Analysis
Issues: 2 bias types
Detected Bias Types
Windows First Powershell Heavy
Summary
The documentation provides examples for Azure CLI and Azure PowerShell, with PowerShell examples included for most command-line tasks. While Azure CLI is cross-platform, the inclusion of Azure PowerShell (which is traditionally more familiar to Windows users) and the ordering of examples (CLI, then PowerShell) show a mild Windows-first bias. There are no Linux- or macOS-specific shell examples (e.g., bash scripting), but no critical tasks are Windows-only, and all core instructions are accessible via CLI.
Recommendations
  • Add explicit bash/shell examples for Linux/macOS users where appropriate, especially for common tasks like parsing JSON output.
  • Clarify that Azure CLI commands work identically on Windows, Linux, and macOS.
  • Consider including a short note or example for using nslookup or dig on Linux/macOS.
  • If PowerShell is shown, consider also showing equivalent bash or shell commands for parity.
GitHub Create Pull Request
Azure Functions Manage connections in Azure Functions ...ob/main/articles/azure-functions/manage-connections.md
Low Priority View Details →
Scanned: 2026-01-14 00:00
Reviewed by: LLM Analysis
Issues: 2 bias types
Detected Bias Types
Windows First Missing Linux Example
Summary
The documentation provides code examples for C# (.NET) and JavaScript, focusing on best practices for managing connections in Azure Functions. While the content is largely language-agnostic, there is a subtle Windows bias: the C# examples and references (such as .NET Framework Data Provider for SQL Server, Entity Framework, and project file instructions) are presented first and exclusively, with no mention of Linux-specific patterns, tools, or cross-platform considerations. There are no PowerShell examples, but the lack of Linux/macOS-specific guidance or parity in configuration and troubleshooting steps (e.g., local.settings.json, connection string management) may create friction for non-Windows users.
Recommendations
  • Include explicit notes or examples for Linux/macOS users, such as how to manage connection strings and environment variables on those platforms.
  • Add parity in configuration instructions (e.g., local.settings.json usage on Linux/macOS, file paths, permissions).
  • Mention cross-platform compatibility of .NET Core and Azure Functions, clarifying any platform-specific caveats.
  • Provide troubleshooting tips or links for common Linux/macOS issues (e.g., sandbox restrictions, file system differences).
  • If relevant, add examples for popular Linux tools or shells (e.g., Bash scripts for environment setup).
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-14 00:00
Reviewed by: LLM Analysis
Issues: 2 bias types
Detected Bias Types
🔧 Windows Tools Windows First
Summary
The documentation page demonstrates mild Windows bias in several areas. Windows-specific tools and patterns (such as PowerShell and the Set-ExecutionPolicy command) are mentioned, and troubleshooting advice is focused on Windows (e.g., warning about WSL Bash). However, Linux/macOS equivalents are provided in most cases, and the overall workflow is cross-platform. Windows instructions sometimes appear before Linux/macOS ones, and troubleshooting tips are Windows-centric.
Recommendations
  • Provide troubleshooting tips for Linux/macOS users alongside Windows-specific advice (e.g., terminal configuration issues in VS Code).
  • Ensure that examples and instructions for Linux/macOS are given equal prominence and ordering as Windows instructions.
  • Expand troubleshooting sections to include common Linux/macOS issues (such as file permission errors, shell compatibility, etc.).
  • Where Windows tools (like PowerShell) are mentioned, clarify Linux/macOS alternatives or note their irrelevance on those platforms.
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-14 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 referencing Visual Studio Code workflows and command palette shortcuts that are more familiar to Windows users (e.g., <kbd>F1</kbd>, right-select, etc.), and by omitting explicit Linux/macOS terminal or CLI alternatives for key steps such as connecting to SQL Server or running Azure Functions locally. There are no PowerShell-specific examples or Windows-only tools, but the lack of Linux/macOS-specific guidance may create friction for non-Windows users.
Recommendations
  • Add explicit instructions for Linux/macOS users, such as alternative keyboard shortcuts (<kbd>Cmd</kbd>+<kbd>Shift</kbd>+<kbd>P</kbd> for command palette), and clarify right-click actions for different platforms.
  • Include examples of connecting to Azure SQL Database using native Linux/macOS tools (e.g., sqlcmd, Azure Data Studio) in addition to the VS Code extension.
  • Provide troubleshooting tips for common Linux/macOS issues (e.g., installing Azure Functions Core Tools, Azurite, or the SQL Server extension).
  • Ensure all CLI commands are platform-agnostic and note any differences in environment setup or permissions for Linux/macOS.
  • Consider adding a section or callouts for Linux/macOS users to highlight any platform-specific steps or considerations.
GitHub Create Pull Request
← Previous Page 38 of 41 Next →