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 176-200 of 1023 flagged pages
Azure Functions Azure Functions Premium plan ...ain/articles/azure-functions/functions-premium-plan.md
High Priority View Details →
Scanned: 2026-01-10 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 page exhibits several Windows-centric biases. Windows and PowerShell examples are consistently provided alongside Azure CLI, but there are no Linux-specific shell examples (e.g., Bash). Windows migration is supported and documented, while Linux migration is explicitly stated as unsupported. The use of PowerShell is emphasized, and Windows terminology and tools are referenced before or more prominently than Linux equivalents. Linux is mentioned as supported, but practical guidance and parity in examples are lacking.
Recommendations
  • Add Linux-specific shell (Bash) examples alongside Azure CLI and PowerShell, especially for configuration and management tasks.
  • Clarify and expand migration guidance for Linux, or provide alternative solutions/workarounds if migration is unsupported.
  • Ensure that references to tools and configuration steps are OS-neutral or provide both Windows and Linux instructions equally.
  • Review and update terminology to avoid Windows-first language; mention Linux support and limitations in the same context as Windows.
  • Where features are unavailable on Linux, provide clear explanations and suggest alternatives or timelines for parity.
GitHub Create Pull Request
Azure Functions Guidance for developing Azure Functions ...b/main/articles/azure-functions/functions-reference.md
High Priority View Details →
Scanned: 2026-01-10 00:00
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
Windows First 🔧 Windows Tools Powershell Heavy
Summary
The documentation demonstrates a moderate Windows bias, primarily by listing Windows-centric tools (Visual Studio, PowerShell) before or more prominently than Linux alternatives. Visual Studio is repeatedly mentioned as a primary development and deployment tool, especially for C#. PowerShell is included as a first-class language, and Azure PowerShell is listed as a deployment method alongside Azure CLI, but there is no mention of Bash or Linux-specific shell usage. There are no explicit Linux-only examples, and Linux development patterns (such as Bash, zsh, or Linux package managers) are not referenced. While Azure Functions Core Tools and Visual Studio Code are cross-platform, the documentation does not highlight Linux workflows or tools, and Windows tools are often listed first or exclusively.
Recommendations
  • Add explicit Linux/Bash shell examples and references, especially in sections discussing command line usage and deployment.
  • Mention Linux package managers (e.g., apt, yum) for installing Azure Functions Core Tools.
  • Clarify that Visual Studio Code and Azure Functions Core Tools are cross-platform, and provide guidance for Linux/macOS users.
  • Include Linux-specific development environment setup instructions or quickstart links alongside Visual Studio and PowerShell.
  • When listing tools, alternate or parallelize Windows and Linux options, or use neutral ordering (e.g., 'Visual Studio Code (Windows, Linux, macOS)', 'Bash or PowerShell').
  • Add troubleshooting or configuration notes for common Linux/macOS issues (e.g., file permissions, environment variables).
GitHub Create Pull Request
Azure Functions Azure Functions Scale and Hosting .../blob/main/articles/azure-functions/functions-scale.md
High Priority View Details →
Scanned: 2026-01-10 00:00
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
Windows First 🔧 Windows Tools Missing Linux Example
Summary
The documentation page demonstrates a Windows bias by prioritizing Windows in descriptions and examples, especially for the Consumption plan, where Windows is listed as 'GA' and Linux as 'Retired.' Windows-specific features (such as PowerShell modules and the full .NET Framework) are highlighted as key use cases for the Consumption plan, with no equivalent Linux-specific examples or tooling mentioned. Additionally, references to App Service pricing link to Windows pricing first, and there is a lack of Linux-focused scenarios or parity in example use cases.
Recommendations
  • Provide Linux-specific examples and use cases alongside Windows ones, such as mentioning Linux-native tools, runtimes, or scenarios (e.g., Bash, Python, Node.js).
  • Avoid listing Windows features or availability before Linux unless there is a technical reason; present both platforms equally in tables and descriptions.
  • Include references to Linux App Service pricing and documentation where relevant, not just Windows.
  • Highlight Linux advantages or unique features (such as container support, custom images, or open-source tooling) in parity with Windows-specific features.
  • Add troubleshooting and deployment examples for Linux environments, not just Windows or PowerShell.
  • Clarify retirement timelines and migration paths for Linux users, ensuring Linux customers have clear guidance and alternatives.
