While fun and satisfying, this is extremely unlikely to be true.
The first attested use is from 1945, on the nose of a P-47 Thunderbolt flown by Captain Milton Thompson of the 509th Fighter Squadron. And his art was exactly what you'd expect: a charging bull with the words "balls out".
It starts in the very first paragraph. “The headlines say yes. […] The headline is wrong.”
And there are numerous such examples. “That was half true. The kill chain ran. The interceptor did not.”
LLMs produce staccato, ugly chains of sentence stumps like this all the time. They’re easy to spot, and your essay is littered with them.
If anything, spending a week on a project like this seems liable to blind you to the shortcomings of the prose, because after putting in a lot of effort you can’t read it with fresh eyes. That’s what editors are for, but an LLM is by nature very weak at editing LLM-generated text.
I want to be able to offer constructive feedback on the structure of the overall essay, for example that the interspersed animated/interactive models often don’t seem strongly connected to the text, but simply reading the words makes this a grind.
This is an exhausting and dispiriting article to try to read because of its short, choppy, clearly AI-generated sentences. The topic is interesting, but whoever caused it to be penned didn’t seem to care enough to make it appealing to read.
Liberty Utilities has nothing to do with libertarian separatists. It's a brand name of Algonquin Power & Utilities Corp, a boring Canadian infrastructure conglomerate that buys regulated water, gas, and electric systems across North America. They bought this chunk of rural California grid from NV Energy in 2009. That's it.
This is sort of a revival and elaboration of some of Bram’s ideas from Codeville, an earlier effort that dates back to the early 2000s Cambrian explosion of DVCS.
Codeville also used a weave for storage and merge, a concept that originated with SCCS (and thence into Teamware and BitKeeper).
Codeville predates the introduction of CRDTs by almost a decade, and at least on the face of it the two concepts seem like a natural fit.
It was always kind of difficult to argue that weaves produced unambiguously better merge results (and more limited conflicts) than the more heuristically driven approaches of git, Mercurial, et al, because the edit histories required to produce test cases were difficult (at least for me) to reason about.
I like that Bram hasn’t let go of the problem, and is still trying out new ideas in the space.
Really nice to see a solidly valuable project develop a sustainable foundation instead of turning into yet another VC-backed devtools startup that will inevitably die in a few years.
This is a bizarre essay by someone who understands neither functional programming nor the history of computers.
> To be kind, we’ve spent several decades twisting hardware to make the FP spherical cow work “faster”, at the expense of exponential growth in memory usage, and, some would argue, at the expense of increased fragility of software.
There is not one iota of support for functional programming in any modern CPU.
Let me put Mike's comment into what I think is its proper context. "Poor support for numerical computing" really means "relative to Mike's dream, which is not actually realisable by any programming language today" :-)
Most readers seem to be misinterpreting Mike as anchoring off other popular programming languages of today, whereas he's looking for language features for which there's (a) no consensus that they'll actually be good when they exist, and (b) don't yet exist. (I'm highly skeptical of dependently typed programming.)
I think that there's a case to be made that numeric programming in Haskell, relative to the state of the art of today rather than the year 2100, really isn't so great – but my concerns are very different than Mike's, and revolve around libraries rather than type system features.
Facebook has large engineering offices in New York, Seattle, London, and Tel Aviv, and smaller presences in Boston and Dublin.
There's also a vast range of engineering projects, from VR through video, mobile apps, machine learning, compilers and programming languages, operating systems, on to data centers.
There have been numerous well-known problems with the Java and Python standard libraries over the years. For instance, the date/time classes in Java were a disaster for a long time, and Python has taken decades to converge on a nearly-good-enough treatment of strings.
I think of programming in Haskell as being more about being able to choose a level of abstraction that makes sense for the situation.
The more abstract code is great when it works well, and when it falters I can easily drop down to something more concrete, or even to C, and still have most of my code benefit from that higher level of thinking.
{-# LANGUAGE DeriveGeneric #-}
import GHC.Generics
-- a generic wrapper type for all Pusher events
data Event a = Event {
eventType :: Text,
eventData :: a
} deriving (Generic)
instance ToJSON a => ToJSON (Event a)
instance FromJSON a => FromJSON (Event a)
data Error = Error {
message :: Text,
code :: Integer
} deriving (Generic)
instance ToJSON Error
instance FromJSON Error
I know nothing about the Pusher protocol, but the standard approach to boilerplate encoding/decoding problems these days is to use GHC.Generics.
It doesn't always fit (typically when your data structures don't resemble the wire encoding), but it kills all the boilerplate when it does.
Since you say that you can magically get away without boilerplate in Ruby in this case, I would expect that the Generics approach will give exactly the same result.