noblethrasher

He was also among a handful of people invited to contribute to a book tributing Alan Kay on his 70th birthday.

https://users.cs.duke.edu/~rodger/articles/AlanKay70thpoints...

He has two.

I have the honor of being the person that incited him to create his first account, which he only used once, to improve something that I said.

https://news.ycombinator.com/user?id=alanone1

Perhaps this one from Graham Hutton?

“A parser for things

Is a function from strings

To lists of pairs

Of things and strings”

Interestingly enough, a professor of organic chemistry[1] created a new Common Lisp implementation[2] just so that, among other things, he can use a very high level functional(ish) language in his research. His CL implementation is specifically designed to allow more seamless interoperability with libraries written in C and C++.

[1] https://drmeister.wordpress.com/about/

[2] https://github.com/clasp-developers/clasp

Also worth noting that language that runs this very website was implemented in Racket.

Java's (Oracle's) strategy is to spend most the innovation on the runtime, and in that regard, it's probably the most advanced platform. The net effect is that you can write some pretty naïve and boring OO-style code that will almost always perform superbly. This is a good thing, and something that I envy as a C# programmer.

His PhD is in Computer Science.

Interestingly enough, the aforementioned quote was just an epigraph for a section whose penultimate point is that “mathematics is nature’s way of showing how sloppy your writing is”, followed by the ultimate point that “formal mathematics is nature’s way of showing you how sloppy your mathematics is”.

That’s also the gist of the Wolfram Physics Project: https://writings.stephenwolfram.com/2020/04/finally-we-may-h...

TLA+ really is quite nice. I write most of my TLA+ specifications longhand and only bother with the toolbox when I think that refinement might be useful. Even then, it's mostly for SANY rather than TLC.

After noodling with with the spec for half an hour or so, I’ll usually have enough insight/confidence to start coding/debugging.

I was just making reference to the fact that the guy that started HN originally planned to get rich by putting art galleries online.

Which, if true, would be hugely ironic.

Good coverage of the topic in the first three minutes of this video: https://www.youtube.com/watch?v=_9iab0z6Kyg

Also, Thierry Coquand, who is behind CoC, and is also one of the developers of the software that became Coq.

Probably not as many as you might imagine: https://news.ycombinator.com/item?id=1884326

https://queue.acm.org/detail.cfm?id=2436698

Link to original demo: https://www.uselesspickles.com/triangles/ (the site's certificate is expired, so you'll get a warning).

Speaking of stupid efficiencies:

“In the progress of the division of labour, the employment of the far greater part of those who live by labour, that is, of the great body of people, comes to be confined to a few very simple operations, frequently one or two. But the understandings of the greater part of men are necessarily formed by their ordinary employments. The man whose whole life is spent in performing a few simple operations, of which the effects too are, perhaps, always the same, or very nearly the same, has no occasion to exert his understanding,or to exercise his invention in finding out expedients for removing difficulties which never occur.

He naturally loses, therefore, the habit of such exertion, and generally becomes as stupid and ignorant as it is possible for a human creature to become. The torpor of his mind renders him, not only incapable of relishing or bearing a part in any rational conversation, but of conceiving any generous, noble, or tender sentiment, and consequently of forming any just judgement concerning many even of the ordinary duties of private life. Of the great extensive interests of his country he is altogether incapable of judging; and unless very particular pains have been taken to render him otherwise, he is equally incapable of defending his country in war.

The uniformity of his stationary life naturally corrupts the courage of his mind, and makes him regard with abhorrence the irregular, uncertain, and adventurous life of a soldier. It corrupts even the activity of his body, and renders him incapable of exerting his strength with vigour and perseverance, in any other employment than that to which he has been bred. His dexterity at his own particular trade seems, in this manner, to be acquired at the expense of his intellectual, social, and martial virtues.

But in every improved and civilized society this is the state into which the labouring poor, that is, the great body of the people, must necessarily fall, unless the government takes some pains to prevent it.”

—Adam Smith, The Wealth of Nations

https://www.pitt.edu/~syd/ASIND.html

I remembering wondering about the same thing a few years ago, and came across this: https://stackoverflow.com/questions/30177559/how-does-find-b...

In response to the criticism of "noun-oriented" programming, check our this video: https://www.youtube.com/watch?v=BDPHfRuAFnU&feature=youtu.be....

It's worth watching from the beginning, but I've linked to the relevant timestamp (8:30).

Most of what I have to say comes from Fielding’s dissertation, along with spending the past several years trying to take it as seriously as possible. Other good sources are McCarthy’s Situation Calculus and all of the stuff that Lamport has written on on TLA+ (especially Specifying Systems[1]).

