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 151-175 of 1023 flagged pages
Azure Functions How to run Durable Functions as WebJobs - Azure ...ure-functions/durable/durable-functions-webjobs-sdk.md
High Priority View Details →
Scanned: 2026-01-10 00:00
Reviewed by: LLM Analysis
Issues: 4 bias types
Detected Bias Types
Windows First Missing Linux Example Powershell Heavy 🔧 Windows Tools
Summary
The documentation page demonstrates a clear Windows bias: it prioritizes Visual Studio and Windows project templates, provides only PowerShell/NuGet Package Manager Console commands for package installation, and references Windows-specific tools like the Storage Emulator and Visual Studio dialogs. There are no Linux-specific instructions, examples, or alternatives for common developer workflows (e.g., using CLI, VS Code, or cross-platform storage emulators).
Recommendations
  • Add explicit instructions for Linux/macOS users, including using .NET CLI (dotnet new, dotnet add package) for project creation and package installation.
  • Provide examples using Visual Studio Code and/or JetBrains Rider, which are cross-platform IDEs.
  • Mention cross-platform alternatives to the Azurite storage emulator and provide setup instructions for Linux/macOS.
  • Include screenshots or step-by-step instructions for project creation in VS Code or via CLI, not just Visual Studio dialogs.
  • List package installation commands for both PowerShell (Windows) and Bash (Linux/macOS) environments.
  • Clarify that the WebJobs SDK and Durable Functions can be developed and run on Linux/macOS, and provide guidance for those platforms.
GitHub Create Pull Request
Azure Functions Task hubs in Durable Functions - Azure ...azure-functions/durable/durable-functions-task-hubs.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 🔧 Windows Tools
Summary
The documentation provides code examples for multiple languages, including PowerShell, which is primarily a Windows-centric shell. PowerShell examples are given equal prominence alongside C#, JavaScript, Python, and Java, but there are no Linux shell (e.g., Bash) equivalents. Additionally, the documentation references tools such as Azure Storage Explorer, which is most commonly used on Windows, and does not mention Linux-native alternatives or CLI-based inspection methods. The configuration examples (host.json, local.settings.json) are platform-neutral, but the overall pattern of example selection and tool recommendations leans toward Windows and Windows-first workflows.
Recommendations
  • Add Linux shell (Bash) examples for orchestration triggers and management tasks, especially where PowerShell is shown.
  • Mention and provide examples for Linux-compatible tools (e.g., az CLI, storage CLI, or open-source alternatives) for inspecting Azure Storage and MSSQL contents.
  • Clarify cross-platform compatibility for all code and configuration samples, noting any OS-specific caveats.
  • Where PowerShell is used, explicitly state if the example works on PowerShell Core (cross-platform) or only on Windows PowerShell.
  • Consider reordering examples or tool recommendations so that platform-neutral or Linux-compatible options are presented first or alongside Windows options.
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
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 Missing Linux Example
Summary
The documentation shows some Windows bias, particularly in the Python quickstart where Windows virtual environment activation commands are presented before Linux equivalents, and in the presence of a PowerShell-specific pivot. There is also a 'powershell' pivot group, but no equivalent for bash or Linux shells. While most commands are cross-platform (using Docker and bash), and Linux activation commands are present, the ordering and structure tend to prioritize Windows or PowerShell scenarios. There are no Linux- or bash-specific pivots or examples for C# or Java, and the PowerShell pivot is present without a corresponding bash or Linux shell pivot.
Recommendations
  • For all language pivots, ensure that both Windows (PowerShell/CMD) and Linux/macOS (bash) command examples are provided and given equal prominence, ideally side-by-side or in tabs.
  • Add a bash or Linux/macOS shell pivot wherever there is a PowerShell pivot, especially for setup and command-line instructions.
  • In the Python section, present Linux/macOS and Windows virtual environment activation commands in parallel (using tabs or clear side-by-side formatting), rather than listing Windows first.
  • For C# and Java, consider including explicit Linux/macOS shell instructions (e.g., for running dotnet or gradlew commands), especially for steps that may differ (such as file paths or permission commands).
  • Review the ordering of instructions to avoid always listing Windows commands or tools first; alternate or present both equally.
  • If possible, provide screenshots or output examples from both Windows and Linux environments to reinforce parity.
