How to type a long dash mastering precise typography techniques

Table of Contents
- Technical Differences and Usage of the Long Dash (Em Dash) in Typography
- Characteristics and Unicode Values of Dash Variants
- Visual Distinction of Dashes in Monospace Fonts
- Manual Typing Methods for the Long Dash (Em Dash)
- Keyboard Shortcuts for Em Dash Insertion
- Alt Code Method for Windows
- Alternative Input Methods for Em Dash
- Software and Tool-Based Solutions for Long Dash (Em Dash) Insertion
- Configuring Long Dash Insertion in Word Processors
- Third-Party Tools and Browser Extensions for Long Dash Automation
- Troubleshooting Common Issues
- Programming and Code Implementation of the Long Dash (Em Dash)
- HTML and CSS Methods for Long Dash Insertion
- Markdown Rendering of Long Dashes
- Programmatic Replacement of Hyphens with Em Dashes
- Replace 2+ hyphens with em dash, preserve single hyphens
- Typography and Stylistic Use Cases of the Long Dash (Em Dash)
- Visual Impact in Headings, Body Text, and UI Design
- Spacing Rules and Em Quad Justification
- Common Misuse and Corrections in Professional Writing
- Case Studies: Em Dash in High-Impact Design
- Troubleshooting and Common Errors in Long Dash (Em Dash) Usage
- Five Common Mistakes and Their Corrections
- Debugging Long Dash Rendering Issues in Web Browsers
The long dash (—) serves as a powerful punctuation tool, bridging ideas with clarity while distinguishing it from hyphens and en dashes in both written and digital communication. Whether used in formal documents, creative writing, or technical manuals, its correct application enhances readability and professionalism. This guide explores the technical distinctions between dash variants, manual and automated insertion methods, and best practices for typographic consistency across platforms. From keyboard shortcuts to code implementation, understanding these nuances ensures precision in every medium.
Misusing dashes—whether through incorrect spacing, wrong Unicode input, or platform inconsistencies—can undermine credibility and disrupt visual flow. By mastering insertion techniques, troubleshooting common errors, and adhering to stylistic guidelines, users can elevate their typography skills for both print and digital environments. The following sections dissect each method, providing actionable steps and comparative analyses to demystify the process.

