It's totally reasonable for tech folks to be leery of a company using a strong market position from one system (Windows/Claude) to push mediocre complementary software (IE/CC).
16,934 karma · joined September 12, 2011
I am interested in programming languages, functional programming (especially Haskell), domain-specific languages, static analysis and program synthesis.
I am working on apply programming language ideas to supply chain planning.
I worked on supply chain optimization at Target for several years, and co-authored a textbook on reinforcement learning based on that experience.
contact: http://jelv.is, tikhon@jelv.is
It's totally reasonable for tech folks to be leery of a company using a strong market position from one system (Windows/Claude) to push mediocre complementary software (IE/CC).
Who would be looking up the integral of one of the most common functions in applied math in a random philosophical article aimed mostly at SREs?
For example, I saw a paper on using metamorphic testing (a particular technique for defining properties to test) to find bugs in the web APIs of Spotify and YouTube[1]. I don't have time to reread the paper just now, but I remember that they found weird behavior in pagination of search results. Not a big deal in that particular case, but I've definitely seen internal APIs with behavior that could be similarly wrong but with a much larger real-world impact.
[1]: https://ieeexplore.ieee.org/document/8074764
Personally, I see property-based testing and formal specification more as tools for design and debugging more than full-on correctness. Even with AI models it's still really hard to fully prove something correct, but having even a partial logical specification can let you trade design time for debugging time and lets you find inconsistencies or potential edge-cases when you're initially figuring out a system, rather than waiting until you have a massive codebase to debug and redesign in production.
It's not a panacea and you still have to be careful at the boundary between your nicely modeled system and the real world, but, once I got the hang of working in that style, having some formal properties or partial logical specifications of the behavior I needed has been really nice to have, as much for saving effort as for ensuring correctness.
I've mostly worked in slightly different domains, but I've found property-based testing useful both as a tool to catch bugs but also as a tool for communication. I spent a couple of years building and supporting a supply chain simulation at Target, where I frequently got requests for new metrics from the supply chain planning team. By teaching them how to specify either the whole metric or, at least, some of the expected behaviors of the metric as mathematical properties, it took far fewer back-and-forth conversations to correctly implement the metric in the simulation. We could then test these things by checking these properties over a bunch of random simulation traces. Day-to-day this saved a bunch of time in debugging small simulation mistakes. In the longer-term, having this test suite also let us rewrite the simulation code in a new style in Rust to drastically increase performance. All of this would have been possible without the set of properties, it would have just involved a whole lot more slow, tedious work.
I still use web searches to look up Emacs things occasionally, but the built-in help commands are still useful because they're naturally tied to (and organized by) the core code entities that power Emacs.
Which is a much more interesting statement in the context of certain other crypto organizations than it is about FTX...
If online comments are anything to go by, I'm not alone.
If you're in the Bay Area and you can get a Sonic fiber connection, I would highly recommend them over AT&T/Comcast/etc.
This seems like a reasonable view to me. It's surprising just how much better priors matter and how we can develop those priors by training on a bunch of text. But it also explains, or at least hints at an explanation, for why LLM capabilities are so jagged, and in such inhuman ways.
Besides, in your example, either kind of gap could be a bug or a missing feature. It's a totally orthogonal question.
"You don't support printing", "pressing the print button doesn't print", "pressing the print button crashes the computer" and "pressing the print button lets an attacker get root access to the system" are all different and it makes sense to distinguish them. (The first is a missing feature, the second and third are different kinds of bugs, the last is a special kind of bug we call a security vulnerability.)
That distinction might not be useful to end-users, but it's useful for the people building the system! If you want to care about quality, committing to a strategy like "we will not add features before we fix known bugs" is totally clear, reasonable and effective. There might be some frontier of issues where it's hard to make a distinction, but that just means there are subtle edge-cases, not that the whole concept is undefined. A lot of perfectly cromulent concepts have edge-cases! You can just decide those on a case-by-case basis; if it's actually so close as to be legitimately confusing—it's not just feigned ignorance or political posturing—which side you choose probably doesn't have much of an effect.
This does depend on having a reasonably clear idea of what you're building, but that "reasonably clear idea" does not have to be anywhere near the detail of a "full spec", much less anything formalized. To me, that seems like a baseline you'd need to build quality software at all, and hardly an unreasonable thing to expect. And if most teams can't manage, well, it's just another explanation for why most software is crap.
There might be some way to design a system from the ground up to avoid this problem (some kind of declarative, capability-based security?), but retrofitting that onto an existing behemoth of a system does not really work.
A great illustration of this idea in context is Andrew Gordon's book on the Battle of Jutland, The Rules of the Game[1]. He mostly contrasts the leadership philosophies in the British Navy shortly before and during the Battle of Jutland. The British Navy became very top-down and procedure-oriented during peacetime, which did not generalize well to operating in battle.
[1]: https://www.goodreads.com/book/show/354137.Rules_of_the_Game
I'm amazing at how anybody can discuss any questions about the tech job market without addressing the end of zero-interest rate policy. "It's interest rates, stupid" ought to be the first thing we consider, and stuff about AI/remote/etc only comes in when we have a specific reason to consider it.
Most people don't—and don't have to—care about quality for their short, simple documents, but that is neither good nor inevitable, and it's always worth trying to do better.
It's a bit odd to get moralistic over saving/spending money in general, but that's especially true around expensive homes.