Web programming is difficult in a different way than say, compiler construction or kernel programming. Web programmers have to deal with malicious users, a potentially vulnerable gigantic stack of applications, sessions, databases, communication costs and whatsoever. One might say: Web programming is mad due to integration issues and malicious users.
On the contrary, take compiler construction. Compiler construction is hard, because language design is hard and because mathematical reasoning about programs and program transformations is hard. Generating code for a language is hard, too. Thus, one might say that compiler construction is hard due to mathematical issues and hard with respect to algorithms.
I do not think, I would be able to build a secure, good webapplication anywhere soon, despite having touched and worked with two large, strong complicated compilers. Thus, I think the difficulties are different.
On the other hand, 'all programming is web programming' is just ridiculous. I mean, one can easily drop a gigantic list of things: kernel programming (without kernels, NOTHING works), compiler construction (without compilers, we'd be in stone age), games (c'mon, totally disregarding egoshooters?), media codec implementors (videos, music, ...). None of these directly interface with the web, but all of them are important (at least kernel programmers and compiler constructors are crucial for usual boxes to somehow work). So, not all development is done for the web.
I just wonder when and especially why Atwoods posts go (rapidly) downhill like this.
To me, web programming isn't as well-defined as most programming topics, and requires competency in too many domain-specific areas for one person to master all of it.
Assuming you know what you want your language/web site to look like, compare..
Writing a parser generator, parsing the tree, optimizing the instructions, generating the instructions, regression testing, benchmarking
with..
Designing a database schema, maintaining HTML/CSS, making a pretty design, writing Javascript, safely deploying, configuring web servers, generating test environments for all browser/OS combinations, doing usability testing, and making sure you're not giving away any of your users' data.
A lot of the compiler-writing phases are yes/no (language design aside), and a lot of the web phases can't be answered easily. E.G. "Is our login system secure?" "Well, probably... Dave's pretty good with this stuff and he thinks it is."
Who cares about platform or depth of technical knowledge? If some PHP hobbyist who knows nothing about mmap(3) delivers a site that works for people then he is a successful programmer.
But assertions like "You hope everything doesn't "move to the web"? Wake the hell up! It's already happened!" irk me.
That is disingenuous at best. Even the most ardent believer of "everything on the web" will fire up Photoshop for even the simplest of graphic requirements. There will always be a requirement for people to know the ins and outs of desktop programming.
The statelessness of HTTP, and the long list of requisite skills (JS/HTML/CSS/SQL) needed to build something application-like are pretty serious. And that's before you even get into messaging, caching, and optimization. In the blog post the buffoon spends a paragraph decreeing the nightmares of web development, and the next calling those who want to develop for it "dumb." I'd say the opposite is true.
Alas, there is somewhere in the middle of the spectrum where it's pretty boring for someone who enjoys programming. But I think any technology can get boring when the job becomes more a task of memorizing an API and using it the way you're supposed to than actually hacking. While C is "hard core," doing something in C with X11 is an exercise in rote and memorization.
He goes on about his IDEs and debuggers. What's with the debuggers guy, too dumb to not make mistakes? What's he working with that he's so happy using, Squeak?
So yes - this guy is an idiot. If you're result oriented, the web is a great place to build an app because there are fantastic frameworks to create things quickly that anyone with a browser can use. And if you're hacking oriented, you can write your own framework.
The programmer does. There are a lot of really smart programmers that just want to work on interesting challenges. And if you're the kind of programmer that enjoys solving difficult problems, you're not going to find many when building web 2.0 apps.
Your problem is that you're focusing on the same challenges and finding them easy, instead of thinking about what new things this simplicity enables. Step up a level, use the higher level tools to build better things - and you'll be challenged again. And you'll make better things.
Just the other day I was looking for a visio replacement, on a hunch I asked here if somebody knew of a web based version of it and I got two viable suggestions. Now, 5 years ago that would have been laughed at with 'that will never happen'. Now it is there.
Give it another 5 years and who knows. Maybe the next iteration of the gimp is going to be a service, not a local program.
I hold absolutely nothing for impossible, I've been wrong too often in the past :)
note to my fanclub: instead of downmodding try to explain why you think this is wrong.
and have a look at this:
For the time being, I find that when there is a web version and a nonweb version, the nonweb version is virtually always more feature rich, more robust, and more polished than the web version. That could easily change in the future.
One thing that is unlikely to change is that I will have more control over the nonweb version, including amoungst other things the ability to refuse/ignore certain upgrades and to know that my data is staying on my local machine and not being sent to third parties at all. This is normally trivial for most things, but it can be very important for mission critical items where consistency, stability, privacy, and customization are more important that being on the bleeding edge.
Of course, it is possible good solutions to even those last problems will be found, but I do not think that one is on the horizon yet.
In short, I think that there is a place for both and that for the near future more things will (and should) move onto the web. But not all of it and in particular not the most important parts.
Some pretty impressive stuff going on out there.
The original comment had to do with amateur programmers that can't do anything else other than write simple php with complete disregard to the complexity of computer science. But when you're making a scalable commercial webservice, you need to know a quite a bit about compilers, concurrency, inheritance, and hardware. Probably the only major difference is that you learn about html + css + ajax instead of MFC (or gasp visual basic).
Software is about the value to the end user, but it's also about cost. When you want to be efficient, you can't just use the simplest tool to implement the features, you need to know much more about the specifics. It just so happens that web development is easier to do poorly than desktop programming.
Always is a very long time.
Where a C programmer may be stuck in a codebase debugging memory leaks, a Python programmer may get stuck walking through a 20-level stack trace to figure out which things are blowing away some attribute on some value that he thought he set and causing the web page to fault.
When we make things "easier", we just take on bigger tasks. Programmer skill will still be the dominant factor in quality of the resulting system. In some ways the "easier" tasks are harder, as there is a lot more opportunity to make bad cost/benefit analysis due to the larger scope of the world of possibilities.