IoT Dps

49
Total Pages
25
Linux-Friendly Pages
24
Pages with Bias
49.0%
Bias Rate

Bias Trend Over Time

Pages with Bias Issues

118 issues found
Showing 26-50 of 118 flagged pages
IoT Dps https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/iot-dps/quick-enroll-device-x509.md ...blob/main/articles/iot-dps/quick-enroll-device-x509.md
High Priority View Details →
Scanned: 2026-01-08 00:53
Reviewed by: LLM Analysis
Issues: 4 bias types
Detected Bias Types
Windows First Missing Linux Example 🔧 Windows Tools Powershell Heavy
Summary
The documentation page exhibits a Windows bias in several ways: Windows is consistently mentioned first or exclusively in prerequisites and instructions, with explicit references to 'Windows-based machine' and 'Windows command prompt.' Linux equivalents are not provided or are only mentioned in passing. Tooling and command-line instructions (especially for .NET and Java) assume Windows environments, and there is reliance on Windows-specific patterns (e.g., registry, command prompt). The certificate creation steps and sample code setup lack Linux-specific guidance, and the use of Git Bash is suggested even for Java, which is cross-platform.
Recommendations
  • Provide explicit Linux instructions and examples alongside Windows ones for all SDKs (C#, Java, Node.js), including terminal commands and environment setup.
  • Replace references to 'Windows command prompt' with 'terminal or command prompt' and clarify platform-specific steps where necessary.
  • Include Linux-specific tooling and usage patterns, such as using bash/zsh, Linux file paths, and environment variable management.
  • Ensure that prerequisites and sample code setup steps are platform-neutral or offer both Windows and Linux variants.
  • Avoid suggesting Windows-only tools (e.g., registry for configuration) and offer cross-platform alternatives.
  • Add screenshots or terminal output examples from Linux environments where appropriate.
  • Clarify that Git Bash is primarily for Windows users and suggest native bash/zsh for Linux/macOS users.
GitHub Create Pull Request
IoT Dps https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/iot-dps/iot-dps-understand-ip-address.md ...main/articles/iot-dps/iot-dps-understand-ip-address.md
High Priority View Details →
Scanned: 2025-08-17 00:01
Reviewed by: Unknown
Issues: 3 bias types
Detected Bias Types
Windows First Powershell Heavy Missing Linux Example
Summary
The documentation references both Azure CLI and PowerShell for managing connectivity, but does not mention or provide examples for Linux-specific tools or workflows. PowerShell is a Windows-centric tool, and its mention alongside Azure CLI (which is cross-platform) without explicit Linux/Bash examples or guidance may imply a Windows-first approach. There are no Linux/Bash command examples or references to Linux firewall tools, and the documentation does not clarify how to perform equivalent tasks on Linux systems.
Recommendations
  • Add explicit Linux/Bash command examples for managing firewall rules and querying DPS IP addresses.
  • Mention Linux-native tools (such as iptables, ufw, or firewalld) for firewall configuration alongside Windows firewall.
  • Clarify that Azure CLI is cross-platform and provide sample commands for both Windows (PowerShell/CMD) and Linux (Bash).
  • Avoid listing PowerShell before Azure CLI, or provide parallel examples for both environments.
  • Include a section or note for Linux users outlining any differences or additional steps required.
GitHub Create Pull Request
IoT Dps https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/iot-dps/how-to-legacy-device-symm-key.md ...main/articles/iot-dps/how-to-legacy-device-symm-key.md
High Priority View Details →
Scanned: 2025-08-17 00:01
Reviewed by: Unknown
Issues: 4 bias types
Detected Bias Types
Windows First Powershell Heavy 🔧 Windows Tools Missing Linux Example
Summary
The documentation demonstrates a Windows-first bias, with Windows tools and workflows (such as Visual Studio, PowerShell, and Windows command prompts) being mentioned before or more prominently than Linux equivalents. In several sections, Windows-specific instructions and tools are detailed, while Linux alternatives are either briefly referenced, deferred to external links, or presented after the Windows instructions. Some programming language pivots (notably C and Python) assume a Windows-based machine by default. The use of PowerShell for key derivation is highlighted, and Visual Studio is the primary IDE discussed for C development, with Linux instructions relegated to linked SDK documentation. While Linux examples are present (notably for device key derivation and some SDK usage), they are less detailed or less immediately accessible.
Recommendations
  • Present Linux and Windows instructions with equal prominence and in parallel, rather than defaulting to Windows-first.
  • For each programming language, provide explicit, step-by-step Linux setup and usage instructions alongside Windows instructions, rather than referring users to external SDK documentation for Linux.
  • Include Linux-native tools (e.g., gcc, make, VS Code, or CLion) as alternatives to Visual Studio for C/C++ development.
  • Where PowerShell is used for Windows, provide a Bash or Python script alternative for Linux/macOS in the same section.
  • Avoid language such as 'This tutorial is oriented toward a Windows-based workstation'—instead, state that the tutorial supports both Windows and Linux, and provide side-by-side instructions.
  • Ensure all command-line examples are shown for both Windows (cmd/PowerShell) and Linux (bash), especially for environment variable setting and running SDK samples.
  • Where possible, provide screenshots or terminal output from both Windows and Linux environments.
GitHub Create Pull Request
IoT Dps https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/iot-dps/quick-create-simulated-device-symm-key.md ...cles/iot-dps/quick-create-simulated-device-symm-key.md
High Priority View Details →
Scanned: 2025-08-17 00:01
Reviewed by: Unknown
Issues: 4 bias types
Detected Bias Types
Windows First Missing Linux Example 🔧 Windows Tools Powershell Heavy
Summary
The documentation demonstrates a clear Windows bias. Windows is mentioned first and most prominently throughout, with explicit references to 'your Windows machine' and 'Windows-based workstation.' Prerequisites and setup instructions focus on Windows tools (Visual Studio, CMD, Git Bash), and Linux alternatives are either relegated to external links or not described in detail. Command-line examples use Windows syntax (cmd) exclusively, and there are no explicit Linux shell (bash) equivalents. The only mention of Linux is a pointer to a separate tutorial, rather than integrated parity within the main flow.
Recommendations
  • Provide parallel Linux/macOS instructions and examples alongside Windows steps, not just as external links.
  • Include bash shell equivalents for all command-line instructions (e.g., git, cmake, npm, pip, java commands).
  • Mention and support Linux-native tools (e.g., GCC, Clang, make) where Visual Studio is referenced, and clarify how to use them.
  • Adjust language to be platform-neutral (e.g., 'your development machine' instead of 'your Windows machine').
  • Where environment variables are set, show both Windows (set) and Linux/macOS (export) syntax.
  • For code editing and building, mention cross-platform editors (e.g., VS Code) and build systems (e.g., CMake, Maven) with Linux usage notes.
  • Ensure screenshots and UI instructions are not Windows-specific, or provide Linux equivalents where relevant.
GitHub Create Pull Request
IoT Dps https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/iot-dps/concepts-device-oem-security-practices.md ...cles/iot-dps/concepts-device-oem-security-practices.md
High Priority View Details →
Scanned: 2025-07-13 21:37
Reviewed by: Unknown
Issues: 3 bias types
Detected Bias Types
Windows First 🔧 Windows Tools Missing Linux Example
Summary
The documentation demonstrates a subtle Windows bias by mentioning Windows-specific features (such as the Windows certificate store and TPMs being standard on Windows devices) without providing equivalent Linux examples or guidance. Windows tools and patterns are referenced, but Linux alternatives are not discussed, and there are no Linux-specific instructions or examples for certificate or TPM management.
Recommendations
  • When referencing the Windows certificate store, also mention common Linux certificate storage locations (e.g., /etc/ssl/certs, or using OpenSSL).
  • When discussing TPM support, note that TPMs are also supported on Linux and provide links or examples for Linux TPM tools (such as tpm2-tools or trousers).
  • Include examples or references for certificate installation and management on Linux-based devices, not just Windows.
  • Where software tools are mentioned for certificate installation, provide cross-platform or Linux-specific tool suggestions (e.g., OpenSSL, tpm2-tools, or shell scripts).
  • Explicitly state that the guidance applies to both Windows and Linux devices, and call out any OS-specific differences or considerations.
GitHub Create Pull Request
IoT Dps https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/iot-dps/quick-create-simulated-device-tpm.md .../articles/iot-dps/quick-create-simulated-device-tpm.md
High Priority View Details →
Scanned: 2025-07-13 21:37
Reviewed by: Unknown
Issues: 4 bias types
Detected Bias Types
Windows First Missing Linux Example 🔧 Windows Tools Powershell Heavy
Summary
The documentation demonstrates a clear Windows bias: it assumes a Windows development environment by default, provides detailed steps and tooling instructions for Windows (e.g., Visual Studio, .NET Core SDK, Simulator.exe), and omits or relegates Linux/macOS instructions to external links. There are no explicit Linux or macOS command-line examples, and Windows-specific tools and patterns (like Visual Studio, Simulator.exe, and Windows command prompts) are referenced throughout, often without Linux equivalents or alternatives.
Recommendations
  • Provide explicit Linux and macOS instructions and examples alongside Windows steps, not just as external links.
  • Include Linux/macOS command-line examples (e.g., using bash, make, gcc, or cross-platform build tools) wherever Windows commands or tools are shown.
  • Mention and demonstrate Linux-compatible TPM simulators and how to run them (e.g., using tpm2-software or other open-source TPM simulators).
  • Offer guidance for installing dependencies and building/running samples on Linux/macOS (e.g., using gcc/clang, CMake, Maven, npm, etc. on those platforms).
  • Avoid assuming Visual Studio or Windows-specific tools are required; clarify when cross-platform alternatives are available.
  • Where possible, use cross-platform language and tools (e.g., 'terminal' instead of 'command prompt', 'editor of your choice' instead of 'Visual Studio').
  • Ensure all code snippets and instructions are tested and validated on Linux/macOS as well as Windows.
GitHub Create Pull Request
IoT Dps https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/iot-dps/how-to-legacy-device-symm-key.md ...main/articles/iot-dps/how-to-legacy-device-symm-key.md
High Priority View Details →
Scanned: 2025-07-13 21:37
Reviewed by: Unknown
Issues: 4 bias types
Detected Bias Types
Windows First Powershell Heavy 🔧 Windows Tools Missing Linux Example
Summary
The documentation demonstrates a Windows-first bias in several areas: Windows-based tools and workflows (Visual Studio, PowerShell, Windows command prompt) are presented as defaults or with more detailed instructions, while Linux alternatives are either referenced externally, presented after Windows, or lack parity in detail. Some sections (notably for C/C#) assume a Windows environment and only briefly mention Linux, often redirecting to external documentation. Windows-specific tools (e.g., Visual Studio, PowerShell) are emphasized, and Linux instructions are sometimes missing or less detailed.
Recommendations
  • Provide Linux and macOS instructions alongside Windows in all language pivots, not just as external references.
  • Avoid language such as 'This tutorial is oriented toward a Windows-based workstation' or, if necessary, ensure equivalent Linux/macOS guidance is present in the same document.
  • For C/C++ development, include explicit Linux build instructions (e.g., using gcc/clang, make, or CMake on Linux) within the main flow, not just as a link.
  • For device key derivation, ensure Linux and macOS examples are as prominent and detailed as Windows/PowerShell ones.
  • Where Windows tools (Visual Studio, PowerShell) are mentioned, provide direct Linux/macOS alternatives (e.g., GCC/Clang, shell scripts) in the same section.
  • Use neutral language in prerequisites and setup steps (e.g., 'On your development machine' instead of 'on your Windows-based machine'), and clarify cross-platform compatibility.
  • Ensure all code samples and command-line instructions are provided for both Windows (cmd/PowerShell) and Linux/macOS (bash/zsh), with clear tabbed or side-by-side presentation.
  • Where possible, avoid requiring Windows-only tools for cross-platform SDKs, or provide equivalent open-source alternatives.
GitHub Create Pull Request
IoT Dps https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/iot-dps/quick-create-simulated-device-symm-key.md ...cles/iot-dps/quick-create-simulated-device-symm-key.md
High Priority View Details →
Scanned: 2025-07-13 21:37
Reviewed by: Unknown
Issues: 4 bias types
Detected Bias Types
Windows First Powershell Heavy 🔧 Windows Tools Missing Linux Example
Summary
The documentation demonstrates a clear Windows bias: instructions and examples are consistently written for Windows environments, with explicit references to Windows tools (Visual Studio, CMD, Git Bash, etc.) and Windows-specific workflows. Linux and macOS alternatives are either mentioned as afterthoughts or deferred to external documentation, and there are no concrete, step-by-step Linux shell examples. Environment setup, build, and run instructions are all Windows-centric, and the use of Windows command prompts and tools is pervasive.
Recommendations
  • Provide parallel Linux (and macOS) instructions alongside Windows steps, including shell commands (bash) for cloning, building, and running samples.
  • List Linux prerequisites (e.g., gcc, make, cmake, mono/dotnet, openjdk, python3, pip, etc.) explicitly in the prerequisites section, not just as a link to external documentation.
  • For each programming language, include Linux-specific build and run commands (e.g., using make/gcc for C, dotnet on Linux, npm/node, python3, mvn/java) and clarify any differences in environment variable syntax (export vs set).
  • When referencing tools like Visual Studio, also mention and provide instructions for Linux alternatives (e.g., gcc/g++, VS Code, CLion, etc.).
  • Avoid phrases like 'on your Windows-based machine' unless the instructions are truly Windows-only; otherwise, use neutral language or provide both OS options.
  • Include screenshots or terminal output from Linux environments where possible, not just Windows.
  • If certain steps are only possible on Windows, clearly state this and provide workarounds or alternatives for Linux/macOS users.
GitHub Create Pull Request
IoT Dps https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/iot-dps/quick-create-simulated-device-x509.md ...articles/iot-dps/quick-create-simulated-device-x509.md
High Priority View Details →
Scanned: 2025-07-13 21:37
Reviewed by: Unknown
Issues: 4 bias types
Detected Bias Types
Windows First Missing Linux Example 🔧 Windows Tools Powershell Heavy
Summary
The documentation demonstrates a clear Windows bias: it is explicitly written for a Windows environment, with Windows-specific tools (Visual Studio, Windows command prompt, Git Bash for Windows, winpty), and Windows instructions always presented first or exclusively. Linux and macOS are only referenced as alternatives, often via links to external SDK documentation, and not given equal, inline treatment. In many sections, only Windows command-line examples are shown, or the Linux equivalents are relegated to secondary tabs or notes. Some steps (e.g., opening Visual Studio, using Windows command prompt) have no direct Linux equivalent described, and the overall workflow assumes a Windows user.
Recommendations
  • Provide Linux (and macOS) instructions and examples inline, not just as links or secondary tabs. For each step, show both Windows and Linux commands side-by-side.
  • Avoid assuming the use of Windows-specific tools (e.g., Visual Studio) as the default; instead, offer cross-platform alternatives (e.g., GCC/Clang, VS Code, or JetBrains IDEs).
  • Where Git Bash or winpty is used for Windows, clarify the native Linux equivalent (plain Bash, no winpty needed).
  • For environment setup, give equal detail for Linux (package managers, build tools, etc.), not just refer to SDK docs.
  • In all code and command examples, present both Windows and Linux syntax, and avoid Windows-only command prompt instructions.
  • Consider restructuring the quickstart to have parallel sections for Windows and Linux/macOS, or use clear pivots/tabs for each OS, ensuring parity in depth and clarity.
GitHub Create Pull Request
IoT Dps https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/iot-dps/concepts-device-oem-security-practices.md ...cles/iot-dps/concepts-device-oem-security-practices.md
High Priority View Details →
Scanned: 2025-07-12 23:44
Reviewed by: Unknown
Issues: 3 bias types
Detected Bias Types
Windows First 🔧 Windows Tools Missing Linux Example
Summary
The documentation demonstrates subtle Windows bias by referencing Windows-specific features (such as the Windows certificate store) and highlighting TPM support as standard on Windows devices. There are no explicit Linux or cross-platform examples, nor are Linux equivalents (e.g., Linux certificate stores, TPM support on Linux) mentioned. The only OS-specific references are to Windows, and no command-line or tooling examples are provided for Linux environments.
Recommendations
  • When mentioning the Windows certificate store, also mention Linux equivalents such as /etc/ssl/certs, PKCS#11 modules, or common Linux certificate management practices.
  • Note that TPM support is available on many Linux distributions, and reference relevant Linux TPM tools (e.g., tpm2-tools) and libraries.
  • Provide examples or references for certificate installation and management on both Windows and Linux platforms.
  • When discussing device manufacturing and provisioning, include OS-agnostic language or explicitly address both Windows and Linux workflows.
  • If mentioning software tools for certificate installation or quality checks, suggest or link to cross-platform or Linux-compatible tools.
  • Consider adding a section or callout that addresses cross-platform considerations and best practices for both Windows and Linux device manufacturers.
GitHub Create Pull Request
IoT Dps https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/iot-dps/quick-create-simulated-device-tpm.md .../articles/iot-dps/quick-create-simulated-device-tpm.md
High Priority View Details →
Scanned: 2025-07-12 23:44
Reviewed by: Unknown
Issues: 4 bias types
Detected Bias Types
Windows First Missing Linux Example 🔧 Windows Tools Powershell Heavy
Summary
The documentation page exhibits a strong Windows bias. It consistently assumes a Windows development environment, especially in the C and C# sections, with prerequisites and instructions focused on Windows-only tools (e.g., Visual Studio, .NET Core on Windows, Simulator.exe). Linux and macOS alternatives are only briefly referenced via external links, and there are no inline, step-by-step instructions or examples for those platforms. The use of Windows command prompts and references to Windows-specific executables further reinforce this bias. There is also a lack of parity in providing Linux/macOS-specific build and run instructions, and troubleshooting tips are Windows-centric.
Recommendations
  • Provide explicit, inline instructions for Linux and macOS environments for each supported language, not just links to external SDK docs.
  • Include Linux/macOS equivalents for all Windows-specific tools (e.g., suggest GCC/Clang and CMake for C, Mono or .NET Core for C#, and how to run the TPM simulator on non-Windows platforms).
  • Show examples of building and running the TPM simulator and SDK samples on Linux/macOS, including terminal commands and any required dependencies.
  • Avoid assuming Visual Studio or Windows command prompts as the default; offer cross-platform alternatives (e.g., VS Code, JetBrains Rider, or CLI-based workflows).
  • List prerequisites for all major platforms in the main documentation, not just in external links.
  • Where troubleshooting is discussed, include common issues and solutions for Linux/macOS users.
GitHub Create Pull Request
IoT Dps https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/iot-dps/quick-enroll-device-x509.md ...blob/main/articles/iot-dps/quick-enroll-device-x509.md
High Priority View Details →
Scanned: 2025-07-12 23:44
Reviewed by: Unknown
Issues: 4 bias types
Detected Bias Types
Windows First Powershell Heavy Missing Linux Example 🔧 Windows Tools
Summary
The documentation demonstrates a Windows bias in several ways: Windows is explicitly referenced as the development environment in multiple places, with instructions such as 'Open a Windows command prompt' and references to Windows-based machines. While some steps mention that they work on both Windows and Linux, the article consistently uses Windows as the example environment, and Linux-specific instructions or clarifications are missing or minimal. Some tooling and scripting examples (such as using Git Bash or sed) are presented, but the overall flow and sample commands are Windows-centric, and Linux users are left to infer how to adapt steps. There are also references to Windows tools and patterns (e.g., registry for secrets, Windows command prompt), and Linux equivalents are not given or are only mentioned as an afterthought.
Recommendations
  • Provide explicit Linux and macOS instructions and command-line examples alongside Windows ones, especially for steps like creating projects, running commands, and editing files.
  • Avoid phrases like 'Open a Windows command prompt'—instead, use neutral language such as 'Open a terminal' and specify differences in sub-sections if needed.
  • When referencing tools (e.g., storing secrets in the registry), mention Linux/macOS equivalents (such as environment variables or configuration files).
  • Ensure that all code and command-line snippets are provided in both Windows (cmd/PowerShell) and Linux/macOS (bash/sh) formats where syntax differs.
  • For certificate creation and manipulation, provide clear instructions for both Windows and Linux users, including any OS-specific prerequisites or tool usage.
  • Where screenshots or UI steps are shown, clarify any OS-specific differences or note that the portal experience is OS-agnostic.
  • Review all references to 'Windows-based machine' and replace with 'development machine' or similar neutral terms, specifying OS only where necessary.
GitHub Create Pull Request
IoT Dps https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/iot-dps/quick-enroll-device-tpm.md .../blob/main/articles/iot-dps/quick-enroll-device-tpm.md
High Priority View Details →
Scanned: 2025-07-12 23:44
Reviewed by: Unknown
Issues: 3 bias types
Detected Bias Types
Windows First Powershell Heavy Missing Linux Example
Summary
The documentation consistently assumes or prioritizes Windows as the development environment, especially in the C# and Java sections. Instructions such as 'Open a Windows command prompt' are given without Linux equivalents, and there is no mention of Linux-specific steps or terminal usage. While some commands (like dotnet and npm) are cross-platform, the narrative and explicit instructions are Windows-centric. There are no PowerShell-specific commands, but the use of 'Windows command prompt' and lack of Linux terminal references indicate a Windows-first bias. Linux users are left to infer how to adapt the steps.
Recommendations
  • Explicitly state that all steps are cross-platform where applicable, and provide parallel instructions for Linux (e.g., 'Open a terminal window' instead of 'Open a Windows command prompt').
  • Where commands differ between Windows and Linux (such as path separators or shell commands), provide both versions or use cross-platform syntax.
  • Include screenshots or notes for Linux environments, especially when referencing file paths or environment variables.
  • Avoid language that assumes Windows as the default (e.g., 'on your Windows-based machine'); instead, use 'on your development machine' and clarify OS-specific differences as needed.
  • For Java and C# sections, mention that the SDKs and tools work on Linux and provide any necessary installation or usage notes for Linux users.
GitHub Create Pull Request
IoT Dps https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/iot-dps/quick-create-simulated-device-symm-key.md ...cles/iot-dps/quick-create-simulated-device-symm-key.md
High Priority View Details →
Scanned: 2025-07-12 23:44
Reviewed by: Unknown
Issues: 4 bias types
Detected Bias Types
Windows First Powershell Heavy 🔧 Windows Tools Missing Linux Example
Summary
The documentation page demonstrates a clear Windows bias. It repeatedly refers to 'your Windows machine' and assumes a Windows-based development environment by default. Instructions and examples are consistently given for Windows first, with Linux or macOS alternatives only mentioned as afterthoughts or via external links. Tooling and workflow references (e.g., Visual Studio, Visual Studio Command Prompt, .cmd scripts, use of 'set' for environment variables, and Windows-style paths) are Windows-centric. There is a lack of explicit, in-place Linux command examples (e.g., for environment variables, building, or running samples), and Linux users are often redirected to other documentation rather than being served directly in the main flow.
Recommendations
  • Provide parallel Linux/macOS instructions and examples alongside Windows instructions, not just as external links or afterthoughts.
  • Include Linux/macOS-specific commands for setting environment variables (e.g., 'export' instead of 'set'), running builds, and executing samples.
  • Mention cross-platform tools (e.g., VS Code, gcc/clang, make) as alternatives to Windows-only tools like Visual Studio.
  • Use neutral language such as 'your development machine' instead of 'your Windows machine' unless the step is truly Windows-specific.
  • Show file paths and command-line examples in both Windows and Unix formats where appropriate.
  • Where possible, avoid referencing Windows-only shells (e.g., 'command prompt', 'Git CMD') as the default; instead, mention Bash or terminal generically.
  • Ensure that all code and workflow steps are validated and documented for Linux/macOS environments, not just Windows.
GitHub Create Pull Request
IoT Dps https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/iot-dps/how-to-legacy-device-symm-key.md ...main/articles/iot-dps/how-to-legacy-device-symm-key.md
High Priority View Details →
Scanned: 2025-07-12 23:44
Reviewed by: Unknown
Issues: 4 bias types
Detected Bias Types
Windows First Powershell Heavy 🔧 Windows Tools Missing Linux Example
Summary
The documentation demonstrates a Windows-first bias, with Windows tools and workflows (Visual Studio, PowerShell, Windows command prompt) presented as the default or primary approach. Linux alternatives are mentioned but often as secondary, less detailed, or referenced externally. Some programming language setup instructions are Windows-centric, and Linux-specific guidance is sometimes relegated to links or brief notes. PowerShell and Windows command prompt are used for examples, while Linux equivalents are less prominent or missing in some sections.
Recommendations
  • Present Linux and Windows instructions in parallel, giving equal prominence to both platforms in all sections.
  • For each command-line example (e.g., cloning repos, setting environment variables), provide both Windows (cmd/PowerShell) and Linux (bash) syntax side by side.
  • In the prerequisites and setup sections, explicitly list Linux (and macOS, if supported) requirements and installation steps, not just as links but with inline instructions.
  • Avoid language like 'This tutorial is oriented toward a Windows-based workstation'—instead, state that the tutorial supports both Windows and Linux, and structure content accordingly.
  • For programming language pivots, ensure Linux build/run instructions are as detailed as Windows ones (e.g., for C, include gcc/make/CMake on Linux, not just Visual Studio).
  • Where PowerShell is used for key derivation, provide a bash/openssl equivalent with equal detail and explanation.
  • Ensure all screenshots and UI walkthroughs are platform-neutral or provide Linux equivalents where applicable.
  • Review all sections for implicit Windows assumptions (e.g., file paths, tool names) and provide cross-platform alternatives.
GitHub Create Pull Request
IoT Dps https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/iot-dps/tutorial-custom-hsm-enrollment-group-x509.md ...s/iot-dps/tutorial-custom-hsm-enrollment-group-x509.md
High Priority View Details →
Scanned: 2025-07-12 23:44
Reviewed by: Unknown
Issues: 4 bias types
Detected Bias Types
Windows First Powershell Heavy 🔧 Windows Tools Missing Linux Example
Summary
The documentation demonstrates a strong Windows bias. All code and command-line examples are presented using Windows tools (cmd, Visual Studio, Windows command prompt), with explicit instructions for Windows environments. Linux and macOS users are repeatedly referred to external SDK documentation, rather than being provided with equivalent, inline instructions or examples. Windows-specific tools (Visual Studio, certmgr.msc, .pfx files, etc.) are mentioned and used exclusively or before any mention of cross-platform or Linux alternatives. In several sections, only Windows command-line syntax is shown, and Linux equivalents are omitted.
Recommendations
  • For each programming language, provide explicit, step-by-step Linux (and macOS, if possible) instructions and examples alongside the Windows ones, rather than referring users to external SDK documentation.
  • Include Linux/macOS command-line equivalents (e.g., bash, sh) for all git, build, and environment variable commands, not just Windows cmd.
  • When referencing tools like Visual Studio or certmgr.msc, also mention and provide instructions for common Linux alternatives (e.g., gcc/clang, OpenSSL, update-ca-certificates, etc.).
  • For certificate management, show how to import certificates into Linux trust stores (e.g., using update-ca-certificates or manual copying to /usr/local/share/ca-certificates) as well as Windows certificate store.
  • For .NET, Node.js, Python, and Java, provide sample commands for running and building on Linux (e.g., dotnet, npm, python, mvn) and note any OS-specific differences.
  • Where environment variables are set (e.g., set VAR=val in cmd), also show the export VAR=val syntax for bash.
  • Add a 'Platform differences' or 'Linux/macOS instructions' callout in each major section, especially where Windows-specific steps are described.
  • Ensure all file paths and command syntax are shown in both Windows (\) and Unix (/) formats.
GitHub Create Pull Request
IoT Dps https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/iot-dps/concepts-device-oem-security-practices.md ...cles/iot-dps/concepts-device-oem-security-practices.md
High Priority View Details →
Scanned: 2025-07-08 04:23
Reviewed by: Unknown
Issues: 3 bias types
Detected Bias Types
Windows First 🔧 Windows Tools Missing Linux Example
Summary
The documentation demonstrates a subtle Windows bias by referencing Windows-specific features and tools before or instead of their Linux equivalents. For example, the Windows certificate store is mentioned as a storage location for certificates, but no Linux alternatives (such as OpenSSL, PKCS#11, or Linux certificate stores) are discussed. TPM support is highlighted as being standard on Windows devices, with no mention of Linux TPM support or tooling. There are no concrete examples or guidance for Linux-based manufacturing environments, and no Linux command-line or tool references are provided.
Recommendations
  • When mentioning certificate storage, include Linux equivalents such as OpenSSL, PKCS#11 modules, or Linux system certificate stores alongside the Windows certificate store.
  • When discussing TPM integration, note that Linux has robust TPM 2.0 support (e.g., tpm2-tools, tpm2-tss) and provide links or references to relevant Linux documentation.
  • Provide example workflows or tool recommendations for both Windows and Linux environments, especially for certificate installation and TPM management.
  • Avoid phrasing that implies Windows is the default or only supported platform (e.g., 'TPMs are included as standard hardware on many Windows devices') and instead acknowledge cross-platform support.
  • Add Linux-specific guidance or examples wherever Windows-specific tools or features are mentioned.
GitHub Create Pull Request
IoT Dps https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/iot-dps/how-to-legacy-device-symm-key.md ...main/articles/iot-dps/how-to-legacy-device-symm-key.md
High Priority View Details →
Scanned: 2025-07-08 04:23
Reviewed by: Unknown
Issues: 4 bias types
Detected Bias Types
Windows First Powershell Heavy 🔧 Windows Tools Missing Linux Example
Summary
The documentation demonstrates a Windows-first bias throughout. Windows-specific tools (Visual Studio, PowerShell) are mentioned before or instead of Linux equivalents, and setup instructions often assume a Windows environment. While some Linux alternatives are referenced, they are often secondary or require following external links. Several code and command examples default to Windows command prompts or tools, with Linux instructions either missing, less detailed, or presented after Windows instructions.
Recommendations
  • Present Linux and Windows instructions in parallel, giving equal prominence to both platforms.
  • For each prerequisite or setup step, provide explicit Linux (and macOS, if relevant) instructions alongside Windows instructions, rather than referring users to external documentation.
  • When mentioning tools like Visual Studio, also mention common Linux IDEs or build systems (e.g., GCC, Clang, VS Code) and provide equivalent setup steps.
  • For command-line examples, show both Windows (cmd/PowerShell) and Linux (bash) commands side by side, using tabbed or clearly separated sections.
  • Avoid language that frames Windows as the default or primary environment (e.g., 'This tutorial is oriented toward a Windows-based workstation'), or balance it with an explicit statement of Linux parity.
  • Ensure all code samples and build/run instructions are fully documented for both Windows and Linux, including environment variable setup, build commands, and troubleshooting tips.
  • Where possible, use cross-platform tools (e.g., Azure CLI, Git Bash, VS Code) and highlight their use to minimize OS-specific dependencies.
GitHub Create Pull Request
IoT Dps https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/iot-dps/iot-dps-understand-ip-address.md ...main/articles/iot-dps/iot-dps-understand-ip-address.md
High Priority View Details →
Scanned: 2025-07-08 04:23
Reviewed by: Unknown
Issues: 3 bias types
Detected Bias Types
Windows First Powershell Heavy Missing Linux Example
Summary
The documentation page references both Azure CLI and PowerShell when discussing connectivity issues and firewall rules, but does not mention or provide examples for Linux-native tools or workflows. PowerShell is called out alongside Azure CLI, which can be used on both Windows and Linux, but the explicit mention of PowerShell (a Windows-first tool) without mentioning Bash or other Linux shells suggests a Windows-centric bias. There are no Linux-specific examples or references to Linux firewall tools (e.g., iptables, ufw), and the guidance assumes familiarity with Windows tools and patterns.
Recommendations
  • Include explicit references to Linux-native tools and workflows (e.g., Bash, iptables, ufw) alongside PowerShell and Azure CLI.
  • When mentioning PowerShell, also mention Bash or other common Linux shells to ensure parity.
  • Provide example commands for both Windows (PowerShell) and Linux (Bash) environments when discussing firewall configuration or automation.
  • Clarify that Azure CLI is cross-platform and provide usage examples in both Windows and Linux contexts.
  • Avoid listing PowerShell before Linux alternatives unless there is a clear reason to do so.
GitHub Create Pull Request
IoT Dps https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/iot-dps/quick-create-simulated-device-tpm.md .../articles/iot-dps/quick-create-simulated-device-tpm.md
High Priority View Details →
Scanned: 2025-07-08 04:23
Reviewed by: Unknown
Issues: 4 bias types
Detected Bias Types
Windows First Powershell Heavy 🔧 Windows Tools Missing Linux Example
Summary
The documentation demonstrates a clear Windows bias. It assumes a Windows development environment by default, provides detailed instructions and tooling references (e.g., Visual Studio, .exe simulators, Windows-specific command prompts) primarily for Windows, and often omits or relegates Linux/macOS instructions to external links. Many code/build/run steps reference Windows tools or paths, and Linux equivalents are not provided inline or are only referenced indirectly.
Recommendations
  • Provide explicit, inline instructions for Linux and macOS environments alongside Windows steps, not just as external links.
  • Include Linux/macOS equivalents for all Windows-specific tools (e.g., Visual Studio alternatives, .exe simulator alternatives, command-line instructions using bash/zsh).
  • When referencing command prompts, include bash/zsh examples and clarify which commands are cross-platform.
  • Ensure that all code samples and build instructions are tested and documented for Linux/macOS, including any required dependencies or environment setup.
  • Avoid assuming the use of Windows-only features or tools (e.g., .exe files, Visual Studio) without providing alternatives.
  • Where possible, use platform-agnostic language and tooling, or clearly indicate platform-specific requirements in each section.
GitHub Create Pull Request
IoT Dps https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/iot-dps/quick-create-simulated-device-symm-key.md ...cles/iot-dps/quick-create-simulated-device-symm-key.md
High Priority View Details →
Scanned: 2025-07-08 04:23
Reviewed by: Unknown
Issues: 4 bias types
Detected Bias Types
Windows First Powershell Heavy 🔧 Windows Tools Missing Linux Example
Summary
The documentation demonstrates a clear Windows bias. It repeatedly refers to 'your Windows machine' and assumes a Windows development environment by default. Instructions and examples prioritize Windows tools (Visual Studio, CMD, Git Bash, etc.), and environment setup steps are Windows-centric. Linux and macOS are only mentioned as alternatives, often with links out to other documentation rather than inline parity. Command-line instructions use Windows syntax (cmd, set) and do not provide Linux equivalents (bash, export, etc.). Visual Studio is emphasized for C/C++ development, with only a brief mention of Linux/macOS alternatives. There are no explicit Linux/macOS command examples or screenshots, and the initial framing and prerequisites are Windows-first.
Recommendations
  • Provide parallel Linux/macOS instructions and examples alongside Windows ones, including shell commands (e.g., use both 'set' and 'export' for environment variables).
  • Include explicit instructions for installing prerequisites (e.g., compilers, SDKs) on Linux/macOS, not just links to external setup guides.
  • Offer build and run instructions for Linux/macOS environments (e.g., using gcc/clang, make, or cmake with Unix Makefiles, and running from bash/zsh).
  • Add Linux/macOS screenshots where appropriate, or clarify when steps are identical across platforms.
  • Avoid language that assumes Windows as the default (e.g., 'on your Windows machine'); instead, use neutral phrasing or mention all supported OSes.
  • For Visual Studio-specific steps, provide equivalent instructions for common Linux IDEs (e.g., VS Code, CLion) or command-line workflows.
  • Ensure all code snippets and commands are cross-platform, or provide platform-specific tabs/pivots.
GitHub Create Pull Request
IoT Dps https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/iot-dps/quick-enroll-device-tpm.md .../blob/main/articles/iot-dps/quick-enroll-device-tpm.md
High Priority View Details →
Scanned: 2025-07-08 04:23
Reviewed by: Unknown
Issues: 3 bias types
Detected Bias Types
Windows First Powershell Heavy Missing Linux Example
Summary
The documentation repeatedly assumes or prioritizes Windows as the development environment, particularly in the .NET and Java sections. Instructions such as 'Open a Windows command prompt' are given, and there are no explicit Linux or cross-platform command-line instructions, even though the SDKs and tools are available for Linux. There is a lack of Linux-specific guidance or parity in setup and execution steps, and Windows terminology is used by default.
Recommendations
  • Provide explicit Linux (and macOS) instructions alongside Windows for all command-line steps, including terminal commands and environment setup.
  • Replace phrases like 'Open a Windows command prompt' with 'Open a terminal window' or provide both Windows and Linux/macOS alternatives.
  • Where commands differ (e.g., path separators, shell syntax), show both Windows (cmd) and Linux/macOS (bash/sh) examples.
  • Clarify that the SDKs and samples work cross-platform, and ensure that all prerequisites and steps are validated on Linux.
  • For Java and .NET, include Linux-specific notes for installing dependencies and running samples, such as using apt, yum, or Homebrew.
  • Avoid assuming the user is on Windows unless the SDK or tool is truly Windows-only.
GitHub Create Pull Request
IoT Dps https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/iot-dps/quick-enroll-device-x509.md ...blob/main/articles/iot-dps/quick-enroll-device-x509.md
High Priority View Details →
Scanned: 2025-07-08 04:23
Reviewed by: Unknown
Issues: 3 bias types
Detected Bias Types
Windows First Missing Linux Example 🔧 Windows Tools
Summary
The documentation exhibits a Windows bias by consistently referencing Windows environments first or exclusively, especially in prerequisites and sample instructions. Several steps explicitly instruct users to use a Windows command prompt, and some certificate creation links and instructions default to Windows-specific tabs or tools. There are missing or unclear instructions for Linux users, particularly regarding command-line environments and tool usage. While some sections mention Linux compatibility, practical Linux-specific guidance is lacking.
Recommendations
  • For all command-line instructions (e.g., creating projects, running samples), provide both Windows (cmd/PowerShell) and Linux/macOS (bash/sh) equivalents, or clarify when commands are cross-platform.
  • In prerequisites, avoid specifying 'Windows-based machine' unless truly required. Instead, list requirements for both Windows and Linux/macOS, and clarify when steps differ.
  • When linking to certificate creation tutorials, ensure that both Windows and Linux tabs are referenced or provide a neutral link, not just the Windows tab.
  • In sample creation steps, avoid phrases like 'Open a Windows command prompt.' Instead, use 'Open a terminal window' and specify differences if necessary.
  • For Java and Node.js sections, clarify that the samples can be run on Linux/macOS as well, and provide any necessary adjustments (e.g., path syntax, shell commands).
  • Where Git Bash or similar tools are referenced, explain their relevance for both Windows and Linux users, and suggest native alternatives for Linux.
  • Add explicit Linux/macOS examples for certificate manipulation (e.g., using openssl, sed, etc.), and clarify any OS-specific nuances.
  • Review all screenshots and UI instructions to ensure they are not Windows-specific, or provide Linux/macOS equivalents where the Azure portal UI differs.
GitHub Create Pull Request
IoT Dps https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/iot-dps/tutorial-custom-allocation-policies.md ...rticles/iot-dps/tutorial-custom-allocation-policies.md
High Priority View Details →
Scanned: 2025-07-08 04:23
Reviewed by: Unknown
Issues: 3 bias types
Detected Bias Types
Windows First Powershell Heavy Missing Linux Example
Summary
The documentation exhibits a Windows bias by prioritizing Windows-specific tools (Visual Studio), providing detailed instructions for Windows environments first, and only referencing Linux or macOS alternatives via external links. PowerShell and Windows command prompt examples are given alongside Bash, but the development environment setup and simulation steps are heavily oriented toward Windows/Visual Studio, with Linux instructions deferred or omitted.
Recommendations
  • Provide step-by-step instructions for setting up the development environment and building/running the Azure IoT C SDK on Linux (e.g., using gcc, make, cmake, and VS Code or other editors).
  • Include Linux/macOS command-line examples (e.g., bash, sh) alongside Windows/PowerShell/cmd examples throughout the tutorial, not just for environment variable setup.
  • Offer explicit guidance for running and debugging the simulated device sample on Linux, including how to build and execute the sample without Visual Studio.
  • Reference Linux prerequisites (e.g., gcc, make, cmake, git) directly in the prerequisites section, not only via external links.
  • Where UI steps are described (e.g., Azure Portal), note any differences for Linux users if applicable, or confirm parity.
  • Ensure that all critical steps (such as building, running, and troubleshooting the sample) are fully documented for both Windows and Linux users within the main tutorial, not just in linked resources.
GitHub Create Pull Request
IoT Dps https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/iot-dps/quick-create-simulated-device-x509.md ...articles/iot-dps/quick-create-simulated-device-x509.md
High Priority View Details →
Scanned: 2025-07-08 04:23
Reviewed by: Unknown
Issues: 4 bias types
Detected Bias Types
Windows First Powershell Heavy 🔧 Windows Tools Missing Linux Example
Summary
The documentation exhibits a strong Windows bias: instructions and examples are consistently presented for Windows first, often exclusively referencing Windows tools (e.g., Visual Studio, Windows command prompt, Git Bash on Windows). Linux and macOS users are repeatedly referred out to SDK documentation or alternate tutorials, and step-by-step parity is lacking. Even when Linux commands are shown, they are secondary to Windows, and the overall workflow assumes a Windows-centric development environment.
Recommendations
  • Provide full, step-by-step instructions for Linux (and macOS) alongside Windows in each section, not just links to external SDK setup guides.
  • Present Linux and Windows instructions in parallel (e.g., using tabs or clear subsections), ensuring equal prominence and completeness.
  • Include Linux-native toolchain examples (e.g., gcc, make, standard Bash) rather than focusing on Visual Studio and Windows command prompt.
  • Avoid assuming the use of Git Bash on Windows as a substitute for a real Linux shell; provide native Linux shell instructions.
  • Ensure all code samples, environment variable setups, and build/run instructions are fully documented for Linux, not just Windows.
  • Where Windows-specific tools are mentioned (e.g., Visual Studio), provide Linux equivalents (e.g., VS Code, CLion, or command-line tools) with equal detail.
  • Consider adding a Linux/macOS quickstart page or a unified cross-platform quickstart with clear pivots for each OS.
GitHub Create Pull Request
← Previous Page 2 of 5 Next →