James Hague

For a perspective of a mathematician that came to evangelize theorem provers, I recommend Kevin Buzzard's MS 2019-09 presentation [0] about LEAN. He highlights cultural misunderstanding and apathy on both sides of the domain divide. He also references the idea that the people who might make the appropriate tools may not have stayed in academia. So, he's structured his courses around using LEAN with the indirect consequence that power users (undergrads) may choose to become open source committers.

[0] https://www.youtube.com/watch?v=Dp-mQ3HxgDE One hour of presentation and then 15 min of q/a. My favorite is around 1:04:00 when someone asks a second time why he disprefers coq, and Buzzard complains that it can't represent some advanced quotient type that he'd have to work around. I'm reminded of [1]

[1] https://prog21.dadgum.com/160.html Dangling by a trivial feature

For anyone lacking the context (I just read someone claim "I've never heard of this author or his games").

Crawford, Eastern Front and Balance of Power were a big deal in their day. These were always niche games, but for those in the know, they were brilliant.

You can read more about this period of videogame history in the freely available online book "Halcyon Days": https://dadgum.com/halcyon/

Feel free to disagree with Crawford, but please don't do it out of ignorance. Know your history. Otherwise you'll be like someone who argues Charlie Chaplin has no business arguing about cinema, because he doesn't ring a bell to you and who watches silent black & white movies anyway?

If there's one thing I take out of this: how easy we forget the history of computing and videogames. Past celebrities and heroes get forgotten, unlike with book and movie authors.

> Imperative/OO [...] programming will just about always win over non-OO declarative programming in an analogy like that (i.e. a Simulation of a real world process)

Some time ago I thought that, too, but I'm no longer convinced. Directly mutating values (OO style) feels more natural at first, but then you have trouble with side effects and order of execution matters more than it should, you start keeping snapshots of the whole state just to get a consistent world state during computation, otherwise this whole mess produces a whole class of bugs on its own. These problem drive you more and more into FP direction, and the FP style definitely does have its merits in this regard.

I think the following article articulates this very well:

"A Worst Case for Functional Programming?"

http://prog21.dadgum.com/189.html

This is hardly a surprise. No matter if you like a language or not, you have to acknowledge that we don't develop software in a vacuum and we cannot ignore market trends. Don't fall in love with your technology [0].

(I won't comment on the Python 2 rewrite though)

I like Perl a lot. Out of the usual, interpreted dynamic languages, it is still my favourite. It's fun, incredibly expressive, got some things right early on (CPAN) and the community is probably the most entertaining out there.

It also caters to a kind of developer that no longer exists, or at least is in the minority now.

I will keep it as a sort of dirty pleasure for myself. Among the likes of Forth and Lisp.

[0] https://prog21.dadgum.com/128.html

Because systems were simpler, the teams that produced them were simpler, too. In the 1980s it was common for one person to have developed an entire commercial program. Just take a look at The Giant List of Classic Game Programmers (https://dadgum.com/giantlist/) and note how many amazing games were written by just one person. It's a lot easier to QA a program when you wrote the entire thing and can manually test it in a few minutes.

But simpler has its cost. Whenever I fire up an emulator to relive my childhood Apple II days, I'm amazed how crude that stuff was. I remember magical worlds and incredible, fast animations. Today they're just flickering 16x16 blobs.

EDIT:

Paste this hacky snippet into your browser's console to save all of the links into your clipboard:

(() =>
{
let result = [...document.querySelectorAll('td a')]
.map((link) =>
link &&
!link.href.includes('ycombinator') &&
!link.href.includes('javascript:void')
? link.href
: ''
)
.filter(Boolean);
result = [...new Set(result)];
result.sort();
copy(result.join('\n\n'));
})();

Just to help, here's a compiled-list of all of the links shared here so…