The big idea behind scalability (IMO) is that we want the pain of maintaining a system to grow logarithmically with respect to the size of the system. Now, size can mean many things (number of customers, lines of code, etc.), but pain is almost always complexity. A potent cure for complexity is symmetry, because every time that we discover a new symmetry, half of the complexity goes away. One way of finding symmetry is to look for invariants.

Roughly speaking (very roughly), having lots of possible states is good (the more states, the more powerful/featureful the system), but having lots of state transitions is bad (especially with respect to security). REST “verbs” help to control complexity by imposing invariants on state transitions. For instance, one good invariant to enforce is that a GET transition mean that a state can always be a start state, whereas a POST must always have an antecedent state. Thus, a REST verb is just label for a set of invariants, and we’re free to choose whatever set of invariants we want. Obviously, the more invariants you have, the weaker they are since an invariant is supposed to be unchanging; i.e. if the size of set of invariants is close to the size of the set of states, then you effectively have no invariants.

[1] https://lamport.azurewebsites.net/tla/book-02-08-08.pdf

It appears that the .NET Core CLR does perform some rudimentary escape analysis: https://github.com/dotnet/coreclr/pull/6653

I didn't say "states", I said "nominal states". These are the states that you would bother to name. They'll correspond to classes in an OOP language or discriminated unions in an ML-stye FP language.

Using your example, you'd have two states: `PrepareDeleteUser` and `DeleteUser` where the latter is only reachable from the former. PrepareDeleteUser will check that the all preconditions are satisfied (e.g. that the current operator has permission to delete the user). Now, you may not choose to reify these states so directly (i.e. you'll just have a deleteUser function that does a check for the preconditions), but they must exist in a robust application nonetheless.

In REST we name our states so we can drive the state machine by using the names (following hyperlinks). Why? Because, among other things, this keeps the client decoupled from the server by letting the client be in control of when to effect a state transition, but keeps the server in charge of what transitions are possible.

I need to attend to some real-life concerns at the moment, but I hope to get back to this discussion soon.

Cheers!

REST doesn't care about the size of the set of verbs, only that the set be constant. HTTP as one particular implementation of REST just happens to have nine verbs.

I tried to implement an IMAP server a few years ago, but otherwise I don't know much about it. However, I do recall that Mark Crispin admitted that he wasn't a very good API designer, and that much of the complexity of IMAP was due to it being intertwined with the complexity of MIME. But, I can't find the sources for those claims at the moment.

HTTP is one particular implementation of REST that happens to have nine verbs. Another implementation might only have two or three. But no RESTful architecture will have much more than nine.

Why?

Because your application is going to have thousands of nominal states, and each one is going to need to support all of the verbs because of the uniform interface constraint.

Why a uniform interface?

A lot to say about this, but basically, the set of verbs is an abstraction of the state machine that is your application. If you have a million states and a million verbs, then you have no abstraction. If you have ten states and a hundred verbs then you have too much abstraction (i.e. you ran afoul of YAGNI). A good degree abstraction is somewhere in between, but if you care about scale (which is the raison d'être for REST), then the size of set of verbs is going to have a logarithmic relation to the size of the set of nominal states.

You can have as many verbs as you want, but they all need to be valid at every state of the application (i.e at every hypermedia target), because you still want a uniform interface.

Responding with a standard error code is okay for verbs that are not supported at a particular state, but it's the uniform interface constraint that forces you to keep the set of verbs small.

Also, HTTP has nine verbs: GET, POST, PUT, DELETE, HEAD, CONNECT, OPTIONS, PATCH, and TRACE.

It's Kinski that is lucky to have survived the filming:

"In My Best Fiend, Herzog says that one of the native chiefs offered in all seriousness to kill Kinski for him, but that he declined because he needed the actor to complete filming"[1]

[1] https://en.wikipedia.org/wiki/Fitzcarraldo

Of possible interest is Kate Kinnear's thesis[1], titled The Aesthetics of Science Fiction Spaceship Design, which is about techniques for procedural generation of sci-fi spaceships. Also discussed on HN[2].

[1] https://uwspace.uwaterloo.ca/handle/10012/4935

[2] https://news.ycombinator.com/item?id=17899458

For the topologists.

I included this note on the flowers to be delivered to my SO:

Me: { 1/n : n ≥ 1 }

You: { 0 }

Us: Me ∪ You

That’s disgusting, and I’m really sorry to have read that happened to you or anyone else.

My policy is that anyone that completes the technical screen (2 – 4 hours of work) gets an on-site interview.

Just this morning, I had to spend about 20 minutes debugging a candidate’s code to get it to both build and run, but he’s still getting invited for an on-site.

True, but what made the Mono REPL particularly remarkable was that it launched with much of the functionality of a notebook, with things like inline graphics.