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

1019 issues found
Showing 51-75 of 1019 flagged pages
Azure Functions Automate function app resource deployment to Azure ...es/azure-functions/functions-infrastructure-as-code.md
High Priority View Details →
Scanned: 2026-01-12 00:00
Reviewed by: LLM Analysis
Issues: 5 bias types
Detected Bias Types
Windows First Windows Examples Prominent Powershell Heavy 🔧 Windows Tools Missing Linux Example
Summary
The documentation page demonstrates several types of Windows bias. Windows examples and terminology are frequently presented before Linux equivalents, especially in code samples and hosting plan definitions. PowerShell is used as the primary scripting language for deployment automation, with less emphasis on Bash or cross-platform CLI. Windows-specific tools and settings (such as WEBSITE_NODE_DEFAULT_VERSION) are highlighted, and some sections (e.g., deployment slots, remote builds, validation) provide more detail for Windows scenarios. Although Linux examples are present, they are often secondary, and some advanced Linux deployment scenarios (such as Bash scripting for deployment) are missing.
Recommendations
  • Present Linux and Windows examples side-by-side, or alternate which is shown first in code samples and explanations.
  • Include Bash or cross-platform Azure CLI scripts for deployment automation, not just PowerShell.
  • Ensure all advanced deployment scenarios (e.g., slot swaps, remote builds, validation) have Linux-specific instructions and examples.
  • Highlight Linux-specific settings and considerations equally with Windows, especially in application configuration tables.
  • Where Windows tools or terminology are mentioned, provide Linux equivalents (e.g., VS Code extensions, deployment commands).
  • Add links to Linux-focused sample repositories and templates.
  • Review all sections for parity in detail and troubleshooting guidance for both platforms.
GitHub Create Pull Request
Azure Functions Azure Functions networking options ...ticles/azure-functions/functions-networking-options.md
High Priority View Details →
Scanned: 2026-01-12 00:00
Reviewed by: LLM Analysis
Issues: 4 bias types
Detected Bias Types
Windows First Powershell Heavy 🔧 Windows Tools Missing Linux Example
Summary
The documentation page exhibits several Windows-centric biases. Hybrid Connections are explicitly supported only for Windows-based function apps, with Linux support called out as missing. Example automation commands are provided for Azure PowerShell and Azure CLI, but PowerShell is highlighted, and there is no mention of Bash or Linux-specific scripting. Subnet sizing recommendations are given for both Windows and Linux, but Windows is listed first and with larger minimums, suggesting a default focus on Windows. No Linux-specific troubleshooting or operational guidance is provided, and Windows features/tools (such as Hybrid Connections) are described in detail without Linux alternatives.
Recommendations
  • Clearly indicate Linux support or limitations for all features, not just Hybrid Connections.
  • Provide Linux/Bash equivalents for all PowerShell examples, especially for automation and configuration.
  • Present Windows and Linux guidance in parallel, or alternate which is listed first to avoid implicit prioritization.
  • Offer troubleshooting steps and tooling guidance that are relevant for Linux-based function apps.
  • Where features are Windows-only, suggest Linux alternatives or workarounds, or explain the roadmap for Linux parity.
  • Include explicit examples for Linux environments in quickstart and tutorial sections.
  • Review all screenshots and UI instructions to ensure they are applicable to both Windows and Linux hosting scenarios.