GitHub Create Pull Request
Azure Functions Quickstart: Create a Java Durable Functions app ...in/articles/azure-functions/durable/quickstart-java.md
High Priority View Details →
Scanned: 2026-01-10 00:00
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
Windows First 🔧 Windows Tools Powershell Heavy
Summary
The documentation demonstrates Windows bias in several ways: Windows is set as the default OS in the Maven plugin configuration, PowerShell and Cmd examples are provided alongside Bash, and Visual Studio Code (a cross-platform tool but often associated with Windows) is emphasized. The Maven plugin configuration explicitly sets <os>windows</os> as the runtime, and there is no mention of Linux or macOS alternatives or considerations for deployment/runtime. Linux-specific instructions, troubleshooting, or parity checks are missing.
Recommendations
  • Add explicit instructions and examples for Linux and macOS users, including shell commands and environment setup.
  • In the Maven plugin configuration, document how to set <os>linux</os> or <os>macos</os> for cross-platform deployment, and clarify when Windows is required.
  • Ensure that Bash examples are presented first, and provide parity for Linux/macOS where PowerShell or Cmd is shown.
  • Include troubleshooting notes or caveats for Linux/macOS users, especially around Azure Functions Core Tools and local development.
  • Clarify that Visual Studio Code is cross-platform and provide links or notes for Linux/macOS installation and usage.
GitHub Create Pull Request
Azure Functions Quickstart: Configure a storage provider by using Netherite ...ticles/azure-functions/durable/quickstart-netherite.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. Windows-specific tools and patterns (such as references to the legacy Azure Storage Emulator and platform-specific configuration steps) are mentioned, sometimes before their Linux equivalents. There is a lack of explicit Linux examples or parity in some instructions, and Windows-centric notes are present. The use of PowerShell is referenced in prerequisites, and Windows-only configuration steps are called out, while Linux instructions are often omitted or assumed.
Recommendations
  • Provide explicit Linux instructions and examples alongside Windows ones, especially for platform-specific steps (e.g., configuration, deployment).
  • Mention Linux tools (such as Azurite) first or equally when discussing local storage emulation, and clarify their usage on both platforms.
  • Include screenshots and walkthroughs for Linux environments (e.g., Azure portal settings, local development) where only Windows examples are shown.
  • Avoid assuming the reader is on Windows; clarify steps that differ for Linux and provide guidance for both.
  • Where PowerShell or Windows CLI is referenced, offer equivalent Bash or Linux shell commands.
  • Add troubleshooting notes for common Linux issues (e.g., permissions, architecture validation) to match Windows coverage.
GitHub Create Pull Request
Azure Functions Quickstart: Create a Python Durable Functions app ...es/azure-functions/durable/quickstart-python-vscode.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 shows a mild Windows bias. While it does provide activation instructions for Linux, macOS, and Windows virtual environments, the Windows (PowerShell) command is listed last, which is a positive. However, throughout the guide, there is a strong emphasis on Visual Studio Code and its integrated tools, which are more commonly associated with Windows workflows. The use of Azurite (with VS Code integration) and the lack of explicit CLI or terminal-based alternatives for Linux users further reinforce a Windows/VS Code-centric approach. There are no explicit Linux command-line examples outside of the virtual environment activation, and the documentation assumes the use of GUI tools and extensions rather than cross-platform CLI workflows.
Recommendations
  • Provide explicit Linux and macOS command-line alternatives for all steps, especially for tasks like starting Azurite, running/debugging the function app, and publishing to Azure.
  • Include examples using the Azure Functions Core Tools CLI directly, not just through Visual Studio Code, to support users who prefer terminal workflows.
  • Mention and demonstrate HTTP test tools available on Linux (such as curl or httpie) rather than generic references to 'HTTP test tool'.
  • Clarify that all steps can be performed on Linux and macOS, not just Windows, and ensure parity in screenshots and instructions.
  • Consider providing a section or callout for users who do not use Visual Studio Code, outlining equivalent steps using only the command line.
