SaxonRobber

I wanted to like Reason, but it is now clearly a dead end. Its torn identity between JS and OCaml has killed the language.

Imagine believing this

Because it lowers the housing stock in urban areas. Wealthy travellers will pay more for accommodations than the local market, so apartments become airbnbs and investors gobble up condos and housing which they turn into short term rentals. The scarcity pushes up the housing prices, but it never balances out because the locals can never make enough to compete with wealthy travellers and are forced farther from the city. The end result is a hollowed out city core.

Airbnb was supposed to be a platform for sharing your house, not starting your own distributed hotel.

Probably

The corporate structure institutionalizes immorality, it cannot be avoided. By law shareholder profits come first, everything else is secondary to that goal.

The person filing the paperwork still isn’t necessarily the one who made the call. In fact, it usually isn’t; they are just the ones whose responsibility it is to carry it out, or else their head is on the block.

It is my experience that everyone who self identifies as a republican or democrat is brainwashed at this point. The worst offenders are those who are so delusional that they mock anyone who avoids political discourse or abstains from voting. They are so high on political fumes that they can’t imagine that there are things more important than our cancerous political process.

Investment is gambling, smarts are winning.

can we get compile time constant variables? something cleaner than enums and defines

That excludes a huge number of students who will have never had the experience to try programming before university.

I never did any programming before my first year, I was planning on going into economics. But then I took an elective in CS and it became my major. I wasn’t alone either, most of the students were not programmers previously.

This is only true if your applications are mostly high level glue.

But it is. A good compiler could unroll my loop and rewrite it with the appropriate vector ops. But that isn’t possible with just python right now.

Damn you’re edgy

This is a pretty pedantic definition.

Plenty of excellent programmers are not mathematicians. How would that work if programming were just math? That’s like saying physics is just math while ignoring all of the experimental parts that have nothing to do with math.

Go succeeded because it was largely ignored by Google. Dart was the darling language which flipped miserably and has only recently became relevant.

They are proven with with math, but their implementation in code certainly isn’t. If it were that simple, we would be using languages like Coq and TLA+ for writing software. But we usually don’t, because math does not cleanly translate into usable programs, it needs a human to distill it into the necessary steps the computer must follow.

I think only academics with a background in CS will typically be familiar with functional programming.

For everyone else, they will have used something simpler like Excel, C, R, Python.

This is actually one of the most frustrating parts about using python. You can’t write normal python code that performs well. Instead you have to use the numpy dsl, which I often find unintuitive and too often results in me needing to consult stack overflow. This is very frustrating because I know how I want to solve the problem, but the limitations of the language prevent me from taking the path of least resistance and just writing nested loops.

My analogy was to compare wood and vinyl as building materials for flooring (I guess I omitted that) and asking if the existence of something newer invalidates something older.

I am skeptical that all language features make code better. It shifts the complexity from the code to the programmer. In order to read a piece of code, I need to potentially keep up with all of the new language features, which is a huge burden in C++.

Those new features also have a tendency for complicating otherwise simple things. Like all of the edge cases that arise from objects with moving and exceptions. Sure the code might look simpler, but there is a lot more going on in the background you have to keep track of.

When I write C++ now, it is typically as C with a few constexprs and templates thrown in. I try to avoid most of the new features because they just distract me from writing code that works.

Julia is similar to matlab by design, which makes it easier for science and engineering folks who are already familiar with it.

I think functional programming advocates underrate simplicity of procedural languages. Programming is not math, algorithms are taught and described as a series of steps which translate directly to simple languages like Fortran or Python.

I think ML is great, but I’m skeptical if it is a big win for scientific computing.

Why does a language need changes to be alive? We don’t ship languages, we ship code written in them. It’s like claiming wood is dead because we have vinyl.

At what point is enough enough?

C++ has had decades to replace C, but it’s really stalled and even lost ground in embedded systems. I can’t see Rust faring much better. C might end up being an eternal language until there is a dramatic enough shift in operating systems to merit replacing it.

I think this readjustment would tend towards extracting more money from fewer people who can pay and letting the rest go without care.

And then those same Lispers will whole sale write off procedural Algol like languages as being "lesser", despite everything that that has been accomplished with languages like C.

And stay away from flavour of the month dominated domains.

Don’t try to reason with clojure zealots, they are just as bad as rust zealots and also less relevant.

He’s also rewritten the same book about 5 times and walked on water after a copy of sicp hit him on the head.

I find ML languages easier to read than Lisps, but that’s an unpopular opinion.