GitHub Create Pull Request
Azure Functions Azure Functions Premium plan ...ain/articles/azure-functions/functions-premium-plan.md
High Priority View Details →
Scanned: 2026-01-12 00:00
Reviewed by: LLM Analysis
Issues: 4 bias types
Detected Bias Types
Windows First Powershell Heavy Missing Linux Example 🔧 Windows Tools
Summary
The documentation page exhibits several Windows-centric biases. Examples and instructions are frequently provided for Azure PowerShell (a Windows-focused tool) alongside Azure CLI, but there are no Linux-specific shell examples (e.g., Bash scripts, Linux-native tools). In migration scenarios, only Windows is supported, with Linux explicitly excluded. The ordering of examples and region scale-out tables consistently lists Windows before Linux, reinforcing a Windows-first perspective. There is also a lack of parity in migration support and troubleshooting guidance for Linux users.
Recommendations
  • Add Linux-specific examples and instructions, such as Bash shell commands or references to Linux-native tools where appropriate.
  • Ensure that CLI examples are clearly marked as cross-platform and provide any necessary Linux-specific notes (e.g., environment variable syntax differences, file paths).
  • Where PowerShell is used, clarify its availability on Linux and provide installation instructions or alternatives for Linux users.
  • In migration and troubleshooting sections, explicitly address Linux scenarios and provide guidance or workarounds if features are not supported.
  • Reorder tables and example lists to alternate or balance Windows and Linux, rather than always listing Windows first.
  • Where features are not available on Linux, provide context and timelines for parity, or suggest alternative approaches for Linux users.
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-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 a moderate Windows bias. Windows-centric tools such as Visual Studio and PowerShell are mentioned prominently and often before cross-platform or Linux-native alternatives. Visual Studio is listed first in C# quickstarts and development tools, and PowerShell is included as a primary language pivot. There is little explicit mention of Linux-specific workflows, editors, or shell environments (e.g., Bash), and no Linux-first examples or tool recommendations are provided. The documentation assumes that Visual Studio and Visual Studio Code are the main local development environments, which may not reflect the preferences of Linux users.
Recommendations
  • Include Linux-specific development tool examples, such as using Bash, Vim, or Emacs for local development.
  • Provide explicit instructions and examples for Linux environments, such as using the Azure CLI in Bash or Zsh, and clarify cross-platform compatibility for all tools.
  • List cross-platform or Linux-native tools (e.g., Azure CLI, VS Code) before Windows-only tools (e.g., Visual Studio) in quickstart and development tool sections.
  • Add guidance for setting up local development environments on Linux, including package installation commands and troubleshooting tips.
  • Ensure parity in language pivots by offering Linux shell examples alongside PowerShell examples where relevant.
GitHub Create Pull Request
Azure Functions Develop Azure Functions locally using Core Tools ...b/main/articles/azure-functions/functions-run-local.md
High Priority View Details →
Scanned: 2026-01-12 00:00
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
Windows First 🔧 Windows Tools Powershell Heavy
Summary
The documentation generally aims for cross-platform parity, but there are subtle signs of Windows bias. Windows command-line examples are provided alongside Bash, and references to 'command prompt' and 'func.exe' (the Windows executable) appear throughout. Azure PowerShell is mentioned as a primary tool for publishing, and PowerShell is given equal prominence as a language, which may not reflect typical Linux workflows. The documentation sometimes lists Windows tools or patterns before Linux equivalents, and references to Windows-specific behaviors (such as MSI installation and func.exe) are present.
Recommendations
  • When showing command-line examples, always present Bash (Linux/macOS) examples first, or provide both Bash and Windows CMD/PowerShell examples side by side.
  • Avoid referring to the Functions host as 'func.exe'—use 'func' or 'the Functions host' to be platform-neutral.
  • When mentioning prerequisites or tools (e.g., Azure CLI, Azure PowerShell), clarify which are cross-platform and which are Windows-specific, and ensure Linux-first or parity in instructions.
  • Where PowerShell is referenced as a language, clarify its cross-platform availability and provide Bash alternatives where appropriate.
  • Review installation and upgrade instructions to ensure Linux package managers (apt, yum, brew, npm) are given equal or greater prominence compared to Windows installers.
  • Audit all references to Windows-specific behaviors or terminology and provide Linux/macOS equivalents where relevant.
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-12 00:00
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
Windows First 🔧 Windows Tools Missing Linux Example
Summary
The documentation demonstrates a Windows bias in several ways. Windows is frequently mentioned first in tables and plan descriptions, and Windows-specific features (such as PowerShell modules and the full .NET Framework) are highlighted as primary use cases for the Consumption plan. There is a lack of Linux-specific examples or tooling references, and Linux support is often described in terms of limitations or retirement (e.g., Linux Consumption plan being retired), rather than as a first-class option. Windows deployment and features are described in more detail, while Linux options are sometimes referenced only in passing or with caveats.
Recommendations
  • Present Linux and Windows options in parallel, rather than listing Windows first or as the default.
  • Include Linux-specific examples, tools, and scenarios (e.g., Bash, Linux-native deployment workflows, Python on Linux).
  • Avoid framing Linux support primarily in terms of limitations or retirement; highlight Linux strengths and supported scenarios.
  • Where Windows-specific features (such as PowerShell modules) are mentioned, also provide equivalent Linux-native alternatives or note cross-platform options.
  • Ensure parity in technical detail and guidance for both Linux and Windows hosting plans, including container support and networking features.
