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

Today I learned: Apple owns a trademark in their new-ish programming language, #swift, for which they applied in 2014. https://tmsearch.uspto.gov/bin/showfield?f=doc&state=4809:6yyi9t.4.8

The *other* Swift programming language (swift-lang.org) was first released in **2007** and has been in active use ever since. https://en.wikipedia.org/wiki/Swift_(parallel_scripting_language)

This isn't legal advice, but that *sure* seems like Apple's swift™ would be subject to a pretty serious challenge

What are your thoughts on operator overloading?

(on a scale from "I can't live without it" to "I'm literally Drew DeVault")

Them: I get the appeal of Free Software, but sometimes I want something that Just Works™, without needing to fuss with it.

Me: M-x emacs-uptime

Emacs: 128 days, 21 hours, 26 minutes, 26 seconds

For some reason, youtube's algorithm has decided that I need to see ads for the Air National Guard, and I keep misreading their url (www.goang.com) as referring to golang.

I bet that confusion doesn't come up all that often!

(That said, there's a part of my mind still trying to come up with what the connection could have been. Maybe if Go wanted to make a push into Ada's territory?)

Possibly the nerdiest argument I've ever heard is claiming that #haskell programmers should stop calling <*> the "TIE fighter" and start calling it the "TIE advanced".

I love it!

Can other languages solve the semipredicate problem (https://en.wikipedia.org/wiki/Semipredicate_problem) in a way that's like to this #raku solution?

Imagine you want a `safe-div` subroutine that doesn't throw an error when the user divides by zero. Here's one approach:

sub safe-div(Numeric $a, Numeric $b --> Numeric) {
if $b != 0 { $a / $b }
else { 0 but role { method divided-by-zero { True }}}}

Then you can call .?divided-by-zero on any 0 returned, but the 0 is still a 0/can be used without destructuring.

I've been watching some programming talks/reading some old blogs, and have reached a decision:

I'm not sure if the level of understanding re: writing good code has gone up in the last ~40 years, but I'm *positive* that it's gone up in the last ~15-20.

I'm not sure what it was about the early 2000s, but somehow that period really seems to have been a low point for collective understanding of software craftsmanship

https://helix-editor.com/ seems like a decent-enough vim-alike. But it really got my hopes up for no reason by calling itself "A post-modern text editor."

A text editor where your code is recognized as a social construct? Innovative and exciting!

… but, no, it's just a "slightly more modern version of something that already called itself modern." How disappointing.

(And if you think programming can't be post-modern, I disagree: https://www.youtube.com/watch?v=Zx_Tjp9WIII
http://www.wall.org/~larry/pm.html )

Wait, immer (a prominent library for immutable data structures in C++, https://sinusoid.es/immer/ ) is *entirely unrelated* to immer (a prominent library for immutable data structures in JS, https://immerjs.github.io/immer/ ) ?

Honestly, as a profession, how do we acknowledge that naming is hard and yet still fail terribly at it so oftern?

I've been reading up on algebraic effects (e.g., of the sort in https://www.eff-lang.org/ )

In terms of programming paradigms, first with "functional programming" and now with "effective programming" … someone sure has a knack for coming up with names that make everyone else sound bad

("No, I prefer to write non-functional and non-effective code" (!))

I somehow missed the #freenode kerfuffle a couple of days ago. It really looks like the effective end of Freenode, at least as we knew it, which is a bit sad.

At the same time, it's *really* exciting that the core idea (and staff) will live on in https://libera.chat/ – and, in some ways, the move may open up even more exciting possibilities in the future.

In totally related news, @liberachat, welcome to #fosstodon!

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?