GitHub Create Pull Request
Azure Functions Create and deploy function code to Azure using Visual Studio Code ...cles/azure-functions/how-to-create-function-vs-code.md
High Priority View Details →
Scanned: 2026-01-10 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. Windows-specific tools and patterns are mentioned in several places, such as PowerShell being included as a primary language, references to Windows installation paths, and troubleshooting advice that singles out Windows/WSL Bash. In cross-compilation instructions for Go and Rust, Windows steps are called out separately and sometimes before Linux/macOS. The PowerShell language is treated as a first-class citizen, which is a Windows-centric technology, and the installation link for PowerShell points to Windows instructions. There are no explicit Linux examples missing, but Windows is often referenced first or with more detail.
Recommendations
  • Ensure all language and tool installation instructions include both Windows and Linux/macOS links and examples, with equal prominence.
  • When referencing PowerShell, clarify cross-platform support and provide Linux/macOS installation instructions alongside Windows.
  • In troubleshooting sections, avoid singling out Windows-specific issues unless Linux/macOS equivalents are also discussed.
  • For cross-compilation steps (Go, Rust), present Linux/macOS instructions before or alongside Windows, not after.
  • Review all references to default shells and terminals to ensure Linux/macOS users are equally supported.
  • Consider including Bash or other Linux-native scripting examples where PowerShell is referenced, or clarify PowerShell's cross-platform capabilities.
GitHub Create Pull Request
Azure Functions IP addresses in Azure Functions ...ocs/blob/main/articles/azure-functions/ip-addresses.md
High Priority View Details →
Scanned: 2026-01-10 00:00
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
Windows First Powershell Heavy 🔧 Windows Tools
Summary
The documentation provides examples for Azure CLI, Azure PowerShell, and Azure Portal, but PowerShell examples are given equal prominence to CLI, and there is no mention of Linux-specific tools or shell patterns. The only local utility mentioned for finding inbound IP addresses is 'nslookup', which is cross-platform, but there are no Linux-specific command-line examples (e.g., using 'dig' or 'host'). The documentation refers to PowerShell without clarifying its cross-platform availability, and does not provide Linux shell scripting equivalents or highlight Linux usage patterns. Windows-centric tools and patterns (PowerShell, Azure Portal) are mentioned before or alongside CLI, but Linux-native approaches are missing.
Recommendations
  • Add Linux-specific command-line examples for finding IP addresses, such as using 'dig' or 'host' in addition to 'nslookup'.
  • Clarify that Azure PowerShell is available cross-platform, or provide bash/shell script equivalents for Linux users.
  • Where PowerShell examples are given, also provide bash or shell script examples for parity.
  • Explicitly mention that all CLI commands work on Linux, macOS, and Windows, and highlight any platform-specific considerations.
  • Consider including a section or callout for Linux users, describing common tools and patterns for managing Azure Functions IP addresses.