GitHub Create Pull Request
Azure Functions Target-based scaling in Azure Functions ...cles/azure-functions/functions-target-based-scaling.md
High Priority View Details →
Scanned: 2026-01-12 00:00
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
🔧 Windows Tools Windows First Powershell Heavy
Summary
The documentation is largely cross-platform and focuses on configuration via JSON and code samples for multiple languages. However, there are subtle signs of Windows bias: (1) PowerShell is grouped with JavaScript/TypeScript in examples, suggesting parity but giving PowerShell more visibility than Bash or Linux shell scripting; (2) a comment in the Java Kafka example specifically calls out enabling a line for Windows, with no equivalent Linux guidance; (3) there is no mention of Linux-specific tools, shell environments, or deployment patterns, and Windows/PowerShell are referenced before Linux alternatives in the limited cases where OS-specific configuration is discussed.
Recommendations
  • Add explicit Linux/Bash shell scripting examples or references where PowerShell is mentioned, to ensure parity.
  • Where OS-specific configuration is referenced (e.g., sslCaLocation for Kafka), provide both Windows and Linux instructions.
  • Avoid grouping PowerShell with JavaScript/TypeScript unless there is a clear cross-platform rationale; consider grouping Bash with PowerShell for parity.
  • Include notes or links for Linux-specific deployment or configuration patterns where relevant.
  • Review all examples and notes to ensure that Windows tools or patterns are not mentioned before Linux equivalents unless there is a technical reason.
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-12 00:00
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
🔧 Windows Tools Windows First Powershell Heavy
Summary
The documentation shows mild Windows bias. Windows-specific tools and instructions are referenced, such as PowerShell and Windows terminal settings. In several places, Windows instructions are given before Linux/macOS equivalents (e.g., compiling Go/Rust for Linux from Windows, troubleshooting shell settings). PowerShell is included as a first-class language, and its prerequisites link only to Windows installation instructions. Some troubleshooting steps reference Windows-specific issues (e.g., default terminal shell not set to WSL Bash). However, most examples and instructions are cross-platform, and Linux/macOS are mentioned where relevant.
Recommendations
  • For PowerShell prerequisites, provide installation instructions for Linux/macOS alongside Windows.
  • In troubleshooting, clarify solutions for Linux/macOS users (e.g., shell settings, emulator usage).
  • When listing platform-specific build steps (e.g., Go/Rust), present Linux/macOS instructions before or alongside Windows, not after.
  • Ensure all tool links (e.g., Azure Functions Core Tools, PowerShell) point to cross-platform documentation.
  • Explicitly mention Linux/macOS compatibility in all relevant sections, especially for language runtimes and extensions.
GitHub Create Pull Request
Azure Functions Deploy a PyTorch model as an Azure Functions application ...n/articles/azure-functions/machine-learning-pytorch.md
High Priority View Details →
Scanned: 2026-01-12 00:00
Reviewed by: LLM Analysis
Issues: 4 bias types
Detected Bias Types
Windows First Powershell Heavy 🔧 Windows Tools Missing Linux Example
Summary
The documentation provides command examples for Bash (Linux/macOS), PowerShell, and Cmd, but Windows-specific tools and patterns (such as 'py' launcher, registry edits, and long path issues) are mentioned first or exclusively. Troubleshooting tips and editor recommendations are Windows-centric, and some Linux-specific issues (such as permissions or package installation) are only briefly mentioned. The documentation assumes familiarity with Windows environments and tools, with Linux/macOS guidance often secondary.
Recommendations
  • Ensure Linux/macOS examples are presented with equal prominence and detail as Windows examples.
  • Include troubleshooting tips for common Linux/macOS issues (e.g., permissions, package installation failures, virtual environment activation quirks).
  • Provide editor recommendations for Linux/macOS (e.g., alternatives to Visual Studio Code, such as Vim or Sublime Text).
  • Offer guidance for resolving long path issues on Linux/macOS (e.g., using different filesystems or symlink strategies), not just Windows registry edits.
  • Use 'python' consistently in examples, with notes about 'py' launcher availability on Windows, rather than defaulting to Windows-first patterns.
  • Add explicit instructions for activating/deactivating virtual environments on Linux/macOS, including shell-specific notes (bash, zsh, etc.).
