If you look at JavaScript and the web browser... well, it's more like a Smalltalk system than a UNIX system! There are no files! It has a weird little dynamic multi-paradigm language! The web browser become the spiritual offspring of Smalltalk as soon as Brendan tacked on JS. :)
Look how WEIRD package management gets for JS when you try and make it supported by UNIX and the filesystem!
As for tools becoming language dependent... what about sourceMaps? Look at how CoffeeScript integrates with our workflow tools these days!
The biggest problem with Smalltalk was that it was made for Personal Computing, and ALWAYS had issues running other people's code or integrating well with collaborators.
The web browser and JavaScript solve a lot of these issues with the whole sandboxed code environment...
The web has NOTHING to do with files, so it seems like the perfect place to just forget about them and move forward...
Relays and switches only got us so far... Machine code only got us so far... UNIX only got us so far...
Why have we lost the courage to continue looking for better solutions and being brave enough to throw away certain concepts?
I mean, look at mobile and touch computing! iOS and Android are completely abandoning the concept of files!
Why? Because they don't really have to be there... Again, look at Smalltalk... and I know, it "failed", but do you really think it failed because it didn't have files? Is that the one reason? Is it even a reason at all??
What? I really don't understand this comment. The web is almost totally file-based. Visiting any website is just downloading and executing files. Including Javascript and CSS files is really just like a copy-paste operation--it just spews everything into the global namespace, which is that of the HTML file that you're currently viewing.
I definitely find "The web has NOTHING to do with files" less agreeable than what kyllo is saying.
Now think about what the browser runtime can do with "files". Well, next to nothing, because the browser doesn't have access to a filesystem.
For a browser to communicate with a filesystem it has to do so through HTTP and only in a very limited way.
That functionality depends entirely on the file system and the file in question, as much as the operations available on an HTTP resource depends on the verbs that the resource implements and how it implements them.
Also, a file system will typically not execute your files. Nothing stops you from executing an HTTP resource in the same manner. Say,
<script type="text/javascript.js" src="bla/bla.js">
or curl http://bla.com/bla.sh | bash
> Now think about what the browser runtime can do with "files"Using the standard HTTP verbs, you can read, write, create and delete resources.
And that's for HTTP--not to mention the other major protocol FTP, the name of which is self-explanatory: File Transfer Protocol.
If you use the UNIX-like definition of file (to say nothing of the Plan 9 definition), which can include dynamically-generated streams such as /dev/random, then sure, the whole web is a set of files. I assume Plan 9 will even serve web sites out of its "filesystem" with the correct poking.
If you use the DOS-like definition of a static file (ignoring CON and a couple of other special cases), then, no, the web is not merely a set of fancy static files on disk. Many, many, many things never have a rest representation on disk as a simple file, even if one could theoretically be manifested at a point in time for some particular web page.
I sort of feel you're trying to conflate these two distinct definitions, and using the fact that the web is a set of stream-files to assert that the web is nothing but a set of disk-files, but that's equivocation.
No, it's kept as an in-memory structure. Certain representations are serialized and cached to files, yes, but that's just a optimization to reduce network requests; you can disable it without affecting the browser.
In particular, "grep -r kyllo ~/.cache/mozilla/firefox/" returns zero results, despite having this post open on my browser.
A web browser is really just a fancy, scriptable file viewer.
I disagree; it's an hypertext engine, with renderers for multiple media types. That hypertext can be loaded and/or cached from files, but that's an implementation detail that does not define the application.
And that's for HTTP--not to mention the other major protocol FTP, the name of which is self-explanatory: File Transfer Protocol.
That's not part of the web.
Smalltalk was actually getting a foothold in the enterprise when Java happened and everyone switched to it.
Eclipse was originally a Smalltalk environment (Visual Age for Smalltalk).
Yes, files also played big a role, because it was not possible to use source control systems with Smalltalk that worked across implementations. So you were bound to a specific vendor.
Actually, Smalltalk projects failed hard in the enterprise during the 90-ies which lead to Smalltalk's demise. 'Java killed Smalltalk' is a myth.
My employer's official application development language has changed just twice in the last 30 years, from COBOL -> Smalltalk -> Java.
I've been thinking about a programming system that stores all the code in a database instead. Versioning would be easier that way too.
https://en.wikipedia.org/wiki/ABAP#ABAP_runtime_environment
It is far less enjoyable than it sounds, especially as no standard tools can manage that code.
That does not necessarily have to be the case. Just like you have abstract collections capable of handling values of any type, I don't see why it should be impossible to have a model of versionable, editable code into which you could inject your own implementations for the particular language you're coding in right now.
I realized the other day how close persistent collections and tools like Git actually are. And given how most modern languages have programs that are essentially trees or groves, and given that said persistent collections tend to be trees...? Well, what do you think?
I would say the downside of this 'rich' environment is that your tools tend to become language dependent. Early Smalltalk code versioning tools were fairly easy to build (I'm guessing), but would definitely be Smalltalk centred. The unfortunate advantage of an ASCII text file is that it very difficult to have more than one interpretation of it's non-existent meta-data.