GitHub Create Pull Request
Azure Functions Migrate apps from Azure Functions version 3.x to 4.x ...rticles/azure-functions/migrate-version-3-version-4.md
High Priority View Details →
Scanned: 2026-01-10 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 Windows bias by providing only PowerShell scripts for identifying function apps to migrate, referencing Azure PowerShell multiple times, and omitting equivalent Linux-friendly options such as Bash, Azure CLI, or shell scripts. The initial migration steps and tooling recommendations (e.g., Visual Studio, .NET Upgrade Assistant) are also Windows-centric, with Linux alternatives mentioned only generically or not at all. There are no explicit Linux command-line examples or instructions for Linux users in the main migration workflow.
Recommendations
  • Provide equivalent Azure CLI or Bash scripts alongside PowerShell examples for identifying function apps to migrate.
  • Explicitly mention and demonstrate how to perform migration steps using Linux/macOS environments, including command-line tools and editors commonly used on those platforms.
  • Add instructions for using cross-platform tools (e.g., VS Code, Azure CLI) for migration, deployment, and validation, and clarify any platform-specific requirements.
  • Ensure that all code snippets and automation scripts have Linux-compatible versions, and link to them where appropriate.
  • Review and update references to Windows-specific tools (e.g., Visual Studio) to include Linux alternatives or clarify cross-platform support.
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-10 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 page exhibits several signs of Windows bias. PowerShell and Windows Command Prompt (cmd) examples are provided for Java, while Bash is only one of several tabs. There are explicit references to 'command prompt' and Windows-style paths (e.g., '\src\main\java\com\fabrikam'), and the Maven archetype flow includes PowerShell and cmd instructions before Bash. There is no mention of Linux-specific tools or patterns (such as xargs, grep, or Linux file paths), and Linux/Bash examples are not consistently prioritized or explained. The use of 'command prompt' and Windows-centric terminology may confuse Linux users. There are no explicit Linux-only examples or troubleshooting notes for Linux environments.
Recommendations
  • Ensure Bash/Linux examples are presented first or equally alongside PowerShell/cmd, especially in tabbed code blocks.
  • Use platform-neutral terminology such as 'terminal' instead of 'command prompt'.
  • Include Linux file path examples (e.g., /src/main/java/com/fabrikam) alongside Windows paths.
  • Add troubleshooting notes or tips for common Linux issues (e.g., permissions, environment variables).
  • Explicitly mention that all commands work on Linux/macOS unless otherwise noted.
  • Where PowerShell/cmd are shown, always provide a Bash equivalent and clarify platform differences.
  • Highlight cross-platform compatibility for Azure Functions Core Tools and other required tools.
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-10 00:00
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
Powershell Heavy 🔧 Windows Tools Windows First
Summary
The documentation includes a dedicated section for PowerShell, a Windows-centric language, and references Azure PowerShell as a primary method for checking runtime versions, alongside the Azure portal and CLI. No explicit Linux-specific tools or shell examples (e.g., Bash) are mentioned, and PowerShell is presented as a standard option for all users, which may imply Windows-first assumptions. There are no Linux-specific examples or guidance, and the documentation does not mention Linux-native tools or workflows.
Recommendations
  • Add Linux-specific examples and guidance, such as using Bash or other Linux shells to interact with Azure Functions.
  • Include references to Linux-native tools (e.g., az CLI in Bash, curl, jq) when describing how to check or update runtime versions.
  • Clarify that PowerShell is optional and provide parity for Linux users by listing Bash or other shell commands alongside PowerShell examples.
  • Explicitly mention cross-platform compatibility and provide guidance for both Windows and Linux environments where relevant.
  • Ensure that documentation does not assume PowerShell as the default for all users, and balance examples between Windows and Linux tools.
GitHub Create Pull Request
Azure Functions Manage connections in Azure Functions ...ob/main/articles/azure-functions/manage-connections.md
High Priority View Details →
Scanned: 2026-01-10 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 bias toward Windows/.NET environments by providing only C#/.NET and JavaScript examples, with a heavy focus on .NET-specific clients and patterns. There are no examples or mentions of Linux-specific tools, shell commands, or configuration patterns. The guidance assumes usage of Visual Studio and .NET SDKs, which are more common in Windows environments. There is no parity for Linux shell, Python, or other cross-platform languages, nor are Linux-specific configuration or troubleshooting steps provided.
Recommendations
  • Add examples for Python (using requests, Azure SDKs), Java, and other cross-platform languages commonly used on Linux.
  • Include Linux shell commands for configuration and troubleshooting, such as using environment variables, editing local.settings.json with nano/vim, or using Azure CLI.
  • Mention Linux-specific considerations for connection management, such as ulimit settings or system resource limits.
  • Provide parity in instructions for creating and managing project files, such as using VS Code or command-line tools instead of Visual Studio.
  • Reference Linux-native tools (e.g., curl, netstat) for monitoring connections.
  • Ensure that configuration file instructions (like local.settings.json) include examples for both Windows and Linux environments.
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-10 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 demonstrates a Windows bias by providing only PowerShell scripts for identifying function apps to migrate, referencing Azure Cloud Shell (which defaults to PowerShell), and omitting equivalent Bash or Azure CLI examples. Windows-centric tools and workflows (such as Visual Studio publishing and PowerShell scripting) are mentioned without Linux alternatives. The order of presentation and lack of Linux-specific instructions or parity in examples further reinforce the bias.
Recommendations
  • Provide equivalent Azure CLI and Bash examples alongside PowerShell scripts for identifying and managing function apps.
  • Explicitly mention cross-platform tools and workflows, such as Visual Studio Code, and include instructions for Linux/macOS environments.
  • Add notes or sections on how to run migration steps on Linux, including shell commands and environment setup.
  • Ensure that references to Windows tools (e.g., PowerShell, Visual Studio) are balanced with Linux alternatives (e.g., Azure CLI, VS Code).
  • Where Cloud Shell is referenced, clarify that both Bash and PowerShell are available, and provide examples for both.
  • Audit all code snippets and instructions to ensure Linux users have clear, actionable guidance.
