codesections @codesections@fosstodon.org

I want to be able to tell my friends why #mastodon is better than the birdsite, so I wrote a thing: "Mastodon Is Better than Twitter: Elevator Pitch"
https://www.codesections.com/blog/mastodon-elevator-pitch/

I want this to be as persuasive as possible to outsiders, so I'd appreciate as much feedback as possible from Mastodon users

question to those of you who've followed webdev for a while:

Where did the association between #react and the phrase "UI is a function of state" come from? It's something I've heard a lot (and that shows up in a lot of blog posts, etc.). I'd kind of thought of it as React's tagline, in fact.

But, to my surprise, that claim doesn't seem to show up in the official docs. Do you know when it started to be associated with React? Was it once listed in the docs and then removed?

I might should slightly walk back ^^^ I do think that many of the practices of "modern" web-dev are ignorant re-inventions of previous solutions (we all need more history!), this one seems to have been an *intentional* re-implementation (much better!):

> In React, this is solved by Context. It is essentially like dynamic scoping for components. It’s like a wormhole that lets you put something on the top, and have every child at the bottom be able to read it

https://overreacted.io/react-as-a-ui-runtime/#context

A few weeks ago, I asked:

> Many programming languages have syntax that means "everything from this token until the end of the line is a comment" (e.g., // in C-family, ; in Lisp family, # in shell family)
>
> Do any have syntax for "everything from this token until the end of the line is a string"?
>
> Why isn't that a common thing to have? It strikes me as something that'd be *super* handy

I just learned that #zig has pretty much *exactly* the syntax I wanted! https://ziglang.org/documentation/master/#Multiline-String-Literals

It recently occurred to me, relatively unprompted, that many of the state management patterns in "modern" "react-ish" webdev are just re-implementations of dynamic scope – with the same advantages and disadvantages dynamic scope has had for the past ~60 years that it's been in use.

(Of course, after noticing this, I checked, and pointing out how not-new this pattern is… is itself not at all new: https://spin.atomicobject.com/2020/04/08/react-contexts-dynamic-scope/ We sure do love reinventing wheels!)

I just watched Gary Bernhardt's 2012 talk, A Whole New World, which has the gimmick of him pretending to have written a text editor and terminal emulator – and then revealing the trick to make the point of how surprising it'd be if he'd actually done so, because no one goes that deep.

From here in 2021, though, I was thinking "oh, _another_ terminal?" Like kitty/hyper/alacritty/zutty…

Does that reflect a large sea change since 2012, or a coincidence?

I'm working with some code where a function takes a `date` parameter, and if no date is provided, calls Date.today _in the default argument constructor_.

The functional programmer in me finds that absolutely horrifying.

I'm not sure why calling an impure function in the argument constructor bothers me so much more than calling it in the body of the function would – but it sure does!

In every programming language I've ever heard of, program control flows left→right and then top→bottom. That is, this psudo code:

{ print "1" } { print "a" }
{ print "2" } { print "b" }
{ print "3" } { print "c" }

would print 1a2b3c

Are there any languages (even eso-langs/DSLs) that invert that order, so that the above would print 123abc?

It occurs to me that a left-to-right control flow would be a good fit for a lot of "pipeline" type data work, and I'm curious if anyone has tried it

For those of you with functional-programming sympathies, what are your thoughts on environmental variables? Do you think they make an otherwise pure function impure?

I'm torn. On the one hand, if a fn is a pure mapping from input => output, it seems pure regardless of how it reads the input. `FOO=1 cmd --bar=2` seems identical `cmd --foo=1 --bar=2`

On the other hand, referential transparency *usually* means being able to reason about a fn from the callsite. And env. vars lose that.

Hmm…

Many programming languages have syntax that means "everything from this token until the end of the line is a comment" (e.g., // in C-family, ; in Lisp family, # in shell family)

Do any have syntax for "everything from this token until the end of the line is a string"?

Why isn't that a common thing to have? It strikes me as something that'd be *super* handy

The joke in this image is both obvious and old, but I still laughed audibly when I unexpectedly came across a presentation slide that described a compiler with the following:

This is the sort of programming ethos to which I aspire:

> I was watching TV, and there was a commercial which proclaimed, "It's time to do what you want!" I replied to the TV, "It's time to write a JSON parser in 6502 assembly language?" Somehow I don't think that's what they had in mind, but the TV is right, I should do what I want.
>
> So, here is my JSON parser.

https://github.com/ppelleti/json65

TIL: many #pascal compilers allowed identifiers of any length, but only examined the first 8 characters to determine what the identifier pointed at.

So `foobarbaz` and `foobarbazqux` are both valid, but refer to the **same** variable!

What I _didn't_ learn was why anyone thought this was a good idea. I assume it was for performance reasons, since Free Pascal doesn't do it anymore (https://wiki.freepascal.org/Identifier#Significant_characters) and 8 makes me guess it has something to do with memory representation.

Anyone know?

I *really* like the Redis protocol, RESP. I don't even use Redis itself all that often, but I've implemented RESP (or subsets of it) multiple times – it's just a great format for programmatic communication

https://redis.io/topics/protocol