GitHub Create Pull Request
Azure Functions Migrate C# app from in-process to isolated worker model ...es/azure-functions/migrate-dotnet-to-isolated-model.md
High Priority View Details →
Scanned: 2026-01-12 00:00
Reviewed by: LLM Analysis
Issues: 4 bias types
Detected Bias Types
Powershell Heavy 🔧 Windows Tools Missing Linux Example Windows First
Summary
The documentation page demonstrates a Windows bias by exclusively providing Azure PowerShell scripts for identifying function apps to migrate, without offering Bash, Azure CLI, or Linux-native alternatives. Windows-centric tools and workflows (PowerShell, Visual Studio) are mentioned as primary options, with no parity for Linux or cross-platform tools. There are no examples or guidance for users working on Linux or macOS environments, and Windows tools are referenced before any mention of alternatives.
Recommendations
  • Provide equivalent Azure CLI (az) or Bash scripts for identifying function apps, alongside PowerShell examples.
  • Explicitly mention cross-platform tooling such as Azure Functions Core Tools and VS Code, and provide instructions for Linux/macOS environments.
  • Include deployment and configuration steps using CLI commands and scripts that work natively on Linux/macOS.
  • Reference Linux and macOS development environments in migration steps, and clarify any differences or requirements.
  • Ensure all automation and CI/CD guidance is platform-neutral, or provide examples for both Windows and Linux pipelines.
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-12 00:00
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
Powershell Heavy Windows First Missing Linux Example
Summary
The documentation page demonstrates Windows bias by providing only PowerShell scripts for identifying function apps to migrate, referencing Azure PowerShell multiple times, and omitting equivalent Linux/bash/CLI examples. The initial migration steps and tooling recommendations (such as Visual Studio and .NET Upgrade Assistant) are Windows-centric, with no mention of Linux-native alternatives or parity in scripting. Linux-specific considerations (such as shell commands or CLI usage) are missing or deferred, and Windows tools are mentioned first or exclusively.
Recommendations
  • Provide Azure CLI/bash examples alongside PowerShell scripts for identifying and managing function apps, ensuring Linux users have clear instructions.
  • Mention Linux-compatible IDEs and tools (such as VS Code, JetBrains Rider, or CLI-based workflows) in migration steps, not just Visual Studio.
  • Explicitly state cross-platform compatibility for tools like .NET Upgrade Assistant, and provide installation/usage instructions for Linux.
  • Add a section or callouts for Linux-specific migration considerations, such as file permissions, environment variables, and runtime differences.
  • Ensure that scripting and automation steps are presented in a platform-neutral way, or offer both Windows and Linux alternatives side-by-side.
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-12 00:00
Reviewed by: LLM Analysis
Issues: 4 bias types
Detected Bias Types
Windows First Powershell Heavy 🔧 Windows Tools Missing Linux Example
Summary
The documentation provides detailed, step-by-step instructions for migrating Azure Functions from the Consumption plan to the Flex Consumption plan, with clear separation between Windows and Linux workflows. However, there is a noticeable Windows bias: Windows examples and tools (such as Azure CLI commands, Kusto queries, and portal steps) are often presented first or in greater detail, and some migration steps (especially for Windows) require more manual effort and use Windows-centric tools. The Linux migration process is streamlined via the 'az functionapp flex-migration' CLI command, but the documentation does not always provide Linux equivalents for all Windows manual steps, and some advanced configuration or troubleshooting guidance is Windows-focused. In addition, references to PowerShell and Windows-specific deployment/storage patterns are more prevalent, and some examples (such as file share access and storage account details) are tailored to Windows.
Recommendations
  • Ensure all manual migration steps and troubleshooting guidance for Windows have equivalent, detailed Linux instructions (not just relying on the automated CLI command).
  • Present Linux and Windows instructions in parallel, or alternate which platform is shown first, to avoid the perception of Windows primacy.
  • Include Linux-specific troubleshooting, advanced configuration, and recovery steps, especially for scenarios where the automated CLI migration may not be sufficient.
  • Reduce reliance on Windows-centric tools and patterns (such as file shares, PowerShell, and Windows-specific storage account settings) in examples, or provide Linux alternatives.
  • Explicitly call out any limitations or differences for Linux users, and provide workarounds or guidance where parity is not yet possible.
  • Expand Linux coverage in sections such as performance benchmarking, monitoring, and post-migration validation to match the depth of Windows guidance.
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-12 00:00
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
Windows First Powershell Heavy 🔧 Windows Tools
Summary
The documentation demonstrates some Windows bias, primarily through the use of Visual Studio Code as the main development environment, frequent references to the command palette (<kbd>F1</kbd>), and inclusion of PowerShell as a supported language. While Linux/macOS instructions are present for Python virtual environments, Windows-specific instructions (Windows Bash, Windows Cmd) are listed separately and prominently. The use of Azurite and Azure Functions Core Tools is cross-platform, but troubleshooting tips and some commands (e.g., 'func.exe host process', 'default terminal for Visual Studio Code isn't set to WSL Bash') are Windows-centric. PowerShell is treated as a first-class language, and Windows terminal patterns are referenced before or alongside Linux equivalents.
Recommendations
  • Ensure Linux/macOS instructions are given equal prominence and clarity as Windows instructions throughout the documentation, not just in language-specific sections.
  • Add troubleshooting notes for Linux/macOS environments (e.g., permissions, common issues with Azurite or Core Tools on Linux).
  • Where possible, use OS-neutral terminology (e.g., 'terminal' instead of 'command prompt') and avoid referencing Windows-specific processes unless necessary.
  • Provide examples or screenshots for Linux/macOS workflows, especially for Visual Studio Code usage and Azurite integration.
  • Clarify that all tools (Azurite, Azure Functions Core Tools, azd) are cross-platform and provide installation links or instructions for Linux/macOS users.
  • Consider including Bash or shell script examples for automation, not just PowerShell.
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-12 00:00
Reviewed by: LLM Analysis
Issues: 4 bias types
Detected Bias Types
Windows First Powershell Heavy 🔧 Windows Tools Missing Linux Example
Summary
The documentation page exhibits several forms of Windows bias. In command examples and troubleshooting steps, Windows (and PowerShell) instructions are often presented before or more prominently than Linux equivalents. Some sections provide only Windows-specific commands or tools (e.g., PowerShell, 'py' launcher), with Linux/Unix alternatives mentioned second or less thoroughly. There are also references to Windows-only packages (e.g., pywin32) and patterns (pip freeze from Windows), but Linux-specific troubleshooting and best practices are less emphasized.
Recommendations
  • Present Linux and Windows instructions side-by-side, or default to Linux-first examples since Azure Functions Python runs on Linux.
  • Ensure all command examples (e.g., checking Python bitness, deleting directories) include both Linux (bash) and Windows (PowerShell/CMD) variants with equal prominence.
  • Highlight Linux deployment patterns and troubleshooting steps, especially since the runtime is Linux-based.
  • Explicitly warn users developing on Windows about cross-platform issues and provide Linux-oriented solutions.
  • Include more Linux tool recommendations (e.g., bash, native package managers) and avoid assuming use of Windows-specific tools (e.g., py launcher, PowerShell).
  • Where packages are Windows-only, suggest Linux alternatives or clarify limitations for Linux deployments.
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
High Priority View Details →
Scanned: 2026-01-12 00:00
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
🔧 Windows Tools Windows First Missing Linux Example
Summary
The documentation page demonstrates a bias towards Windows environments by exclusively using Visual Studio Code and its extensions (such as the SQL Server (mssql) extension and Azure Functions Core Tools) for all instructions and examples. There are no references to Linux-native tools (e.g., sqlcmd, Azure Data Studio, or command-line alternatives), nor are there any examples or instructions for using the CLI outside of Visual Studio Code. The workflow assumes the use of GUI-based tools and patterns common to Windows, such as right-clicking in explorers, and does not mention Linux-specific considerations or alternatives.
Recommendations
  • Provide equivalent instructions for Linux users, including how to use azd, Azure Functions Core Tools, and SQL database access from the terminal.
  • Include examples using command-line tools such as sqlcmd or Azure Data Studio for database access and manipulation.
  • Mention installation and usage steps for Azure Functions Core Tools and azd on Linux, including any required dependencies.
  • Add notes or sections that clarify cross-platform compatibility and highlight any differences in workflow or available features between Windows and Linux.
  • Offer alternative workflows that do not require Visual Studio Code or its extensions, especially for users who prefer or require terminal-based development.
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-12 00:00
Reviewed by: LLM Analysis
Issues: 4 bias types
Detected Bias Types
Windows First Powershell Heavy 🔧 Windows Tools Missing Linux Example
Summary
The documentation page exhibits a moderate Windows bias. Windows-specific instructions (e.g., PowerShell commands, references to Windows terminal, and troubleshooting for Windows/WSL) are presented alongside, or sometimes before, Linux/macOS equivalents. The use of PowerShell for permission setting is highlighted, and troubleshooting tips focus on Windows environments (e.g., avoiding WSL Bash). There is limited coverage of Linux/macOS workflows, with some examples and troubleshooting steps missing or less detailed for non-Windows platforms.
Recommendations
  • Ensure Linux/macOS instructions are presented with equal prominence and detail as Windows instructions, including troubleshooting tips.
  • Provide Bash or shell script equivalents for all PowerShell commands, and clarify when each should be used.
  • Include explicit examples and troubleshooting steps for Linux/macOS users, such as common permission issues, terminal settings, and environment setup.
  • Avoid Windows-centric language (e.g., referencing 'func.exe' host process) and use platform-neutral terminology where possible.
  • Review and expand documentation for missing or placeholder sections for Linux/macOS and non-Windows languages/tools.
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-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 a moderate Windows bias. Windows and PowerShell examples are presented alongside Azure CLI and portal methods, but Windows-specific tools and patterns (such as PowerShell cmdlets and Visual Studio behaviors) are described in detail, often before or with more context than their Linux equivalents. Linux-specific instructions are present but sometimes less detailed, and certain operations (like pinning via portal or PowerShell) are explicitly unavailable for Linux, with CLI as the only option. The documentation also references Windows-centric developer workflows (e.g., Visual Studio publish dialogs) without Linux IDE equivalents.
Recommendations
  • Ensure Linux instructions are as detailed and prominent as Windows instructions, including troubleshooting and workflow notes.
  • Where Windows-specific tools (e.g., PowerShell, Visual Studio) are mentioned, provide equivalent Linux developer workflows (e.g., VS Code, CLI scripting).
  • Clarify limitations for Linux (e.g., portal/PowerShell unavailability) and suggest alternative approaches or workarounds.
  • Consider presenting CLI examples before platform-specific tools to promote cross-platform parity.
  • Add explicit Linux troubleshooting and migration guidance, matching the depth provided for Windows.
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-12 00:00
Reviewed by: LLM Analysis
Issues: 4 bias types
Detected Bias Types
Windows First Powershell Heavy Missing Linux Example 🔧 Windows Tools
Summary
The documentation page exhibits a moderate Windows bias. Windows hosting scenarios and settings are frequently mentioned before Linux equivalents, and PowerShell examples and features are highlighted (such as managed dependencies in PowerShell and specific settings for Windows plans). Linux-specific guidance is less prominent, and in some cases, Linux examples or parity are missing or relegated to later sections. Windows tools and patterns (such as Visual Studio and PowerShell) are referenced more often and earlier than Linux alternatives.
Recommendations
  • Ensure Linux hosting scenarios and settings are described alongside Windows, not after or as exceptions.
  • Provide Linux-specific examples and CLI commands wherever PowerShell or Windows tools are referenced.
  • Highlight Linux deployment and troubleshooting workflows with parity to Windows (e.g., mention Linux Consumption plan status and alternatives up front).
  • Include cross-platform development tools (such as VS Code, CLI, and scripting) in examples, not just Visual Studio or PowerShell.
  • Clarify which features/settings are Windows-only and suggest Linux equivalents or workarounds.
  • Balance the order of presentation so Linux is not always secondary to Windows.
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-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 frequently presents Windows-specific instructions and examples before Linux equivalents, especially in sections about updating stack configurations and using the Azure CLI. Windows tools and patterns (such as .NET SDK, Visual Studio Code, and PowerShell) are referenced prominently. In some cases, Linux instructions are less detailed or deferred, and Python on Windows is explicitly unsupported. There is a consistent pattern of presenting Windows steps first, which may make Linux users feel secondary.
Recommendations
  • Present Windows and Linux instructions in parallel, or alternate which platform is shown first in each section.
  • Ensure that all examples and step-by-step guides are equally detailed for both Windows and Linux.
  • Add more Linux-specific troubleshooting and toolchain guidance, such as common Linux IDEs and package managers.
  • Explicitly acknowledge Linux parity in introductory sections, reassuring users that all platforms are supported.
  • Where a feature is unsupported on a platform (e.g., Python on Windows), provide clear alternatives or migration paths.
  • Include Linux shell (bash/zsh) command examples alongside PowerShell where relevant.
  • Review and update any references to Windows-only tools to include Linux equivalents (e.g., .NET SDK installation on Linux, VS Code extensions for Linux).
GitHub Create Pull Request
Azure Functions How to disable functions in Azure Functions ...blob/main/articles/azure-functions/disable-function.md
High Priority View Details →
Scanned: 2026-01-11 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 presents examples for disabling Azure Functions using the Azure Portal, Azure CLI, and Azure PowerShell. Azure PowerShell, a Windows-centric tool, is given equal prominence to the cross-platform Azure CLI, with full command examples provided. There are no Linux-specific shell examples (e.g., Bash), nor is there mention of Linux-native tools or scripting patterns. Additionally, the only explicit platform limitation mentioned is a Linux restriction regarding hyphens in function names, but no workaround or alternative is provided. The documentation does not address Linux-specific workflows or highlight parity issues, and PowerShell is presented as a primary method despite its limited adoption on Linux.
Recommendations
  • Add explicit Bash or shell script examples alongside Azure CLI commands to demonstrate Linux workflows.
  • Clarify that Azure CLI is cross-platform and recommend it as the primary automation tool for both Windows and Linux users.
  • De-emphasize Azure PowerShell as a primary method, or note its limited adoption on Linux and macOS.
  • Provide guidance or workarounds for Linux-specific limitations (e.g., hyphen restriction in function names), including links to relevant issues or documentation.
  • Include a section or note on platform compatibility for each tool, helping users choose the best method for their OS.
  • Where possible, mention Linux-native configuration management tools or patterns (e.g., environment variables, scripting with Bash) for managing app settings.
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
High Priority View Details →
Scanned: 2026-01-11 00:00
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
Windows First Missing Linux Example 🔧 Windows Tools
Summary
The documentation demonstrates a Windows bias primarily through its reliance on Visual Studio Code and Windows-centric tools and workflows. The Azurite storage emulator is referenced with npm installation, but no explicit Linux-specific instructions or troubleshooting are provided. The tutorial assumes the use of Visual Studio Code and Core Tools, which are available cross-platform, but there is no mention of Linux-specific shell commands, environment setup, or alternative editors. The instructions for starting Azurite and running/debugging the function app use Visual Studio Code commands and keyboard shortcuts that are most familiar to Windows users. There are no explicit Linux or macOS terminal examples, nor any mention of platform-specific differences in configuration or execution.
Recommendations
  • Add explicit instructions for Linux and macOS users, including shell commands for starting Azurite and running/debugging the function app outside of Visual Studio Code.
  • Provide examples of configuring and running Azure Functions using native Linux tools and terminal commands (e.g., bash, zsh) in addition to Visual Studio Code.
  • Include troubleshooting notes for common Linux issues (e.g., file permissions, npm installation, environment variables).
  • Mention alternative editors or workflows for users who do not use Visual Studio Code.
  • Clarify that keyboard shortcuts and command palette instructions may differ on Linux/macOS and provide equivalents.
GitHub Create Pull Request
Azure Functions Azure Functions Core Tools reference ...cles/azure-functions/functions-core-tools-reference.md
High Priority View Details →
Scanned: 2026-01-11 00:00
Reviewed by: LLM Analysis
Issues: 4 bias types
Detected Bias Types
🔧 Windows Tools Powershell Heavy Windows First Missing Linux Example
Summary
The documentation for Azure Functions Core Tools shows evidence of Windows bias. The reference to the main executable as 'func.exe' in the title and description suggests a Windows-centric perspective. There is explicit mention of PowerShell as a supported worker runtime and managed dependencies, but no equivalent mention of Bash or other Linux shells. Some features (such as local encryption of settings and log streaming) are noted as not supported for Linux in certain plans, but Linux alternatives or workarounds are not described. The documentation does not provide Linux-specific examples, nor does it mention cross-platform nuances (e.g., file paths, shell commands) that would help Linux users. Windows tools and patterns (such as .NET Framework 4.8, .pfx certificates, and the Microsoft Azure Storage Emulator) are referenced without Linux equivalents or alternatives, and these references often appear before any mention of Linux support.
Recommendations
  • Update the title and description to reference the cross-platform nature of Core Tools (e.g., 'func' or 'func.exe' as appropriate for OS).
  • Provide Linux-specific examples and notes, such as using Bash, Linux file paths, and Linux-compatible certificate formats.
  • Mention Linux equivalents for Windows-only tools (e.g., recommend Azurite instead of Microsoft Azure Storage Emulator for local storage emulation).
  • Document any limitations or differences for Linux users, and provide workarounds or alternatives where features are not supported.
  • Ensure parity in examples and instructions, giving equal prominence to Linux and macOS usage alongside Windows.
  • Clarify cross-platform support for features like encryption, log streaming, and Docker integration, and note any OS-specific requirements.
GitHub Create Pull Request
Azure Functions Connect a function app to Azure SQL with managed identity and SQL bindings ...ctions-identity-access-azure-sql-with-managed-identity.md
High Priority View Details →
Scanned: 2026-01-11 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 referencing Windows-centric tools and workflows, such as PowerShell and Azure Portal, and by omitting explicit Linux or cross-platform command-line examples. While Azure CLI is mentioned, the instructions and examples prioritize Windows tools (PowerShell, Azure Portal) and do not provide parity for Linux users (e.g., Bash, native Linux tools). SQLCMD is referenced in Cloud Shell, but there is no mention of Linux-specific alternatives or considerations. The documentation does not provide step-by-step instructions for Linux environments, nor does it clarify cross-platform compatibility for all steps.
Recommendations
  • Add explicit Linux/Bash examples alongside PowerShell and Azure Portal instructions.
  • Clarify that Azure CLI and SQLCMD commands work in Bash on Linux, and provide any necessary installation or usage notes for Linux users.
  • Include screenshots or walkthroughs for Linux terminal environments where appropriate.
  • Ensure all steps that reference Windows tools (e.g., PowerShell) are matched with Linux equivalents (e.g., Bash scripts, Linux terminal commands).
  • Review and update language to avoid assuming the user is on Windows (e.g., replace 'Cloud Shell with PowerShell' with 'Cloud Shell (Bash or PowerShell)').
GitHub Create Pull Request
Azure Functions Use Python and TensorFlow for machine learning in Azure ...ure-functions/functions-machine-learning-tensorflow.md
High Priority View Details →
Scanned: 2026-01-11 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 examples for Bash, PowerShell, and Cmd, but Windows-specific tools and patterns (such as 'py' launcher, registry edits, and path conventions) are often mentioned first or exclusively. Troubleshooting advice is Windows-centric (e.g., registry edits for long paths), and some commands use Windows-specific syntax. Linux troubleshooting and environment-specific issues are less emphasized, and Linux equivalents for some Windows-specific advice are missing.
Recommendations
  • Ensure troubleshooting sections include Linux/macOS-specific advice, such as handling long paths, permissions, or package installation errors.
  • When mentioning Windows-specific tools (e.g., 'py' launcher, registry edits), provide Linux/macOS equivalents or clarify which steps are OS-specific.
  • Balance the order of examples so that Bash/Linux instructions are presented first or equally with Windows instructions.
  • Add notes about common Linux/macOS issues (e.g., file permissions, virtual environment activation differences, dependency installation problems).
  • Where possible, use cross-platform commands or clarify OS-specific differences in command syntax and expected behavior.
GitHub Create Pull Request
Azure Functions Develop legacy C# class library functions using Azure Functions ...cles/azure-functions/functions-dotnet-class-library.md
High Priority View Details →
Scanned: 2026-01-11 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 a Windows bias by prioritizing Windows tools and patterns, referencing Windows-specific paths and installers, and providing command-line examples primarily for Windows (cmd, PowerShell) without equivalent Linux/bash examples. Visual Studio, a Windows-centric IDE, is consistently mentioned first, and instructions for ReadyToRun binaries default to Windows targets. There is a lack of explicit Linux/macOS parity in tool usage, environment setup, and example commands.
Recommendations
  • Provide equivalent bash/zsh command-line examples alongside cmd and PowerShell, especially for package installation and Azure Functions Core Tools usage.
  • Explicitly mention and demonstrate Linux/macOS support for Azure Functions development, including file paths, environment variable access, and deployment steps.
  • Include instructions for publishing ReadyToRun binaries targeting Linux (e.g., linux-x64) and macOS (e.g., osx-x64), not just Windows (win-x86).
  • Balance the order of IDE/tool recommendations (e.g., mention Visual Studio Code and CLI before or alongside Visual Studio).
  • Reference cross-platform installation methods (such as Homebrew for macOS, apt for Ubuntu) for Azure Functions Core Tools.
  • Add notes or sections highlighting any platform-specific differences, caveats, or best practices for Linux/macOS users.
GitHub Create Pull Request
← Previous Page 3 of 41 Next →