GitHub Create Pull Request
Azure Functions Migrate Consumption plan apps to Flex Consumption in Azure Functions ...unctions/migration/migrate-plan-consumption-to-flex.md
High Priority View Details →
Scanned: 2026-01-10 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 migration instructions for both Linux and Windows Azure Functions apps, but there is a noticeable Windows bias. Windows examples and instructions are often presented first, with more detailed and numerous CLI and portal steps. Windows-specific tools and patterns (such as PowerShell, Visual Studio, and Windows storage/file share details) are mentioned more frequently and in greater depth. Linux instructions are sometimes less detailed, and certain migration automation tools (like az functionapp flex-migration) are only available for Linux, but this is called out as an exception rather than the norm. Some sections lack Linux parity in example scripts or troubleshooting steps.
Recommendations
  • Ensure that Linux and Windows instructions are presented with equal prominence and detail, possibly alternating which platform is shown first.
  • Provide equivalent Linux examples for all CLI, portal, and troubleshooting steps, including shell script examples where PowerShell is used for Windows.
  • Highlight Linux-specific tools and workflows (such as bash, Linux file system paths, and deployment methods) alongside Windows tools.
  • Where features or tools are Windows-only or Linux-only, clearly indicate this at the start of relevant sections and provide alternative workflows for the other platform.
  • Expand troubleshooting and recovery sections to include Linux-specific error patterns and diagnostic commands.
  • Review all code samples and ensure that Linux shell (bash) and Windows (PowerShell) examples are provided side-by-side where applicable.
GitHub Create Pull Request
Azure Functions Respond to blob storage events using Azure Functions ...ticles/azure-functions/scenario-blob-storage-events.md
High Priority View Details →
Scanned: 2026-01-10 00:00
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
Windows First Powershell Heavy 🔧 Windows Tools
Summary
The documentation demonstrates a moderate Windows bias. Visual Studio Code is used as the primary development environment, and instructions frequently reference Windows-specific workflows (e.g., command palette, F1, terminal types). PowerShell is included as a first-class language, with dedicated templates and examples. Windows-specific instructions (such as terminal selection and activation of Python virtual environments) are provided before or in more detail than Linux equivalents. The use of Azurite and Azure Functions Core Tools is cross-platform, but the documentation assumes familiarity with Windows conventions and tools, and troubleshooting advice is Windows-centric.
Recommendations
  • Ensure Linux/macOS instructions are presented with equal prominence and detail as Windows instructions, especially for terminal commands and environment setup.
  • Provide troubleshooting tips for Linux/macOS environments, not just Windows (e.g., default terminal issues, permissions).
  • Include explicit instructions for using Visual Studio Code and Azure CLI on Linux/macOS, and clarify any differences in workflow.
  • Balance PowerShell examples with Bash or other shell equivalents where possible.
  • Consider adding a section or callouts for common Linux/macOS developer patterns (e.g., using native package managers, file system differences).
  • Avoid assuming Windows as the default platform in notes and examples; use neutral language or parallel instructions.
GitHub Create Pull Request
Azure Functions Troubleshoot Python function apps in Azure Functions ...n/articles/azure-functions/recover-python-functions.md
High Priority View Details →
Scanned: 2026-01-10 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 demonstrates a Windows bias in several areas: Windows and PowerShell commands are frequently presented before their Linux equivalents, or sometimes exclusively. Windows-specific tools and patterns (such as Visual Studio Code, PowerShell, and Windows command line) are mentioned prominently, often with more detailed instructions than for Linux. Some troubleshooting steps and examples prioritize Windows workflows, and Linux alternatives are sometimes less detailed or missing. The documentation also references issues arising from Windows/macOS development environments, but does not provide equally thorough guidance for Linux users.
Recommendations
  • Ensure all command-line examples are provided for both Windows (PowerShell/CMD) and Linux (Bash), and present them side-by-side or in a neutral order.
  • Avoid listing Windows commands or tools first; alternate or group by OS.
  • Expand Linux-specific troubleshooting steps and examples to match the detail given for Windows.
  • Include explicit instructions for Linux users in sections that currently only mention Windows/macOS (e.g., exporting requirements.txt, checking Python interpreter bitness).
  • Reference cross-platform tools and editors (such as VS Code, but also alternatives) and avoid assuming Windows as the default development environment.
  • Add guidance for common Linux deployment scenarios, including package management and environment setup.
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-10 00:00
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
🔧 Windows Tools Windows First Powershell Heavy
Summary
The documentation demonstrates some Windows bias, particularly in the deployment and connection steps. Windows/PowerShell instructions are present and given equal prominence to Linux/macOS, but Windows-specific tools and patterns (such as PowerShell scripting and Set-Variable) are used. The prerequisites mention setting JAVA_HOME, which is more common on Windows, and the PowerShell SDK is referenced (though commented out). There is no explicit Linux example missing, but Windows instructions are provided and sometimes use Windows-centric terminology (e.g., 'command prompt'). Visual Studio Code is the only editor mentioned, which is cross-platform but more commonly associated with Windows workflows. The use of Azurite and Azure CLI is platform-neutral, but the scripting examples for retrieving keys are split into Linux/macOS (bash) and Windows (PowerShell), with the Windows example using PowerShell-specific constructs.
Recommendations
  • Ensure Linux/macOS examples are always provided alongside Windows/PowerShell examples, and consider listing Linux/macOS instructions first to avoid implicit Windows-first bias.
  • Where possible, use platform-neutral commands (e.g., Azure CLI, bash) and avoid PowerShell-specific constructs unless necessary.
  • Clarify that Visual Studio Code and all tools are fully supported on Linux/macOS, and provide links to installation instructions for those platforms.
  • If referencing environment variables (e.g., JAVA_HOME), provide instructions for setting them on both Windows and Linux/macOS.
  • Consider adding explicit notes or pivots for Linux users, especially in sections where Windows terminology or tools are used.
  • Review all code snippets and instructions to ensure Linux parity, and avoid assuming Windows as the default development environment.
