Hacker News Reader

Comment by williamcotton | Hacker News Reader

> I'm extremely interested in the idea of taking the syntax highlighting, formatting, and code completion OUT of these specialized IDEs and plugins and into some kind of standard "bidirectional channel" between a language processor or compiler, its macro system, and the user's editor of choice.

Well maybe if we stopped using ASCII files as our source code and used a richer type of document we could start to make some improvements!

What kind of rich document? Well, what about HTML? Did you know you can even embed interactive elements in such documents? What if we started embedding our source code and editors in our documents instead of the other way around? The whole model is inverted, but mainly for historical reasons, because you know, in 1979 all we had was VT100 to interface with our machines... it's like we never moved on... why is my "code" a splattering of ASCII files in a directory? A package definition, tests, dotfiles for this and for that... ship the editor, the tests, the docs, the examples, and the source ALL as one document!

View on HN

That may have been the case in 1979, but in 1980, we got Smalltalk. This environment was (almost) completely without the concept of a file. Code was stored in a persistent 'image', like everything else, and was accessible through normal object based data structures. This, and the fact that all of the source code for the system was immediately available, made it extremely easy to build and extend language level tools like browsers and debuggers.

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.

Thank you for mentioning Smalltalk! My comment was heavily inspired by that "computing environment".

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??

The web has NOTHING to do with files, so it seems like the perfect place to just forget about them and move forward...

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.

They're representations of resources, not files. Some of them are stored as files on the server, but that's purely incidental and irrelevant to the browser; it treats them just the same as it treats the runtime generated representations, such as this HTML we're viewing.

Files are representations of resources as well. Some of these are mapped to data stored on disk blocks, but others aren't. Some file systems are not disk abstractions at all. While I agree that calling HTTP resources "files" is not entirely correct, they're presented in a very file system-like hierarchy, and in most cases I'd say that they are not meaningfully distinct from files in a file system.

I definitely find "The web has NOTHING to do with files" less agreeable than what kyllo is saying.

Think about files in the context of a filesystem and an operating system. You can move them around, read to them, write to them, execute them...

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.

> You can move them around, read to them, write to them, execute them...

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">

    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.

This HTML we're viewing may be runtime-generated on the server, but it's still saved on my machine as one or more files in a temporary folder and then opened by my browser application, is it not? A web browser is really just a fancy, scriptable file viewer.

And that's for HTTP--not to mention the other major protocol FTP, the name of which is self-explanatory: File Transfer Protocol.

This HTML we're viewing may be runtime-generated on the server, but it's still saved on my machine as one or more files in a temporary folder and then opened by my browser application, is it not?

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.

Define "file". Read off from the definition of file whether the WWW is just a set of "files".

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.

One of the reasons Smalltalk failed is called Java.

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.

And actually Sun approached Viacom to license Smalltalk at much less than what they were currently charging. Viacom wouldn't budge so Sun invested in "Oak" that they were already playing with in house.

Thanks for sharing the information.

np, sorry I was too lazy to post any links but I think I gave enough info to find it on the internet.

Yeah, Java killed Smalltalk in the enterprise.

My employer's official application development language has changed just twice in the last 30 years, from COBOL -> Smalltalk -> Java.

I made the switch from Smalltalk to Java. I remember how disappointing it was to return to such a primitive language. I also used the VisualAge for Java products, which I recognized immediately as Smalltalk tools. I wasn't at all surprised to find out they were actually written in Smalltalk

It was an engineering feat. VAJ was a Smalltalk engine that ran both Smalltalk and Java.

> Smalltalk was actually getting a foothold in the enterprise when Java happened and everyone switched to it.

Actually, Smalltalk projects failed hard in the enterprise during the 90-ies which lead to Smalltalk's demise. 'Java killed Smalltalk' is a myth.

While Smalltalk is awesome, do keep in mind that in 1980 it only ran on very expensive machines, and the software license was also expensive. This was still true 10 years later.

I've been thinking about a programming system that stores all the code in a database instead. Versioning would be easier that way too.

Version control is a database for storing code.

These kinds of systems already exist for a long time in widespread use:

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.

I would say the downside of this 'rich' environment is that your tools tend to become language dependent.

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?

> What if we started embedding our source code and editors in our documents instead of the other way around?

We all agreed that was a bad idea: http://en.wikipedia.org/wiki/Opendoc

All? I'm sure Alan Kay would disagree. The problem with OpenDoc is that it emerged at an unfortunate time and asked you to work with vastly inferior languages than what you'd actually need to make this work without getting insane in the process.

HTML is ASCII.

Sure, but compare "HTML + Web Browser + HTTP" to "ASCII + VT100"...