GitHub Create Pull Request
Azure Functions Quickstart: Create a Durable Functions app that uses the MSSQL storage provider ...n/articles/azure-functions/durable/quickstart-mssql.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 exhibits several signs of Windows bias. The local SQL Server setup instructions are provided exclusively as PowerShell scripts, which are most familiar to Windows users and may be less accessible to Linux users. The use of SQL Server Express is specifically mentioned for 'your local Windows computer', while Linux alternatives are not described. There are no bash or shell script equivalents for the Docker setup, nor are there explicit instructions for Linux package installation or troubleshooting. The troubleshooting section references Docker Desktop, which is primarily a Windows/macOS tool. Overall, Linux users are expected to adapt Windows-centric instructions, and Linux-specific patterns or tools are missing.
Recommendations
  • Provide bash/sh script equivalents for all PowerShell commands, especially for Docker-based SQL Server setup and validation.
  • Explicitly mention and provide instructions for installing and running SQL Server Express or SQL Server on Linux distributions.
  • Include troubleshooting steps relevant to Linux environments, such as using docker CLI directly or managing containers without Docker Desktop.
  • Clarify that Visual Studio Code and Azure Functions Core Tools are cross-platform, and provide installation instructions for Linux.
  • When referencing tools (e.g., SQLCMD), include installation instructions for Linux and macOS.
  • Add notes or examples for common Linux patterns, such as using environment variables, file paths, and permissions.
  • Ensure that all code snippets and commands are available in both PowerShell and bash formats, and indicate which OS each example targets.
GitHub Create Pull Request
Azure Functions Build a serverless workflow using Durable Functions - Azure Functions ...unctions/durable/scenario-build-serverless-workflow.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 command-line instructions for multiple platforms, but Windows-specific tools and patterns (Cmd, PowerShell) are often presented alongside or before Linux equivalents. In several places, Windows command examples are given with dedicated tabs (Cmd, PowerShell), and Windows-specific instructions (such as .venv activation) are detailed. The use of 'command prompt' language and explicit Windows tabs, as well as the inclusion of PowerShell and Cmd examples for Azure CLI and Functions Core Tools, indicate a Windows-first and PowerShell-heavy bias. Linux/macOS instructions are present but sometimes less detailed or appear after Windows options.
Recommendations
  • Ensure Linux/macOS instructions are always presented first or equally alongside Windows instructions.
  • Provide bash/zsh examples as the primary shell instructions, with Windows alternatives clearly marked as secondary.
  • Avoid using 'command prompt' as a generic term; use 'terminal' or specify platform.
  • Where possible, consolidate instructions to use cross-platform commands (e.g., bash) and only provide platform-specific alternatives when necessary.
  • Review all examples to ensure Linux users have clear, complete, and tested instructions for every step.
  • Consider adding WSL (Windows Subsystem for Linux) guidance for Windows users who prefer a Linux-like environment.
GitHub Create Pull Request
Azure Functions Create and Manage Function Apps in a Flex Consumption Plan ...in/articles/azure-functions/flex-consumption-how-to.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 moderate Windows bias. Windows-centric tools and patterns (such as Visual Studio Code, Azure CLI, and PowerShell) are emphasized throughout, with instructions and examples tailored to these environments. Visual Studio Code is presented as a primary development environment, which, while cross-platform, is often associated with Windows workflows. Powershell is included as a supported runtime, and references to folder structures and deployment steps for Powershell projects are present. There is no explicit mention of Linux-specific shell commands (e.g., bash, zsh), nor are there examples using Linux-native tools (such as curl, wget, or direct bash scripting). The documentation does not provide guidance for Linux package managers or shell environments, nor does it address potential differences in file system paths, permissions, or environment setup for Linux users. The absence of Linux-specific examples and troubleshooting steps may make it less accessible for developers working primarily on Linux systems.
Recommendations
  • Add explicit Linux shell (bash/zsh) examples alongside Azure CLI commands, showing usage in Linux environments.
  • Include guidance for installing prerequisites (such as Azure CLI) on Linux distributions, referencing package managers like apt, yum, or zypper.
  • Provide troubleshooting tips for common Linux-specific issues (e.g., file permissions, case sensitivity, environment variables).
  • Mention and demonstrate alternative editors (such as Vim, Emacs, or JetBrains IDEs) for Linux users, or clarify that Visual Studio Code is cross-platform.
  • Clarify any differences in deployment or runtime behavior between Windows and Linux (e.g., remote build requirements for Python projects built on Windows vs. Linux).
  • Ensure that all PowerShell-specific instructions are paired with bash equivalents where possible.
  • Explicitly state platform compatibility for all tools and commands, and avoid assuming a Windows-first workflow.
