Communities

Writing
Writing
Codidact Meta
Codidact Meta
The Great Outdoors
The Great Outdoors
Photography & Video
Photography & Video
Scientific Speculation
Scientific Speculation
Cooking
Cooking
Electrical Engineering
Electrical Engineering
Judaism
Judaism
Languages & Linguistics
Languages & Linguistics
Software Development
Software Development
Mathematics
Mathematics
Christianity
Christianity
Code Golf
Code Golf
Music
Music
Physics
Physics
Linux Systems
Linux Systems
Power Users
Power Users
Tabletop RPGs
Tabletop RPGs
Community Proposals
Community Proposals
tag:snake search within a tag
answers:0 unanswered questions
user:xxxx search by author id
score:0.5 posts with 0.5+ score
"snake oil" exact phrase
votes:4 posts with 4+ votes
created:<1w created < 1 week ago
post_type:xxxx type of post
Search help
Notifications
Mark all as read See all your notifications »
Meta

Welcome to Software Development on Codidact!

Will you help us build our independent community of developers helping developers? We're small and trying to grow. We welcome questions about all aspects of software development, from design to code to QA and more. Got questions? Got answers? Got code you'd like someone to review? Please join us.

Post History

71%
+3 −0
Meta Issue with the Monospace font

What's wrong As Moshi's comment points out, single backticks only work for inline code (code that appears within a paragraph of other text, and contains no line breaks). The following raw text: ...

posted 8mo ago by trichoplax‭  ·  edited 8mo ago by trichoplax‭