Right now the terminal is our window and it is nothing but colored ASCII. You can create something interactive and "graphical" like vim or emacs inside of it, but then you can't ship that complete dev environment very easily... it has to be rebuilt from scratch by the individual programmer.

The web makes it very easy to ship interactive, dynamic documents and environments around.

You're not the first to have this idea, nor will you be the last. Think about why it has not succeeded already.

I have thought long and hard about why Smalltalk failed and have had numerous discussions with people and the general ideas are:

* poor marketing * expensive, closed license * not enough effort put in to tooling

But almost everyone agrees that there is a LOT that was lost when Smalltalk didn't take over the marketplace... the point is, it wasn't because they didn't go with the concept of a filesystem...

(I think everyone downvoting you is an idiot)

I understand what you're saying, but the problem is, I don't want to have to use the preferred editor of the person that happens to be maintaining some random projects I'm editing. I like my VIM and my grep, and my colleague likes her Eclipse and her InstaSearch.

Now, that doesn't mean we should eschew all metadata, but I rather see some structured data formats that can be interpreted by the editor and fitted to the user, instead of the other way around.

In fact, I'd rather see the web itself move more in that direction. HTML/CSS may be wonderful in terms of the freedom they give to the developer, but it's no free lunch: we lost a lot of potential interoperability by going with free-form, unstructured formats instead of more content and less design driven ones.

Why can't we embed vim or emacs in a web document?

Can I please point out that building graphical interfaces in ASCII is just about as bone-headed as my suggestion? :)

Why can't we embed vim or emacs in a web document?

We can, that's not the issue. The problem is that if you embed an editor - any editor - into the project, you're forcing everyone to use it, while currently each developer has the freedom to choose his own.

And if don't embed the editor, then there's nothing to discuss; one can already use web based editors if one wants to, and I can use VIM ;)

Can I please point out that building graphical interfaces in ASCII is just about as bone-headed as my suggestion? :)

The whole reason I like VIM is because it barely has any graphical interface. The whole experience is extremely content focused, without a mess of buttons and toolbars obstructing the vision. I talk to it[1], it does what I tell it, and it stays out of my way.

So I agree, but it doesn't apply in this case :)

[1] http://yanpritzker.com/2011/12/16/learn-to-speak-vim-verbs-n...

What if <THIS SPACE LEFT BLANK> and the end-user can supply their own editor?

But then, how do we ship around the source editors meta data that is REALLY important, like, custom DSL syntax highlighting?

Do we need a universal syntax highlighting engine? What other universal engines do we need to build interfaces in to Emacs and Vim and Eclipse and XCode and Visual Studio in order to tackle some of these issues?

You just need some standard, structured format for describing the syntax of a particular language. And we already have these; we use them as source for the parsers of the languages themselves. So it's mostly a question of augmenting them to provide highlighting-specific hints to the symbols.

If you embed vim, half the universe will hate you on principle. If you embed emacs, same story.

Why not embed the whole OS? Now it is starting to sound like the apple ][ days.

Well, why not? Isn't each instance of a web document just a little OS that we've shipped to the end user?

The question shouldn't be "Why not?" -- it's "Why?". If you are running a browser, you are already using an operating system. Why would you run another one?

Running editors (or whole operating systems, for that matter) in a browser seems like a backwards way of solving this. If you really need to ship a whole development environment including the editor, and not just the config files, project files or syntax highlighting plugins, you might as well use a virtual machine. If a programmer has no idea of how to set their editor of choice up for what they're developing, they won't be building a decent development environment in Javascript.

My point is that the web browser IS a virtual machine! It also happens to be the VM with the largest install base. It is a lot easier to ship something that runs on this VM than to convince people to download yet another VM.

And this isn't about developers knowing how to set up their editors. It is more about DSLs. It is more about the fact that there is more to coding than just writing source. Hell, it is about trying to come up with a way that we aren't totally beholden to source! It's just data, and frankly, not the most important data around software!

Sometime other paradigms, and I don't just mean other languages, but things like spreadsheets, graphs, and visual languages can be great DSLs that properly model and convey information MUCH better than source... but you can't really embed those in eclipse or vim, can you?

Think about if you released a project on GitHub and it didn't have tests, documentation, or example use. Would anyone use it? What if it was competing with other projects that DID have tests, docs, and examples? What is that code with tests was slightly worse? Which project are other developers going to want to interact with and use?

We live in a world were our programs, our source, and our peers live in a distributed ecosystem and as far as I can tell our tools and operating systems are starting to get in the way.

Have you seen how awfully messy web development becomes when you try to bootstrap from a filesystem? Things like JSFiddle are MUCH more elegant, but are, how shall I put it... missing some key tools for a new ecosystem of distributed computing. ;)

In short no. You could maybe make that argument about the browser, but certainly not about the document.