GitHub Create Pull Request
Azure Functions Respond to database changes in Azure Cosmos DB using Azure Functions ...-functions/scenario-database-changes-azure-cosmosdb.md
High Priority View Details →
Scanned: 2026-01-10 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 several signs of Windows bias. Windows-specific instructions and tools (such as PowerShell and Windows command prompt) are presented alongside or before Linux/macOS equivalents. The troubleshooting section specifically references issues with WSL Bash, which is unique to Windows environments. There is a reliance on PowerShell for permission setting, and the Linux/macOS instructions are less detailed. Some examples and troubleshooting steps are only provided for Windows, and there is no parity in examples for Linux shell environments. Additionally, the use of Visual Studio Code and its integration with Windows tools is emphasized, with limited mention of Linux-specific workflows.
Recommendations
  • Provide equivalent Linux/macOS shell commands and troubleshooting steps wherever Windows/PowerShell instructions are given.
  • Ensure that Linux/macOS instructions are as detailed and prominent as Windows instructions, including error handling and permissions.
  • Include examples and troubleshooting for common Linux environments (e.g., Ubuntu, Fedora) and shells (bash, zsh).
  • Avoid referencing Windows-specific issues (like WSL Bash) without also mentioning Linux/macOS equivalents.
  • Consider adding a dedicated section for Linux/macOS users, outlining any unique steps or caveats.
  • Review all code and command snippets to ensure they work cross-platform, and explicitly state any platform-specific requirements.
GitHub Create Pull Request
Azure Functions How to target Azure Functions runtime versions ...b/main/articles/azure-functions/set-runtime-version.md
High Priority View Details →
Scanned: 2026-01-10 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 a moderate Windows bias. Windows and PowerShell examples are presented alongside Azure CLI, but PowerShell is given equal prominence despite being Windows-centric. The documentation provides detailed instructions for Windows users, including Visual Studio integration and PowerShell scripts, while Linux-specific instructions are less detailed and rely solely on Azure CLI. Some features (like pinning via the portal or PowerShell) are explicitly stated as unavailable for Linux, but alternative Linux workflows are not always fully explored or explained. The documentation also references Windows tools and patterns (e.g., .csproj edits, Visual Studio dialogs) without Linux equivalents.
Recommendations
  • Provide Linux-specific examples for all major workflows, including pinning and viewing runtime versions, not just via Azure CLI but also with other common Linux tools or scripting languages (e.g., Bash).
  • Clarify and expand on Linux limitations, and suggest alternative approaches or workarounds where features are unavailable (e.g., portal or PowerShell).
  • When referencing Windows-specific tools (e.g., Visual Studio, .csproj), offer Linux alternatives (e.g., VS Code, command-line deployment, or other editors).
  • Ensure that Linux instructions are as detailed and actionable as Windows instructions, including troubleshooting steps and integration with common Linux development environments.
  • Consider reordering or balancing the presentation of Windows and Linux content so that neither is implicitly prioritized.
