Azure App Configuration
166
Total Pages
109
Linux-Friendly Pages
57
Pages with Bias
34.3%
Bias Rate
Bias Trend Over Time
Pages with Bias Issues
479 issues found
Showing 226-250 of 479 flagged pages
Azure App Configuration
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-app-configuration/azure-pipeline-export-task.md
.../azure-app-configuration/azure-pipeline-export-task.md
Medium Priority
View Details →
Detected Bias Types
Powershell Heavy
Missing Linux Example
Summary
The documentation provides only a PowerShell example for consuming exported key-values, with no equivalent example for Bash or other Linux shells. This suggests a bias toward Windows users and environments, as Linux users are not shown how to access pipeline variables in their preferred shell. No explicit mention of Windows-only tools or patterns elsewhere, but the lack of Linux parity in code samples is notable.
Recommendations
- Add Bash (and/or sh) examples for accessing environment variables, e.g., 'echo "$myBuildSetting"'.
- Explicitly state that the exported variables are available in all supported agent operating systems and shells.
- Where PowerShell is mentioned, also mention Bash or other common Linux shells to ensure parity.
- Review screenshots and UI instructions to ensure they are not Windows-centric (e.g., avoid showing only Windows-style UI if Linux agents are supported).
Create Pull Request
Azure App Configuration
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-app-configuration/enable-dynamic-configuration-java-spring-push-refresh.md
...ps://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-app-configuration/enable-dynamic-configuration-java-spring-push-refresh.md
Medium Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Summary
The documentation provides environment variable setup instructions for Windows (cmd and PowerShell) before Linux/macOS (bash), and includes explicit PowerShell and Windows command prompt examples. While Linux/macOS instructions are present, Windows tooling and patterns are mentioned first and more prominently. There are no Linux-specific tool recommendations or parity in example ordering.
Recommendations
- Present Linux/macOS (bash) environment variable instructions before or alongside Windows examples, rather than after.
- Include Linux-specific tooling or deployment notes where relevant (e.g., mention Maven deployment from Linux shells).
- Avoid giving Windows command prompt and PowerShell examples first; alternate or group by OS.
- Explicitly state that all steps are cross-platform and highlight any OS-specific caveats.
- Where Visual Studio Code is recommended, also mention other popular Linux editors (e.g., Vim, Emacs) for parity.
Azure App Configuration
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-app-configuration/quickstart-python.md
.../articles/azure-app-configuration/quickstart-python.md
Medium Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Summary
The documentation page exhibits mild Windows bias in the prerequisites and environment variable setup sections. Windows-specific setup instructions (Windows command prompt and PowerShell) are listed before Linux/macOS equivalents, and Windows tools (setx, PowerShell) are mentioned explicitly. The link for Python setup refers only to Windows documentation, omitting Linux/macOS setup guidance. However, code samples and most instructions are platform-neutral, and Linux/macOS commands are present where relevant.
Recommendations
- Provide links for Python setup on Linux and macOS alongside the Windows documentation link in the prerequisites.
- Present environment variable setup instructions in a neutral order (e.g., group by OS or list Linux/macOS first occasionally).
- Explicitly mention that all code samples and instructions are cross-platform unless otherwise noted.
- Consider adding a short section or note on running the Python app on Linux/macOS, including any OS-specific considerations.
- Ensure parity in troubleshooting or exception handling guidance for Linux/macOS users if relevant.
Azure App Configuration
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-app-configuration/enable-dynamic-configuration-dotnet.md
...p-configuration/enable-dynamic-configuration-dotnet.md
Medium Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Summary
The documentation demonstrates a Windows-first bias in several areas. Visual Studio is listed as the only development environment in prerequisites, and all project creation instructions assume its use. When setting environment variables, Windows command prompt and PowerShell instructions are presented before Linux/macOS equivalents. PowerShell is mentioned multiple times, and screenshots show Windows terminals. There are no Linux-specific development environment instructions or screenshots, and the workflow is tailored to Windows users.
Recommendations
- Add instructions for creating and running .NET Framework apps using cross-platform editors (e.g., Visual Studio Code with Mono, JetBrains Rider) or clarify Windows-only requirements.
- Present environment variable commands for Linux/macOS before or alongside Windows commands, not after.
- Include Linux/macOS terminal screenshots and clarify any platform-specific behaviors.
- Explicitly state platform limitations (e.g., .NET Framework is Windows-only, but .NET Core/.NET 5+ can run cross-platform) and link to cross-platform alternatives.
- Reduce reliance on PowerShell and Windows command prompt in examples; provide Bash/zsh equivalents where possible.
Azure App Configuration
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-app-configuration/howto-targetingfilter-javascript.md
...-app-configuration/howto-targetingfilter-javascript.md
Medium Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Summary
The documentation demonstrates a mild Windows bias in the section about setting environment variables: Windows Command Prompt and PowerShell instructions are presented first, followed by macOS/Linux. No Linux-specific tools or patterns are mentioned elsewhere, but the ordering and explicit inclusion of PowerShell and Windows command prompt examples indicate a 'windows_first' and 'powershell_heavy' bias.
Recommendations
- Present environment variable instructions in a neutral or platform-agnostic order (e.g., Linux/macOS first, or group all together).
- Explicitly mention that all commands work cross-platform unless otherwise noted.
- Consider providing Linux/macOS examples before Windows, or in parallel, to avoid implicit prioritization.
- If possible, use platform-agnostic tooling (e.g., .env files, cross-env npm package) for environment variable setup in Node.js tutorials.
Azure App Configuration
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-app-configuration/quickstart-feature-flag-python.md
...re-app-configuration/quickstart-feature-flag-python.md
Medium Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Summary
The documentation page exhibits mild Windows bias. In the environment variable setup section, Windows Command Prompt instructions are presented first, followed by PowerShell, macOS, and Linux. PowerShell is given its own tab, and Windows-specific tooling (setx) is mentioned before Unix equivalents. However, Linux/macOS instructions are present and correct, and the rest of the documentation is platform-neutral.
Recommendations
- Rotate or randomize the order of platform instructions so that Linux/macOS are sometimes presented first.
- Combine macOS and Linux instructions into a single 'Unix' tab to reduce duplication and emphasize parity.
- Explicitly mention that all examples work equally well on Linux/macOS, not just Windows.
- Add troubleshooting notes for Linux/macOS users (e.g., shell differences, environment variable persistence).
- Where possible, use cross-platform commands (e.g., Python's os.environ) in examples to demonstrate platform neutrality.
Azure App Configuration
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-app-configuration/howto-labels-aspnet-core.md
...es/azure-app-configuration/howto-labels-aspnet-core.md
Medium Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Summary
The documentation demonstrates per-environment configuration using Azure App Configuration in the context of an ASP.NET Core application. It references modifying 'launchSettings.json' and uses .NET CLI commands, which are cross-platform, but the workflow and examples are tailored to Visual Studio/Windows development patterns. There are no explicit Linux or cross-platform environment variable setting examples (e.g., using bash or export), and the only method shown for changing environments is via 'launchSettings.json', which is primarily used in Windows/Visual Studio workflows.
Recommendations
- Include instructions and examples for setting environment variables on Linux/macOS (e.g., using 'export ASPNETCORE_ENVIRONMENT=Production' in bash).
- Mention alternative ways to set environment variables outside of 'launchSettings.json', such as through shell commands or CI/CD pipelines.
- Clarify that the .NET CLI commands are cross-platform and can be run on Windows, Linux, or macOS.
- Add a note or section for developers using Linux or macOS, highlighting any differences or additional steps required.
Azure App Configuration
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-app-configuration/quickstart-go-console-app.md
...s/azure-app-configuration/quickstart-go-console-app.md
Medium Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Summary
The documentation provides environment variable setup instructions for all major platforms (Windows Command Prompt, PowerShell, macOS/Linux), but consistently lists Windows (cmd and PowerShell) before Linux/macOS. PowerShell and Windows Command Prompt commands are given equal or greater prominence than bash equivalents, and the use of setx (a Windows-specific tool) is described in detail, including the need to restart the command prompt. There are no missing Linux examples, but the ordering and emphasis subtly prioritize Windows tooling and patterns.
Recommendations
- Alternate the order of platform-specific instructions so that Linux/macOS is listed first in some sections, or present all platform instructions in parallel tabs to avoid implicit prioritization.
- Avoid giving extra explanatory detail to Windows-specific tools (e.g., setx and restart) unless similar context is provided for Linux/macOS.
- Where possible, use cross-platform commands (such as 'env' or 'printenv') in examples, or clarify that the Go application will work identically on all platforms once environment variables are set.
- Consider adding a note at the top stating that all major platforms are supported and that instructions are provided for each.
Azure App Configuration
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-app-configuration/howto-labels-aspnet-core.md
...es/azure-app-configuration/howto-labels-aspnet-core.md
Medium Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Summary
The documentation page demonstrates configuring environment-specific values in Azure App Configuration using an ASP.NET Core app. It references and builds upon a prior Windows-centric quickstart, uses only .NET/C# code examples, and instructs users to modify 'launchSettings.json' (a Visual Studio/Windows-centric file) for environment variables. There are no Linux-specific instructions, nor are cross-platform alternatives (such as setting environment variables via the shell) provided.
Recommendations
- Include instructions for setting environment variables on Linux/macOS (e.g., using export in bash/zsh) alongside the launchSettings.json method.
- Clarify that 'launchSettings.json' is primarily used in Visual Studio and may not apply to all development environments.
- Provide examples or notes for running the sample app on Linux/macOS, including any differences in file paths or commands.
- Reference cross-platform .NET Core development practices, ensuring parity for non-Windows users.
- Link to documentation on configuring environment variables in different operating systems.
Azure App Configuration
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-app-configuration/quickstart-go-console-app.md
...s/azure-app-configuration/quickstart-go-console-app.md
Medium Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Summary
The documentation provides environment variable setup instructions for Windows Command Prompt and PowerShell before mentioning the equivalent commands for macOS/Linux. Both Windows and Linux/macOS are covered, but Windows instructions are consistently presented first and PowerShell is explicitly called out, which may signal a subtle Windows-first bias.
Recommendations
- Alternate the order in which Windows and Linux/macOS instructions are presented, or present them in parallel (side-by-side tabs or tables) to avoid implying priority.
- Avoid giving Windows-specific instructions (e.g., setx, PowerShell) more prominence than Linux/macOS equivalents.
- Consider using tabs or collapsible sections for each OS to provide equal visibility.
- Explicitly state that all major platforms are supported and that the instructions are equivalent.
- Where possible, provide cross-platform commands (e.g., using a tool like cross-env or platform-agnostic scripts) or note any platform-specific caveats.
Azure App Configuration
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-app-configuration/howto-labels-aspnet-core.md
...es/azure-app-configuration/howto-labels-aspnet-core.md
Medium Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Summary
The documentation demonstrates environment-specific configuration using ASP.NET Core and Azure App Configuration, but it assumes a Windows development environment by referencing 'launchSettings.json' and does not provide equivalent Linux/macOS instructions or examples. There are no mentions of Linux-specific environment variable management or cross-platform development patterns.
Recommendations
- Include instructions for setting environment variables on Linux/macOS (e.g., using export in the shell or .env files) alongside the 'launchSettings.json' method.
- Mention that 'launchSettings.json' is primarily used by Visual Studio and may not apply in all environments, especially on Linux.
- Provide examples of running the application and setting ASPNETCORE_ENVIRONMENT from the command line on Linux/macOS, such as 'ASPNETCORE_ENVIRONMENT=Production dotnet run'.
- Clarify that the steps apply to all platforms and highlight any platform-specific differences where relevant.
Azure App Configuration
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-app-configuration/howto-labels-aspnet-core.md
...es/azure-app-configuration/howto-labels-aspnet-core.md
Medium Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Summary
The documentation demonstrates environment-based configuration using ASP.NET Core and Azure App Configuration, but it assumes the use of Visual Studio-style project structures (e.g., launchSettings.json) and does not provide any Linux-specific instructions or examples. There are no mentions of Linux tools, environment variable setting patterns, or cross-platform considerations. The only method shown for setting environment variables is via launchSettings.json, which is primarily used in Windows/Visual Studio development environments.
Recommendations
- Include instructions for setting environment variables on Linux/macOS, such as using export in the terminal or setting variables inline with the dotnet run command.
- Mention alternative ways to run and configure the application outside of Visual Studio, such as from the command line or in Docker containers.
- Add a note clarifying that launchSettings.json is not used when running dotnet applications outside of Visual Studio or Visual Studio Code, and provide equivalent steps for Linux users.
- Provide example commands for building and running the application on Linux/macOS, and explain how to set ASPNETCORE_ENVIRONMENT in those environments.
Azure App Configuration
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-app-configuration/howto-labels-aspnet-core.md
...es/azure-app-configuration/howto-labels-aspnet-core.md
Medium Priority
View Details →
Detected Bias Types
Missing Linux Example
Windows First
Summary
The documentation focuses exclusively on ASP.NET Core and .NET tooling, referencing only Windows-centric development patterns (such as editing launchSettings.json and using Visual Studio project structure). There are no Linux-specific instructions or examples, and the workflow assumes familiarity with Windows development environments.
Recommendations
- Include explicit instructions for setting environment variables on Linux/macOS (e.g., using export in the terminal or configuring environment variables in launch scripts).
- Mention how to run and debug the application using common Linux editors (like VS Code) or command-line tools, not just through launchSettings.json.
- Clarify that the dotnet CLI is cross-platform, and provide terminal commands for both Windows (cmd/PowerShell) and Linux/macOS (bash/zsh).
- Add a note or section about file path differences and environment variable conventions between Windows and Linux.
- Provide screenshots or examples that reflect Linux/macOS environments in addition to Windows.
Azure App Configuration
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-app-configuration/howto-labels-aspnet-core.md
...es/azure-app-configuration/howto-labels-aspnet-core.md
Medium Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Summary
The documentation demonstrates environment-based configuration using ASP.NET Core and Azure App Configuration, but it assumes the use of Windows-centric tooling and patterns. It references modifying 'launchSettings.json' (a Visual Studio/Windows convention) and does not provide equivalent instructions or examples for Linux or cross-platform development environments. There are no Linux shell or cross-platform CLI examples for setting environment variables or running the application in different environments.
Recommendations
- Include instructions for setting environment variables on Linux/macOS (e.g., using 'export ASPNETCORE_ENVIRONMENT=Production' in the shell) alongside the 'launchSettings.json' method.
- Mention that 'launchSettings.json' is primarily used in Visual Studio and may not be present or used in all development environments, especially on Linux.
- Provide examples of running the application from the command line with environment variables set for both Windows (using 'set' or 'setx') and Linux/macOS (using 'export').
- Clarify that the instructions apply to cross-platform .NET Core development and highlight any platform-specific steps.
Azure App Configuration
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-app-configuration/howto-labels-aspnet-core.md
...es/azure-app-configuration/howto-labels-aspnet-core.md
Medium Priority
View Details →
Detected Bias Types
Missing Linux Example
Windows First
Summary
The documentation page demonstrates configuring environment-specific values in Azure App Configuration using an ASP.NET Core app. All examples and instructions are centered around .NET and the use of launchSettings.json, which is primarily a Visual Studio/Windows-centric pattern. There are no examples or guidance for setting environment variables or running the app in Linux or cross-platform scenarios, such as using shell commands or Docker. The workflow implicitly assumes a Windows development environment.
Recommendations
- Include examples for setting environment variables in Linux/macOS shells (e.g., export ASPNETCORE_ENVIRONMENT=Production) alongside the launchSettings.json method.
- Mention how to run the application in Linux environments, possibly using the terminal or Docker, and how to override environment variables at runtime.
- Clarify that launchSettings.json is a Visual Studio/.NET Core convention and provide alternative instructions for developers using other editors or platforms.
- Add a note or section on cross-platform development, highlighting any differences or additional steps required for Linux/macOS users.
Azure App Configuration
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-app-configuration/concept-enable-rbac.md
...rticles/azure-app-configuration/concept-enable-rbac.md
Medium Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Summary
The documentation page demonstrates a subtle Windows bias by referencing Visual Studio Credential as the first and only concrete example of a development environment, which is primarily a Windows tool. There are no explicit code examples or command-line instructions, but the mention of Visual Studio as the default development context and the lack of Linux-specific or cross-platform tooling references (such as VS Code, CLI, or Bash) indicate a Windows-first perspective. No Linux or cross-platform development environments or workflows are mentioned.
Recommendations
- Include examples that reference cross-platform development environments, such as Visual Studio Code, Azure CLI, or JetBrains Rider.
- When mentioning authentication methods, provide parity by listing Linux/macOS-friendly options (e.g., Azure CLI Credential, EnvironmentCredential) alongside Visual Studio Credential.
- Explicitly state that the instructions apply to all platforms and, where relevant, provide platform-specific notes or examples.
- Add a section or note on how to perform role assignments using Azure CLI or Azure PowerShell, both of which are cross-platform.
- Avoid assuming Visual Studio as the default development environment; mention it as one of several options.
Azure App Configuration
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-app-configuration/howto-labels-aspnet-core.md
...es/azure-app-configuration/howto-labels-aspnet-core.md
Medium Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Summary
The documentation demonstrates environment-based configuration using Azure App Configuration in the context of an ASP.NET Core app. It references modifying 'launchSettings.json' and running the app with 'dotnet run', which are cross-platform, but the workflow and examples implicitly assume a Visual Studio/Windows development environment. There are no explicit instructions or examples for Linux or macOS users, such as using environment variables via the shell or running the app outside of Visual Studio tooling.
Recommendations
- Add explicit instructions for setting environment variables on Linux/macOS (e.g., using 'export ASPNETCORE_ENVIRONMENT=Production' in the shell) and running the app from the command line.
- Mention that 'launchSettings.json' is primarily used by Visual Studio and that on Linux/macOS or in CI/CD, environment variables are typically set via the shell or pipeline configuration.
- Provide a Linux/macOS example alongside the 'launchSettings.json' example to ensure parity.
- Clarify that the 'dotnet' CLI commands are cross-platform, and provide any OS-specific notes if behavior differs.
Azure App Configuration
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-app-configuration/howto-labels-aspnet-core.md
...es/azure-app-configuration/howto-labels-aspnet-core.md
Medium Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Summary
The documentation demonstrates configuration management using Azure App Configuration in the context of an ASP.NET Core application. It references modifying 'launchSettings.json' and running the app with 'dotnet build' and 'dotnet run', but does not provide any Linux- or cross-platform-specific guidance or examples. The workflow and tooling described (e.g., launchSettings.json) are more familiar to Windows/Visual Studio users, and there is no mention of Linux environment variable configuration or command-line alternatives.
Recommendations
- Add explicit instructions for setting environment variables on Linux/macOS (e.g., using 'export ASPNETCORE_ENVIRONMENT=Production' in the shell) and running the app from the terminal.
- Mention that 'launchSettings.json' is primarily used by Visual Studio and may not be relevant for all development environments, especially on Linux.
- Provide cross-platform guidance for testing in different environments, such as command-line examples for both Windows (set ASPNETCORE_ENVIRONMENT=Production) and Linux/macOS (export ASPNETCORE_ENVIRONMENT=Production).
- Clarify that the dotnet CLI commands are cross-platform, but environment variable setup may differ between operating systems.
- Include a note or table summarizing how to set environment variables for different platforms.
Azure App Configuration
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-app-configuration/concept-enable-rbac.md
...rticles/azure-app-configuration/concept-enable-rbac.md
Medium Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Summary
The documentation page demonstrates a subtle Windows bias by referencing Visual Studio Credential as the first and only concrete example of a development environment, which is primarily a Windows tool. There are no explicit examples or instructions for Linux or cross-platform environments, nor are command-line examples (such as Azure CLI or Bash) provided. The documentation assumes portal-based or Visual Studio-based workflows, which may not be as accessible or common for Linux users.
Recommendations
- Include explicit examples for Linux and cross-platform environments, such as using Azure CLI or Bash scripts to assign roles or authenticate.
- Mention and provide examples for development environments commonly used on Linux, such as VS Code, JetBrains Rider, or command-line workflows.
- When discussing DefaultAzureCredential, clarify how it works in non-Windows environments and provide guidance for Linux/macOS users.
- Balance references to Visual Studio with equivalent cross-platform tools or IDEs.
- Provide step-by-step instructions for role assignment using Azure CLI or PowerShell Core (which is cross-platform), not just the Azure Portal.
Azure App Configuration
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-app-configuration/howto-labels-aspnet-core.md
...es/azure-app-configuration/howto-labels-aspnet-core.md
Medium Priority
View Details →
Detected Bias Types
Missing Linux Example
Windows First
Summary
The documentation page demonstrates configuring environment-specific values in Azure App Configuration using an ASP.NET Core app. All examples and instructions assume the use of .NET Core tooling and workflows, but they reference only the modification of launchSettings.json (a Visual Studio/Windows-centric file) for environment variables, without mentioning Linux/macOS equivalents (such as setting environment variables via shell or using other configuration files). There are no examples for setting environment variables or running the app in Linux/macOS environments, and the workflow implicitly assumes a Windows/Visual Studio context.
Recommendations
- Add instructions for setting the ASPNETCORE_ENVIRONMENT variable in Linux/macOS shells (e.g., export ASPNETCORE_ENVIRONMENT=Production dotnet run).
- Mention that launchSettings.json is primarily used by Visual Studio and dotnet CLI, and provide alternative methods for other environments.
- Include examples or notes on how to run and configure the app in Linux/macOS terminals.
- Ensure screenshots and file paths are not Windows-specific, or provide cross-platform alternatives.
Azure App Configuration
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-app-configuration/howto-labels-aspnet-core.md
...es/azure-app-configuration/howto-labels-aspnet-core.md
Medium Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Summary
The documentation demonstrates environment-based configuration using ASP.NET Core and Azure App Configuration, but it assumes usage patterns and tooling common to Windows development. It references modifying launchSettings.json (a Visual Studio/Windows-centric file) and does not mention or provide examples for Linux or cross-platform environment variable management. There are no instructions for setting environment variables or running the app in Linux shells, nor any mention of Linux development workflows.
Recommendations
- Include instructions or examples for setting environment variables in Linux/macOS shells (e.g., using 'export ASPNETCORE_ENVIRONMENT=Production' in bash/zsh).
- Mention alternative ways to configure environment variables outside of launchSettings.json, such as through shell commands or CI/CD pipelines.
- Clarify that the steps apply to both Windows and Linux, and provide parallel examples for Linux users.
- Reference cross-platform editors and tools, not just Visual Studio/Windows-specific files.
- Add a note or section on running and testing the app in Linux environments, including relevant commands.
Azure App Configuration
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-app-configuration/concept-enable-rbac.md
...rticles/azure-app-configuration/concept-enable-rbac.md
Medium Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Summary
The documentation page demonstrates a subtle Windows bias by referencing Visual Studio Credential as the first and only concrete example of a development environment, which is primarily a Windows tool. There are no explicit Linux or cross-platform command-line examples, nor are Linux development environments (such as VS Code on Linux, CLI, or other editors) mentioned. Additionally, there are no PowerShell-specific commands, but the lack of Linux or cross-platform examples and the prioritization of Windows-centric tools indicate a 'windows_first' and 'missing_linux_example' bias.
Recommendations
- Include examples and references for Linux development environments, such as using VS Code, JetBrains Rider, or command-line interfaces.
- Provide explicit CLI-based instructions (e.g., using Azure CLI) for role assignment and authentication, which are cross-platform.
- Mention cross-platform credential options (such as Azure CLI Credential) alongside Visual Studio Credential.
- Ensure that all steps and tooling references are inclusive of both Windows and Linux users, avoiding the implication that Visual Studio is the default or only development environment.
Azure App Configuration
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-app-configuration/howto-labels-aspnet-core.md
...es/azure-app-configuration/howto-labels-aspnet-core.md
Medium Priority
View Details →
Detected Bias Types
Missing Linux Example
Windows First
Summary
The documentation page demonstrates configuring environment-specific values in Azure App Configuration using an ASP.NET Core app. All examples and instructions assume the use of .NET (C#) and reference editing launchSettings.json, which is a pattern typical for Windows development environments. There are no examples or guidance for Linux-based workflows, such as using environment variables via shell or configuring for deployment on Linux servers/containers. The documentation does not mention or show how to set environment variables outside of launchSettings.json, which is not always used in Linux or containerized deployments.
Recommendations
- Add examples for setting environment variables using Linux shell commands (e.g., export ASPNETCORE_ENVIRONMENT=Production) and explain how to run the application in different environments from the command line.
- Mention how to configure environment variables in common Linux deployment scenarios, such as Docker containers or systemd services.
- Clarify that launchSettings.json is primarily used for local development and may not be present or used in production or Linux-based deployments.
- Provide parity in instructions by showing both Windows (launchSettings.json) and Linux (shell/environment) approaches for setting environment variables.
Azure App Configuration
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-app-configuration/howto-labels-aspnet-core.md
...es/azure-app-configuration/howto-labels-aspnet-core.md
Medium Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Summary
The documentation demonstrates environment-specific configuration using ASP.NET Core and Azure App Configuration, but all examples and instructions assume a Windows-centric development environment. It references modifying 'launchSettings.json' (a Visual Studio/Windows convention) and does not mention or provide guidance for Linux or cross-platform development environments. There are no examples for setting environment variables or running the app in Linux shells or containers.
Recommendations
- Include instructions for setting environment variables in Linux/macOS shells (e.g., export ASPNETCORE_ENVIRONMENT=Production) alongside the launchSettings.json method.
- Mention that 'launchSettings.json' is primarily used by Visual Studio and dotnet CLI on Windows, and provide alternatives for Linux users.
- Add examples for running the application in Linux/macOS terminals, including how to set environment variables inline (e.g., ASPNETCORE_ENVIRONMENT=Development dotnet run).
- Clarify that the instructions apply to all platforms and explicitly call out any platform-specific steps.
- Consider including a section or note on running and configuring the app in Docker containers, which is a common cross-platform scenario.
Azure App Configuration
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-app-configuration/configuration-provider-overview.md
...e-app-configuration/configuration-provider-overview.md
Medium Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Summary
The documentation page demonstrates a Windows/.NET bias by listing .NET-based provider libraries first, providing only .NET Framework and ASP.NET Core sample links (which are Windows-centric), and omitting explicit Linux or cross-platform usage examples. There is no mention of Linux-specific tools, patterns, or sample applications, and the ordering prioritizes Windows technologies over Linux-native frameworks.
Recommendations
- Add explicit Linux usage examples for each provider library, especially for .NET (e.g., running on Ubuntu, Docker, or other Linux environments).
- Include links to sample applications or guides for deploying configuration providers in Linux containers, cloud-native environments, or with Linux-based orchestration tools.
- Balance the order of provider libraries to avoid implicit prioritization of Windows/.NET; consider grouping by language or platform family.
- Mention cross-platform compatibility for .NET Standard and .NET Core providers, clarifying that they run on Linux and macOS as well as Windows.
- Provide guidance or references for using configuration providers in popular Linux scenarios (e.g., with systemd services, in Kubernetes pods, etc.).