GitHub Create Pull Request
Azure Functions App settings reference for Azure Functions ...ain/articles/azure-functions/functions-app-settings.md
High Priority View Details →
Scanned: 2026-01-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 demonstrates some Windows bias in several areas. Windows-specific settings and examples (such as WEBSITE_NODE_DEFAULT_VERSION, AzureWebJobs_TypeScriptPath, and PowerShell configuration) are presented without equivalent Linux examples or with Windows as the default. Windows tools (Azure PowerShell) are mentioned as a preferred method for managing settings, and PowerShell-specific settings are documented in detail. In some cases, Linux alternatives are missing or only briefly referenced, and examples often use Windows-style paths or conventions before Linux equivalents.
Recommendations
  • Ensure all OS-specific settings (e.g., WEBSITE_NODE_DEFAULT_VERSION, AzureWebJobs_TypeScriptPath) have clear Linux equivalents or explicitly state their OS applicability.
  • Provide Linux-first or parallel examples for settings, especially where Windows paths or conventions are shown (e.g., show both %HOME% and $HOME for paths).
  • When mentioning tools for managing app settings, list Azure CLI before or alongside Azure PowerShell, and provide bash examples where applicable.
  • Expand documentation for Linux-specific behaviors, such as file system storage, environment variable delimiters, and runtime differences.
  • Review PowerShell-heavy sections and ensure parity for other language stacks and platforms, including bash or shell scripting for Linux.
  • Audit all examples and notes to ensure Linux users are not required to infer their usage from Windows-centric instructions.
GitHub Create Pull Request
Azure Functions Azure OpenAI embeddings input binding for Azure Functions ...unctions/functions-bindings-openai-embeddings-input.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 provides dedicated examples and configuration details for PowerShell, which is primarily a Windows-centric tool. PowerShell is the only shell scripting language featured, with no equivalent Bash or Linux shell examples. The configuration and example sections for PowerShell are more detailed compared to other languages, and there is no mention of Linux-specific tools or patterns. This demonstrates a bias toward Windows environments and tooling.
Recommendations
  • Add equivalent Bash or Linux shell scripting examples alongside PowerShell, especially for function configuration and invocation.
  • Explicitly mention cross-platform compatibility for all examples, clarifying how Linux users can achieve the same results.
  • Include references to Linux tools (e.g., bash, sh, zsh) and provide sample scripts for these environments.
  • Ensure that documentation for configuration files (such as function.json) includes notes or examples for both Windows and Linux file system conventions.
  • Review the order of presentation to avoid prioritizing Windows/PowerShell examples over Linux alternatives.
