So... You are saying 'you should write everything yourself with libraries that basically don't exist'? I agree with you somewhat, but it's not very realistic; it's so much faster to use something that gets you 80% of the way with minimum work. And you know it'll break in a bit but that's life.
Also, thinks like Django or ASP.NET have been pretty stable for a very long time. We have large Django projects from 10 years and updating those was a breeze.
it's not very realistic
It is totally realistic. I have multiple projects running that do not use any external code. With millions of users.Those projects are PHP though. PHP has a lot of bells and whistles on board. Unfortunately with PHP 8, they started introducing a lot of breaking changes. So they lost my trust and I will use Python for new projects.
Not sure yet if I will use Django (As you said, it seems pretty stable) or do the good old CGI approach. If I do the latter, I will probably write a new CGI library for it, because in the Python ecosystem it is all about long running processes nowadays and I think that is the wrong approach.
Years ago I had to deploy on a network file system which was very slow for file stats. (It was designed for HPC and bandwidth.)
Python startup (by default) requires a large number of stat calls. It took our CGI app over a second just to start.
I was able to improve it by packaging the Python std lib as a zipfile, and our app as another, since zipimports avoid a lot of stat calls.
TurboGears had just come out. I did a prototype using it. Its was so much faster!
For organizational reasons were were not able to switch. IT took over and, after several years, replaced it all with a Java version.
PHP starts up from scratch on every request, yet it blows Python out of the water performance wise.
PHP is quite slow at encoding and decoding JSON, very slow at any kind of tree data structure, and has among the highest memory usage of any language at printing a string of text to a console or otherwise.
Python is faster at all of those things and it's quite slow. Those are kind of web related tasks, and the web benchmarks for say django vs laravel don't show that PHP is any kind of winner.
I know startup times can take a toll like establishing db connections, cache checking (like redis), file imports, etc. If you are using something that starts up for every request, then you have to be aware of those kinds of things and design around them.
I literally gave a timing number in my comment.
The >1 second time was for a very unusual circumstance. Unless you timed PHP startup time using straight CGI (not mod_cgi, nor FastCGI) on a Lustre file system about 15 years ago, with the appropriate set of extensions enabled for what our application needed, you can't really compare the two.
> PHP starts up from scratch on every request
Congratulations.
Now getting back to your request to "Name one", the PHP documentation at https://www.php.net/manual/en/install.unix.commandline.php gives essentially the same answer as I did:
"By default, PHP is built as both a CLI and CGI program, which can be used for CGI processing. If you are running a web server that PHP has module support for, you should generally go for that solution for performance reasons."
Particularly async runtimes have become more popular - where you can have a single process handling concurrent requests and awaiting/yielding in between their api/db calls. Instead of having many processes that don't share resources that might be waiting 10ms/100ms for api/db calls.
For applications that make large numbers of api/db calls - especially slower ones, may prefer async runtimes over individual processes per request.
I'm not at all saying CGI is a bad option, just that there are real benefits to reusing, pooling and caching resources.
Frameworks really shine at quickly proving out concepts. They enable prototypes that would have otherwise been too costly to produce, which is often the difference between a project moving forward or not.
The problem is often what comes next: teams fall for the productivity boost and carry the rapid design forward expecting similar gains throughout the rest of the project.
I use frameworks when I want to get ideas out of my head. I tend to throw framework code away if I take the project further, and I’m in a better position to implement from scratch knowing what I’d do differently.
YMMV, the environment you work in makes a big difference, the kind of thing you’re building makes a big difference, etc.
When I face an issue with the framework, I tend to question my ability as a programmer, even though i could code it myself.
Like a non trivial django form, I could have just manually coded the form, then just pass the data to the view, validate it manually. Instead of fighting
A great example of finding a way out of clutches of a dichotomy.
But that’s not why we adopt frameworks. We do it so that engineers are fungible commodities. It makes it easier to find, hire and onboard additional resources. Also requires fewer resources since you don’t need folks on your team dedicated to maintaining your house-built framework.
So, while I agree that building something in house is better for getting exactly what you want from a framework, it isn’t very practical from a business standpoint.
If it doesn't then the code you wrote yourself will eventually break as the rest of the world advances their APIs and standards.
Even a website written in pure HTML and put up on a small linux server a decade ago would have rendering issues as well as probably not allowed past browsers or corporate firewalls due to older SSL libraries.
Unfortunately the only apps that live in a vacuum are embedded apps not connected to the internet. We should all be monitoring our dependencies for security upgrades. Eventually even a stable framework like Django goes out of long term support. I wrote a Django app in 2008 that is still in heavy use today and at some point had to go through and upgrade to a new major version. It wasn’t a breeze, it took me a few weeks. To leave the app live on that 10 year old version would have been irresponsible for security reasons. The only apps that live in a vacuum are embedded apps, like the one in a vacuum cleaner.
It's so old it has no https interface.
I do depend on my hosting provider to keep Apache and FreeBSD up to date, if only for security reasons.
Frameworks are always eventually the wrong approach.
But so many projects need a 1.0 without breaking the bank.
Just take Ruby on Rails, which is probably a great example of a framework that runs into the problems you're describing. My experience with more contemporary, generally more junior, dev teams is that the "Rails" part of the framework is essential for these developers to maintain any loose semblance of adherence to any kind of architecture or design principles.
Earlier in my career I remember, even junior devs, spending a fair amount of time thinking about about the abstractions they were using, making design decisions, and often times being more guilty than not of over thinking abstractions.
Today I've seen so many very bright and talented engineers whose sole view of good software is minimizing the time from request to PR (and code reviews that strong favor minimizing the time from PR -> prod).
If you have a bunch of senior engineers (not SV "senior", but truly experienced), and they're the type that still pick up SICP form time to time, or spend a Saturday reading a section of TAOCP, then sure I think the framework-free approach is best. But you also don't need to tell that to a team of engineers like that.
Otherwise, frameworks and even languages that do the most handholding when it comes to design decisions are going to remain essential.
A lean library will turn in to a framework if you decide to build anything more than a minimally complex app.
The widgets are conditional imports. If you don’t use the tree widget, it is never imported.
You could argue that you can make money writing without frameworks but at what cost and how many teams can successfully do that ? Framework gives any team (even average ones) the headstart they need to continue to actually do something that makes money.
Too many devs care way too much about having a pretty solution instead of a cost-efficient one. The solutions space usually has a middle ground somewhere (affectionately called 'horrible hack' every once in a while). It's what makes a difference between a software engineer and a programmer.
To paraphrase, anyone can build good software, but it takes an engineer to build good software quickly.
Libraries can change as well. Frameworks are just that, a bunch of libraries.
You gain development speed in the beginning, but you lose it later on when the framework introduces breaking changes and you have to keep working around a changing stack. Or the framework gets abandoned and it would be too much work to maintain it. Because it has so much bells and whistles you don't need. This one for example contains 1298 files without dependencies.
Both, coding everything yourself or using lean libraries are better. There are very few lean libraries unfortunately. Keeping code elegant and simple is a rare skill.
When there is a lean, well done library for my use case, I use it. Because if shit hits the fan, I can maintain the library myself.