[groby_b]

Sigh. Maybe instead of ranting at your "typical software engineer", the author should spend a moment to consider that maybe it "could be built again" - but it never has.

So the question then turns to, why has it never been built? Is it maybe because Hypercard (and other visual systems) become entirely unmaintainable once we get to large-scale systems? And maybe it is because most people don't want a trivialized programming environment? They either want a full system, or just a product?

[dahjelle]

> They either want a full system, or just a product.

While I think this is true at the moment, it seems that there is an interesting question behind that, as well. Why don't more people want to create their own software? I do think the author has an implicit point: because, frankly, creating software stinks. Jon Skeet's talk [1] demonstrates this admirably. I spend a shockingly large part of my time working around bugs and leaky abstractions in other software rather than implementing my own ideas.

I don't know if it is possible to design a system with a solid enough abstraction that these problems don't exist. I do know that HyperCard came unusually close, as I know several folks who made HyperCard stacks who wouldn't imagine creating software in any typical fashion.

I hold out hope that such a useful system could be created again, one that gives people enough flexibility to create software solutions of their own (perhaps within a genre of software) and that is able to combat the currently-accurate stigma of programming being "hard".

[1] http://msmvps.com/blogs/jon_skeet/archive/2009/11/02/omg-pon...

[WiseWeasel]

