Slashdot Mirror
Removing Software Complexity
t482 writes "Charles Simonyi (ex Xerox Parc & Microsoft ) says that Software "has become a field where we focus on incremental improvements in processes. That course is futile, because it can never solve the problem of human imperfection."
Even as software collapses under the weight of its own complexity, we've barely begun to exploit its potential to solve problems. The challenge, Simonyi believes, is to find a way to write programs that both programmers and users can actually read and comprehend. Simonyi's solution? To create programming tools that are so simple and powerful that the software nearly writes itself.
"Software should be as easy to edit as a PowerPoint presentation," Simonyi asserts."
Little known fact: This is the same Simonyi who invented hungarian notation.
Google for "the tactical nuclear weapon of code obfuscation" to receive further enlightenment
Dave
I write a blog now, you should be afraid.
I take it that Hungarian notation has been left by the waysideon the road to less complexity:)
I agree wholeheartedly with the complexity issue.
I measure my success as a programmer by whether or not another programmer (or myself far in the future) can throw my work onto the screen and understand very quickly what the code is trying to do.
Bugs can be fixed, features can be added and performance can be enhanced later. But not very easily if the code is too complex or, equivalently, has too much abstraction.
"Provided by the management for your protection."
Will write the programming tools? Seems to me Simonyi's not talking about a replacement for modern programming, but an incremental advancement over say AppleScript or Hypercard. More powerful userland tools will not completely replace programming: someone will need to write the components. Or is he thinking that all the components will be in the OS, and thus third party programmers could be eliminated and the OS vendor and the user would be the only parts of the transaction?
Saying software is too complex is stating the bleeding obvious. But the world is complex and it's not that easy building software, wether you're a programmer or user, that can simplify it. A clue to this is how good, user-friendly software is much harder to write.
He keeps on pushing his Intentional Software barrow, but where are the techniques that actually deliver results. Anything most programmers will come up with will be just as impenetrable as C. The problem is programmers are not known for their empathy for users and don't really want to try to find out what it means to not know how to use a computer or its software.
Reliable, Great Value Hosting: $7.95/mo 2.4G/120G
There's a whole raft of tools out there that put this philosophy into action - witness MS Access, VB etc. Even an Excel spreadsheet can be viewed as a 'programming environment' really.
There are 2 kinds of problems that programmers solve - technical problems and business problems. The technical problems can be abstracted by tools like the above, but the business problems remain.
Techniques such as Object Oriented design, abstraction, etc etc are just as useful for solving these kinds of problems as they are, for example, when writing a new web browser.
It's difficult to see how a groovy GUI can hide or solve these problems. You're still going to need a certain set of skils to guide the development and architecture of any nontrivial system.
I'm sure we've all see complex websites that have been put together by naive users of Frontpage - bloated HTML, endless redundancy (cut-n-paste) and a hideous task for someone else (with a similar skill level) to pick up and modify. It's hard to see how you can prevent these kind of problems when you go down the "everyone can use it" path.
Simonyi has a good point. Don't let Hungarian notation bother you -- it's a kludge on top of an essentially untyped unprotected language (C) trying to get back some of the protections offered by strong typing, and while Hungarian notation is a horrible solution, so are all the others.
But the problem is that while keeping clarity is a great idea, it's proven immensely hard to do. Fred Brooks (viz., the No Silver Bullet paper) argues that this is because the problems we're solving with software are intrinsically complex; there's no way to reduce the complexity below a certain point. On the other hand, anyone who writes real code knows that they spend a hell of a lot of their time writing the equivalent of a for loop over index i again and again and again. There's some unnecessary redundancy there.
But saying that you want less complexity is a lot different from saying you know how to get rid of the complexity.
Not only that, but it is entirely unmaintainable, even by him.
Real programming is a whole lot more than just pushing some buttons around.
Sticking feathers up your butt does not make you a chicken - Tyler Durden
People want to make the world in their image. So, they hot-rod their cars, paint their rooms new colors and ask for new software. That software need to do something that hasn't been done *and published in a coherent way* before. So the programmers delve into the details of APIs and language capabilities and create complexity.
.NET and web services) We all know how Visual Basic attracted lots of newbie programmers without formal degrees who clamored to read Compu-Mags for tips, and MS beefed it into a full-fledged development environment (compiled exe's, generate COM natively, getting away from variants). It has solved many problems, but didn't create a world of commodization as hope (even if there are 100's of OCX vendors in those same Compu-mags)
Also, the migration between new hardware, capabilities (higher bandwidth, wireless) or goals (FPS gaming) and such are always going to create a complex "first example" that need many iterations before commodization.
I think this guy is premature to assume all programming goals are easily commoditized right now. If people were to give up behaviors when the plug-ins given to them don't exist or are buggy, thee'd be a lot of hodge-podge solutions.
Example: Visual Basic programming was supposed to be a "glue" for clicking together COM ocmponents, and MS was touting a new era of component "publishers" and "subscribers" (and next up is the same thing via
But it just doesn't happen in the long run. You can buy enterprise that does thing from soup to nuts and still find tons of work in "making it your own" with interfaces, reports and other customizations (talk to an SAP project manager).
Anyway, this is an interesting topic, but ultimately limited.
I'm not saying things like API obfuscation or similar. I mean people don't generally think logically. Computers don't think emotionally. The average person has no idea about algorithms, or why you may want an O(lg(n)) algorithm in preference to an O(n^2) algorithm.
For these things, professional programmers will still be required.
I can't say that I don't give a fuck. I've just run out of fuck to give.
... all of those technologies make designing simple apps a piece of cake. Shouldn't be that hard to make a visual IDE for newbies that generates those XML.
Intelligence shared is intelligence squared.
Someone just needs to write a program that users can run, to check and make sure that the target program runs correctly!
(yes, I'm joking)
(\(\
(^.^)
(")")
*beware the cute-bunny virus
All keyboards that are not IBM Model M keyboards are evil.
Don't you know anything?
I think it's great for them to pursue tools that make it easier for non-programmers to do more useful things for themselves.
I'm not too concerned that this will replace the current type of programming, though. The biggest problem is that the real-world problem being solved is almost always more complicated than the domain experts themselves realize.
When I sit down with a client domain expert to write a program for them, they are invariably surprised by what I uncover. I gradually tease out a huge variety of scenarios that they've never thought through or decisions that they make on the basis of "experience" whose rules they can't possibly express explicitly, comprehensively, unambiguously, and without contradiction -- on their own.
It just doesn't matter how easy it is to explain the rules to a computer if you don't have the skill that experienced programmers have: to completely specify the problem. Fully explaining how to solve a problem to something other than another intelligent and experienced human is harder than most non-programmers realize. (Of course Simonyi knows this, but the journalists who cover his work probably don't.)
"Those who have never entered upon scientific pursuits know not a tithe of the poetry by which they are surrounded."
Another company tried something like this in the mid 90s (1996 to 1998). Their product was called Icon Author (glorified flow chart using icons and flowchart symbols) it was simpler, but the logic still perplexed some of the temps we hired at the company where I was working during that time. They even tried to make it cross-platform, but they failed because they used MFC (and MFC on the Mac sucked {on purpose probably}). They might have succeed today if they use wxWindows.
The problem with this idea will be getting around the complexities of programming--like the logic. Some people just aren't logical thinkers. Icon author made programming somewhat easier but it didn't make the logic easier. Some people have problems with concepts such as loops and data structures. They may get around this problem, but it will have be done by making sacrifies.
At the next eco-hypocrisy-meeting, count the private jets used to get to the meeting. Should be interesting to see that
No, VB and Access made it possible for untrained people (and naive managers) to THINK (quite incorrectly) that they could write software and DB apps.
Exactly.
There is no silver bullet for making software easy, and this has been known for decades.
Cobol, for instance, was supposed to be English-like, and hence understandable and programmable by non-programmers. Other English-like programming languages have made the same claim. Wrong every time on all counts.
The problem is that specifying arbitrary algorithms requires extreme precision, unambiguity, and tedious detail far beyond anything the average person is even interested in attempting, let alone capable of. It doesn't particularly matter which language or tool is offered, what matters most is the person's abilities (and willingness!) to be excruciatingly detailed and logical and patient.
This has been studied to death, but hope springs eternal...
Another kind of lack of silver bullet are declarative languages...it's vastly easier to declare what is needed than it is to specify procedurally how to achieve the goal. However, no one has ever invented a Turing complete declarative language, and there is good reason to think that such a thing is impossible (infinite potential problem domains).
Simonyi is a very intelligent and experienced guy, so he likely knows this. I hope he does; he should. So I like to interpret what he's saying as a grandiose way to say that he's hoping to make a big improvement in the art of programming -- there certainly is huge room for improvement.
But if he literally means he hopes to make all programming as easy as making powerpoint slides, then he is a fool or a liar (but he might still produce some cool tools).
(Making really cool graphics for the backgrounds of powerpoint slides is an art, BTW ;-)
Professional Wild-Eyed Visionary
Calculating a differential query means that you modify the outcome of a query based on how the data changed instead of reexecuting the whole query.
And abstraction is the fundamental means of reducing complexity.
The history of programming is the movement from physically inserting patch cables to program a computer to manipulating abstractions. In languages like C, those abstractions are still pretty close to the hardware; in OO languages they tend to be closer to the problem domain. Edsger Dijkstra once said that software development was unique as a profession because it required practitioners to operate at 7 levels of abstraction - from transistor to algorithm to software architecture to business domain. Of course, very few of us deal with "transistor-level" programming these days.
So, Simonyi's "intentional" programming is part of this broad sweep of improvement in programming languages in the last 50 or so years. The current emphasis behind Model-driven architecture is a similar desire to somehow take away all that messy code stuff and replace it with nice, easy to understand pictures.
The problem with both these approaches is that complexity exists inherently in the problem domain. The role of a software development team is to chose a path through that complex problem domain and implement it with working code. Right now, I don't believe we have tools which are sufficiently expressive and intuitive to model the complexity of the problem domain, and we must be years if not decades away from being able to convert such models to working code.
UML is lovely - it's a great language for expressing software ideas and conveying a lot of information in a graphical format, but the average business user just does not get it; in my experience they are primarily useful for communicating between developers.
Use cases (in textual form) are far more useful for communicating with business users, but to convert a usecase into a working program would require natural language parsing at a level that must be a generation away.
We should wish Simonyi luck - his ambitions are worthy, and will benefit all working developers if they bear fruit. And what better use to put a couple of billion dollars to ?
It's all very well in practice, but it will never work in theory.
very well put.
another way to put it..
Everyone can write a novel, but it takes good writer to write a good novel.