Technical Differences and Usage of the Long Dash (Em Dash) in Typography
The long dash, commonly referred to as the em dash (—), is a punctuation mark used to denote a break in sentence structure, often replacing commas, parentheses, or colons for emphasis or clarity. Unlike its shorter counterparts—the hyphen (-) and en dash (–)—its length spans the width of a capital letter "M" in a given font, hence its name. Understanding the distinctions between these three symbols is critical for precise typography, as incorrect usage can lead to ambiguity or misinterpretation in written communication. This section explores their technical specifications, visual differentiation, and practical applications through structured comparisons and typographic guidelines.
Characteristics and Unicode Values of Dash Variants
The hyphen, en dash, and em dash serve distinct functions in typography, each with unique Unicode encoding and proportional lengths. Below is a comparison table summarizing their key attributes, including Unicode values, visual representation, and common use cases.
| Symbol | Name | Unicode Value | Common Usage |
|---|---|---|---|
| - | Hyphen (Soft Hyphen) | U+002D (Standard Hyphen) U+00AD (Soft Hyphen, non-breaking) |
|
| – | En Dash | U+2013 (Standard En Dash) |
|
| — | Em Dash | U+2014 (Standard Em Dash) |
|
Note: The Unicode values listed are for the standard characters. Variations such as the horizontal bar (U+2015) or figure dash (U+2012) exist but are less commonly used in modern typography.
Visual Distinction of Dashes in Monospace Fonts
Monospace fonts, such as Courier New, display each character with uniform width, making it easier to visually compare the lengths of the hyphen, en dash, and em dash. Below is a step-by-step guide to identifying these symbols in such fonts, accompanied by examples for clarity.
Importance of Visual Differentiation:
Monospace fonts are frequently used in programming, technical documentation, and legacy systems where precise character representation is critical. Misidentifying dashes in these contexts can lead to syntax errors, formatting issues, or miscommunication. The following examples illustrate how each dash appears in a monospace environment and how to distinguish them based on proportional length.
Step-by-Step Visual Comparison:Practical Exercise for Typographers:
1. Hyphen (-):
Length: Approximately half the width of a lowercase "n" in the same font. Example in Courier New: abcdefghijklmnopqrstuvwxyz^^^^^^^^^^^^^^^^^^^^^^^^^^
(Hyphen width: ~50% of "n")
Use Case: Always the shortest dash, used for word division or compound terms. 2. En Dash (–):
Length: Spans the width of a single lowercase "n" (or uppercase "N" in some fonts). Example in Courier New: abcdefghijklmnopqrstuvwxyz^^^^^^^^^^^^^^^^^^^^^^^^^^
(En dash width: ~100% of "n")
Use Case: Slightly longer than a hyphen, used for ranges or connections between terms. 3. Em Dash (—):
Length: Equivalent to the width of a capital "M" (or uppercase "N" in some fonts). Example in Courier New: MNOPQRSTUVWXYZ^^^^^^^^^^^^
(Em dash width: ~140% of "n")
Use Case: The longest dash, used for sentence breaks or emphasis.
To reinforce visual distinction, type the following sequence in a monospace font and measure the relative lengths:
word-hyphenated–en-dashed—em-dashed
Observe how the spacing between words varies due to the differing lengths of each dash. This exercise helps train the eye to recognize the proportional differences quickly, even in non-monospace fonts where visual cues are less pronounced.Manual Typing Methods for the Long Dash (Em Dash)
The long dash, or em dash, serves as a versatile punctuation mark in typography, offering flexibility in sentence structure and emphasis. Unlike hyphens or en dashes, it functions independently of spacing rules and is widely used in formal writing, technical documentation, and design layouts. Mastering its manual insertion across different operating systems ensures consistency and professionalism in digital and printed media.Keyboard shortcuts and alternative input methods vary by platform and application, requiring precise execution to avoid typographical errors. Below are structured techniques for generating the em dash (Unicode U+2014) efficiently, alongside compatibility tables for cross-platform use.
Keyboard Shortcuts for Em Dash Insertion
Operating systems and applications often provide dedicated shortcuts to insert an em dash, reducing reliance on manual Unicode input. These methods leverage built-in typographic features, ensuring compatibility with most text editors, word processors, and integrated development environments (IDEs).Windows
macOS
Linux (GNOME/KDE)
Note: Shortcuts may vary by application or keyboard layout. Test in the target software to confirm functionality.
Alt Code Method for Windows
The Alt code method is a reliable way to insert the em dash in Windows applications, provided the numeric keypad is used. This technique bypasses font-specific issues and ensures the correct Unicode character is inserted.To generate an em dash using the Alt code:
1. Ensure `Num Lock` is activated on the numeric keypad.
2. Press and hold the `Alt` key.
3. Type the sequence `0151` using the numeric keypad.
4. Release the `Alt` key to insert the em dash (`—`).
Unicode Reference: The em dash corresponds to U+2014 in the Unicode standard, which is the numeric value used in Alt code input.Verification:
Alternative Input Methods for Em Dash
Beyond keyboard shortcuts, several alternative methods exist for inserting an em dash, each with specific use cases in coding, design, and documentation. The following table summarizes these methods, including syntax and compatibility across platforms and applications.| Method | Syntax/Example | Compatibility | Notes |
|---|---|---|---|
| LaTeX | \textendash or --- (with spaces) |
LaTeX compilers (e.g., pdflatex, Overleaf) | Use --- only if the document class supports it; otherwise, \textendash is preferred. |
| HTML Entities | — |
HTML, XML, XHTML, and most web-based editors | Renders as `—` in browsers and WYSIWYG editors. |
| Unicode Paste | Copy `—` from a Unicode source (e.g., browser character map) | All platforms (cross-application) | Risk of font substitution if the source font lacks the glyph. |
| Markdown | --- (with spaces) or — (direct paste) |
Markdown processors (e.g., GitHub, VS Code Preview) | Some parsers (e.g., CommonMark) require explicit — for consistency. |
| Microsoft Word | Ctrl + Alt + - (hyphen) |
Microsoft Word (Windows/macOS) | Automatically adjusts spacing per style settings. |
| Adobe InDesign | Type --- (with spaces) or use the Type > Special Characters menu |
Adobe InDesign (Windows/macOS/Linux) | Spacing may require manual adjustment in paragraph styles. |
Best Practice: For cross-platform consistency, use Unicode (`—`) or HTML entities (`—`) in digital documents. In print design, rely on application-specific shortcuts or manual insertion to maintain typographic integrity.
Software and Tool-Based Solutions for Long Dash (Em Dash) Insertion
The long dash (em dash) is a versatile punctuation mark used to indicate abrupt changes in thought, parenthetical explanations, or emphasis in typography. While manual methods exist, modern word processors and specialized tools streamline its insertion, ensuring consistency and adherence to typographic standards. Below are structured approaches for enabling, configuring, and automating long dash usage across popular software and third-party extensions, tailored for professional and technical writing environments.Configuring Long Dash Insertion in Word Processors
Most professional word processors provide built-in methods to insert long dashes, often through keyboard shortcuts, special character menus, or auto-correction settings. These tools prioritize typographic accuracy by distinguishing between hyphens, en dashes, and em dashes, which are frequently confused due to their similar appearances.Microsoft Word
Microsoft Word offers multiple methods to insert a long dash, including:
Google Docs
Google Docs simplifies long dash insertion through:
LibreOffice Writer
LibreOffice provides robust typographic controls:
AutoCorrect and Typographic Rules
Most modern word processors default to converting repeated hyphens (`--` or `---`) into em dashes. However, users should verify these settings to avoid unintended replacements, particularly in code, URLs, or technical notation where hyphens serve distinct functions.
Third-Party Tools and Browser Extensions for Long Dash Automation
For users requiring advanced typographic control or cross-platform consistency, third-party tools and browser extensions automate long dash insertion and enforce stylistic standards. These solutions are particularly useful in collaborative environments, technical documentation, or multilingual writing.Browser Extensions
Extensions like Grammarly and LanguageTool offer real-time corrections, including hyphen-to-em-dash conversions, with customizable rules:
Desktop Applications
Specialized typography tools provide granular control:
Standalone Typographic Utilities
For batch processing or template-based workflows:
Important Considerations for Tool Selection
When selecting tools for long dash automation, prioritize:
1. Cross-platform compatibility to ensure consistency across operating systems.
2. Customizable rules to avoid over-correction in technical or code contexts.
3. Integration with existing workflows, such as cloud-based collaboration (Google Docs) or version control (Git).
4. Unicode support to guarantee proper rendering in non-Latin scripts (e.g., CJK typography).
Troubleshooting Common Issues
Incorrect Character RenderingSome fonts or systems may display em dashes as en dashes (`–`) due to font substitution. To mitigate:
Keyboard Shortcut Conflicts
Custom shortcuts in word processors may override default em dash assignments. Resolve conflicts by:
AutoCorrect Overrides
Disabling auto-replacement for hyphens in technical documents:
Example Workflow for Technical Writing
For a scientific paper requiring strict em dash usage:
1. Configure Word’s AutoCorrect to replace `---` with `—`.
2. Use `Ctrl` + `Alt` + `0151` for manual insertion in equations or code snippets.
3. Install LanguageTool to enforce consistency in collaborative drafts.
4. Export to PDF via File > Save As > PDF/XPS to preserve typographic integrity.

