Ordinal vs. cardinal. It’s “first” not “onest”, right? Even the ancient proto-Germanic speakers could tell there’s a difference. (In fact, it’s basically a contraction of “foremost”, and has nothing to do with numbers; their weak numeracy was an advantage on this topic)

If we weren’t implicitly choosing 1-indexing it would be 1nd for “second” (and still not “onend” or something). That breaks down once you get to third and fourth, though.

Why the fuck would you spell it “1st” if it’s not 1?

Edit: Which is not pronounced “onest”. I think people might be missing the point here; I’m actually a fan of zero indexing.

Why? It seems exactly as valid to me, and more valid if you like positional numberings of your physical stuff.

You just count the number of times you departed from an item in order, rather than the times you arrived.

EZ, no password on password manager.

[Points at head]

Yes. That being said, it matters which language you choose. COBOL is always a bad choice, unless writing in COBOL is the whole point. There isn’t really a universal best choice, either. Python is often a good one, but if you’re doing something big it will become this meme.

I don’t think that’s quite right. It’s more like if you have to choose a language before you know what you’re doing, Python is the best choice. For anything large enough it’s multiple places down the list, but you really don’t want to have to learn Rust and possibly reinvent wheels for your quick boilerplate hack.

Maybe I just like the idea of a closing tag being very specific about what it is that is being closed (?).

That’s kind of what I was getting at with the mental scoping.

My peeve with json is that… it doesn’t properly distinguish between strings that happen to be a number and “numbers"

Is that implementation-specific, or did they bake JavaScript type awfulness into the standard? Or are numbers even supported - it’s all binary at the machine level, so I could see an argument that every (tree) node value should be a string, and actual types should be left to higher levels of abstraction.

I actually don’t like the attributes in xml, I think it would be better if it was mandatory that they were also just more tagged elements inside the others, and that the “validity” of a piece of xml being a certain object would depend entirely on parsing correctly or not.

I particularly hate the idea of attributes in svg, and even more particularly the way they defined paths.

I agree. The latter isn’t even a matter of taste, they’re just implementing their own homebrew syntax inside an attribute, circumventing the actual format, WTF.

Hmm, so in tree terms, each node has two distinct types of children, only one of which can have their own children. That sounds more ambiguity-introducing than helpful to me, but that’s just a matter of taste. Can you do lists in XML as well?

I think we did a thread about XML before, but I have more questions. What exactly do you mean by “anything can be a tag”?

It seems to me that this:

<address>
    <street_address>21 2nd Street</street_address>
    <city>New York</city> 
    <state>NY</state>
    <postal_code>10021-3100</postal_code>
</address>

Is pretty much the same as this:

  "address": {
    "street_address": "21 2nd Street",
    "city": "New York",
    "state": "NY",
    "postal_code": "10021-3100"
  },

If it branches really quickly the XML style is easier to mentally scope than brackets, though, I’ll give it that.

What was the git flag to basically rewrite history again?

I’ve definitely been guilty of this, but if I can redo my changes in narrative form before I push I bet I won’t have to.

It’s a weekday, but I’m not a pro, so either llama or hamster. Maybe sloth, we’ll see where today’s project goes.

Does anybody know if there’s a standard method to do a 1-way broadcast from mobile wifi hardware? (Or Auracast, it looks like the same thing) It’s for a sort of mesh network where links may change very rapidly, and so a handshake doesn’t make sense.

Also, it should turn an error into an empty but successful call. /s

I’d guess it’s less true for something statically typed, just because that reduces the ways it can be unintuitive.

A lot of people feel that way. If I need to generate a set of numbers or a certain string, though, it’s pretty easy to punch out a one-liner in GHCi, and that’s usually my use case.

Such is life.

I will confess that I get a sense of psychological comfort from strict typing, even though everyone agrees Python is faster for a quick hack. I usually go with Haskell for quick stuff.

See, the thing with Vim is that I don’t actually know which of the endless features I need. I don’t really feel like I’m missing much with the basic text editors.

Maybe you could shine some light on it for me? Right now I’m the sideways-glancing monkey meme every time IDEs come up.

Should they be more or less difficult, though? Really basic coding seems easier to me than remembering an endless soup of hotkeys I’ll rarely need.

TIL. I had tried to understand it a bit, but felt lost pretty fast, and then eventually found out that’s because it’s huge. Is there a good intro to the basic instructions you’re aware of?

By “play act the compiler” I mean a fairly elaborate system of written notes that significantly exceeds the size of the actual program. Like, it’s no wonder they started thinking about building machine compilers at that stage.

I wouldn’t be able to write Rollercoaster Tycoon in assembly because keeping track of all that code in assembly files must be hell, but people pretending like you need to be some kind of wizard to write assembly code are exaggerating.

Well, they’ve got a point for the bigger machine codes. Just the barebones specification for x86 is a doorstopper IIRC.

From what I’ve heard, writing big stuff in assembly comes down to play-acting the compiler yourself on paper, essentially.