GitHub Create Pull Request
Azure Functions Azure Functions Web PubSub input binding ...azure-functions/functions-bindings-web-pubsub-input.md
High Priority View Details →
Scanned: 2026-01-10 00:00
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
Missing Linux Example Powershell Heavy Windows First
Summary
The documentation provides code samples for C#, JavaScript, and Python, but omits complete samples for PowerShell and Java, stating they are pending or unsupported. There is no explicit Windows bias in terms of tools or patterns, but the lack of PowerShell samples (which are typically Windows-centric) and the absence of Linux-specific instructions or parity for shell scripting or deployment can be considered a subtle bias. The documentation does not mention Linux tools or provide bash examples, and PowerShell is referenced but not supported, which may leave Linux users underserved.
Recommendations
  • Add complete PowerShell samples and clarify cross-platform compatibility, including how to run PowerShell on Linux.
  • Provide bash or shell script examples for configuration and deployment steps, especially for scenarios where PowerShell is referenced.
  • Explicitly mention Linux support and provide instructions or examples for Linux environments where relevant.
  • Ensure parity in language support and examples, so that Linux users (who may prefer Python, bash, or Java) are not left out.
  • If certain features are Windows-only, clearly state this and offer Linux alternatives or workarounds.
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-10 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 page for Azure Functions Core Tools exhibits several signs of Windows bias. The reference to the tool as 'func.exe' in the description and the repeated mention of PowerShell as a supported worker runtime suggest a Windows-centric perspective. There is a lack of explicit Linux or macOS examples, and Windows-specific tools such as the Microsoft Azure Storage Emulator are referenced without Linux alternatives. Instructions and notes often assume Windows environments (e.g., trusted certificate creation, .pfx files) and do not provide parity guidance for Linux users. Furthermore, the order of runtime and tooling references tends to prioritize Windows technologies over Linux equivalents.
Recommendations
  • Add explicit Linux/macOS examples for commands, including shell syntax and environment-specific notes.
  • Reference the tool as 'func' or 'Azure Functions Core Tools' rather than 'func.exe' to avoid Windows-centric naming.
  • When mentioning PowerShell, also highlight Bash or other Linux-native scripting options where relevant.
  • Include information about Linux-compatible storage emulators (such as Azurite) wherever the Microsoft Azure Storage Emulator is mentioned.
  • Clarify certificate handling and trusted certificate creation steps for Linux/macOS users, including alternative workflows.
  • Ensure that runtime and tooling lists do not prioritize Windows technologies; present cross-platform options equally.
  • Add troubleshooting or setup notes for common Linux/macOS issues (e.g., file permissions, Docker installation, .NET SDK installation).
GitHub Create Pull Request
Azure Functions Create your function app resources in Azure using Bicep ...ure-functions/functions-create-first-function-bicep.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 provides deployment and validation instructions using both Azure CLI and Azure PowerShell, but it gives equal prominence to PowerShell, a Windows-centric tool, and includes PowerShell examples for all language pivots. There is no mention of Linux-specific shell usage (e.g., Bash), nor are there any Linux-specific notes or examples. The use of PowerShell is presented as a primary option alongside Azure CLI, which is cross-platform, but the lack of explicit Linux shell examples or notes may create a subtle Windows bias.
Recommendations
  • Add explicit Bash shell examples for Azure CLI commands to demonstrate Linux usage and shell syntax.
  • Clarify that Azure CLI commands work on all platforms (Windows, Linux, macOS) and can be run in Bash, PowerShell, or CMD.
  • Include notes or sections for Linux/macOS users, such as file path differences (e.g., './main.bicep' vs '.\main.bicep') and environment setup.
  • Consider reducing the prominence of PowerShell unless there are Windows-specific steps, or balance with equivalent Linux shell instructions.
  • Add troubleshooting or environment setup guidance for Linux users (e.g., installing Azure CLI on Ubuntu, using VS Code on Linux).
GitHub Create Pull Request
Azure Functions Develop and run Azure Functions locally ...in/articles/azure-functions/functions-develop-local.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 page demonstrates a moderate Windows bias. Windows-centric tools such as Visual Studio and PowerShell are mentioned prominently and often before their Linux/macOS equivalents. Visual Studio (Windows-only) is listed first in environment tables for C#, and PowerShell examples and references are included in multiple places. While the page does mention cross-platform support and includes Visual Studio Code and command-line options, Windows tools and patterns (Visual Studio, PowerShell, Edge Network Console) are often listed before Linux alternatives, and Linux-specific examples or workflows are not highlighted or given parity.
Recommendations
  • Ensure that Linux/macOS tools and workflows are presented with equal prominence and ordering as Windows tools, especially in environment tables and lists.
  • Add explicit Linux/macOS examples or screenshots where appropriate (e.g., using bash/zsh, Linux package managers for Core Tools, Linux-specific troubleshooting).
  • For HTTP test tools, mention Linux-native tools (e.g., httpie, wget) alongside curl, and clarify cross-platform usage.
  • Where PowerShell is referenced, also provide bash/zsh equivalents for common operations (e.g., using curl or other CLI tools).
  • In sections about Visual Studio, clarify that it is Windows-only and suggest Linux/macOS alternatives (e.g., JetBrains Rider, VS Code).
  • Consider adding a parity checklist to ensure that all guidance is equally actionable on Linux/macOS systems.
