its the lack of functions thats the problem, not the GOTO itself!

the problem is that you can GOTO a particular instruction, but you can also fall through to it from the previous instruction

whereas a tail call is calling a function which can only ever be accessed by an explicit CALL or GOTO or similar things

my reason for saying GOTO is not harmful is that GOTO is, basically, a tail call

the thing that's harmful is that blocks of code bleed into one another invisibly

*They've been destroying themselves even without him, but now they can speed it way up

hot take: GOTO is not harmful

the original Ghost Busters theme song is so good

also Sigourney Weaver is so incredible

https://www.youtube.com/watch?v=Fe93CLbHjxQ

heard someone claim that abortion technology is why women got the right to vote and like no man it was electricity actually

Giant Brains: Or Machines That Think (1949), by Edmund C. Berkeley looks like a delightful little romp of a book

Grim Fandango

slightly more seriously tho, this is sort of a common observation that you could just reduce hours instead of doing layoffs

the usual response, i think, is that not all work can be parceled up like that

im not sure i but that tho, tbh

RE: https://mas.to/@carnage4life/117406451112399471

if you lay of 30,000 of 80,000 workers, that's 60% of your workforce retained

the average work time of the original 80,000 workers is now 60% of what it was, because 30k dont work at all

60% of 5 days is 3 days

so as long as Bezos had ~80k workers, hes not wrong, on average!

lmao

An interesting perspective considering Amazon has laid off 30,000 corporate employees in the past year as part of an AI efficiency push instead of giving workers 3-day workweeks because AI can do some of their work.

but i think this algorithm takes exponentially longer than long multiplication, which is just a tight loop of left shifts and conditional adds, so its just a curiosity not a real algorithm :)

T(n) is just Sum[i = 0 to n] i

so its a trivial loop. and as you compute T(n) you also need to compute T(n-1) so you can avoid a second loop easily

so the original L(n) lookup can be traded for a single tight linear loop of n cycles

that frees half the memory for the cost of a few extra (but fast) operations

but we can do better than that it seems, because the squares are sums of adjacent triangular numbers:

S(n) = T(n) + T(n-1)

as noted on the OEIS page for squares: https://oeis.org/A000290#:~:text=Sum%20of%20two%20consecutive%20triangular%20numbers%20A000217%2E%20%2D%20Lekraj%20Beedassy%2C%20May%2014%202004

this means that you can halve the size of the lookup table, replacing L(n) with S(n) = n*n

L(2k) = S(k)
L(2k+1) = S(k) + k

so that adds a right shift to get from 2k+1 to 2k, and a conditional add to add k back in if you had 2k+1 instead of 2k

the key table is the stored quarter squares

L(n) = floor(n^2 / 4)

which is OEIS sequence A002620

I noticed the following APPARENT pattern:

L(2k) = k^2
L(2k+1) = k^2 + k

and OEIS confirms this:

https://oeis.org/A002620#:~:text=a%282n%29%20%3D%20A000290%28n%29%2E%20a%282n%2B1%29%20%3D%20A002378%28n%29%2E%20%2D%20Gary%20W%2E%20Adamson%2C%20Nov%2029%202008

so I was watching Inigo Quilez's video about Babylonian Multiplication, which is used in shaders and oldschool game programming to turn multiplication into addition/subtraction + some table lookups, and I realized you can trade off some space for time

https://www.youtube.com/watch?v=CsMrHzp850M

great video from Baldur Bjarnason

Software developers are not okay

https://www.youtube.com/watch?v=KsEpW03gxKg

i think tech folx who are noping out of the modern tech industry should go back to what folx used to do -- start their OWN things, make their OWN products, make their OWN companies

Vale Margaret Hamilton.
She was a Software Engineer.
She was the _first_ Software Engineer because she defined the term, Software Engineering:
"When I first came up with the term, no one had heard of it before, at least in our world. It was an ongoing joke for a long time. They liked to kid me about my radical ideas. It was a memorable day when one of the most respected hardware gurus explained to everyone in a meeting that he agreed with me that the process of building software should also be considered an engineering discipline, just like with hardware. Not because of his acceptance of the new 'term' per se, but because we had earned his and the acceptance of the others in the room as being in an engineering field in its own right."

Margaret Hamilton led the Software Engineering team at MIT that created the software that ran NASA's Apollo Guidance Computer. The photo of her standing next to a stack of source code printouts — that's her work, and she was essential to NASA's mission of landing people on the Moon for the first time ever and getting them back to Earth again safely.

Margaret Hamilton, computing pioneer who led software development for the Apollo program, dies at 90
https://news.mit.edu/2026/margaret-hamilton-computing-pioneer-dies-1007

#MargaretHamilton #SoftwareEngineer #SoftwareEngineering #ComputerScience #NASA #MIT #Apollo #MoonLanding