Do you know the difference between a prophesy and an empirical observation? If you can’t distinguish between those basic things, why do you feel comfortable snarking so confidently?
I just watched “While You Were Sleeping” with my wife while we decorated for Christmas. It was still better than 99.9% of movies from this decade and it’s not because the plot is particularly sophisticated.
When can I expect 2010s movies to feel as good as 90s and early 2000s movies felt 10 years ago? Is there going to be a future golden age when this decade’s churned-out Disney / Marvel / Star Wars reboots and sequels feel inspired?
It took ten years and twenty movies for the Marvel franchise to go stale and years more for hating on it to become cool ‡. That's an accomplishment by any metric not specifically designed to facilitate the latter.
You will never be 10 years younger again, but the kids who grew up with those movies will carry forward their fond memories of the good in them and when they find their voice on the adult stage they will reclaim them, making hating on them uncool again, just as we did for the Star Wars prequels. Whether you embrace or reject the backlash-to-the-backlash will be up to you but I'd like to put in a word for the psychological benefits of trying to see the good in things. It's much more fun than ruminating on the bad, both for yourself and those around you.
‡ Yes, I'm sure you were doing it before it was cool.
How did you make the leap from a critical passing quip about Marvel movies that I “ruminate on the bad”? I’m glad you like Marvel movies, the point of my comment wasn’t to cause offense.
Is the supposition that I also forgot that I disliked movies in earlier decades? I don’t find explanations that require people to deny their own memory to be particularly convincing.
I have seen tons of great movies made after 2010, but must admit I’m having trouble thinking of any blockbuster-type movies that stand up to the best of the 70s, 80s, and 90s.
Does Fury Road count? I dunno. The closest I can get aside from that are a couple Tarantino movies. Jurassic Park, the first Mission Impossible movie, Aliens, Jaws, hell even Independence Day. Nothing’s quite up there. Lots that are a kind of janky B-movie sort of good, but nothing as solid as those. Almost all are marred by lots of CG that might look ok at the time but seem dodgy and very distracting within 5 years max, for one thing (to be fair, Jurassic Park suffers from that in a couple scenes, too)
I struggle to even think of many post-2010 films that stand up to the casual flicks of the 1990s, never mind The Matrix, or Gladiator, or the others you mentioned.
Horror, action-horror, and comedy-horror are in a really great place and have been for a while. Drama’s doing fine. Comedy’s been a bit weak for many years IMO. All the good ones I can think of are comedy/something—like, Red Rocket is very good and quite funny but also… damn dark and leans drama often enough that I’m not sure just “dark comedy” covers the difference between it and a straight comedy, it’s more a dark-comedy/drama. Or, uh, is The Art of Self Defense a comedy? Like… sorta? I can think of a couple alright ordinary comedies but nothing that stands out.
> All for... an occasional convenience far outweighed by the overall drag of using it
If you have any long-running operation that could be interrupted mid-run by any network fluke (or the termination of the VM running your program, or your program being OOMed, or some issue with some third party service that your app talks to, etc), and you don’t want to restart the whole thing from scratch, you could benefit from these systems. The alternative is having engineers manually try to repair the state and restart execution in just the right place and that scales very badly.
I have an application that needs to stand up a bunch of cloud infrastructure (a “workspace” in which users can do research) on the press of a button, and I want to make sure that the right infrastructure exists even if some deployment attempt is interrupted or if the upstream definition of a workspace changes. Every month there are dozens of network flukes or 5XX errors from remote endpoints that would otherwise leave these workspaces in a broken state and in need of manual repair. Instead, the system heals itself whenever the fault clears and I basically never have to look at the system (I periodically check the error logs, however, to confirm that the system is actually recovering from faults—I worry that the system has caught fire and there’s actually some bug in the alerting system that is keeping things quiet).
The system I used didn't have any notion of repair, just retry-forever. What did you use for that? I've written service tree management tools that do that sort of thing on a single host but not any kind of distributed system.
Repair is just continuous retrying some reconciliation operation, where “reconciliation” means taking the desired state and the current state and diffing the two to figure out what actions need to be performed. In my case I needed to look up what the definition of a “workspace” was (from a database or similar) in terms of what infrastructure should exist and then query the cloud provider APIs to figure out what infrastructure did exist and then create any missing infrastructure, delete any infrastructure that ought not exist, and update any infrastructure whose state is not how it ought to be.
> I've written service tree management tools that do that sort of thing on a single host but not any kind of distributed system.
That’s essentially what Kubernetes is—a distributed process manager (assuming process management is what you are describing by “service tree”).
> they don’t actually get you out of having to handle errors
I wrote a durable system that recovers from all sorts of errors (mostly network faults) without writing much error handling code. It just retries automatically, and importantly the happy path and the error path are exactly the same, so I don’t have to worry that my error path has much less execution than my happy path.
> but the part of that transaction that failed was “charging the customer” - did it fail before or after the charge went through?
In all cases, whether the happy path or the error path, the first thing you do is compare the desired state (“there exists a transaction exists charging the customer $5”) with the actual state (“has the customer been charged $5?”) and that determines whether you (re)issue the transaction or just update your internal state.
> once you’ve built sufficient atomicity into your system to handle the actual failure cases - the benefits of taking on the complexity of a DE system are substantially lower than the marketing pitch
I probably agree with this. The main value is probably not in the framework but rather in the larger architecture that it encourages—separating things out into idempotent functions that can be safely retried. I could maybe be persuaded otherwise, but most of my “durable execution” patterns seem to be more of a “controller pattern” (in the sense of a Kubernetes controller, running a reconciling control loop) and it just happens that any distributed, durable controller platform includes a durable execution subsystem.
I'm not nearly as angsty as the parent on this subject, but they don't really free the developer from guessing about hidden allocations--Go's allocations are still very much hidden even if developers can reasonably guess about the behavior of the escape analyzer. I think it would have been better if Go _required_ explicit assignment of all variables. That said, despite not being a big fan of this particular decision, Go is still by far the most productive language I've used--it strikes an excellent balance between type safety and productivity even if I think some things could be improved.
> It's been many years since I wrote any Go for a living, but does Go seriously lack a way to say "foo is probably 32 bytes, give me the 32 byte array, and if I'm wrong about how big foo is, let me handle that" ?
Not in the static type signature, but you can do that as a runtime check either by casting and handling the potential panic (as described above) or by checking the size and returning an error if it's not as expected, which is what the library does.
The protocol supports query strings so the server can generate content based on the string, which can be used for an in-Gemini Gemini search engine. It doesn't have to be all static content. People could also build out a directory (like the now defunct DMOZ and similar directories for the Web).