So if I want to edit some open source project, I would be forced to dick around with vim if the person who made the project wrote it in that? Are you trying to go forwards or backwards?

If you're trying to write code, what to HTTP bring to the game? I think in this case, HTTP would be equivalent to a really, really, really long cord for your keyboard to wherever your code is.

Also, if you're using characters or glyphs to write code. It's always ASCII (or your character set of choice). It doesn't matter if it's in the browser or in a terminal. HTML presenting the code that your writing is just cruft.

Right now I'm looking at my terminal. It has a bunch of tabs. Each one of those tabs is a little "runtime". However, it is a runtime made up of ascii characters. That's what runs inside of it. Little letters, sometimes colored, sometimes made to look like borders for windows.

And I've got this other thing called my web browser. It also has a bunch of tabs, and each one of those tabs is a little "runtime" as well. This one just happens to support embedding images, video, audio, non mono-spaced fonts...

My terminal runtime communicates through the filesystem. (it's UNIX, files all the way down...)

My web browser "runtime" communicates through HTTP.

That's all I'm sayin'.

---

Also, I KNOW why UNIX is all files and I get the whole concept of piping ASCII around... yeah, it's fucking awesome! And it's why UNIX is STILL around. It'll be around forever, and man, I DO like it, but should we use it for everything? Why?

Piping ASCII around only gets you so far. :)

Why am I getting so much HN downvote love for talking about some of the downsides of the UNIX-way?

But most developers are already using runtimes that support images, videos, audio and non-monospaced fonts: they're called Qt, GTK, Cocoa, etc. So that's not really a reason to switch to the web.

Sure, but those runtimes are EXTERNAL to their editors!

BTW, are you familiar with Literate Programming by Donald Knuth?

And the reason I'm mentioning the web is because, well, it's a nearly universal runtime and the best thing we've got that might get a lot of really important and forgotten about concepts from Smalltalk back in to the mainstream of computing!

Also, are you familiar with Don Knuth's Literate Programming? Thoughts on that?

(And yes, I realize this thread is going absolutely everywhere, but I've got a lot of questions!)

Sure, but those runtimes are EXTERNAL to their editors!

No more than than the web browser vis-à-vis the kind of editors you're talking about. They're built on top of the graphical APIs, much like web apps are built on top of HTML/CSS/JS.

(Note that I'm referring to graphical editors like Eclipse or Sublime, not ncurses editors in a graphical terminal emulator)

Maybe, but without a concrete example / vision, I find it hard to believe that I'd be willing to lose the comfort of my development environment for the hack-y, keyboard-hostile world of web applications.

Also, are you familiar with Don Knuth's Literate Programming? Thoughts on that?

In a very vague way; it didn't really appeal to me, sorry.

> In a very vague way; it didn't really appeal to me, sorry.

+1 The more prose can be kept out of code the better.

I'm curious, how do you document your code?

Or are you strictly in the camp that if it is machine-readable and works properly that you've done your job?

Function/method/class docstrings (sorry, my comment may have been misleading) to document the purpose/contract/API, terse inline comments for the implementation only when something is not obvious to a skilled developer. And of course carefully-chosen variable names. I'm not at all a fan of heavily commented code. It just adds more bytes to comprehend, more bytes to maintain, and worst of all a high probability than the code doesn't exactly match the documentation, which causes a significant mental load. Also sometimes leads to people showing off in their natural language descriptions of their code. Same for literate programming: I want as few characters as possible that I have to understand, with that statement appropriately qualified :)

I can't say I see your point. What does switching to HTTP bring you?

HTTP is just piping around ASCII.

I don't think you're getting down voted for talking about the downsides of UNIX. You haven't actually mentioned a downside of UNIX, you've just suggested that we should switch to some other model.

Ok, so let's say you download a GitHub project... it has docs that run in a web browser, tests that run in python, some code that actually does something... it has some dotfiles for this and for that... well none of that DOES anything. It all depends on there being certain tools on your end of things...

I'm saying that instead, we just ship all the tools along with the code... and you can do that in browserland, and that's NOT the UNIX-way at all!

...it has nothing to do with HTTP, it has to do with the web browser runtime as compared to the runtime built on top of a filesystem!

UNIX land doesn't not play well when running any arbitrary stuff that comes it's way... sure, it might not have root, but, uhm, yeah if some code wipes out my entire user account, I'll be pretty bummed out... that's not gonna happen in the browser with it's sandboxed environment that has been battle-tested by trillions of page requests!

Find me another runtime that is as many places and is readily available to run third-party, untrusted code, and I'll happily jump ship! (aint gonna happen!)

¿Is it? The HTML that contains your comment is UTF-8.

Sorry, you're right. HTML is text.

I'd seriously hope it's Unicode these days.

Reply on news.ycombinator.com