Programming and Code Implementation of the Long Dash (Em Dash)
The long dash, or em dash, plays a critical role in programming and markup languages, where precise typographic control is essential for readability and semantic accuracy. Developers must account for platform-specific rendering behaviors, encoding standards, and syntax-specific methods to ensure consistent em dash representation. Below are structured approaches for embedding long dashes in HTML, Markdown, and programmatically via scripting languages, along with considerations for cross-platform consistency.HTML and CSS Methods for Long Dash Insertion
HTML and CSS provide multiple ways to insert an em dash (`—`), each with distinct use cases and compatibility considerations. The choice between entity references, Unicode characters, or CSS-generated content depends on context, such as dynamic content generation or static markup.Entity References and Unicode Characters
HTML supports both named and numeric entity references for the em dash, along with direct Unicode insertion. The most reliable methods include:
CSS `content` Property for Generated ContentNamed Entity: `—` (MDASH) Numeric Entity: `—` (decimal) or `—` (hexadecimal) Direct Unicode: `—` (U+2014)
The CSS `content` property enables dynamic insertion of em dashes in pseudo-elements (e.g., `::before`, `::after`), useful for decorative or structural separators. This method is particularly valuable in responsive design where typographic elements must adapt to layout changes.
Example:
```css
.separator::before {
content: "—";
font-size: 1.2em;
padding-right: 0.5em;
}
```
Cross-Browser and Encoding Considerations
Range: —— ```
Markdown Rendering of Long Dashes
Markdown’s handling of long dashes varies by platform due to its lack of standardized em dash support. While some parsers interpret `---` as an em dash, others render it as a literal sequence or convert it to an en dash (`–`). Understanding these differences is critical for documentation, README files, and collaborative writing environments.Platform-Specific Behavior
The following table summarizes how major Markdown processors render `---` and direct Unicode (`—`):
| Platform/Parser | `---` Rendering | `—` Rendering | Notes |
|---|---|---|---|
| GitHub Flavored Markdown (GFM) | En dash (`–`) | Em dash (`—`) | Requires explicit Unicode for em dashes. |
| CommonMark | Literal `---` | Em dash (`—`) | No automatic conversion. |
| Reddit/Slack Markdown | Em dash (`—`) | Em dash (`—`) | Supports `---` as em dash. |
| Typora/Visual Studio Code | Em dash (`—`) | Em dash (`—`) | Customizable via plugins. |
Programmatic Replacement of Hyphens with Em Dashes
Automated text processing often requires converting hyphens (`-`) or en dashes (`–`) to em dashes (`—`) for typographic consistency. Below are code snippets in Python and JavaScript to achieve this using regular expressions, with examples demonstrating input/output transformations.Python Implementation
Python’s `re` module enables pattern-based replacements. The following script replaces sequences of hyphens (e.g., `--`, `---`) with an em dash, while preserving single hyphens for code or lists:
```python
import re
def replace_hyphens_with_em_dash(text):
Replace 2+ hyphens with em dash, preserve single hyphens
pattern = r'(? replacement = lambda m: '—' if len(m.group(0)) >= 2 else m.group(0)return re.sub(r'-{2,}', '—', text)
# Example usage
input_text = "This is a test---with hyphens--and en-dash–but no em-dash."
output_text = replace_hyphens_with_em_dash(input_text)
print(output_text)
```
Output:
```
This is a test—with hyphens—and en-dash—but no em-dash.
```
JavaScript Implementation
JavaScript’s `String.replace()` with a regex supports similar functionality. This snippet handles edge cases like hyphens in URLs or code blocks by excluding them from replacement:
```javascript
function replaceHyphensWithEmDash(text) {
// Replace 2+ hyphens with em dash, skip hyphens in URLs/code
return text.replace(/-(?=[^-]|$)/g, match => {
return match.length >= 2 ? '—' : match;
});
}
// Example usage
const inputText = "File-paths: example--file.txt and ranges (10--20).";
const outputText = replaceHyphensWithEmDash(inputText);
console.log(outputText);
```
Output:
```
File-paths: example—file.txt and ranges (10—20).
```
Key Considerations for Regex-Based Replacement
Typography and Stylistic Use Cases of the Long Dash (Em Dash)
The long dash, or em dash, serves as a versatile punctuation mark capable of conveying emphasis, abrupt transitions, or parenthetical interruptions in typography. Its visual weight and flexibility make it indispensable in headings, body text, and user interface (UI) design, where clarity and hierarchy are critical. Proper application enhances readability, while misuse disrupts visual coherence. This section explores the stylistic impact of the em dash across different contexts, including spacing conventions, typographic best practices, and common errors in professional writing.Visual Impact in Headings, Body Text, and UI Design
The em dash’s role varies significantly depending on the text environment, influencing hierarchy, emphasis, and user experience.Headings and Titles
In headings, the em dash can create visual breaks or highlight key phrases without the formality of colons or parentheses. For example:
Body Text
Within body text, em dashes replace commas, parentheses, or colons to signal abrupt shifts or added emphasis. Examples include:
UI Design (Dashboards, Menus, and Forms)
In UI, em dashes improve scannability and indicate relationships between elements. Consider these scenarios:
Typography Comparison
A visual analysis reveals how spacing and font weight interact with the em dash:
Spacing Rules and Em Quad Justification
Proper spacing around em dashes ensures readability and typographic harmony. The following conventions apply universally:No Spaces Before or After
The em dash functions as a single unit, eliminating the need for spaces. Incorrect:
"This is incorrect— this has spaces." (Disrupts flow.)
Correct:
"This is correct—no spaces here." (Maintains visual continuity.)
Em Quad Justification
An em quad (the width of the current font’s "M") governs spacing in justified text. When using em dashes in justified paragraphs:
p {
text-align: justify;
text-justify: inter-word;
}
```
For precise control, use CSS `` (soft hyphen) or `word-spacing` properties.
Hyphenation Considerations
Avoid hyphenating words adjacent to em dashes unless necessary for line breaks. Example:
Common Misuse and Corrections in Professional Writing
Misapplied em dashes create visual noise or ambiguity. Below are frequent errors and their fixes:Incorrect Spacing
Overuse in Lists or Bullets
Replacing Commas or Parentheses Improperly
UI Design Overuse
Dashboard
├── Metrics
├── Overview
└── Reports
```
Inconsistent Length
Blockquote Example: Key Rule
The em dash should function as a visual punctuation mark, not a structural separator. Its primary role is to interrupt or emphasize, never to replace commas, colons, or bullets without intentional stylistic contrast.
Case Studies: Em Dash in High-Impact Design
Real-world applications demonstrate the em dash’s versatility across industries. Below are analyzed examples:Magazine Headlines (e.g., The New Yorker)
Software Documentation (e.g., Apple’s Human Interface Guidelines)
Academic Writing (e.g., Harvard Business Review)
Mobile App UI (e.g., Duolingo)
Government Reports (e.g., UN Sustainable Development Goals)
Typographic Pitfall: Political Speechwriting
Data Visualization (e.g., Tableau Dashboards)
Troubleshooting and Common Errors in Long Dash (Em Dash) Usage
The proper implementation of the long dash (em dash) is critical for clarity, typographic consistency, and readability in professional writing. However, common mistakes—ranging from incorrect character substitution to rendering issues—can compromise document integrity, particularly in digital and cross-platform environments. Below are systematic approaches to identifying, diagnosing, and resolving these errors, including browser-specific fixes and diagnostic workflows for misrendered characters.Five Common Mistakes and Their Corrections
Incorrect character substitution is the most frequent issue when inserting long dashes, often stemming from keyboard shortcuts or copy-paste inconsistencies. Below are five prevalent errors, their root causes, and verified solutions to ensure accurate em dash usage.Key Principle: The em dash (—) must be distinguished from the en dash (–) and hyphen (-), as each serves distinct typographic roles. Unicode standards enforce strict character encoding (U+2014 for em dash, U+2013 for en dash).
-
Using Hyphens or En Dashes Instead of Em Dashes
Hyphens (-) and en dashes (–) are frequently misapplied in place of em dashes (—), particularly in informal writing or when relying on keyboard shortcuts. This error disrupts punctuation hierarchy and can lead to misinterpretation in technical or legal documents.
- Incorrect: "The report—due Friday—was incomplete." (Hyphen or en dash misused)
- Correct: "The report—due Friday—was incomplete." (Em dash for parenthetical emphasis)
Fix: Replace the character with the actual em dash (Unicode U+2014) via manual input (Alt+0151 on Windows, Option+Shift+Hyphen on macOS) or software tools like Microsoft Word’s "Insert Symbol" feature.
-
Incorrect Unicode Input or Font Fallback Issues
Systems or applications may default to a substitute character (e.g., a question mark or hyphen) when the em dash is unsupported in the active font or encoding. This often occurs in legacy systems, custom web fonts, or non-Unicode environments.
- Symptoms: The em dash renders as "?" or "–" despite correct input.
- Root Cause: Missing font support for the Unicode em dash (U+2014) or CSS `@font-face` fallback misconfiguration.
Fix:
- Verify the font stack in CSS includes a system font with em dash support (e.g., `font-family: Arial, "Helvetica Neue", sans-serif;`).
- Use CSS `font-feature-settings` to enable OpenType features:
font-feature-settings: "kern", "liga", "dlig"; - Fallback to a web-safe font like "DejaVu Sans" or "Noto Sans" if custom fonts fail.
-
Keyboard Shortcut Conflicts or Regional Input Settings
Keyboard shortcuts for em dashes (e.g., `Alt+0151` on Windows, `Option+Shift+Hyphen` on macOS) may not function due to regional input method configurations or conflicting software (e.g., screen readers, accessibility tools). This leads to manual input errors or reliance on incorrect alternatives.
- Example: A user in a German keyboard layout may accidentally trigger an en dash (–) instead of an em dash (—) due to layout conflicts.
Fix:
- Reset keyboard shortcuts to default in system settings (e.g., Windows: "Language & Region" > "Advanced Keyboard Settings").
- Use the Unicode input method (e.g., `Ctrl+Shift+U` followed by `2014` on Windows/Linux) as a universal fallback.
- Test shortcuts in a plain text editor (e.g., Notepad) to isolate software interference.
-
Copy-Paste Contamination from Non-Unicode Sources
Text copied from PDFs, scanned documents, or legacy systems often contains "smart quotes" or substitute characters (e.g., `–` instead of `—`) that corrupt em dash integrity. This is exacerbated when pasting into web forms or CMS platforms lacking validation.
- Symptoms: Em dashes appear as "–" or "‐" (Unicode U+2013/U+2010) after pasting.
Fix:
- Use a text sanitization tool (e.g., Unicode Normalizer) to replace all dashes with the correct em dash.
- Enable "Paste as Plain Text" in applications like Microsoft Word or Google Docs.
- Manually verify critical dashes in the final output using a Unicode character map (e.g., `Ctrl+Shift+U` > `2014`).
-
CSS or HTML Entity Misinterpretation
Developers may inadvertently use HTML entities (`—`) or CSS properties that alter rendering, such as `text-rendering: optimizeLegibility`, which can trigger font substitution. Additionally, inline styles or conflicting CSS rules may override em dash styling.
- Incorrect: `—` (Font lacks em dash support)
- Correct: `—` (Fallback to system font)
Fix:
- Replace HTML entities with direct Unicode input where possible:
—→—(U+2014). - Inspect CSS for `font-family` restrictions and add fallbacks:
font-family: "Noto Sans", "DejaVu Sans", sans-serif; - Disable `text-rendering` optimizations if they interfere with glyph consistency.
Debugging Long Dash Rendering Issues in Web Browsers
Browser inconsistencies, font loading delays, or conflicting CSS can cause em dashes to render incorrectly as hyphens, question marks, or missing characters. Below are structured diagnostic steps, including inspectable HTML/CSS snippets, to resolve these issues.Critical Note: Always test em dash rendering in multiple browsers (Chrome, Firefox, Safari) and devices, as font rendering engines (e.g., HarfBuzz, DirectWrite) handle Unicode differently.
-
Inspecting Font Fallbacks and Substitution
Modern browsers use font fallback chains to replace unsupported glyphs. If an em dash is missing, the browser may substitute a hyphen or a placeholder. Use browser dev tools to diagnose the issue.
- Steps:
- Open DevTools (`F12` or `Ctrl+Shift+I`).
- Select the em dash in the "Elements" tab and inspect its computed styles.
- Check the "Computed" tab for `font-family` and note any fallbacks.
- Verify the "Rendered Font" in the "Font" section of the "Elements" tab.
Example HTML/CSS for Debugging:
This is an em dash—test..debug-dash {
font-family: "CustomFont", "DejaVu Sans", sans-serif;
font-feature-settings: "kern", "dlig";
/ Force fallback testing /
font-variant-ligatures: common-ligatures;
}
Expected Outcome: If the em dash renders as a hyphen, the fallback chain is broken. Add a web-safe font
Mastering the long dash transcends mere punctuation; it reflects attention to detail and adherence to typographic conventions that elevate professional and creative work. From manual keyboard inputs to automated software solutions, the methods outlined here ensure accuracy across devices and platforms. Whether refining a manuscript, designing user interfaces, or coding web content, the correct use of long dashes fosters consistency and polish. By applying these techniques, writers, designers, and developers can eliminate ambiguity, enhance readability, and maintain visual harmony in their projects.
The journey from hyphen confusion to seamless long dash integration begins with awareness and practice. Armed with the knowledge of Unicode values, platform-specific shortcuts, and stylistic best practices, users can navigate typography challenges with confidence. This guide serves as both a reference and a troubleshooting manual, ensuring that every long dash serves its intended purpose—connecting ideas with precision and professionalism.
- Steps:
Leave a Comment
Comments are moderated before appearing. The data you submit is processed according to the Privacy Policy of www.linuxunplugged.com.