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 10mo ago by trichoplax‭ · edited 10mo ago by trichoplax‭

Answer

#3: Post edited by

trichoplax‭ · 2024-03-11T13:29:31Z (10 months ago)
Typo

Copy Link

Raw

Markdown

## 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

trichoplax‭ · 2024-03-11T13:28:56Z (10 months ago)
Mention that 2 line breaks are required but 1 still causes a similar problem

Copy Link

Raw

Markdown

## 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

trichoplax‭ · 2024-03-11T13:23:52Z (10 months ago)

Copy Link

Raw

Markdown

## 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.

Communities

Post History