GitHub Create Pull Request
Azure Functions Update Language Versions in Azure Functions ...n/articles/azure-functions/update-language-versions.md
High Priority View Details →
Scanned: 2026-01-10 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 a moderate Windows bias. Instructions and examples for updating language versions in Azure Functions are frequently presented with Windows as the primary or default context, especially in tabbed sections and CLI commands. Windows-specific tools and patterns (such as .NET SDK, PowerShell, and Windows OS flags in CLI commands) are often mentioned before their Linux equivalents. In some cases, Linux instructions are relegated to notes or secondary tabs, and there are explicit statements about unsupported scenarios for Linux (e.g., Python on Windows). There is also a heavier focus on PowerShell and Windows-centric workflows, with less parity in Linux-specific troubleshooting and examples.
Recommendations
  • Ensure that Linux instructions and examples are presented with equal prominence and detail as Windows examples, including in tabbed sections and CLI command samples.
  • Avoid presenting Windows as the default or first option; instead, use neutral language or parallel presentation for both OSes.
  • Expand troubleshooting and workflow sections to include Linux-specific guidance and examples, not just Windows-centric tools.
  • Where features are unsupported on Linux or Windows, provide clear alternatives or workarounds for the affected platform.
  • Include explicit Linux development toolchain recommendations and examples (e.g., for .NET, Node.js, Python) alongside Windows/PowerShell references.
GitHub Create Pull Request
Azure Functions Storage considerations for Azure Functions ...ain/articles/azure-functions/storage-considerations.md
High Priority View Details →
Scanned: 2026-01-10 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 page demonstrates a Windows bias by frequently referencing Windows-specific hosting plans, configuration settings, and deployment patterns before their Linux equivalents. PowerShell examples and tooling are presented alongside Azure CLI, but Windows scenarios (such as Consumption plan details and Azure Files usage) are described first or exclusively in several sections. Linux-specific features, such as mounting Azure Files shares, are relegated to a separate section and lack parity in example depth and troubleshooting guidance. There are also references to Visual Studio and Azurite, which are primarily Windows-centric tools, with little mention of Linux alternatives.
Recommendations
  • Ensure that Linux hosting scenarios are described with equal prominence and detail as Windows scenarios throughout the documentation.
  • Provide Linux-specific examples and troubleshooting steps wherever Windows/Powershell examples are given, including deployment, configuration, and scaling.
  • Include references to Linux-compatible tools (such as VS Code, Storage Explorer, or CLI-based workflows) alongside or before Windows-centric tools like Visual Studio and Azurite.
  • Clarify which features and settings apply to Linux, Windows, or both, and avoid presenting Windows as the default or primary platform.
  • Expand the 'Mount file shares' section to include more Linux examples, troubleshooting, and best practices, matching the depth of Windows guidance elsewhere.
GitHub Create Pull Request
Azure Functions https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/durable/durable-functions-bindings.md .../azure-functions/durable/durable-functions-bindings.md
High Priority View Details →
Scanned: 2026-01-09 00:34
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
🔧 Windows Tools Powershell Heavy Windows First
Summary
The documentation provides examples for multiple languages, including Python, Java, JavaScript, C#, and PowerShell. However, there is a notable bias toward Windows-centric tools and patterns: PowerShell is included as a first-class example language, and its usage is described in detail, including references to function.json and run.ps1 files. The documentation refers to configuration files and patterns (function.json, run.ps1) that are most familiar to Windows/PowerShell users, and does not mention Linux shell equivalents or provide guidance for Bash or other Linux-native scripting environments. The inclusion of PowerShell as a primary example language and the lack of Linux shell (e.g., Bash) examples or references to Linux tooling indicate a Windows-first and PowerShell-heavy bias.
Recommendations
  • Add Bash or other Linux shell scripting examples alongside PowerShell for parity, especially in sections describing function.json usage and orchestration client invocation.
  • Reference Linux-native tools and workflows (e.g., bash scripts, environment variable usage, file system paths) where relevant, not just Windows/PowerShell equivalents.
  • Clarify that function.json and run.ps1 are not exclusive to Windows and provide guidance for Linux users on how to work with these files and triggers in a Linux environment.
  • Consider including a 'platform notes' section that highlights any differences or considerations for Linux users, such as file permissions, path formats, or shell usage.
  • Ensure that any references to scripting or automation are balanced between Windows (PowerShell) and Linux (Bash/sh), or explicitly state if a feature is only available on Windows.