GitHub Create Pull Request
Azure Functions Tutorial: Trigger Azure Functions on blob containers using an event subscription ...s/azure-functions/functions-event-grid-blob-trigger.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 Missing Linux Example
Summary
The tutorial demonstrates a bias toward Windows environments by exclusively using Visual Studio Code and its extensions for all development, deployment, and Azure resource management steps. All instructions rely on VS Code command palette actions and extensions (Azure Functions, Azure Storage, Azurite), which are most commonly used on Windows and may not be available or work identically on Linux. There are no CLI (az, bash, PowerShell) or Linux-native alternatives provided for key tasks such as creating storage accounts, blob containers, uploading files, or deploying functions. The documentation does not mention or show examples using Linux shell commands, nor does it acknowledge differences or provide parity for Linux users.
Recommendations
  • Provide equivalent instructions using Azure CLI (az) for all resource creation, deployment, and management steps, including creating storage accounts, blob containers, uploading files, and deploying function apps.
  • Include examples using bash shell commands for file uploads and local testing, especially for Linux users.
  • Mention and document how to use Azurite outside of Visual Studio Code, e.g., via npm or Docker, with command-line usage examples.
  • Add a section or callouts for Linux/macOS users, highlighting any differences in workflow or tool installation.
  • Where possible, avoid requiring Visual Studio Code extensions for critical steps, or provide alternatives using platform-agnostic tools.
GitHub Create Pull Request
Azure Functions Create your function app resources using Azure Resource Manager templates ...ns/functions-create-first-function-resource-manager.md
High Priority View Details →
Scanned: 2026-01-10 00:00
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
🔧 Windows Tools Powershell Heavy Windows First
Summary
The documentation provides deployment instructions using Azure CLI and Azure PowerShell, with PowerShell examples given for all supported languages. PowerShell is a Windows-centric tool, and its inclusion as a primary tab (alongside CLI) reflects a Windows bias. There are no explicit Bash or Linux shell examples, and no mention of Linux-specific tools or workflows. The documentation assumes users are comfortable with PowerShell, which is less common on Linux platforms. Additionally, the Azure Cloud Shell is referenced, but its default shell (Bash or PowerShell) is not clarified, and PowerShell is presented as a first-class option.
Recommendations
  • Add Bash shell examples for all supported languages, using Azure CLI commands in a Linux-native style.
  • Clarify that Azure Cloud Shell supports both Bash and PowerShell, and provide guidance for Linux users.
  • Explicitly mention cross-platform compatibility for all commands and tools.
  • Consider reordering tabs or examples so that Bash/Azure CLI is presented before PowerShell, to avoid Windows-first impression.
  • Highlight any differences or considerations for Linux users (e.g., environment variables, file paths, shell syntax).
GitHub Create Pull Request
Azure Functions Azure Functions custom handlers .../articles/azure-functions/functions-custom-handlers.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 exhibits Windows bias primarily through the use of Windows-centric executable naming conventions (e.g., 'handler.exe') in configuration and examples, and by referencing Windows-style deployment patterns before Linux equivalents. While the text mentions that the executable can be 'handler' on Linux or macOS, all configuration and code samples default to 'handler.exe', and there are no explicit Linux/macOS deployment or configuration examples. Additionally, there is no mention of Linux-specific tools or patterns, and Windows conventions are presented first and most prominently.
Recommendations
  • Provide parallel examples using Linux/macOS conventions (e.g., 'handler' instead of 'handler.exe') in configuration files and folder structures.
  • Explicitly show how to build and deploy custom handler executables on Linux/macOS, including sample commands and file naming.
  • Include notes or sections on platform-specific considerations, such as file permissions and executable formats for Linux/macOS.
  • Reference Linux/macOS tools (such as bash scripts or shell commands) alongside Windows tools where relevant.
  • Ensure that instructions and examples do not default to Windows conventions, but instead present cross-platform options equally or in platform-specific subsections.
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-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 Windows bias in several ways: Windows tools and patterns (Visual Studio, MSI installer, Windows paths) are mentioned first or exclusively, PowerShell and Windows command prompt examples are provided, and Linux-specific instructions or examples are missing or relegated to secondary status. The ReadyToRun example only shows Windows as the target platform, and references to local development and environment variables use Windows-centric paths and terminology. There is little to no mention of Linux equivalents, such as bash, Linux file paths, or Linux-specific deployment instructions.
Recommendations
  • Add Linux-specific examples and instructions alongside Windows ones, especially for local development, environment variables, and deployment.
  • Include bash and Linux CLI examples for package installation and project setup, not just Windows command prompt and PowerShell.
  • Show ReadyToRun configuration for Linux (e.g., linux-x64) in addition to Windows (win-x86).
  • Reference Linux file paths and environment variable conventions where appropriate.
  • Ensure parity in tool recommendations, such as highlighting VS Code and CLI usage for both Windows and Linux, not just Visual Studio.
  • Explicitly mention cross-platform compatibility of Azure Functions Core Tools and provide installation instructions for Linux (apt, yum, etc.).
