beza1e1

Nearly the same insights here (http://beza1e1.tuxen.de/). My conclusions: If you want to get a big audience you have to hustle. Post every blog on every social channel and so on. This is not the game I want to play. My motivation to blog is to clarify and archive my thoughts. Sometimes it is useful to point someone to an old blog post instead writing a log comment. Going for a blog with a big audience only makes sense if it is a funnel for selling something. Books, courses, app, etc. Having your core followers for some interaction is nice to develop new stuff. Blog about a topic, get the feedback, work it into another book/course/app. Blog about different topics and test which of them evokes the most reactions.

The ol all requirements up front -> design -> implement that people classically associate with waterfall came from an infographic on how not to do waterfall. Actual waterfall looks very much like actual agile, in that it is designed around iteration loops. The primary difference is that waterfall prescribed steps in the iteration process, and agile is just a set of principles in a manifesto. Edit: reference: https://beza1e1.tuxen.de/waterfall.html TLDR: the original impetus for waterfall is basically what we call agile today. Someone copy-pasted a random chart from a paper (one the paper specifically said was too problematic) into a DOD process spec, that turned into a standard because the DOD loves to standardize everything, and big companies all adopted the fundamentally flawed approach and called it waterfall.

It follows from Turing completeness. See https://en.wikipedia.org/wiki/Turing_completeness. It takes very little for a system to become Turing complete. And once it is, you can include arbitrary computations. Proving that they stop is impossible in general due to the well-known Halting problem. https://beza1e1.tuxen.de/articles/accidentally_turing_complete.html offers examples showing how easy it is to accidentally get Turing completeness, including multiple widely used type systems.

Reminded me of this classic about irradiated cows messing with a computer at a railway junction: https://beza1e1.tuxen.de/lore/crash_cows.html

This is another classic from his list "We can't send mail more than 500 miles": https://beza1e1.tuxen.de/lore/500mile_email.html

I LOVE stuff like this. Reminds me of "OpenOffice does not print on Tuesdays" https://beza1e1.tuxen.de/lore/print_on_tuesday.html

Unlike in Scala, you can chain your custom methods in D. For example, seqOfChars.map!(a => a.toLower).filterIfNotDigitChar.sort.uniq; is simply not possible in Scala. Here is a great presentation about fp in D: http://beza1e1.tuxen.de/stuff/FunctionalD.pdf

> Part of the reason is why lean and agile are the only successful methodologies in software... I would highly disagree with a blanket assumption like this: An discussion on HN [0] discussed the article Waterfall ( Everybody likes to laugh about the Waterfall methodology) [1] and I highly recommend both the article and a discussion as a deeper reflection of assumption of 'Agile vs Waterfall (or anything else)'. [0] https://news.ycombinator.com/item?id=18662668 [1] http://beza1e1.tuxen.de/waterfall.html BTW, I keep a small personal wiki of articles from around the web that I find interesting, just in case I might come across as personally invested in any topic; I find the discussion enlightening.

> That characterization isn't enough to distinguish a Turing complete interpreter from something that trivially manipulates an input datum. An interpreter is just a program containing code paths, which are activated in response to the input (the interpreted code). It is surprisingly simple to make an interpreter that is "accidentally" Turing complete (this IMHO so often happens by accident that I love to say that if an interpreter is not "obviously" more restricted than a Turing machine, it probably is Turing complete). This is not just my opinion - there lots of pages in the internet of things that are "accidentally" Turing complete, for example: http://beza1e1.tuxen.de/articles/accidentally_turing_complete.html https://www.gwern.net/Turing-complete

Classic: http://beza1e1.tuxen.de/articles/accidentally_turing_complete.html and https://www.gwern.net/Turing-complete (Not to say that TC itself is bad, but unexpected/accidental TC is normally a sign of bad omen)

Yes, here's a great list of turing completeness where you might not expect it (even Minecraft): http://beza1e1.tuxen.de/articles/accidentally_turing_complete.html

There's... a lot of wrong stuff here. Tackling some of the highlights: > ASCII code pages map the upper 128 positions (0x7F:0xFF) of the ASCII byte. Each page holds a different character set. This is one way internationalisation can be achieved. This is at best a poor explanation, and at worst outright wrong. The actual key thing is charset--there's a wide variety of charsets. Because ASCII is an inherently 7-bit charset, a lot of charsets were created by setting the first 128 characters to be ASCII and mapping in different characters for these charsets. IBM (I believe) came up with the term 'code page' to refer to the different character sets they came up with. > Unicode provides a unique code for every character, regardless of the language. That's not really true. Unicode keeps track of "code points". Several code points may together make up what we think of a character--consider that something like à can consist of either a precomposed "à" code point or an "a" + "` diacritic" sequence. Thus there's an entire concern about Unicode normalization that a lot of people prefer to sweep under the rug. > When creating a new file using touch, your computer will interpret that file as binary file. Okay, what's happening here is you've got a command here, the file command, whose entire job is to look at a file and guess what the contents of that file is. For text files, part of that guessing process often involves guessing what the character encoding of the file is. That…

TeX is not a "language"; it's just a tool for typesetting when you want to go the last mile of achieving book-quality printing. The fact that it turns out to be possible to (ab)use its macros (originally designed merely to save the user some typing effort) to do "programming" shows only that it's easy for things to become "accidentally Turing complete" [1], and the cleverness/perversity of its user community. > TeX was designed for typesetting, not for programming; so it is at best “weird” when considered as a programming language. — DEK, Digital Typography, page 235 > In some sense I put in many of TeX's programming features only after kicking and screaming. — DEK, Digital Typography, page 648 > So TeX is a programming language but I had to put in those features kicking and screaming. […] In a way I resent having every language be universal because they’ll be universal in a different way. […] I was really thinking of TeX as something that the more programming it had in it, the less it was doing its real mission of typesetting. When I put in the calculation of prime numbers into the TeX manual I was not thinking of this as the way to use TeX. I was thinking, “Oh, by the way, look at this: dogs can stand on their hind legs and TeX can calculate prime numbers.” — DEK, interviewed in Peter Seibel's Coders at Work > Michael Plass, who was Don's student and worked with Don on TeX, told me once that "Don tried very hard not to make TeX a programming language. Unfortunately, he…

See also: https://beza1e1.tuxen.de/articles/accidentally_turing_complete.html

Ah thanks! We've changed to that from https://beza1e1.tuxen.de/lore/crash_cows.html now. Submitters: "Please submit the original source. If a post reports on something found on another site, submit the latter." - https://news.ycombinator.com/newsguidelines.html

A surprising number of things are Turing-complete, I wouldn't be too surprised if with the addition of some clever rules, this list was one of them. :D https://beza1e1.tuxen.de/articles/accidentally_turing_complete.html

This brings to mind The Story of Mel from programming folklore. http://beza1e1.tuxen.de/lore/story_of_mel.html

A lot of things are Turing-complete. The funniest one to me are Powerpoint slides. https://beza1e1.tuxen.de/articles/accidentally_turing_complete.html https://gwern.net/turing-complete

In addition it is actually hard to not make a template language accidentally Turing complete. Here is an entertaining list of accidentally Turing complete things: https://beza1e1.tuxen.de/articles/accidentally_turing_complete.html

At first I thought you posted the Tuesday's printer bug https://beza1e1.tuxen.de/lore/print_on_tuesday.html

I think is the one you are looking for: https://beza1e1.tuxen.de/lore/index.html Also posted on HN awhile back: https://news.ycombinator.com/item?id=23005140 Edit: yep, here are your Crash Cows: https://beza1e1.tuxen.de/lore/crash_cows.html

https://beza1e1.tuxen.de/articles/accidentally_turing_complete.html lists a few type-related things. Type inference has been proven to be undecidable in some cases (e.g. with dependent types).

Well, famously the halting problem is undecidable. As a consequence (via Rice's theorem [1]), all nontrivial semantic properties of computer programs are undecidable. That is, there's no algorithm that can answer "does program x have property y?" for all programs, although obviously it's possible to prove propositions about many individual programs. Because Turing completeness is a fairly low bar to clear, there are infamously a lot of systems that were not designed (or indeed designed not) to be Turing-complete but nevertheless turned out to be so [2]. As such, things like the Java type system is undecidable – in principle there exist Java programs that the compiler can neither reject nor accept. [1] https://en.wikipedia.org/wiki/Rice%27s_theorem [2] https://beza1e1.tuxen.de/articles/accidentally_turing_complete.html

There's a whole collection of Software Folklore over here https://beza1e1.tuxen.de/lore/ Relevant thread: https://news.ycombinator.com/item?id=23005140

If you wanna try them all from A to Z: https://beza1e1.tuxen.de/one_letter_proglangs.html

emergent behaviour in complex systems is still reasonably simple, (eg OpenOffice won't print on a Tuesday [0] or moving my mouse makes Windows faster [1]) but maybe that makes it easier for us to appreciate how behaviour can emerge from distal properties interacting in a system. LLMs like ChatGPT will bring this to a whole new level. I'm not insinuating that ChatGPT is conscious but I think it definitely advances discussions on what you are calling a "spirit" [0] https://beza1e1.tuxen.de/lore/print_on_tuesday.html [1] https://retrocomputing.stackexchange.com/questions/11533/why-did-movin…

Yeah but how is Turing completeness directly relevant to that? Article doesn't seem to explain, just says "Turing Complete" in the title. Again, so what? I suppose it's somewhat indirectly vaguely reassuring? P.S. You might like this http://beza1e1.tuxen.de/articles/accidentally_turing_complete.html

Similarly: open office cannot print on Tuesdays. https://beza1e1.tuxen.de/lore/print_on_tuesday.html (Date embedded in printjob and parsed by the wrong filter)

That's pretty much it. It's notoriously easy to reach Turing Completeness without even trying. If you search for "Accidentally Turing Complete", you'll find several lists like this: https://beza1e1.tuxen.de/articles/accidentally_turing_complete.html I say "notorious" since this can often have negative implications for security.

> if the universe is that simple does that imply a complex runtime? There is a tradeoff to be made between (algorithmic) information specified as a program/software versus an interpreter/hardware http://www.hutter1.net/publ/ctoex.pdf However, all we really need is a Turing-complete runtime, which can be very simple, e.g. https://en.wikipedia.org/wiki/Rule_110 https://beza1e1.tuxen.de/articles/accidentally_turing_complete.html One easy way to make our universe is to run all possible programs (even if you don't think our universe is computable, we would still end up running simulations which are indistinguishable to arbitrary precision). We can even apply an anthropic argument to this: that the vast majority of programs are not universes conducive to containing life, but we must necessarily find ourselves in one which is. https://www.kurzweilai.net/in-the-beginning-was-the-code