GitHub Create Pull Request
Azure Functions https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-host-json.md ...b/main/articles/azure-functions/functions-host-json.md
High Priority View Details →
Scanned: 2026-01-09 00:34
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
Powershell Heavy 🔧 Windows Tools Windows First
Summary
The documentation page exhibits mild Windows bias. The 'managedDependency' feature is described as only supported for PowerShell functions, which are primarily associated with Windows environments. Several configuration examples and descriptions reference Windows-centric tools, conventions, or environment variables (e.g., %TEMP%, LOCALAPPDATA, APPDATA), and the use of PowerShell-specific files (requirements.psd1). In some cases, Windows environment variables are mentioned before Linux equivalents, and Linux-specific behaviors are only briefly noted (e.g., console log color suppression). There is limited mention of Linux-specific patterns or parity, and no Linux shell or tooling examples are provided.
Recommendations
  • Explicitly mention Linux support or limitations for features such as managedDependency, and provide equivalent Linux examples or alternatives where possible.
  • Where environment variables or paths are referenced (e.g., %TEMP%, LOCALAPPDATA), also include Linux equivalents (e.g., $TMPDIR, $HOME/.local/share) and clarify cross-platform behavior.
  • For PowerShell-specific features, note whether Bash or other Linux-native scripting environments have similar support or planned parity.
  • Include Linux shell (bash/zsh) examples for configuration overrides and local development, not just Windows/PowerShell.
  • Add notes or tables summarizing platform-specific behaviors for all relevant settings, especially those that interact with the OS or file system.
  • Ensure that documentation does not assume Windows as the default platform, and that Linux/Mac users are equally supported in examples and explanations.
GitHub Create Pull Request
Azure Functions https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-machine-learning-tensorflow.md ...ure-functions/functions-machine-learning-tensorflow.md
High Priority View Details →
Scanned: 2026-01-09 00:34
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, PowerShell, and Cmd, but often lists Windows-centric tools and patterns first or with more detail. Windows-specific issues (e.g., long path errors, registry edits) are discussed in depth, while Linux/macOS troubleshooting is minimal. PowerShell and Cmd examples are given equal prominence to Bash, but Windows tools (like 'py' launcher and registry edits) are referenced without Linux equivalents. Some troubleshooting steps and notes are Windows-only, and Linux users may find less guidance for common issues.
Recommendations
  • Ensure Linux/macOS troubleshooting steps are as detailed as Windows ones (e.g., discuss common Linux permission or path issues).
  • When listing command tabs, alternate the order or place Bash first to avoid implicit Windows primacy.
  • Provide Linux/macOS equivalents for all Windows-specific tools and patterns (e.g., discuss alternatives to 'py' launcher, registry edits, and long path issues on Linux).
  • Add more Linux/macOS-specific tips and troubleshooting notes, such as handling Python environment issues, file permissions, and package installation errors.
  • Review all examples to ensure parity in explanation and depth for Linux/macOS users.
GitHub Create Pull Request
Azure Functions https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-run-local.md ...b/main/articles/azure-functions/functions-run-local.md
High Priority View Details →
Scanned: 2026-01-09 00:34
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
Windows First Powershell Heavy 🔧 Windows Tools
Summary
The documentation demonstrates mild Windows bias. Windows-specific tools (PowerShell, func.exe) and terminology are referenced throughout, sometimes before or instead of Linux equivalents. Examples for command-line usage are generally cross-platform, but some sections (such as cURL usage) provide Windows command line syntax before or alongside Bash, and references to func.exe and MSI installers are Windows-centric. The requirement for Azure PowerShell or Azure CLI is mentioned, but PowerShell is listed first. There is no explicit mention of Linux-specific shell environments or package managers (e.g., apt, yum) for installation, and some instructions (such as MSI uninstall) are Windows-only. The documentation does not provide Linux-specific troubleshooting or highlight differences in behavior between platforms.
Recommendations
  • Ensure all command examples are shown for both Bash (Linux/macOS) and Windows CMD/PowerShell, with clear labeling and parity.
  • When referencing installation or upgrade methods, include Linux/macOS package managers (apt, yum, brew, npm) and instructions, not just MSI for Windows.
  • Avoid using Windows-centric terminology (e.g., func.exe) when referring to cross-platform tools; use 'func' or 'Functions host' instead.
  • List Azure CLI before Azure PowerShell, or mention both together, as CLI is more platform-neutral.
  • Add troubleshooting notes for Linux/macOS environments, especially for common issues (permissions, path, virtual environments).
  • Explicitly state platform compatibility and any differences in behavior or requirements between Windows, Linux, and macOS.