Lego Mindstorms (http://mindstorms.lego.com/) is kind of like Hypercard for the modern age. It's got interesting applications (robotics and automation), and an easy-to-learn programming environment. I'd say it's the perfect product for a budding geek to cut her teeth on.

[groby_b]

Hm. I've never seen a HyperCard project that was both maintainable and of a large-ish size. I think _that_ is where the HyperCard idea broke down - navigating through a bunch of cards is significantly more difficult than through a bunch of text files.

Granted, that _may_ be a question of the tools. But I do find it telling that in the long time since the "death" of HyperCard nobody could come up with compelling tools.

And creating software is hard because ultimately, it requires analytical thinking. Which, by itself, is hard. Yes, the choice of tool modulates the hardness of the problem - but the underlying issues are still hard. (Note: I do not claim non-programmers _can't_ reason analytically. I claim the effort/result ratio is not right for them)

It's the same reason most people buy furniture instead of building it. Acquiring the necessary skill set is simply too much effort for the result.

[dahjelle]

I definitely agree that software desire requires analytical thinking. (It certainly put a halt in my thoughts about a mass-appeal software builder: if they don't "get" [or want to get, or whatever] Excel, they don't have a chance for much else.)

I do think, though, that not being able to make projects of large-ish size isn't necessarily important for a wide variety of use cases. Most of the best apps I know of do only a very small thing—but do it very well. I think HyperCard allow people to do small things exactly the way they wanted. Which maybe wasn't very well, but was good enough for their needs and better than the alternatives.

As I mentioned in my other comment [1], I wonder if the parallel is somewhat like the UNIX command line. You probably aren't going to write a MySQL competitor in bash. But there are a whole class of small custom tools that you will write.

To perhaps restate my original point (and this is where perhaps we agree), the abstractions of HyperCard eventually didn't (couldn't?) adapt. Perhaps, as you said, because of cards. As someone else commented, also partially because of the codebase, but also, I think, because things like color and networking and a greater number of standard UI widgets all had to be added.

[1] http://news.ycombinator.com/item?id=3294915

[6ren]

Spreadsheets are arguably a "trivialized programming environment".

[praptak]

Which (sort of) supports GP's argument. We have programming environments on one end, full products on another and spreadsheets (maybe also MS Access) in the middle. The environment looks crowded.

Btw, I'd love spreadsheets-as-apps replaced with something more maintainable but they also have a huge advantage: you can start using a spreadsheet with zero programming. Unless you copy that, you can't compete for that niche.

[6ren]

If we have room at the ends (for new programming environments, and new products), why can't we have room in the middle?

Something else with zero programming is online form builders; some already have constraints and reporting systems. If they added simple programming constructs, it could be as powerful as you like. (e.g. google forms enables you to skip to different questions based on previous answers, though it's getting away from easy visualization, unlike spreadsheets). You can view them as being a database, derived from input forms - what's stopping them growing towards unmaintainable real databases, in the way that spreadsheets can grow into unmaintainable apps?

A way to think about this is not in terms of a complex thing, but in terms of a simple thing... a toy... to which you can add-on complexity. e.g. I'm not sure that the first spreadsheets were fully programmable, but just related different cells by formula. And I know for sure that the first RDBs didn't have stored procedures.

Maybe, this could be done for many webapps: wiki + scripts; reddit + scripts (what would that be?); youtube + scripts (we have it a little bit with links on parts of the video). The puzzle is imagining what could possibly be the use of these... it helps if you already have a manual version that you are automatic (that's what the visicalc guys did: "spreadsheets" existed, on paper, before them: http://inventors.about.com/library/weekly/aa010199.htm).

There's visual webapps for assembling webservices, but they don't seem to have taken off. Maybe the "problem" is that they scale - the thing you create is good for more than just one person, unlike most spreadsheet documents, which (excluding templates) contains your own specific data - often, proprietary business data. Because it can scale, people invest more effort in it, and are happy to use proper APIs etc. And then, consumers don't have an unsatisfied need, because it's already done. Therefore, perhaps the "toy" needs to be about a particular business or person (e.g. be about their data).

Also: Arguably, Flash authoring tools took the place of hypercard.

[praptak]

I think we agree - my point was not that there is no room in the middle but that if you want to go there you need to give some zero-programming benefits for starters.

And yes, forms are an example of what this benefit might be.

[6ren]

Yes, I think your zero-programming point was spot on (though check that spreadsheet link: I was surprised to learn that visicalc automated existing paper spreadsheets, so "programming" wasn't even an issue, at least for its initial massive success).

But note that we're not really in "support of GP's argument" anymore. ;-) That's what I was arguing against (but excellently provocative questions BTW).

[groby_b]

Point well taken. So the question then becomes, why only one (or a small number of) such environments? (Also, I consider spreadsheets hardly trivial. I marvel at what some people can do in Excel ;)

And my answer to my own question is still the one I previously implied: There is no market for this kind of environment.

Consider, your problem needs to be:

* Repetitive enough to benefit from automation

* Complicated enough that automating it would yield a significant gain in the long run.

* Simple enough to not require going to an actual full-blown programming environment.

* Not numerically solvable, since spreadsheets have that covered.

* Not solvable via macro-recording or workflow solutions, since that market is also well-covered.

I'd say that does leave a fairly small sector. Hence, low demand for Hypercard-like solutions.

[6ren]

I had the same reaction of "no market" from the article, but on reflection I suggest turn it around: instead of thinking of it as "a programming environment", think of it as a specific application first, which has customization added to it, and eventually becomes programmable. Seeing it this way, such environments are very common - they are just not presented as "programming environments". And that may be what is different about Hypercard - how it it thought of, not what it actually was.

- I think macro-recording etc counts as a trivialized programming environment

- Many standard desktop applications are programmable (though today point, they just throw in a pre-existing language) - Word processors (Word uses VB, .net; OpenOffice uses Java/Python; Adobe acrobat uses Javascript. I think you'll find in earlier word-processors (for eg), they had more limited programming environments, before that, not fully programmable scripting; before that, only macros, before that only specific and limited explicit configuration... and before that, no customization at all.

- Flash authoring tools can do what Hypercard did, and more; they are also very easy to use for simple things, and even do it in a similar way to hypercard (but include a full programming environment for more complex things, like spreadsheets do). NOTE: flash's programming abilities have been enhanced tremendously over the years. I don't know the origins, but I wouldn't be surprised if it initially didn't have a "programming" capability, but just customizing some aspects of playing movies.

- html + javascript itself is not that different from hypercard, especially if you include an "authoring tool", of which a great many exist.

- wiki's are also hyperlink based...

- online forms (wufoo, google forms) - they derive a database from forms (like ORM, but skipping the objects, to be "FRM"), and include constraints, different paths, and reporting tools.

- vim has a programming language, but it's about as pretty as programming with a spreadsheet. This is because it evolved from something simpler, to get specific tasks done - I don't think vi was programmable! certainly not in the earliest versions (emacs is the exception, beginning with an actual programming language). I'm not even sure that shells were initially programmable for that matter... and that's about as close to a programmer as a tool can get.

[Also please check my follow-up comments, esp: visicalc was not initially about programming.]

---

TL;DR I put it to you that any tool can have automation added on to it - and if we view it this way, "trivialized (or specialized) programming environments" are the norm, not the exception. Their goal is not "programming", but to solve the specific problems and meet the specific needs of their users. But the natural direction of a customization/configuration is programmability (and then to add programming features to help manage complexity, e.g. libraries, namespaces etc). It might take a while to get there. Some instances we see are only part-way there (see above); some stop growing/die before becoming attaining that level of customizability.

Going back to flash, ActionScript 3 added optional static types, enabling dramatically faster performance; before then, it was a version of Javascript; before that, it was a kind of hacked together script thing. I don't know what they had way back in Flash 1.0, but I suspect it wasn't yet programmable... just as visicalc 1.0 wasn't programmable...

[groby_b]

If you look at it as purely customization, yes, there's a thriving market. But the author is specifically looking for something that creates a world 'where the distinction between the “use” and “programming” of a computer has been weakened'.

And the point is that those are fundamentally different activities. There's only a very small intersection that needs the simplicity of "use" and the complexity of "programming". And given that's an incredibly hard balance to strike, I stand by "no market" - at least for a product _specifically_ aimed there.

[6ren]

aka "operation" vs "design". I agree, for targeting that explicitly as a pedagogical or philosophical end in itself. A cool ideal, btw (though I think it works better with less powerful programming - more concrete, perhaps only regular or context free not turing complete).

In real (non-coding) life, there's usually overlap, of "adjustments". e.g. you're cutting tomatoes with a knife, and adjust the knife's angle, or your grip, or move the tomato, spin it on a vertical axis, rotate it, try sawing vs slicing, maybe change knives, etc. Perhaps you exclaim "This is the best knife for tomatoes!" and resolve to use only it henceforth. But many of these adjustments are unconscious, and part of everything we do. Is it "operation" or "design"? I think it's fuzzy in practice; we often chip away at things as we learn and adapt.

True, in software, there's usually a sharp line between user (operating) and programmer (designing). Customization crosses that line: macros, templates - even, hiding menus you don't use. Is hiding a menu "programming"? While not turing complete, it's a step closer to it.

I agree there's not much market for the combination, in itself. Programming is so accessible these days, if you want to do it, you just do it. Probably starting with HTML "programming", then Javascript or PHP. It even looks like a real website! It's like hypercard, but global.