Answer
#3: Post edited by user avatar trichoplax‭ · 2024-03-11T13:29:31Z (8 months ago)
Typo
  • ## What's wrong
  • As [Moshi's comment](https://software.codidact.com/comments/thread/9295#comment-23542) points out, single backticks only work for inline code (code that appears within a paragraph of other text, and contains no line breaks).
  • The following raw text:
  • > ```text
  • > A paragraph with `inline code` showing.
  • > ```
  • is rendered as:
  • > A paragraph with `inline code` showing.
  • However, adding a line break[^1] stops the single backticks from being recognised as inline code. The following raw text:
  • > ```text
  • > A paragraph with `inline
  • >
  • > code` showing.
  • > ```
  • is not rendered as code:
  • > A paragraph with `inline
  • >
  • > code` showing.
  • ## How to fix it
  • In Markdown, a code block uses three or more backticks and allows line breaks for multiple lines of code. The following raw text:
  • > ````text
  • > ```
  • > Multiple
  • > lines of
  • > code now
  • > ```
  • > ````
  • renders as:
  • > ```text
  • > Multiple
  • > lines of
  • > code now
  • > ```
  • In nearly all cases you will only need 3 backticks. More can be used for those cases where you need to post a code block that itself contains 3 backticks. You can edit this post to see an example of 4 backticks for this reason.
  • In this particular case, you can also apply syntax highlighting by adding the name of the programming language on the same line as the opening backticks:
  • ````text
  • ```python
  • for line in file:
  • print(line)
  • ```
  • ````
  • renders as:
  • ```python
  • for line in file:
  • print(line)
  • ```
  • ## Why it only looked half wrong
  • If the code has simply failed to render as code anywhere, it might have been easier to see that the Markdown syntax was incorrect. However, as you noticed, part of the code was rendered correctly, which is confusing.
  • The reason for this is that there is an alternative method of indicating a code block in Markdown: text with 4 or more leading spaces is treated as code.
  • So the single backtick was ignored, due to having no closing backtick on the same line, but all of the code after the first level of indentation was displayed with code formatting.
  • [^1]: Technically 2 line breaks are required to cause this problem, since in Markdown a single line break is converted to a space. In many code blocks double line breaks will be present, and in those with none the code block will still look incorrect as it will display on one line instead of several.
  • ## What's wrong
  • As [Moshi's comment](https://software.codidact.com/comments/thread/9295#comment-23542) points out, single backticks only work for inline code (code that appears within a paragraph of other text, and contains no line breaks).
  • The following raw text:
  • > ```text
  • > A paragraph with `inline code` showing.
  • > ```
  • is rendered as:
  • > A paragraph with `inline code` showing.
  • However, adding a line break[^1] stops the single backticks from being recognised as inline code. The following raw text:
  • > ```text
  • > A paragraph with `inline
  • >
  • > code` showing.
  • > ```
  • is not rendered as code:
  • > A paragraph with `inline
  • >
  • > code` showing.
  • ## How to fix it
  • In Markdown, a code block uses three or more backticks and allows line breaks for multiple lines of code. The following raw text:
  • > ````text
  • > ```
  • > Multiple
  • > lines of
  • > code now
  • > ```
  • > ````
  • renders as:
  • > ```text
  • > Multiple
  • > lines of
  • > code now
  • > ```
  • In nearly all cases you will only need 3 backticks. More can be used for those cases where you need to post a code block that itself contains 3 backticks. You can edit this post to see an example of 4 backticks for this reason.
  • In this particular case, you can also apply syntax highlighting by adding the name of the programming language on the same line as the opening backticks:
  • ````text
  • ```python
  • for line in file:
  • print(line)
  • ```
  • ````
  • renders as:
  • ```python
  • for line in file:
  • print(line)
  • ```
  • ## Why it only looked half wrong
  • If the code had simply failed to render as code anywhere, it might have been easier to see that the Markdown syntax was incorrect. However, as you noticed, part of the code was rendered correctly, which is confusing.
  • The reason for this is that there is an alternative method of indicating a code block in Markdown: text with 4 or more leading spaces is treated as code.
  • So the single backtick was ignored, due to having no closing backtick on the same line, but all of the code after the first level of indentation was displayed with code formatting.
  • [^1]: Technically 2 line breaks are required to cause this problem, since in Markdown a single line break is converted to a space. In many code blocks double line breaks will be present, and in those with none the code block will still look incorrect as it will display on one line instead of several.
#2: Post edited by user avatar trichoplax‭ · 2024-03-11T13:28:56Z (8 months ago)
Mention that 2 line breaks are required but 1 still causes a similar problem
  • ## What's wrong
  • As [Moshi's comment](https://software.codidact.com/comments/thread/9295#comment-23542) points out, single backticks only work for inline code (code that appears within a paragraph of other text, and contains no line breaks).
  • The following raw text:
  • > ```text
  • > A paragraph with `inline code` showing.
  • > ```
  • is rendered as:
  • > A paragraph with `inline code` showing.
  • However, adding a line break stops the single backticks from being recognised as inline code. The following raw text:
  • > ```text
  • > A paragraph with `inline
  • >
  • > code` showing.
  • > ```
  • is not rendered as code:
  • > A paragraph with `inline
  • >
  • > code` showing.
  • ## How to fix it
  • In Markdown, a code block uses three or more backticks and allows line breaks for multiple lines of code. The following raw text:
  • > ````text
  • > ```
  • > Multiple
  • > lines of
  • > code now
  • > ```
  • > ````
  • renders as:
  • > ```text
  • > Multiple
  • > lines of
  • > code now
  • > ```
  • In nearly all cases you will only need 3 backticks. More can be used for those cases where you need to post a code block that itself contains 3 backticks. You can edit this post to see an example of 4 backticks for this reason.
  • In this particular case, you can also apply syntax highlighting by adding the name of the programming language on the same line as the opening backticks:
  • ````text
  • ```python
  • for line in file:
  • print(line)
  • ```
  • ````
  • renders as:
  • ```python
  • for line in file:
  • print(line)
  • ```
  • ## Why it only looked half wrong
  • If the code has simply failed to render as code anywhere, it might have been easier to see that the Markdown syntax was incorrect. However, as you noticed, part of the code was rendered correctly, which is confusing.
  • The reason for this is that there is an alternative method of indicating a code block in Markdown: text with 4 or more leading spaces is treated as code.
  • So the single backtick was ignored, due to having no closing backtick on the same line, but all of the code after the first level of indentation was displayed with code formatting.
  • ## What's wrong
  • As [Moshi's comment](https://software.codidact.com/comments/thread/9295#comment-23542) points out, single backticks only work for inline code (code that appears within a paragraph of other text, and contains no line breaks).
  • The following raw text:
  • > ```text
  • > A paragraph with `inline code` showing.
  • > ```
  • is rendered as:
  • > A paragraph with `inline code` showing.
  • However, adding a line break[^1] stops the single backticks from being recognised as inline code. The following raw text:
  • > ```text
  • > A paragraph with `inline
  • >
  • > code` showing.
  • > ```
  • is not rendered as code:
  • > A paragraph with `inline
  • >
  • > code` showing.
  • ## How to fix it
  • In Markdown, a code block uses three or more backticks and allows line breaks for multiple lines of code. The following raw text:
  • > ````text
  • > ```
  • > Multiple
  • > lines of
  • > code now
  • > ```
  • > ````
  • renders as:
  • > ```text
  • > Multiple
  • > lines of
  • > code now
  • > ```
  • In nearly all cases you will only need 3 backticks. More can be used for those cases where you need to post a code block that itself contains 3 backticks. You can edit this post to see an example of 4 backticks for this reason.
  • In this particular case, you can also apply syntax highlighting by adding the name of the programming language on the same line as the opening backticks:
  • ````text
  • ```python
  • for line in file:
  • print(line)
  • ```
  • ````
  • renders as:
  • ```python
  • for line in file:
  • print(line)
  • ```
  • ## Why it only looked half wrong
  • If the code has simply failed to render as code anywhere, it might have been easier to see that the Markdown syntax was incorrect. However, as you noticed, part of the code was rendered correctly, which is confusing.
  • The reason for this is that there is an alternative method of indicating a code block in Markdown: text with 4 or more leading spaces is treated as code.
  • So the single backtick was ignored, due to having no closing backtick on the same line, but all of the code after the first level of indentation was displayed with code formatting.
  • [^1]: Technically 2 line breaks are required to cause this problem, since in Markdown a single line break is converted to a space. In many code blocks double line breaks will be present, and in those with none the code block will still look incorrect as it will display on one line instead of several.
#1: Initial revision by user avatar trichoplax‭ · 2024-03-11T13:23:52Z (8 months ago)
## What's wrong
As [Moshi's comment](https://software.codidact.com/comments/thread/9295#comment-23542) points out, single backticks only work for inline code (code that appears within a paragraph of other text, and contains no line breaks).

The following raw text:

> ```text
> A paragraph with `inline code` showing.
> ```

is rendered as:

> A paragraph with `inline code` showing.
 
However, adding a line break stops the single backticks from being recognised as inline code. The following raw text:

> ```text
> A paragraph with `inline
> 
> code` showing.
> ```

is not rendered as code:

> A paragraph with `inline
> 
> code` showing.

## How to fix it
In Markdown, a code block uses three or more backticks and allows line breaks for multiple lines of code. The following raw text:

> ````text
> ```
> Multiple
> lines of
> code now
> ```
> ````

renders as:

> ```text
> Multiple
> lines of
> code now
> ```

In nearly all cases you will only need 3 backticks. More can be used for those cases where you need to post a code block that itself contains 3 backticks. You can edit this post to see an example of 4 backticks for this reason.

In this particular case, you can also apply syntax highlighting by adding the name of the programming language on the same line as the opening backticks:

````text
```python
for line in file:
    print(line)
```
````

renders as:

```python
for line in file:
    print(line)
```

## Why it only looked half wrong
If the code has simply failed to render as code anywhere, it might have been easier to see that the Markdown syntax was incorrect. However, as you noticed, part of the code was rendered correctly, which is confusing.

The reason for this is that there is an alternative method of indicating a code block in Markdown: text with 4 or more leading spaces is treated as code.

So the single backtick was ignored, due to having no closing backtick on the same line, but all of the code after the first level of indentation was displayed with code formatting.