Personally, I think the image model is a huge win for a single programmer, while the file model makes it easier to integrate changes from a big team. (There's not really a "DVCS for images" yet.) When I look around, I see that tools that have won tend to support big teams of less-efficient programmers.
So it's not really surprising to me that, by numbers, the file model dominates. That's not an indictment of the image model.
What do you mean by "better"? There are more Corollas than BMW 5's on the streets here, but does that mean they're better, or worse, or better for a particular use case? I'll take the image model for building a fast prototype any day, even if I have to hand it over to a big team writing C or Java for the final product.
How much of this do you feel is due to the lack of tools (VCS, IDEs, etc) equipped to deal with the image model, and how much is inherent to the models?
Is this limitation inherent? I think that's impossible to say. How many people accurately predicted the importance of a DVCS, before ever seeing one built? Or for that matter, a garbage collector? In cases where it's not obvious, the tools drive our understanding.
I don't see anything inherent in image models that would prevent this, though languages don't seem designed in a way that would make this particularly easy. For example, right now we're collaboratively editing a (very simple) shared image (HN).
I enjoy git on the command line, but _tight_ integration with the editor is an almost sublime experience.
So git's well-defined data structure already enables quite a bit of editor magic, but Codeq's extra layer of abstraction is very intriguing. Also, the fact that you can query the engine and get back simple data compares favorably to the mishmash of shelling out and git object parsing done by many tools today.
WRT Smalltalk's image, code management is only one of its marquee features, so I think Smalltalkers would object to calling image vs files a false dichotomy. The image is more akin to a versioned virtual machine than an SCM. I've never known the magic of the image (or a Lisp machine), so I lack an opinion on which is superior.
¹ Drew Neil's excellent video introductions to fugitive: http://vimcasts.org/episodes/archive (April/May 2011)
² and other _content_ tracking DVCSs
None of the Lisp machines really had image-based development. The MIT ones all had an Emacs that worked on text source files. You'd boot into a system image, but that was more like a kernel binary, than the Smalltalk image with a class browser. Interlisp had a structured editor that worked on s-expressions in memory, kind of like the Smalltalk class browser, but these were saved to files (the system would automatically track which definitions were saved in which files, and could tell you about changes: http://larry.masinter.net/interlisp-ieee.pdf).
Yeah, I agree. That was inaccurate on my part. What I said really only applies to the code management side.
Another example is Plan9. Some of its innovations were ported (/proc, utf8, ...), but some things probably never will (everything is a file).
Programmers seem to love adopting the features of Lisp, as long as they can re-assure themselves they are not actually programming in Lisp.
http://srikumarks.github.com/jexpr/
{do: [
{fetchURL: "http://some.data.source/",
timeout: 30.0,
onfail: {raiseError: "URL not reachable"}},
{fork: [
{displayInElement: "element_id"},
{cacheInLocalStorage: "prefix"}
]}]}
more here:http://srikumarks.github.com/gyan/2012/04/15/j-expressions/
http://srikumarks.github.com/gyan/2012/04/14/creating-dsls-i...
http://lambda-the-ultimate.org/node/2887
EDIT: And for the record, I actually think it's a brilliant idea.
When I started coding professionally I used IBM's VisualAge for Java (which was actually a multi-language tool based on Smalltalk) and it did exactly that: all Java classes were managed as code artefacts held in the IDE's internal repository. You had to export from the IDE if you wanted your standard files-in-directores source/objects. It worked very naturally and when IBM moved to Eclipse instead I found it to be quite a step backwards in terms of working with my code. But the drawback was was you could do exactly what the VisualAge IDE supported and not much more.
The file-based model gives a level of low-cost interoperability that's pretty hard to beat.
The mere mention of editors and IDEs suggests to me that they envision analysis as the gateway drug.
The fact that the file model continues to dominate suggests to me that there may be significant drawbacks as well.
Possibilities:
* Losing the ability to use file-based tools costs too much. This is less that the function model is bad and more that existing tools happen to be file-based
* The model will eventually win, it's just taking a really long time for thoughts/tools to catch up.
* The model is better, but has not caught on for reason unrelated to its utility. The model is Betamax.
* The file-based model is better