GitHub Create Pull Request
Azure Functions Continuously update function app code using Azure Pipelines ...icles/azure-functions/functions-how-to-azure-devops.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. Windows-based examples (e.g., 'windows-latest' agent pools) are presented first for .NET and PowerShell, and the default appType is Windows. PowerShell is included as a first-class language, with only Windows agent pool examples. Windows deployment patterns and terminology (slots, agent pools) are emphasized, and Linux support is often mentioned as an exception or secondary consideration. Some Linux-specific notes are present, but parity is not fully achieved.
Recommendations
  • Present Linux and Windows examples side-by-side, or alternate which is shown first for each language.
  • For PowerShell, clarify whether Linux hosting is possible, and provide Linux agent pool examples if supported.
  • Explicitly state platform requirements and limitations for each language and deployment scenario.
  • Avoid language that implies Windows is the default or preferred platform; treat both platforms equally in instructions and examples.
  • Add more Linux-focused troubleshooting and best practices sections.
  • Where agent pool is specified, explain the rationale for choosing 'windows-latest' or 'ubuntu-latest', and offer guidance for cross-platform compatibility.
GitHub Create Pull Request
Azure Functions Configure function app settings in Azure Functions ...ns/functions-how-to-use-azure-function-app-settings.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 Windows-centric biases. Windows and PowerShell tools are consistently presented alongside or before Linux alternatives, and in some cases, Linux support is explicitly limited or omitted. Examples and instructions for key operations (such as plan migration, FTPS deployment, and platform features) are either Windows-only or prioritize Windows, with Linux support described as unavailable, limited, or planned for retirement. There is a heavy reliance on PowerShell examples, and Windows-specific tools (Kudu, App Service editor, in-portal console) are featured, while Linux equivalents are missing or marked unsupported.
Recommendations
  • Provide explicit Linux examples and instructions wherever Windows or PowerShell examples are given, especially for CLI and deployment operations.
  • Clarify Linux support status for all features and tools, and offer alternative workflows for Linux users when Windows-only tools are mentioned.
  • Include bash or shell script examples for Linux users alongside PowerShell commands.
  • Document Linux-specific limitations and workarounds in a dedicated section to help users plan accordingly.
  • Ensure parity in screenshots and UI walkthroughs for both Windows and Linux environments.
  • Update the documentation to reflect any upcoming changes to Linux support (such as retirement of Linux Consumption plan) and guide users on migration paths.
