198
Virgin Markdown, HTML vs chad plain Text (thelemmy.club)
submitted 1 month ago by to c/memes@lemmy.world
70 comments fedilink hide all child comments
 

Change my mind.

you are viewing a single comment's thread
view the rest of the comments
[–] 1 point 1 month ago* (8 children)

Machines do read Rust. Just because those machines are compiling the Rust code doesn't mean they aren't reading it. And every affordance the Rust devs included to make it easier for that compiler to do its job makes it harder for humans to read, but Markdown's affordances are equally helpful for humans as for computers; and they're designed to be so because they were adapted from shorthand that was already in use.

  • permalink
  • fedilink
  • source
  • parent
  • hideshow 8 child comments
    •
  • [–] 1 point 1 month ago (7 children)

    Debate all you want, but the literal first sentence on Wikipedia: https://en.wikipedia.org/wiki/Programming_language

    A programming language is an engineered language for expressing computer programs,[1] typically allowing software to be written in a human readable manner.

  • permalink
  • fedilink
  • source
  • parent
  • hideshow 7 child comments
    •
  • [–] 1 point 1 month ago (6 children)

    I never disagreed with the Wikipedia lede. I only said its primary purpose isn't human-readability, and Markdown's is.

  • permalink
  • fedilink
  • source
  • parent
  • hideshow 6 child comments
    •
  • [–] 1 point 1 month ago (5 children)

    If a language's primary purpose is for a machine to read it, why does anyone use Python instead of C, when Python is typically CPython? Python is still used because it is more human readable.

    If you were saying this about something like CBOR compared to JSON, I'd agree, but the primary purpose of most programming languages is to be human readable, and to, in a human readable format, define instructions and guardrails.

  • permalink
  • fedilink
  • source
  • parent
  • hideshow 5 child comments
    •
  • [–] 1 point 1 month ago* (4 children)

    Let's try to define the problem space here. I realize we're actually slightly off-target on this discussion when we're talking about languages like Rust and Python and C, because neither plaintext nor markdown are trying to fill that niche. Json is nearer the mark, though still doing something slightly different. Markdown, as humorously implied by the name of the format, is a markup format; more in line with HTML and LaTeX than with Rust or Javascript. And plaintext is also, in its own way, a markup format; albeit one with which computers would struggle particularly.

    Think about an HTML file. There's a ton of stuff in that file--basically everything within the <angle-brackets> --that's solely there for the purpose of the machine rendering the file. It doesn't provide much if any semantic information for the human reader; we can tell where the document starts, we don't need the <html> tag. We probably don't need anything in the <head> tag except for maybe the <title> , and that's likely to be repeated in the body anyway. We don't need the CSS, we don't need any of the Javascript, and if we don't need the opening tags, we don't need the closing tags either. We also don't need the opening <body> tag, because without the <head> tag, we can tell that the content starts at the beginning of the file. We don't need <p> or <div> or <br> tags, because we can see the line breaks visually. We don't need <span> in almost any scenario. Not only don't we need all of that information, but we couldn't easily parse it if we did.

    Of course some of the formatting options are useful, because they provide formatting information that's semantic (like <strong> and <em> and <h1> ) and some provide structural information that's semantic (like <table> and the list tags), though a lot of those are packed so full of additional parameters and styling and handles and such that they actually lose a lot of semantic meaning for humans because they're buried under a ton of stuff we can't easily parse. So they're not the best way for humans to read it, but they do work for humans who can figure them out.

    A lot of stuff is included in an HTML file for the benefit of a computer that will be reading the file which adds no useful information for a human. Even the stuff that does add useful information for a human could be communicated more easily in other ways. In short, the things which are added to plaintext to make HTML make parsing simpler for the computer and more difficult for the human. This is because its primary function is to provide direct and unambiguous control over document presentation, which means that it has to be clear and unambiguous to the computer.

    Now, if you consider plaintext, you run into the opposite problem: it's entirely human-focused. There's nothing there providing any useful information for a computer, unless the computer has some advanced sentiment analysis or a decent neural network working on the problem (either of which would certainly be hugely resource-expensive). A computer can't tell what the important words are in a plaintext document, or what the title is, or whether a single line on its own is a header or just a very short paragraph. It doesn't know what a list looks like, or a table. Humans can read it fairly well (though honestly the lack of formatting might present some challenges to them as well). In short, the things which aren't included in plaintext make parsing very difficult for the computer while making it reasonably simple for the human. Its primary function is to provide text content to a human, which means that it can be formed and formatted however the human wants.

    Contrast both with Markdown. Every syntactic tag and mark is equally useful for both the human reader and the computer reader. A human does not need additional training to utilize every character in a Markdown file, and a computer does not need additional functionality (beyond a parser for the language) to utilize every character in a Markdown file. The things which have been added to plaintext to make markdown make parsing simpler for both human and computer. A developer doesn't have to meticulously craft a document that humans will have trouble reading, and a computer can still comprehend it as well as an HTML file. Its primary function is to be equally readable for computer and for human.

  • permalink
  • fedilink
  • source
  • parent
  • hideshow 4 child comments
    •
  • [–] 1 point 1 month ago (3 children)

    the things which are added to plaintext to make HTML make parsing simpler for the computer and more difficult for the human

    This is the crux of where we disagree. <title> exists to be human readable. A machine would be happier with a binary identifier.

    A human does not need additional training to utilize every character in a Markdown file

    Uhh ask any non-tech person to write a markdown file. This simply is not true.

    A header 2 tag (h2) in HTML requires no more training than a header 2 tag (##) in Markdown. They both exist to make it easier for a human to dictate to a machine what should happen.

  • permalink
  • fedilink
  • source
  • parent
  • hideshow 3 child comments
    •
  • [–] 1 point 1 month ago (2 children)

    <title> exists to be human readable.

    The text within <title> exists to be human readable, but the tag itself exists so that the browser application knows what to put in the title bar.

    Uhh ask any non-tech person to write a markdown file. This simply is not true.

    Write, sure. But I meant read.

    A header 2 tag (h2) in HTML requires no more training than a header 2 tag (##) in Markdown.

    I did mention that that was one of the more bilaterally semantic parts of the language, alongside emphasis and strong tags. But I still think the ## is easier for a regular user to understand.

  • permalink
  • fedilink
  • source
  • parent
  • hideshow 2 child comments
    •
  • [–] 1 point 1 month ago (1 child)

    If <title> isn't intended to be human readable, why not use \0 instead? Every tag could be 2-3 characters, saving space and increasing machine processing speed.

  • permalink
  • fedilink
  • source
  • parent
  • hideshow 1 child comment
    •
  • [–] 1 point 1 month ago

    This is the entire argument I'm making. HTML makes compromises that makes it harder for the human to read and also harder (or at least less optimal) for the machine to read. Markdown codifies an existing human-readable format in a way that a machine can handle easily, too.

  • permalink
  • fedilink
  • source
  • parent