It's hard to unpack without knowing more about the use case, but adding discriminant properties (e.g. "user_type") to all the types in the union can make it easier to handle the general and specific case.
E.g.
if (user.user_type === 'authenticated') {
// do something with user.name because the type system knows we have that now
}
The dot com boom is an apt analogy: the internet took off, we understood it had potential, but the innovation didn't all come in the first wave. It took time for the internet to bake, and then we saw another boom with the advent of mobile phones, higher bandwidth, and more compute per user.
It is still simply too early to tell exactly what the new steady state is, but I can tell you that where we're at _today_ is already a massive paradigm shift from what my day-to-day looked like 3 years ago, at least as a SWE.
There will be lots of things thrown at the wall and the things that stick will have a big impact.
Having used the latest models regularly, it does feel like we're at diminishing returns in terms of raw performance from GenAI / LLMs.
...but now it'll be exciting to let them bake. We need some time to really explore what we can do with them. We're still mostly operating in back-and-forth chats, I think there's going to be lots of experimentation with different modalities of interaction here.
It's like we've just gotten past the `Pets.com` era of GenAI and are getting ready to transition to the app era.
I’ve never been able to put it into words, but when we think about engineering in almost any discipline, a significant amount of effort goes into making things buildable by different groups of people. We modularize components or code so that different groups can specialize in isolated segments.
I always imagined if you could have some super mind build an entire complex system, it would find better solutions that got around limitations introduced by the need to make engineering accessible to humans.
The "iPhone moment" gets used a lot, but maybe it's more analogous to the early internet: we have the basics, but we're still learning what we can do with this new protocol and building the infrastructure around it to be truly useful. And as you've pointed out, our "bandwidth" is increasing exponentially at the same time.
If nothing else, my workflows as a software developer have changed significantly in these past two years with just what's available today, and there is so much work going into making that workflow far more productive.
You posted on X a while back asking for a crowdsourced definition of what an "agent" was and I regularly cite that thread as an example of the fact that this word is so blurry right now.
The collective backlog of every software company probably stretches into centuries.
This gives us the tooling to
A.) burn through those faster.
B.) solve more complex problems.
If your entire job as an engineer is “take tickets with very clear acceptance criteria and turn into component / basic business logic”, I’d be worried for sure. I was initially worried myself when all this landed two years ago, but using it daily and now building enterprise scale apps with it, I know we’ve got at least another decade or two before it’s able to tackle the full breadth of an engineers role.
- Some early studies have shown modest gains (can try and link later)
- It’s still very early. LLMs have only been publicly available for 2 years, copilots a little less than that.
- It’s mostly anchored on cold starts ie I’m creating something from scratch. Leveraging LLMs in existing and mature codebases is definitely going to pick up.
- The majority of devs aren’t really using these tools or using them to their full ability. It takes a lot of fiddling to understand the limits and strengths, but when you do, you basically stop writing code and write more prose.
I will be surprised if in ten years even a quarter of your keyboard inputs will be towards code directly vs directing your friendly coding robot.
I've seen some pretty wild conditional string interpolation where there were like 3-4 separate phrases that each had a number of different options, something akin to `${a ? 'You' : 'we'} {b ? 'did' : 'will do' } {c ? 'thing' : 'things' }`.
When I was first onboarding to this project, I was tasked with updating a component and simply tried to find three of the words I saw in the UI, and this was before we implemented a straightforward path-based routing system. It took me far too long just to find what I was going to be working on, and that's the day I distinctly remember learning this lesson. I was pretty junior, but I'd later return to this code and threw it all away for a number of easily greppable strings.
One of the things I was gobsmacked by the first time I used Figma years ago was its performance, which has only gotten better with time. From what I understand, they've built some custom stuff for WebGL for their renderer.
Here it looks like it's powered by React. I'm curious if anyone's used both and can compare the performance of the two.
https://www.anthropic.com/jobs?team=4050633008