What's wrong with Software nowadays and how we can fix it

A lot of people use software, but does that really mean they need to know how to create their own?

sbov's car analogy suggestion is apt: a lot of people drive cars, but should they be expected to be able to maintain their own?

A kinda related side observation:

I found my brief stint working with Max/MSP (a visual language typically used by musicians) to be illuminating. This is a tool for non programmers (musicians in this case) to write software for their own use and it succeeds at this. Its kind of like excel for musicians. But, just like excel, the software created by these people, while functionally they work and do what the musician wants, are written in pretty terrible spaghetti code (giving visual programming a bad name in the process), because the users never learned software engineering principles (even simple ones like abstraction).

Just as with excel, this is fine for write-only once-off tools and I certainly do think that more excel-like tools that allow non-programmers to solve their own problems are necessary and will help in software literacy. However, I don't think that these tools or skills will achieve a world where most people can write and modify software in general because they won't have been trained in the software principles we take for granted. Try and debug a large non-programmer-created excel sheet sometime for example. :)

My point is that its not exactly like basic arithmetic, but as you say its not thaaat different either. Yes, some excel-like tools and a bit of training will allow more people to create their own little solutions to their day to day problems, and this is something worth striving for, but it won't be enough to let them create/modify large software in the general case. For that, they need the full blown mathematicians training (or, some of it, anyway).

> you can do something yourself that used to require a professional

I suppose THIS is what the goal is or should be. Not to make everyone a programmer, but to allow people to do more things for themselves that they previously required experts for.

This looks interesting to me as a programmer, but it looks much too complex and niche-knowledge-dependent to be, in my opinion, a real contender as a tool to allow non-programmers to program.

I only glanced at it, though, so maybe its easier than it seems, but to me, the samples looked complex enough that I don't see it.

It does look great as an experiment into different programming models though and that's something I always enjoy (and is needed if we're to get better future tools).

I don't think he was talking about present day technology; rather, he was referring to abstract machines.

Whoever taught you computer science must have had a very pessimistic attitude, which is surprising to me as most of the academics I've talked with think the computers of the distant future will have no limitations.

In the preset day, though, we have limited time and must choose our battles carefully. I respect the OP for his attempts, if a little a misguided. Just ask any active member of the Linux kernel and they'll tell you how often they see such people undertake similarly bold approaches which deliver little outcome (and, hopefully, a life lesson...)

Perhaps there's intended subtext saying that computers have the capability to do such things, but we are unable to do such things with the current technology and knowledge. I mean, you're right. The statement shouldn't have been said without being explicit.

I dunno. I'm just trying to give benefit of the doubt.

In writing this defense of the article, I realize that such a flawed premise shouldn't exist when talking about teaching fundamentals.

After reading the thesis, the proposed model of computing is like a concurrent Smalltalk where everything is completely mutable, even an object's code and prototype chain. The author then writes a function to calculate the Fibonacci sequence by turning it into a distributed system, with some effort, and then runs the code and talks about its performance!

At first glance, there seems to be a lot of incidental complexity and creative choice in expressing a function from integer to integer in this system, which goes against the ideas of code reuse and separating meaning from optimization -- i.e. that there is one global Fibonacci function that we can inspect and understand and don't have to rewrite for performance, or in another language, or to run in a distributed fashion.