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 826-850 of 1023 flagged pages
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-identity-based-connections-tutorial.md
...tions/functions-identity-based-connections-tutorial.md
Medium Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Summary
The documentation is primarily focused on Windows-based Azure Functions, as explicitly stated in the introduction. It only provides examples and instructions for C# class library functions on Windows, with no equivalent Linux or cross-platform guidance. There are also references to Azure Files as the default file system for Windows deployments, but no mention of Linux file system options or differences in deployment patterns. The tutorial does not provide Linux-specific steps or highlight any differences for Linux-based function apps.
Recommendations
- Explicitly state in the introduction whether the steps are applicable to Linux-based function apps, and if not, provide a parallel Linux tutorial or note the differences.
- Include Linux-specific instructions and examples, especially for ARM template configuration, environment variable settings, and deployment considerations.
- Discuss storage options and behaviors for Linux function apps, such as how Azure Files is not the default for Linux Consumption plans, and provide guidance for secret management in those scenarios.
- Where platform-specific behaviors exist (e.g., the use of AzureWebJobsStorage__accountName in Linux Consumption), provide clear, step-by-step Linux examples.
- Ensure parity in prerequisites and tooling, mentioning any Linux-compatible tools or SDKs required for the tutorial.
Create Pull Request
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-develop-local.md
...in/articles/azure-functions/functions-develop-local.md
Medium Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Summary
The documentation generally aims for cross-platform parity, but there is a subtle Windows bias. Visual Studio (Windows-only) is consistently listed first in C# sections, and Windows tools like PowerShell and Microsoft Edge Network Console are highlighted among HTTP test tools. Linux-specific tools or workflows are not given equal prominence or called out explicitly, and there are no Linux-first examples or mentions of Linux-specific editors or shells.
Recommendations
- Alternate the order of environment/tool listings so that Windows-only tools (e.g., Visual Studio) are not always listed first. For example, sometimes list Visual Studio Code or command-line options before Visual Studio.
- Explicitly mention and provide examples for Linux/macOS shells (e.g., bash, zsh) where 'command prompt or terminal' is referenced, and clarify that these instructions apply equally to Linux/macOS.
- In the HTTP test tools section, include Linux-native tools (e.g., httpie, wget) alongside curl, and avoid listing PowerShell or Microsoft Edge before cross-platform or Linux-native tools.
- Where possible, add screenshots or example commands from Linux terminals in addition to Windows/PowerShell.
- Call out any platform-specific differences or considerations, especially for file paths, environment variables, or tool installation steps.
- Consider a dedicated section or callout for Linux/macOS users, especially in areas where the workflow or tooling may differ.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-event-hub-cosmos-db.md
...icles/azure-functions/functions-event-hub-cosmos-db.md
Medium Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Summary
The documentation provides both Bash (Linux/macOS) and Cmd (Windows) examples for all command-line steps, ensuring cross-platform coverage. However, in every case, the Windows (Cmd) examples are presented after the Bash examples, which may subtly prioritize Linux. There is no exclusive use of Windows tools (such as PowerShell), but the documentation does use Windows-specific command syntax (Cmd) alongside Bash. There are no missing Linux examples, and all tools used (Azure CLI, Maven, Azure Functions Core Tools) are cross-platform. There is no mention of PowerShell, only Cmd. The documentation is slightly 'powershell_heavy' in the sense that it uses Windows command prompt syntax, but not actual PowerShell. The bias is minimal and mostly in the order of presentation ('windows_first' bias would be present if Windows examples came first, but here Bash comes first).
Recommendations
- Consider presenting both Bash and Cmd examples side-by-side or in a tabbed interface (as is already done), but clarify that both are equally supported.
- Explicitly mention that all tools and commands are cross-platform and supported on Windows, Linux, and macOS.
- Optionally, include PowerShell examples for Windows users who prefer PowerShell over Cmd.
- Ensure that any troubleshooting or environment setup steps (such as setting environment variables) include notes for both Bash and Windows (Cmd/PowerShell) users.
- Continue to avoid referencing Windows-only tools or patterns unless a Linux/macOS equivalent is also provided.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-how-to-use-nat-gateway.md
...es/azure-functions/functions-how-to-use-nat-gateway.md
Medium Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Summary
The documentation demonstrates a Windows bias by explicitly recommending Windows as the operating system for the function app and not providing equivalent guidance or examples for Linux. There are no Linux-specific instructions, notes, or parity checks, and the only runtime stack mentioned is .NET, which is often associated with Windows. No PowerShell or Windows command-line tools are shown, but the OS recommendation is clear and exclusive.
Recommendations
- Provide parallel instructions for creating the function app using Linux as the operating system, including any differences in configuration or limitations.
- Add a note clarifying whether the steps and features (such as VNet Integration and NAT Gateway) are fully supported on Linux-based function apps, and link to relevant documentation.
- If there are differences in the portal UI or required settings for Linux, include screenshots and step-by-step guidance for Linux users.
- Mention other supported runtime stacks (e.g., Node.js, Python) and clarify if the tutorial is applicable to them, especially on Linux.
- Avoid recommending Windows as the default unless there is a technical reason; if so, explain the reason and provide guidance for Linux users.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-scale.md
.../blob/main/articles/azure-functions/functions-scale.md
Medium Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Summary
The documentation generally maintains parity between Linux and Windows, but there is a subtle Windows bias in the ordering and references. Windows is often listed first in tables and explanations, and some links (such as App Service plan pricing) default to Windows. There are no explicit Linux command-line or deployment examples, but also no Windows/Powershell examples, so the bias is mostly in ordering and framing rather than in example content.
Recommendations
- Alternate the order in which Windows and Linux are presented in tables and explanations, or use alphabetical order to avoid implicit prioritization.
- Where pricing or documentation links are provided, ensure both Linux and Windows options are equally visible and accessible.
- Add explicit Linux-focused examples or notes where relevant, especially in sections discussing deployment, scaling, or troubleshooting.
- Clarify when features are Linux-only or Windows-only, and provide guidance for users of both platforms.
- Review terminology to ensure that neither platform is implied as the default or primary option.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-infrastructure-as-code.md
...es/azure-functions/functions-infrastructure-as-code.md
Medium Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Summary
The documentation generally provides parity between Windows and Linux, with explicit sections and code samples for both platforms throughout. However, there is a recurring pattern of presenting Windows examples and terminology before Linux equivalents (windows_first). Additionally, PowerShell is highlighted as a primary deployment method, with detailed PowerShell scripts and references, while Linux-native shell (bash) or cross-platform CLI examples are less emphasized (powershell_heavy). There are no significant omissions of Linux examples, but the ordering and tool emphasis may subtly prioritize Windows users.
Recommendations
- Alternate the order of Windows and Linux examples, or present Linux examples first in some sections to balance visibility.
- Where PowerShell is shown, also provide equivalent bash/Azure CLI scripts for Linux/macOS users, especially in deployment and validation sections.
- In lists of deployment options, avoid always listing PowerShell before CLI or portal; consider grouping by cross-platform tools first.
- Explicitly state that all examples are cross-platform unless otherwise noted, and highlight any platform-specific differences up front.
- Ensure that all referenced sample repositories and templates include both Windows and Linux variants, and link to both equally.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/monitor-functions-reference.md
...rticles/azure-functions/monitor-functions-reference.md
Medium Priority
View Details →
Detected Bias Types
Missing Linux Example
Windows First
Summary
The documentation page exhibits a bias toward Windows by explicitly noting that certain metrics are not supported or available for Linux plans, without providing Linux alternatives or guidance. Additionally, the documentation often describes features and metrics in the context of Windows or general App Service plans, with Linux-specific limitations mentioned as exceptions rather than being treated equally or first.
Recommendations
- Provide equivalent Linux examples or guidance where metrics or features are not supported, including workarounds or alternative monitoring strategies for Linux-based Azure Functions.
- Clearly indicate feature parity (or lack thereof) in a dedicated section, and link to up-to-date tracking or roadmap items for Linux support.
- Where features are unavailable on Linux, suggest best practices or third-party tools that Linux users can leverage for similar monitoring needs.
- Avoid presenting Windows/App Service plan features as the default; instead, structure documentation to address both Windows and Linux scenarios equally, or lead with Linux where possible to balance historical bias.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/manage-connections.md
...ob/main/articles/azure-functions/manage-connections.md
Medium Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Summary
The documentation provides code examples and configuration guidance primarily for C# (.NET) and JavaScript, but when discussing configuration files and connection strings, it references patterns and file names (such as 'local.settings.json' and 'Application settings') that are more familiar to Windows/Azure Portal users. There are no explicit Linux or cross-platform command-line examples (e.g., Bash, Linux environment variables), and the documentation does not mention Linux-specific tools or patterns for managing environment variables or configuration. The .NET examples dominate, and there is no mention of Linux shell usage or parity in configuration management.
Recommendations
- Include Linux/Bash shell examples for setting environment variables and managing configuration, especially for local development and deployment scenarios.
- When referencing configuration files (like 'local.settings.json'), clarify how these are used or mapped in Linux environments, including deployment via CLI or containers.
- Provide parity in code and configuration examples for both Windows and Linux environments, such as showing how to set connection strings using Azure CLI or environment variables in Bash.
- Mention cross-platform tools (e.g., Azure CLI) and provide examples for both PowerShell (Windows) and Bash (Linux/macOS) where relevant.
- Avoid assuming the reader is using Windows or the Azure Portal for configuration; explicitly address both Windows and Linux workflows.
Azure Functions
Durable Functions best practices and diagnostic tools
...s/durable/durable-functions-best-practice-reference.md
Low Priority
View Details →
Detected Bias Types
Windows First
Summary
The documentation provides a balanced overview of Durable Functions best practices and diagnostic tools, with examples and guidance for multiple languages. However, in the section on Azure Functions performance settings, PowerShell is listed before Python, which may subtly suggest Windows-first bias. No critical diagnostic tools or examples are Windows-only, and Linux/macOS users are not blocked from completing any tasks.
Recommendations
- When listing language-specific guidance, alternate the order or list languages alphabetically to avoid subtle Windows-first bias.
- Ensure that examples and tool recommendations include Linux/macOS equivalents where relevant.
- Explicitly mention cross-platform compatibility for diagnostic tools and extensions (e.g., Application Insights, VS Code extension).
Azure Functions
App settings reference for Azure Functions
...ain/articles/azure-functions/functions-app-settings.md
Low Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Summary
The documentation is generally cross-platform and provides parity for both Windows and Linux users. However, there are minor instances of Windows bias: Windows-specific syntax (e.g., %HOME% in AzureWebJobs_TypeScriptPath) is shown without a Linux equivalent, and Azure CLI and Azure PowerShell are recommended for programmatic management of settings, with no mention of Linux-native tools. In the WEBSITE_TIME_ZONE section, Windows and Linux examples are both given, but Windows is listed first. The WEBSITE_NODE_DEFAULT_VERSION setting is clearly marked as Windows-only, which is appropriate. Overall, Linux/macOS users can complete all tasks, but minor friction exists due to Windows-first ordering and tool recommendations.
Recommendations
- Where Windows-specific syntax is shown (e.g., %HOME%), add the Linux equivalent (e.g., $HOME).
- When recommending Azure CLI and Azure PowerShell, clarify that Azure CLI is fully cross-platform and PowerShell Core is available on Linux/macOS.
- Consider listing Linux examples before or alongside Windows examples in sections where both are relevant.
- Explicitly mention cross-platform alternatives or note when a setting/tool is Windows-only.
Azure Functions
App settings reference for Azure Functions
...ain/articles/azure-functions/functions-app-settings.md
Low Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Summary
The documentation is largely cross-platform and covers both Windows and Linux scenarios for Azure Functions app settings. However, there are minor instances of Windows bias: Windows-specific tools (Azure PowerShell) are mentioned before Azure CLI, and some examples (such as path syntax for AzureWebJobs_TypeScriptPath) use Windows-style paths. Additionally, the explanation of reserved delimiters in app setting names describes Windows behavior first, and the Windows-only setting WEBSITE_NODE_DEFAULT_VERSION is presented without a Linux equivalent. Overall, Linux parity is strong, but Windows is occasionally prioritized in examples and tool recommendations.
Recommendations
- When recommending tools for managing app settings, mention Azure CLI before or alongside Azure PowerShell, as Azure CLI is cross-platform.
- Where path examples are given (e.g., AzureWebJobs_TypeScriptPath), provide both Windows and Linux path syntax, or use a neutral example.
- For settings that are OS-specific (like WEBSITE_NODE_DEFAULT_VERSION), clarify the Linux equivalent or explicitly state that Linux uses a different mechanism (e.g., linuxFxVersion).
- In explanations of delimiters (double-underscore vs colon), present Linux behavior first or equally, and clarify differences.
- Review all examples and ensure Linux/macOS scenarios are equally represented, especially in sample values and tool usage.
Azure Functions
App settings reference for Azure Functions
...ain/articles/azure-functions/functions-app-settings.md
Low Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Powershell Heavy
Summary
The documentation provides comprehensive coverage of Azure Functions app settings, with examples and explanations for both Windows and Linux. However, there are minor signs of Windows bias: some settings (e.g., WEBSITE_NODE_DEFAULT_VERSION) are marked as Windows-only, and Windows-style paths (e.g., %HOME%\typescript) are used in examples without Linux equivalents. PowerShell-specific settings are detailed, and Azure PowerShell is mentioned as a recommended tool for managing settings, with no equivalent Linux CLI emphasis. In some cases, Windows terminology or tools are referenced before Linux alternatives.
Recommendations
- For settings with OS-specific values (e.g., WEBSITE_TIME_ZONE, AzureWebJobs_TypeScriptPath), provide both Windows and Linux examples side-by-side.
- When referencing tools for managing app settings, mention Azure CLI equally with Azure PowerShell, and provide cross-platform command examples.
- Where Windows paths or conventions are shown, add Linux equivalents (e.g., /home/typescript).
- For PowerShell-specific settings, clarify their scope and provide parity for other language runtimes where applicable.
Azure Functions
Guide for running C# Azure Functions in an isolated worker process
...icles/azure-functions/dotnet-isolated-process-guide.md
Low Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Summary
The documentation provides both Windows and Linux guidance for running C# Azure Functions in an isolated worker process. However, there are several instances where Windows-specific tools, commands, and examples are mentioned first or exclusively, such as PowerShell and Visual Studio, with Linux equivalents appearing later or less prominently. Some CLI commands and deployment instructions are shown for both platforms, but Windows tools (Visual Studio, PowerShell) are often listed before Linux alternatives (VS Code, Azure CLI). Additionally, certain sections (e.g., ReadyToRun, debugging, deployment requirements) provide Windows-specific guidance before Linux, and PowerShell is referenced as a primary automation tool.
Recommendations
- Ensure Linux and macOS examples are given equal prominence and ordering alongside Windows examples, especially in 'Getting Started', deployment, and debugging sections.
- Where PowerShell or Visual Studio are mentioned, always provide equivalent Azure CLI and VS Code instructions, and consider listing them first or in parallel.
- Add explicit Linux/macOS command-line examples for all critical operations (e.g., deployment, debugging, performance optimizations).
- Clarify any platform-specific limitations or differences, and link to Linux/macOS-specific guides where available.
- Review the ordering of sections and examples to avoid implicit Windows-first bias.
Azure Functions
Guide for running C# Azure Functions in an isolated worker process
...icles/azure-functions/dotnet-isolated-process-guide.md
Low Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Minor Powershell Mentions
Summary
The documentation provides a balanced approach for both Windows and Linux users, with explicit sections and examples for Linux deployment and configuration. However, there are minor instances where Windows-specific tools (Visual Studio, Azure PowerShell) are mentioned before their Linux equivalents (Visual Studio Code, Azure CLI), and Windows examples (such as ReadyToRun and deployment commands) are sometimes presented first. Azure PowerShell is referenced as a deployment option, but Azure CLI is also covered. No critical functionality is Windows-only, and Linux/macOS users can complete all tasks with the information provided.
Recommendations
- Ensure Linux and Azure CLI examples are presented alongside or before Windows/PowerShell examples where possible.
- Where Windows-specific instructions are given, provide equivalent Linux/macOS commands and clarify cross-platform applicability.
- Highlight Visual Studio Code and Azure CLI as primary cross-platform tools in 'Getting Started' and deployment sections.
- Consider grouping deployment instructions by platform or tool rather than by Windows-first ordering.
Azure Functions
App settings reference for Azure Functions
...ain/articles/azure-functions/functions-app-settings.md
Low Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Summary
The documentation provides comprehensive coverage of Azure Functions app settings for both Windows and Linux. However, there are minor signs of Windows bias: Windows-specific examples (e.g., environment variable delimiters, paths) are sometimes mentioned first or exclusively, PowerShell settings are detailed, and Windows tools (Azure PowerShell) are recommended alongside Azure CLI. Some settings are marked as Windows-only, but Linux equivalents are generally provided. Overall, Linux parity is strong, but minor friction remains.
Recommendations
- Ensure Linux examples (e.g., environment variable delimiters, file paths) are shown alongside Windows examples, not just mentioned second.
- Where PowerShell is referenced, also provide equivalent Azure CLI or Bash commands for Linux/macOS users.
- When recommending tools for programmatic management (e.g., Azure CLI or Azure PowerShell), clarify Linux support and provide CLI-first guidance.
- Review sample values (e.g., paths like '%HOME%\typescript') and provide Linux equivalents (e.g., '/home/typescript').
- Continue to highlight OS-specific behaviors (e.g., colon delimiter differences) and provide clear guidance for Linux users.
Azure Functions
Guide for running C# Azure Functions in an isolated worker process
...icles/azure-functions/dotnet-isolated-process-guide.md
Low Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation generally aims for cross-platform parity, but there are several areas where Windows is prioritized or Linux is underrepresented. Windows-specific tools and configuration steps (such as Visual Studio, PowerShell, and Windows CLI commands) are often mentioned before or more prominently than their Linux equivalents. Some examples and instructions are Windows-first, and Linux-specific guidance is sometimes relegated to tabs or brief notes. In a few places, Linux-specific deployment or configuration steps are referenced but not shown in full, and PowerShell is mentioned as a primary automation tool alongside Azure CLI, but Bash or Linux shell equivalents are not always provided.
Recommendations
- Ensure that all command-line examples (especially for deployment, configuration, and debugging) are shown for both Windows (PowerShell/CMD) and Linux (Bash), either side-by-side or in clearly labeled tabs.
- When listing tools or methods (e.g., Visual Studio, Visual Studio Code, Azure CLI, Azure PowerShell), avoid always listing Windows-centric tools first; alternate or group by OS.
- Where PowerShell is mentioned, provide Bash or shell script equivalents for Linux/macOS users.
- In sections where configuration or deployment steps are shown for Windows, ensure that Linux equivalents are equally detailed and visible.
- Explicitly call out any OS-specific limitations or differences, and provide links to Linux/macOS-specific guidance where appropriate.
- Review the order of presentation in tables and lists to avoid reinforcing a Windows-first perspective.
Azure Functions
App settings reference for Azure Functions
...ain/articles/azure-functions/functions-app-settings.md
Low Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Summary
The documentation provides a comprehensive reference for Azure Functions app settings, covering both Windows and Linux scenarios. However, there are minor signs of Windows bias: Windows-specific syntax (e.g., %HOME% in AzureWebJobs_TypeScriptPath) is used in examples, and some settings (like WEBSITE_NODE_DEFAULT_VERSION) are labeled 'Windows only' without immediately offering Linux equivalents or clarifying Linux alternatives. Additionally, when discussing tools for programmatic management of settings, Azure CLI and Azure PowerShell are mentioned, but Linux-native tools (such as Bash scripts or REST calls via curl) are not referenced. Most examples and explanations are OS-neutral, and Linux-specific settings are documented, but Windows terminology and patterns sometimes appear first or exclusively.
Recommendations
- Where settings are Windows-only, explicitly state Linux alternatives or clarify if not applicable.
- For settings like AzureWebJobs_TypeScriptPath, provide Linux path examples alongside Windows ones.
- When recommending tools for managing settings, mention Linux-native options (e.g., Bash/curl) in addition to Azure CLI and PowerShell.
- Ensure that examples and explanations for app settings consistently show both Windows and Linux syntax where relevant.
- Review the order of presentation for settings and examples to avoid defaulting to Windows-first unless the feature is Windows-only.
Azure Functions
Guide for running C# Azure Functions in an isolated worker process
...icles/azure-functions/dotnet-isolated-process-guide.md
Low Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Summary
The documentation provides a balanced overview of running C# Azure Functions in an isolated worker process, with clear support for both Windows and Linux environments. However, there are minor signs of Windows bias: Windows-specific tools (Visual Studio, PowerShell) are often mentioned before Linux equivalents (VS Code, Azure CLI), and some CLI examples default to Windows syntax. Azure PowerShell is listed as a deployment option alongside Azure CLI, but Linux-specific guidance is present and not missing. All critical tasks (creation, deployment, configuration, debugging) are documented for both platforms.
Recommendations
- Where multiple tools are listed (e.g., Visual Studio, VS Code, Azure CLI, Azure PowerShell), alternate the order or explicitly note Linux/macOS support for each.
- Ensure that CLI examples are shown for both Windows (PowerShell) and Linux (bash) where relevant, especially in deployment and configuration sections.
- Highlight Linux/macOS parity in introductory sections to reassure cross-platform users.
- Consider adding explicit 'Linux/macOS' tabs or callouts in sections where Windows tools are referenced, to guide non-Windows users.
Azure Functions
App settings reference for Azure Functions
...ain/articles/azure-functions/functions-app-settings.md
Low Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Summary
The documentation provides a comprehensive reference for Azure Functions app settings, covering both Windows and Linux environments. However, there are minor signs of Windows bias: Windows-specific examples (such as environment variable delimiters and sample paths) are sometimes presented first or exclusively, PowerShell settings are detailed, and Windows tools (Azure PowerShell) are mentioned alongside Azure CLI for managing settings. Linux equivalents are generally present, but Windows terminology or examples appear more frequently or are prioritized in some sections.
Recommendations
- Ensure all examples (e.g., environment variable syntax, file paths) are shown for both Windows and Linux, or clarify OS-specific differences.
- Where Windows tools (PowerShell) are mentioned, ensure Azure CLI or Linux-native alternatives are equally highlighted and placed before or alongside Windows tools.
- Review sample values and code snippets to provide Linux/macOS equivalents where applicable (e.g., paths, environment variable formats).
- Consider alternating the order of Windows and Linux examples to avoid implicit prioritization.
- Explicitly state OS applicability for settings that differ between Windows and Linux (e.g., WEBSITE_TIME_ZONE).
Azure Functions
App settings reference for Azure Functions
...ain/articles/azure-functions/functions-app-settings.md
Low Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Powershell Heavy
Summary
The documentation provides a comprehensive reference for Azure Functions app settings, covering both Windows and Linux scenarios. However, there are minor signs of Windows bias: Windows-specific examples (e.g., path syntax, Node.js version setting) are sometimes shown first or exclusively, PowerShell settings are detailed, and Windows tools (Azure PowerShell) are mentioned alongside Azure CLI. Linux equivalents are generally present, but Windows terminology and settings appear earlier or more prominently in some sections.
Recommendations
- Ensure all examples (e.g., path syntax, environment variable values) are shown for both Windows and Linux/macOS, or use cross-platform syntax where possible.
- When mentioning tools for managing settings (Azure CLI, Azure PowerShell), list Azure CLI first or equally, and provide Bash shell examples alongside PowerShell.
- For settings that are Windows-only, clearly label them as such and provide Linux/macOS alternatives or clarifications where applicable.
- Review ordering of settings and examples to avoid consistently showing Windows-specific content first.
- Expand Linux/macOS guidance in sections where Windows terminology dominates (e.g., file paths, environment variable delimiters).
Azure Functions
Guide for running C# Azure Functions in an isolated worker process
...icles/azure-functions/dotnet-isolated-process-guide.md
Low Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Summary
The documentation provides a generally cross-platform guide for running C# Azure Functions in an isolated worker process, with explicit support for both Windows and Linux. However, there are several instances where Windows tools, commands, and configuration options are mentioned first or more prominently than their Linux equivalents. Windows-specific instructions (e.g., for ReadyToRun, checking 32/64-bit, and preview SDK configuration) are often presented before Linux, and Windows CLI commands are sometimes shown without immediately adjacent Linux alternatives. Azure PowerShell is listed as a deployment option, but Linux users may not use PowerShell as commonly. Nevertheless, Linux deployment and configuration are covered, and Linux-specific instructions are included.
Recommendations
- Ensure that Linux and macOS examples are presented alongside Windows examples, ideally in parallel or with equal prominence.
- Where CLI commands are shown for Windows, immediately provide the Linux equivalent (especially for az CLI commands and configuration checks).
- When listing deployment tools, clarify which are cross-platform (e.g., Azure CLI, Core Tools) and which are Windows-centric (e.g., Azure PowerShell, Visual Studio).
- Consider adding explicit macOS notes where relevant, especially for development and debugging.
- In sections where Windows instructions are given first, alternate the order or use tabs to allow users to select their OS.
Azure Functions
Guide for running C# Azure Functions in an isolated worker process
...icles/azure-functions/dotnet-isolated-process-guide.md
Low Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Powershell Heavy
Summary
The documentation provides both Windows and Linux guidance for running C# Azure Functions in an isolated worker process, but there are several instances where Windows tools, commands, and examples are mentioned first or exclusively. Windows-specific tools (Visual Studio, PowerShell) are often listed before their Linux equivalents, and some CLI instructions are Windows-centric. However, Linux options (Azure CLI, Visual Studio Code, containers) are also covered, and critical tasks can be completed on Linux/macOS. The bias is mostly in ordering and tool emphasis, not in functional gaps.
Recommendations
- Ensure Linux and macOS examples are presented alongside Windows examples, ideally in parallel or with equal prominence.
- When listing tools or methods, alternate the order or use neutral phrasing (e.g., 'Visual Studio Code or Visual Studio').
- Add explicit Linux/macOS instructions where only Windows commands are shown, especially for PowerShell or Visual Studio steps.
- Highlight cross-platform tools (Azure CLI, VS Code, Core Tools) before Windows-only tools.
- Add tabs or sections for Linux/macOS where only Windows instructions are present.
- Clarify when a tool or step is Windows-only, and provide Linux/macOS alternatives where possible.
Azure Functions
App settings reference for Azure Functions
...ain/articles/azure-functions/functions-app-settings.md
Low Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Summary
The documentation provides a comprehensive reference for Azure Functions app settings, covering both Windows and Linux scenarios. However, there are minor signs of Windows bias: Windows-specific settings and examples (such as WEBSITE_NODE_DEFAULT_VERSION, AzureWebJobs_TypeScriptPath using Windows-style paths, and PowerShell settings) are presented without always giving Linux equivalents or alternatives. Windows tools (Azure PowerShell) are mentioned before Azure CLI in some guidance. Some examples (e.g., path syntax) use Windows conventions first. Overall, Linux and macOS users can complete all tasks, but may encounter minor friction or need to adapt examples.
Recommendations
- Where path examples are given (e.g., AzureWebJobs_TypeScriptPath), provide both Windows and Linux/macOS syntax.
- When referencing tools for managing app settings, mention Azure CLI before or alongside Azure PowerShell, as CLI is cross-platform.
- For settings that are Windows-only, clearly label them as such and provide Linux alternatives or clarify if not applicable.
- Ensure that examples and sample values are balanced between Windows and Linux (e.g., WEBSITE_TIME_ZONE shows both, which is good).
- Review PowerShell-specific sections to ensure Linux users are not confused; clarify when settings are only relevant to PowerShell workloads.
Azure Functions
Deployment technologies in Azure Functions
...s/azure-functions/functions-deployment-technologies.md
Low Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Summary
The documentation provides a broad overview of Azure Functions deployment technologies, but there is a mild bias toward Windows in the ordering and examples. Windows-specific tools (Visual Studio, Windows-only deployment options) are often mentioned first or exclusively, and some deployment methods (Source control, Local Git, FTPS) are labeled as 'Windows-only' without Linux equivalents or workarounds being clearly described. While Linux options are present and discussed, Windows tools and patterns (such as Kudu, Visual Studio) are referenced before their Linux counterparts, and Linux-specific instructions are sometimes less detailed.
Recommendations
- Ensure Linux deployment methods are given equal prominence and ordering in tables and lists.
- Provide explicit Linux/macOS command-line examples and tool recommendations alongside Windows/Visual Studio instructions.
- Clarify alternative Linux workflows for Windows-only deployment technologies (e.g., Source control, Local Git, FTPS), or link to relevant Linux documentation.
- Add more detail about Linux-specific deployment nuances, especially for remote build, container deployments, and troubleshooting.
- Where Windows tools are referenced (e.g., Visual Studio), also mention cross-platform tools (e.g., VS Code, Azure Functions Core Tools) with equal depth.
Azure Functions
Azure Functions networking options
...ticles/azure-functions/functions-networking-options.md
Low Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows First
Summary
The documentation provides CLI, PowerShell, and portal examples for configuring Azure Functions networking, but PowerShell examples are included alongside CLI and portal, which may favor Windows users. The Hybrid Connections feature is Windows-only, but this is clearly stated and justified. In some sections, Windows and Linux subnet sizing recommendations are given, but Windows is mentioned first. Overall, Linux parity is mostly maintained, but minor ordering and example biases exist.
Recommendations
- When providing automation examples, ensure that Azure CLI (cross-platform) examples are always present and shown before PowerShell.
- Explicitly note Linux/macOS compatibility in automation sections.
- Where subnet sizing recommendations are given, list Linux and Windows equally or alternate order.
- Consider adding bash or shell script examples where relevant.
- Ensure screenshots and portal instructions are not Windows-centric (they appear neutral here).