GitHub Create Pull Request
Azure Functions https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/machine-learning-pytorch.md ...n/articles/azure-functions/machine-learning-pytorch.md
High Priority View Details →
Scanned: 2026-01-09 00:34
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 (such as 'py' launcher, registry edits, and long path issues) are mentioned more frequently and with greater detail. Windows commands and troubleshooting steps are often presented before or with more emphasis than their Linux equivalents. Some troubleshooting advice is exclusively for Windows, and Visual Studio Code (a cross-platform editor but with strong Windows association) is recommended without mention of alternatives. Linux-specific issues and solutions are less detailed.
Recommendations
  • Ensure troubleshooting sections include Linux/macOS-specific advice where relevant (e.g., file path issues, permissions, package installation problems).
  • Present Bash/Linux/macOS examples before or alongside Windows examples to avoid implicit prioritization.
  • Include alternative code editors (e.g., Vim, Emacs, Sublime Text) in recommendations, or clarify that VS Code is cross-platform.
  • Balance the depth of troubleshooting guidance for both platforms, e.g., discuss common Linux/macOS errors and their solutions.
  • Where Windows-specific tools (like 'py' launcher or registry edits) are mentioned, provide equivalent Linux/macOS context or alternatives.
  • Add explicit notes for Linux/macOS users about potential issues (such as virtual environment activation, permissions, or dependency installation).
GitHub Create Pull Request
Azure Functions https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/bring-dependency-to-functions.md ...icles/azure-functions/bring-dependency-to-functions.md
High Priority View Details →
Scanned: 2026-01-09 00:34
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
🔧 Windows Tools Windows First Missing Linux Example
Summary
The documentation demonstrates Windows bias primarily in the Java section, where the example uses a Windows-specific ffmpeg binary (ffmpeg.exe) and omits Linux equivalents. The Java code references Windows-style paths and does not mention Linux deployment nuances or provide Linux-specific examples. Additionally, PowerShell is mentioned as an upload option for Azure Files, but Linux-native tools (e.g., scp, rsync) are not referenced. The Python section is more Linux-aware, but overall, Windows tools and patterns are mentioned first or exclusively in some places.
Recommendations
  • In Java examples, provide both Windows and Linux ffmpeg binary usage, including path and execution differences.
  • Explicitly mention Linux deployment considerations for Java, such as executable permissions and path formats.
  • When listing upload options for Azure Files, include Linux-native tools (e.g., azcopy, scp, rsync) alongside PowerShell and Azure CLI.
  • Ensure that all code samples and instructions are cross-platform, or clearly indicate platform-specific steps.
  • Add notes or tables summarizing differences in file system paths, permissions, and execution between Windows and Linux environments.
GitHub Create Pull Request
Azure Functions https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/create-first-function-azure-developer-cli.md ...functions/create-first-function-azure-developer-cli.md
High Priority View Details →
Scanned: 2026-01-09 00:34
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
Windows First Powershell Heavy 🔧 Windows Tools
Summary
The documentation demonstrates a moderate Windows bias. Windows-specific tools and patterns (such as PowerShell and Cmd) are given explicit, detailed instructions and examples, sometimes before or in addition to Linux equivalents. The virtual environment setup for Python, for example, provides three tabs: Linux/macOS, Windows (bash), and Windows (Cmd), with Windows variants receiving their own sections. In the 'Invoke the function on Azure' section, Windows (Cmd) and PowerShell instructions are provided alongside bash, with PowerShell highlighted for the PowerShell language pivot. The use of 'terminal or command prompt' throughout also subtly prioritizes Windows terminology. Additionally, the Powershell language pivot receives special treatment in several places, including unique instructions and code samples.
Recommendations
  • Ensure Linux/bash instructions are always presented first or equally alongside Windows-specific instructions.
  • Use neutral terminology such as 'terminal' instead of 'command prompt' where possible.
  • For PowerShell examples, clarify cross-platform support and provide bash equivalents where relevant.
  • Where multiple tabs are used for OS-specific instructions, consider grouping Linux/macOS and Windows equally, and avoid giving Windows variants more prominence.
  • Explicitly mention that all CLI commands work on Linux/macOS unless there are genuine platform-specific caveats.
  • Audit all code samples and instructions to ensure Linux users have clear, direct guidance and are not required to infer steps from Windows-centric instructions.
GitHub Create Pull Request
← Previous Page 8 of 41 Next →