It's less a binary pay/no pay, and more the value of accessing the dev tools. If you consider the fact that AI companies are most likely losing money running the models, then AI tools are incredibly cheap - they're in some ways paying you to use it.
No model maker is going to try to generate a profit off users using their models, they're gonna try to generate it some other way - much like dev tools.
Unreadable slop and "tasteful" choices are independent of each other. You can make "tasteful choices" that makes code unreadable (I know from experience).
Readability also has some level of objectiveness to it. There's only so many ways you can abstract a concept, and so many ways you can express logic.
In that sense, readability has way more to do with skill in abstraction, than taste. In fact picking bad abstraction layers or expressing logic in odd manners because of taste is a great way to write unreadable slop.
Nothing that you talked about pertains to art. Writing good code does not mean you're making art.
You shouldn't strive for internal consistency with yourself, you should strive for external consistency with the other developers in your team. If someone reads your code and immediately knows it was you, you probably aren't doing a good job.
And that's the difference. If you are doing a good job as a software engineer, no one should notice you. If you're making good art, everyone should see you. And that is the difference between devs who think they're good, and devs who are truly good.
Some of the worse engineers I've ever interacted with had too strong of a "taste" for what they felt were right and were completely unable or unwilling to work outside of that. Developing a superiority complex because you think you have "taste" is a great way to torpedo your team.
Coding for others is not art, it does not have much meaning in of itself. Your users won't marvel at your choice of language or your usage of design patterns - they care about how the end product looks and works.
In a world like that where you have to work in a team, why you ever wear your inflexibility as a badge of pride? The ones who are the most useful are the ones who can code any way, any how, and can plugin anywhere - "taste" be damned. If you want to be a net positive on the teams you work on, stop thinking it's about you, because it's not.
I don't have personal experience with this, but React Native Web claims to solve this issue: https://necolas.github.io/react-native-web/, not sure if anyone has had experience with this. Of course, you will have issues with dependency hell/package maintenance.
Another great option seems to be Flutter web. I was really impressed by the "batteries included" approach to Flutter, and Dart has a pretty comprehensive standard library. This is in contrast to React's "just find a random package on npm and pray it doesn't bite you in the future."
Obviously rewrites are expensive, but I personally think both approaches are worth considering versus abandoning native components completely. WebView isn't without problems (and also, you don't need React Native to use WebView).
I worked with Django at a startup for <1y on a team of ~10 engineers. Django migrations are easy and better than a lot of what's out there, but I thought they could be better for the following reasons:
1. Merge migrations are annoying. Especially when you get some engineering velocity going, it's very common to get some conflict. Almost every single time, the merge migrations did not conflict at all.
2. Migrations made checking out someone's code to run on your local machine difficult. You gotta remember to unmigrate before checking out your own branch again, otherwise some future migration may fail.
3. Migrating/unmigrating can be hard to reason with. There has been a lot of cases were a junior engineer pulls the latest code, then realizes their DB is borked due to migrations (maybe a phantom migration that is no longer in their codebase). In some of those cases, we just tell them to start from scratch, since it's easier.
The solution outlined by OP is nice because it eliminates the overhead of those migration files, and only looks at the intended state (the SQL file), and the actual state (the database). While the migration files do provide some necessary ceremony for dealing with user data in prod, I'm not sure if we've ever gotten anything good out of said ceremony versus the overhead we needed to maintain.
We had something similar at Google, where you change some CREATE TABLE statements in an SQL file, then run a migration based on that changed SQL file. It was insanely nice. I think this tool can be super useful, especially with a lot more people using something like Litestream.
I'm personally (and maybe naively) of the opinion that DB migrations should be as painless/automated and without ceremony as possible. I wish there were more tools like this out in the wild.
I see a good number of commenters mention that they also went through the same program/went through something similar.
I was wondering if getting the degree translated into any professional benefits? The conventional wisdom is that degrees don't matter, but the author in this blog post says otherwise and they unfortunately have not written a follow-up. I personally have a degree, so don't have perspective.
No model maker is going to try to generate a profit off users using their models, they're gonna try to generate it some other way - much like dev tools.