GitHub Create Pull Request
Azure Functions host.json reference for Azure Functions 2.x ...b/main/articles/azure-functions/functions-host-json.md
High Priority View Details →
Scanned: 2026-01-10 00:00
Reviewed by: LLM Analysis
Issues: 3 bias types
Detected Bias Types
Powershell Heavy 🔧 Windows Tools Windows First
Summary
The documentation page shows evidence of Windows bias in several areas. The 'managedDependency' feature is explicitly stated as only supported for PowerShell-based functions, which are primarily associated with Windows environments. Several configuration examples and explanations reference Windows-specific tools, conventions, or environment variables (e.g., %TEMP%, LOCALAPPDATA, APPDATA), and these are mentioned before or instead of Linux equivalents. The documentation also references debugging and logging behaviors that are more common in Windows (e.g., file logging, Application Insights integration, Kudu performance counters) without equivalent Linux-specific guidance. Linux-specific notes (such as 'DisableColors' for console logging) are present but minimal and secondary.
Recommendations
  • Provide parity for managed dependencies in Linux environments and non-PowerShell languages, or clarify alternatives for Linux users.
  • When referencing environment variables or folders (e.g., %TEMP%, LOCALAPPDATA, APPDATA), also mention Linux equivalents (e.g., $TMPDIR, $HOME/.local/share, /tmp) and how the runtime resolves these on Linux.
  • Include Linux-specific examples and troubleshooting steps for logging, debugging, and file paths, especially for features like Application Insights, file logging, and snapshot debugging.
  • Ensure that documentation for features like Kudu performance counters and file logging explains their behavior and availability on Linux, or provides alternatives.
  • Where features are Windows-only, clearly label them as such and provide guidance for Linux users.
  • Add more explicit Linux examples in sample configuration files and usage scenarios.
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
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 presents both Windows and Linux options for Azure Functions deployment with GitHub Actions, but Windows is frequently listed first in examples, tabs, and instructions. Windows-specific tools and terminology (e.g., PowerShell, 'windows-latest', Windows templates) are prominent, and PowerShell is only supported on Windows and Linux, with Windows examples shown first. There is a slight tendency to prioritize Windows in structure and ordering, which may subtly reinforce Windows as the default or preferred environment.
Recommendations
  • Alternate the order of Windows and Linux examples/tabs, or present Linux first in some sections to balance perception.
  • Explicitly state parity between Windows and Linux options where applicable, and highlight any differences or limitations for each platform.
  • Ensure that Linux-specific tools, patterns, and workflows are mentioned with equal prominence and detail as Windows equivalents.
  • Where PowerShell is referenced, clarify its cross-platform availability and provide Bash or shell alternatives for Linux users where relevant.
  • Add a summary table or section comparing Windows and Linux deployment workflows, highlighting similarities and differences to help users choose.
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-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-specific tools and patterns (such as 'py' launcher, registry edits, and Windows path conventions) are mentioned prominently. PowerShell and Cmd examples are provided alongside Bash, but Windows-specific troubleshooting (e.g., registry edits for long paths) is described in detail, while equivalent Linux/macOS issues are not. In some cases, Windows commands are listed before Linux equivalents, and certain error scenarios are only addressed for Windows. The use of Visual Studio Code is suggested without mention of Linux-specific editors. There is also a lack of parity in troubleshooting steps and environment setup for Linux/macOS users.
Recommendations
  • Ensure troubleshooting steps are provided for Linux/macOS users, not just Windows (e.g., long path issues, permissions).
  • When listing command examples, alternate the order or explicitly state parity between platforms.
  • Include Linux/macOS-specific environment setup and troubleshooting guidance, such as common issues with Python virtual environments, permissions, or package installation.
  • Mention Linux/macOS-friendly editors (e.g., Vim, Emacs, Sublime Text) alongside Visual Studio Code.
  • Provide more detailed Bash examples and explanations where PowerShell/Cmd examples are given.
  • Review all references to Windows tools (e.g., 'py' launcher, registry edits) and ensure Linux/macOS equivalents are described or linked.
GitHub Create Pull Request
Azure Functions Monitor executions in Azure Functions .../main/articles/azure-functions/functions-monitoring.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 exhibits mild Windows bias. It references features and streaming log methods that are either unsupported or limited on Linux (e.g., built-in log streaming not available for Linux Consumption plan), and mentions Performance Counters as unsupported on Linux. There are no Linux-specific examples, troubleshooting steps, or alternative tools provided, and Windows/portal-centric workflows are described first or exclusively. PowerShell is mentioned as a supported language, but not emphasized over others.
Recommendations
  • Add explicit Linux examples and troubleshooting steps for monitoring and log streaming, especially for scenarios where features differ (e.g., log streaming on Linux Consumption plan).
  • Provide parity by listing Linux-compatible tools and workflows (such as Azure CLI, SSH, or container logs) alongside or before Windows/portal-centric methods.
  • Clarify limitations for Linux environments in relevant sections, and suggest alternative approaches where features are unavailable (e.g., alternatives to Performance Counters on Linux).
  • Include a table or section comparing Windows and Linux feature support for monitoring and logging, to help users choose the best approach for their platform.
GitHub Create Pull Request
← Previous Page 7 of 41 Next →