3 ms·
It's true that much (most?) progress in programming has come through higher-level representations of programs. But this has made programming easier for programm
by gruseom 19y ago
It's true that much (most?) progress in programming has come through higher-level representations of programs. But this has made programming easier for programmers, not for non-programmers. Why? Because much of the complexity in programming is intrinsic to the problems themselves. The ability to distill and organize abstractions to address that complexity, and to formulate them precisely enough to be suitable for mechanical execution, is essential to programming. This ability is not going to magically appear once programs are represented as "something akin to a PowerPoint presentation, [or] a flow chart, [or] a sketch of what they want the actual user screen to look like" rather than in code. Actually, just the reverse is true. We program in code not because we're "coders", but because code happens to be by far the best medium for precisely expressing abstractions. If these other representations were so much better that they enabled non-programmers to specify working systems (i.e., to program), then they'd be better for programmers too. We'd all use them.
I'm not saying that Simonyi won't come out with anything of value. Maybe it will help to facilitate dialogue between programmers and domain experts about how a system should work. But the hype that it will turn non-programmers into programmers is pure PR.
- xirium 19y agoI thought that understanding program flow was a huge implediment to non-programmers and that if we had graphical flowchart method then at least small tasks could be performed by non-programmers. However, after using ETL software which works exactly this way, I'm much less confident.
- apathy 19y agoDoes anyone remember IBM Data Explorer, which became OpenDX? The program was based on the notion of mapping flows as topological bundles, thus it could (and would) attempt to automatically parallelize whatever independent operations it could. Programs could be set up as, quite literally, flowcharts, with a given box having input hooks (multiple), output hooks (usually single), and a piece of code, usually a C++ library, that would produce or consume the data flowing through the 'pipes'. I demonstrated this to a bunch of high school kids at a national science fair (ran it on an SGI in Ithaca while presenting at the fair in DC... it was hard to compete with the UIUC Cave VR developers otherwise) and the kids seemed to understand it instantly. Hey, look at that, functional programming in a visual style. What's not to like. Needless to say it has not set the scientific programming world on fire and the project, while still maintained and used (I believe) by a handful of groups, isn't terribly high profile. A screenshot can be seen on OpenDX.org : http://opendx.org/images/opendx-screenshot.jpg http://opendx.org/images/opendx-screenshot.jpg I 'contributed' the RPM spec file, played with it for a while, but by the time it had been opensourced, I was no longer working in the type of environment where it was a major advantage. Plus I no longer had a pile of nodes to throw at arbitrary computational task nor much need. Sometimes I miss that sort of thing. Lots of times, actually. I've been daydreaming about it lately... although these days I like to use iPython for that sort of thing, it would be nice if the self-documenting aspect of the UI and the generated programs could be retained. Anyways.
- bayareaguy 19y agoKhoros[1], AVS[2] and LinkWinds[3] all do the same sort of thing as OpenDX. I think these sorts of "boxes and arrows" programming systems suffer from being monolithic environments with idiosyncratic interfaces and little or no support for external software engineering tools. What's worse for them is they generally compete for mindshare with scripting languages or scriptable environments (i.e. things like Mathematica) with larger communities. I don't think they will ever gain wide acceptance until they allow the same level of reuse as systems based on structured text. [1] http://www.arsc.edu/support/resources/khoros.html http://www.arsc.edu/support/resources/khoros.html [2] http://www.avs.com http://www.avs.com [3] http://www.openchannelfoundation.org/projects/LinkWinds http://www.openchannelfoundation.org/projects/LinkWinds
- ntoshev 19y agoAbility for precise modeling is the most important thing that separates programmers from non-programmers. Dealing with complexity is probably the runner-up, but domain experts should be just as good or better in handling this one. Programming may someday escape the need for precision. The "compilers" of the day may be able to offer meaningful defaults and fitting. This sounds like full-blown AI, but it doesn't need to be, just as Google looks like it but is not. In fact the way to do it may be some kind of statistical approach relying on tones of code already written.
- gruseom 19y agoAbility for precise modeling is the most important thing that separates programmers from non-programmers. Dealing with complexity is probably the runner-up, but domain experts should be just as good or better in handling this one. It's the need for precision that brings out the complexity. In my experience working with domain experts, they usually don't realize how complex their domain is. Only when we start trying to nail things down precisely do the contradictions and edge cases come out of the woodwork. Invariably it's order(s) of magnitude harder than it looked at first. Usually they are surprised and say they had no idea there was so much to do. So while I agree that domain experts are accomplished at handling complexity, they do so the way that humans do it (ambiguously and inconsistently), not the way that computers do it (through formal specification). The ultimate bottleneck in software development is that there just aren't that many humans who can do the latter well. I agree that if programming ever does escape the need for precision, then the game changes, completely and unrecognizably. A pet belief is that this would require computers that work more like the way humans do (down to the lowest level), but that's a wild guess. In any case, I haven't seen any evidence of things progressing in this direction, have you?
- ntoshev 19y agoHumans resolve a lot of the complexity intuitively and unconsciously. It is not an inherently bad way to handle it, just incompatible with current programming paradigms. This is not to discount the value of clear explicit thinking in humans, it is just to say that programming would benefit a lot from ability to apply common sense to mundane things. For some dramatic evidence that imprecise is better and it really works, look at the success of Google and the non-delivery of the Semantic Web. Google's approach is probably best explained by Peter Norvig in his "Theorizing from Data" lecture: http://www.youtube.com/watch?v=nU8DcBF-qo4 http://www.youtube.com/watch?v=nU8DcBF-qo4 State of the art in natural language processing is achieved with statistical inference, not building precise linguistic models. See e.g. Marti Hearst's text here: http://www.edge.org/q2008/q08_7.html http://www.edge.org/q2008/q08_7.html Back to programming languages, I believe that a lot of the Ruby/Rails success is due to mimicking natural language in DSLs. Rails goes as far as using pluralization. DSLs bring convenience at the price of less understanding: people tend to try using them intuitively, without understanding precisely what happens, much more so than they do with libraries/frameworks. Perl, similarly, was created with linguistic principles in mind: http://www.wall.org/~larry/natural.html http://www.wall.org/~larry/natural.html It is by no means conclusive evidence, but I believe there is an underlying trend.