2,358 karma · joined June 21, 2008
And fully agree on the GC part. GC doesn't remove the work of resource management. It simplifies it vastly. This can some times lull people into thinking they can ignore resources altogether.
This definitely drives people to comment on other things.
My gut feeling screams they made a problem themselves in the first place which they then "solved". Similar to a "solution running around looking for a problem" type of deal.
You would think an old http header is a string. It's not. It looks like a string though :)
Taking the argument to the extreme, assembly is a misfit.
You don't have to think that much about your relational model, so you can postpone all kinds of nasty questions about data integrity and multiplicity early on. This enables a team to move fast and break things.
The switch to something like Postgres comes later in the project where you know your requirements better and you need a system where you have more control over your data. You might even have a person responsible for maintaining your data for you on the payroll.
Personally, I usually just grab Postgres these days and use `json` columns for the documents and loosely fitting data, then drag out things into a more relational model as we go.
Though Erlang is a counterexample.
To do so you can use eg model checking, and you require a semantic definition for doing so.
I don't recall floating point stuff being hard to encode. See eg the flocq project.
And the mistake people make is that they don't start with a simple model. They move straight into the heavy ones.
It matters close to 0.
No function runs forever.
Also if you want to reboot/repurpose the server, 15 minutes is max wait time.
And finally, you don't want people running long jobs here when you have a solution there.
Arm is different but probably easier to decode. So you can widen the decoder.
You can simulate this by making a tm which runs 1 step of each machine at a time. This also hints at the equivalence other people have spoken of.
2. No. Minks are kept in small cages with a very high density of biomass. This makes it a perfect incubator. Also ferrets have some similarities with humans in the upper respiratory system, making this more of a concern.
I dont think there is a single reason.
It is strong in the area because you have the perfect storm of large complex protocols bundled with the need for very high reliability and robustness of systems. Few languages does that particular mix as well as Erlang.
The advantage is you avoid storing fp registers unless you are going to use them.
That flag could easily determine what you can run where.
You see, the shitloads of working code really works and solves problems. But you might not understand why. The work with proofs gets you closer to an understanding of the underlying why-question.
And I don't think PL-research will ever catch up to the real-world experiments done in code. It took 40 years to embrace garbage collection for typical programs, so I don't have hope anything else will move soon.
The problem is that getting the notation right is actually quite hard. People write, to the best of their effort, to make the description succinct and understandable. But the notation is pliable, in the same way much mathematics is written: it isn't as rigorous as we would like.
Writing the same thing in regular prose is much much harder and there are many more ways things can go wrong.
So the state-of-the-art demands formal proof which can be verified by a machine. And it shows in the precision of the notation, which often leaves little to no room for wrong interpretation.