Light Table - a new IDE concept - <AUTHOR> http://www.chris-granger.com/2012/04/12/light-table---a-new-ide-concept/ <comment><USER3>
        - Smallest unit of code is the function.
        - Able to get instant feedback on code changes.
        - Multiple editors with just one function in it. Show code
          in an "area of concern" not just in a file.
        - The coding environment can show also results, app
          windows, graphics, other tools.
        - Can save the configuration of the above.

Smalltalkers have been doing this in commercial projects since the 80's. If only we could have communicated about this as well as Mr. Granger.

EDIT - Also:

        - You should never have to look for documentation
        - Files are not the best representation of code,
          just a convenient serialization.
        - Editors can be anywhere and show you anything - not just text.
        - Trying is encouraged - changes produce instaneous results
        - We can shine some light on related bits of code

Things like this were happening in Smalltalk environments since the 80's. The first and the last points above were satisfied by lightning fast "senders" and "implementers" searches.

<comment><USER4> Of course this comment was inevitable. If Smalltalkers really believe their environment is the right way to code, their attitude should not be one of "we did this first, meh" but instead be "here's what we did right, here's what we did wrong. heed the lessons of history and good luck, you are on a mission from God."

I think with the proper care and nurturing, we could be at the beginning of a renaissance where many of the great ideas of the 60s and 70s that have been isolated to a small group of people (who are aging rapidly) are being rediscovered and reimagined by this generation. This is happening in no small part due to Rich Hickey and the Clojure community's unbelievable foresight in developing Clojure and ClojureScript in just the right way that it balances these pure, beautiful ideas with pragmatism in a way that makes them irresistible.

Those who lived through the heyday of Xerox PARC, the AI lab, the lisp machines and Smalltalk should see this as an opportunity to help make sure things don't go off the rails this time. Otherwise, we may end up back here again in 25 years with the C++ and MySQL of the future installed in our cybernetic implants.

I can already point to projects that are invisibly pushing us towards another deep, sticky, next-generation tarpit, and people are diving in because it's not yet recognizable as such. (I won't name names!) Lets try to make it so this time around we truly realize the dreams of computation by encouraging people who are building elegant, beautiful things for the modern era, no matter how much the ideas therein have been tried before.

<comment><USER5> Interesting stuff, I'm quite new to programming, could you please recommend some reading materials to get acquainted with these ideas?

As a newbie, I'd like to educate myself so I can contribute to the "right" projects for this time and learn to avoid the tarpits.

<comment><USER4> Here are some links:

<http://www.infoq.com/presentations/Simple-Made-Easy>

<http://t.co/cJgpnX5B>

<http://www.youtube.com/playlist?list=PL4BFC3F13B846707B>

[http://books.google.com/books/about/Mindstorms.html?id=HhIEA...](http://books.google.com/books/about/Mindstorms.html?id=HhIEAgUfGHwC)

<http://worrydream.com/>

<http://vpri.org/>

Part 4 primarily of:

[http://www.amazon.com/The-Design-Essays-Computer- Scientist/d...](http://www.amazon.com/The-Design-Essays-Computer- Scientist/dp/0201362988)

<comment><USER6> s/ <http://t.co/cJgpnX5B> / <http://tele-task.de/archive/video/flash/14029/> /

</comment></comment></comment></comment></comment><comment><USER7> Isn't it ironic that this is posted on a site that does startup funding and the comments are "please put this on kickstarter" not "please apply for Y Combinator"?

Is it possible that Kickstarter will disrupt Y combinator style startup funding?

If we (the consumers) can bypass the investors and pay for what we want, why do we need the startup gatekeepers?

Obviously this wouldn't work for all startups but a large portion of founders might be better off on kickstarter? Unless of course the advice/mentoring/network effect that Y combinator, et al provide is vital to a startups success.

Food for thought.

<comment><USER8> Kickstarter is for products, YC is for businesses.

(More or less, I'm not saying it's black and white)

<comment><USER9> Ah, but business should be product-based...

<comment><USER8> That's certainly true, but the two aren't mutually exclusive. Kickstarter will get you the funds to go out and build a cool product, but it won't tell you how to generate a model that's sustainable, teach you how to go to market, or even tell you if there's an available market at all.

<comment><USER10> Exactly. I can imagine a need for "Kickstarter mentors".

</comment></comment></comment></comment></comment><comment><USER11> For years I've been bothered by the fact that we still use ASCII text-based documents to program. Having spent a good deal of time programing in APL, a language that uses symbols extensively, I'd like to think that I saw just how different things could be.

Having said that, every time I've looked into graphical programming paradigms they almost always seem to fall apart or get in the way of translating ideas and thoughts into machine instructions.

In the end, at least for me, it's about having an environment and a language that gets out of the way and let's me program the way you'd play the piano: The music just flows and the technical bits that make it happen are invisible.

<comment><USER12> Oh wow. I've never used APL but this demo of it always blows me away [http://www.youtube.com/watch?v=a9xAKttWgP4&feature=youtu...](http://www.youtube.com/watch?v=a9xAKttWgP4&feature=youtube_gdata_player)

<comment><USER13> If APL looks good to you, it may be worth checking out its descendent J: <http://www.jsoftware.com/>

</comment></comment></comment><comment><USER14> This is great, however it glosses over the elephant in the room: what if a function is called multiple times, or what happens when code within a function is run multiple times? Which data do you display in the data flow view? What is really needed is an intuitive way to select a context or multiple contexts.

SubText's approach to this is to let you dig deeper in the call tree by clicking on function calls, but for a language like Clojure you also need a way to select a context for a piece of code nested within a function. For example suppose you have

        (map (fn [x]
               ...
               ...)
             xs)

You need an intuitive way to display or select a context for the fn.

<comment><AUTHOR> There are several options here:

\- show multiple iterations in place \- show a single iteration with a forward and back \- show multiple blocks for some reasonable n iterations \- ...

I definitely don't think that's going to be an issue longer term and I think there are lots of potential avenues to play around with :)

<comment><USER15> You could just sample and show _an_ example - that's good enough for many uses.

<comment><USER16> I like the previous/next idea -- for me, it's often much easier to understand what a chunk of code does when you can see its behavior on multiple inputs.

</comment></comment></comment></comment><comment><USER17> I can't get my hands on this soon enough. It makes so much sense: we're moving away from the files and folders metaphor everywhere, so why not in the IDE too?

<comment><USER18> We might not want the hassle of dealing with files and folders all the time, but I sometimes worry that a new generation of "programmers" will emerge who have no understanding of how the underlying filesystem works.

<comment><USER19> I sometimes worry that a new generation of "programmers" will emerge who have no understanding of how the underlying _anything_ works.

For as useful as sites like stackoverflow are for sharing knowledge, it is potentially encouraging a generation of copy/paste coders who's job it is to find and glue snippets together until they get the desired outcome.

Maybe I'm getting old, but I'm starting think some knowledge needs to be earned. [get off my lawn].

If you aren't comfortable slinging files and directories around, you probably aren't a very productive software developer.

As far as ide's go, this concept is definitely intriguing. But I believe putting too much faith in abstractions like what is implied by being function focused(there is no "file") rather than file focused(these are your "files") has the potential of blowing up in your face. I think you need both.

Anyone who had to code on a team using VB6 remembers the pain of *.frx files and how they needed to be version controlled, but you didn't need to worry about them because it was an implementation detail required by the ide. UNTIL, 2 people made visual edits to the same screen and then the project wouldn't open. GOOD TIMES.

<comment><USER20> Speaking of file conflicts:

I'm picturing an alternate universe in which 'the database' stands in for 'the filesystem'. Data is laid out in a manner logical for its origins. Most programs use the library-provided implementation, of course, but there is a little more variability than in our world.

People have spent the past fifty odd years writing utility programs for manipulating databases instead of files, so concerns like 'moving' data between programs are still basically trivial.

In that universe functions really _are_ the basic building block of code, and the database engine's consistency guarantees handle editing conflicts implicitly (with logging for version control, of course). Too bad, perhaps, that we're here rather than there.

Thoughts, criticisms, elaborations?

<comment><USER21> Reminded me of something Jaron Lanier wrote... found it:

"For instance, there is the idea of the computer file, which was debated up until the early 80s. There was an active contingent that thought that the idea of the file wasn't a good thing and we should instead have a massive distributed data base with a micro-structure of some sort. The first (unreleased) version of the Macintosh did not have files. But Unix jumped the fence from the academic to the business world and it had files, and Macintosh ultimately came out with files, and the Microsoft world had files, and basically everything has files. At this point, when we teach undergraduates computer science, we do not talk about the file as an invention, but speak of it as if it were a photon, because it in effect is more likely to still be around in 50 years than the photon."[1]

<http://www.edge.org/documents/day/day_lanier.html>

</comment></comment></comment></comment></comment><comment><USER22> Whenever I get the chance to use a spreadsheet, I really enjoy it. I find it really satisfying to set up cascading functions and see them update in real- time. I'd like to see that experience translated to general programming. I'd like to update code and see the unit tests update automatically, and an understandable representation of the objects being manipulated.

<comment><USER23> "I'd like to update code and see the unit tests update automatically"

I think you have that a bit backwards there. I want to write the tests and have my code automatically update to make them pass.

<comment><USER24>
        /**
         * Auto-generated, do not edit!
         */
        function add(x, y) {
          /* test 1 */
          if (x == 2 && y == 2) {
             return 4;
          }
          /* test 2 */
          if (x == 1 && y == -1) {
             return 0;
          }
        }

<comment><USER25> Simple. Do some monte carlo comparisons between a large number of generated functions, based on various heuristics like number of instructions. So quickly get rid of explicit mapping of tests, especially if used larger. Add some genetic algorithms and a little more AI stuff ;)

One interesting thing though with auto-generated code based on specific test code is that when the test fails at some point the process just has to be repeated, potentially being done automatically.

<comment><USER26> Why not jump to prolog if you want to want to declare what the properties of the code are and have the compiler figure out how to actually do it?

</comment></comment></comment></comment></comment><comment><USER27> Am I the only one who wants to see multiple, proportional fonts in editors?

Sure, I want to keep the methods themselves in monospaced font, but can't I have the method declaration in a larger size, and comments in a proportional serif?

There is a wealth of design experience out there in communicating things better and more quickly with typography, so why do we not take advantage of that in our IDEs?

<comment><USER28> In most cases there's little reason to have the code in monospaced font either. People really just need their blocks (and their continuation lines) to be properly left-aligned, and that works fine, because even in proportional fonts, a tab at the beginning of the line is always the same width.

Just don't mix spaces and tabs.

Sometimes you want columns of figures to be aligned throughout, but fortunately most fonts respect the rule that all digits should be the same width (for exactly this reason).

My emacs is set for Dejavu Sans semicondensed bold at 6pt ... I find that for code, bold or demibold works a lot better than regular weight.

<comment><USER28> Disclaimer: although I really do code in proportional fonts, using emacs is only a 90% solution. It's harder to navigate code when hitting the up/down keys causes your cursor to jump left and right because emacs' proportional- font implementation is just a thin skin over a fixed-width world. I'm still looking for a next-generation IDE which will free me from this kind of issue.

</comment></comment></comment><comment><USER29> I wasn't really sure of all of the benifits, then I saw the picture of the video game making example and it dawned on me... make it happen! I'm throwing money at my screen but nothing is happening.

</comment><comment><USER30> This is pretty exciting stuff. IIRC ibdknox used to work on Visual Studio when he was at Microsoft.

<comment><AUTHOR> I did indeed. I used to be the Program Manager for C# and VB in the IDE. :)

A number of the ideas presented here started brewing during my time there, but it took me a bit to figure out what the overall abstraction should be. I really love the drafting table parallel - it's especially interesting when you start thinking about what we can do with touch...

<comment><USER31> This is great, I would love to try something like it. Making each code artifact living outside of the file paradigm should enable new way to develop, but in the past what I saw trying failed (at least for me). The drafting table look like the abstraction that can make this work. The interactivity would be key too.

I can't help but think of a drafting pad and drafting notebook to allow us to work on our system everywhere...

</comment></comment></comment><comment><USER32> Light Table looks brilliant and clearly deserves much success... but I can't help but wonder if it will ever catch on as much as I'd hope, because the alternative -- using plain-text files -- is (IMO) a canonical example of the simple-to-implement, New-Jersey-style, worse-is-better approach.

As comments elsewhere in this thread (e.g., see stcredzero's and gfodor's comments) detail, the ideas behind Light Table have been around for _decades_ , yet somehow failed to catch on in prior incarnations. Why?

Some here say it's because earlier proponents of these ideas were just too early, meaning that hardware and infrastructure weren't sufficiently powerful at the time. Others here say that early proponents and their implementations were too ideological and not pragmatic enough. Maybe.

My gut tells me earlier incarnations lost out in the marketplace because MIT/Stanford-style approaches tend to lose out to simple-to-implement, New Jersey-style, 'worse-is-better' approaches in the long run. What prevents Light Table from suffering a similar fate?

I hope I'm wrong.

<comment><USER33> Light Table has problems for non-trivial code anyway. What happens when functions have side effects like deleting files? Most of my code involves networking, especially Android devices talking to http servers providing functionality that has state. Things don't run in isolation, there are databases involved and code can't be called willy nilly.

And a lot of code is about error handling. In addition to the normal path I really need to see the flow through the problems - permissions issues, timeouts, resource limits, service failures etc.

</comment></comment><comment><USER34> If this showed up as a Kickstarter project, I'd put $100 behind it right now.

The bickering over KS/YC or product/business is zero-sum. I just want to use this, and I'm prepared to put my money where my mouth is to see Chris Granger working on it full-time.

</comment><comment><USER35> @ibdknox: you definitely need to get this project on kickstarter (to fund the work on an open source implementation ideally) it could really change the way people approach software development and Clojure in particular. The ideas you're presenting aren't necessarily new, but if they didn't caught on was more due to being done at the wrong time or the wrong way. I could definitely see you being able to pull it off!

<comment><USER36> Anyone's who's Googled around for the "proper" way to setup Emacs for Clojure development (and found innumerable blog posts dating back 5 years each with completely different instructions) is intimately aware of what an easy-to-use IDE for clojure, one with a simple install procedure on multiple platforms, would do for language adoption.

</comment></comment><comment><USER37> My two wishes: 1) vim style editing as an option 2) support static languages with every feature but the real time debugging, if need be.

My second wish may seem like it is missing one of the main, most beneficial features. But the other features are enough, such as " Multiple editors with just one function in it." or "Show code in an area of concern"

</comment><comment><USER4> Awesome stuff. I think ClojureScript and Bret's visionary talk are brewing a perfect storm: the era of projectional, structural, domain specific editing in the browser is finally coming. This looks awesome and as the author mentions it is just the beginning.

</comment><comment><USER38> This is awesome. I love the idea and the implementation looks great. ibdknox claims that it would work with any dynamic language. I'm not sure there is anything capable of finding dependent functions in Python without actually executing the code.

Could someone illuminate me?

<comment><USER39> Take a look at these:

[1] <http://docs.python.org/library/parser.html>

[2] <http://docs.python.org/library/ast.html>

[3] <http://docs.python.org/library/symtable.html>

</comment></comment><comment><USER7> "...but there's no reason this couldn't be done for any language with a dynamic runtime."

With your (ibdknox) background, could this work for c#/f#? I like Visual Studio, but I feel more and more it gets in my way when I'm debugging/navigating code. There is too much "chrome"/widgets/toolbars and hundreds of specialized windows, each with their own chrome that eat up precious space on my 27" monitor.

When I use it on my 15" laptop I really have to strip everyting away and use a simple editor window.

I'd love an editor with the power of Visual Studio without all the noise.

<comment><AUTHOR> It could indeed, they'd need to focus on building out the evaluation context (basically a REPL), but as I recall there was a prototype of one somewhere.

Past that, the new Roselyn language models would fill in a bunch of the gaps that would make this particularly hard currently.

The real problem for making it happen in VS is political though :( I actually pitched similar ideas while I was there.

</comment></comment><comment><USER40> It looks a lot like what I already do with Emacs.

Is Light Table also programmable in the language it's written in? I find extensibility and compose-ability far more important in an editor than any single feature alone.

Cool demo. I like the idea of alternate real-time visualizations of my code; especially in large and unfamiliar systems.

<comment><USER41> Could you name the modes, which help you accomplish live-debug and 1-click documentation effects?

<comment><USER42> You might also find eldoc-mode[1] and it's various mode-specific children (c-, perl-, ...) to a useful minor-mode. It displays a short string describing the function-at-point, and the order and name of it's arguments. Sort of zero- click docs. Whatever way it does it could probably be hacked up to display more complete docs in a split window or frame. Something I'll think about when I finally get an SSD :)

[1] <http://emacswiki.org/emacs/ElDoc>

</comment></comment></comment><comment> timmy-turner Great to see another clojure tool heading away from the old traditional and largely text based environments to something new and better. Anyhow, looks a lot like Code-Bubbles to me (<http://www.andrewbragdon.com/codebubbles_site.asp>). As he was talking about how other engineers work, on big tables where they place and organize all their current notes, items, documents - in the future, I'd like to have a large epaper covered, touch and object sensitive desk and couple of light epaper devices to take down and organize notes and code. Software will become more complicated in the future, so I think at some day we will need to adapt and use more powerful tools than the ones we currently have.

</comment><comment><USER43> This really looks great. The doc and play views alone would be fabulous as I'm trying to learn clojure. Seems like an incredible sandbox environment for learning the language and exploring open source to understand how things are working. What are your plans for releasing/availability?

</comment><comment><USER44> Where is the download link?

Just please don't let it become another Code Bubbles - a nice idea, breathtaking video, and no working tool available in the coming years.

<comment><USER45> Indeed, love the idea but not the transparency. Disappointing to see closed- source, demo-only videos on the top of HN.

</comment></comment><comment><USER11> As concepts go, not a bad start. One of my immediate thoughts was that this would be better served on a multi-monitor system. Every single one of our development machines has three 24 inch 1920 x 1200 screens. It's fantastic. You can keep everything you need up and available. It makes working on complex ideas an absolute pleasure.

On the hardware design front we use a program use a EDA tool called Altium Designer for schematics and board design. This, by far, is the most well thought-out application I have seen when it comes to multi-monitor smarts. It makes for a nicely flowing and efficient design process.

</comment><comment><USER46> Very interesting, especially if multiple language support becomes part of it. Is making this a "generic" IDE a project goal?

I for one would be most interested in Python, and even SQL (for the docs / drafting table).

<comment><USER47> He talks in very generic terms, so I think you can gauge this to be the overall intent. But, I would have some reservations about the challenges of live-evaluation in other languages. It's not insurmountable by any means, but using a lisp really gives you a massive head start.

</comment></comment><comment><USER48> This is very cool indeed.

Cedric Vivier has made a LiveScratchpad that does live JavaScript evaluation in Firefox.

<http://neonux.github.com/LiveScratchpad/>

It would be cool to add the multiple function source to that!

</comment><comment><USER49> This fills me with hope.

Functionally striking, visually beautiful -- it makes me feel suddenly like things are coming together in a way that might stick this time around.

In form: Value placed on aesthetics -- beautiful & functional design -- is a concept that's taken root in the marketplace at large.

In code: Like gfodor commented, it feels like the doors are open wider than they've been in a long time to new ideas, and that we see some elegant language mechanisms being rediscovered and rising to the top.

In tools: The same pattern ... with lots of points of reference, a critical mass of seekers and open source contributors, and bootstrapped on powerful tools that allow rapid expression of new ideas, the good ones see the light of day and, if successful, can take an advantage of an unprecedented kinetics of this ecology to rise to viability and then prominence.

I hope you'll forgive me if I'm blowing this out of proportion to wax elegiac or whatever -- it just suddenly feels like a good day to be a programmer.

</comment><comment><USER9> Lovely demo, well explained. I'm using the same principles for my visual design web application, and I see the same simplicity and elegance here as well. Can't wait to try it out.

</comment><comment><USER50> One thing I notice while playing video games is that having an SSD doesn't help that much once the game is loaded. This is because game devs think about file access and make sure that it is optimized. It would be nice to just get something like eclipse that takes 5 minutes to become usable and slows down all the time because it is hitting the file system without any regard for performance.

Due to a jar locking problem I'm having to restart eclipse several times a day and it is so painful watching it "build" and validate all this code when my real build happens on the command line.

I wish video game developers would start writing IDEs for other reasons like graphics as well. They seem to be the only ones who understand flow and how disrupting it is for a program to just become unresponsive for even a few seconds.

</comment><comment><USER51> Looks gorgeous!

Interestingly, the whole idea of "the environment (and the IDE) is dynamic" is present in almost any Smalltalk dialect.

The file is just a convenient way to serialize the code but is not necessary for the act of programming.

Damn, I was expecting this from Ruby, I thought Clojurers were happy to use emacs :p

</comment><comment><USER52> Now, all you need is a kickstarter.

</comment><comment><USER53> Hardly a "new" concept. MS Research did something akin to his different functions on one light table. Displaying HTML in the REPL is (I believe) a Factor thing, amongst others. Documentation everywhere is supported by any decent IDE these days.(Except it's usually a hover tip, not a separate window). Code is not a file is the subject of entire Internet rants.

Don't get me wrong, this is cool when you tie it together. But it's hardly new. I'm inclined to say it would benefit from research into what others have done, but maybe I'm wrong. Maybe you really need to be unencumbered by old ideas to push this again, and maybe succeed this time.

</comment><comment><USER54> "Files are not the best representation of code, just a convenient serialization."

I agree. Files (and version control systems) leak a tremendous amount of valuable information. They are a very '20th century' technology.

I'm working on a tool that behaves like a distributed version control system (branching and merging) but stores more fine-grained information about the programming process. This information can be played back and developers can tell a story about why the code is the way it is:

<http://www.storytellersoftware.com>

</comment><comment><USER55> This looks amazing, it would be a perfect tool for learning programming in the first place, but can easily work great for experts as well. Incredible. When can we get a download link to try this out?

</comment><comment><USER56> Have you released the prototype or do you plan to? I cannot seem to find it on your GitHub account.

<comment><USER30> I don't see the code out there, but here is his github: <https://github.com/ibdknox>

</comment></comment><comment><USER57> I like it. I'd not be surprised if someone comes up with vim and emacs version any time near soon.

<comment><USER58> Emacs is most of the way already. It doesn't have an interactive code display thing like this (as far as I know), but most everything else either already works or works similarly.

For example, getting documentation is just as easy. (Actually, I don't know if you can search by docstring, but otherwise it's the same.) You can also get the same experience as having functions rather than files open by having a lot of little "windows" (in the Emacs sense) with a function in each. Since you can have multiple "windows" open on a single buffer, it can work for functions in different parts of the same file as well.

In short: Emacs has all the building blocks you need (as always) and some of the features are already easy to replicate. Building something like this on top of Emacs just makes sense.

</comment></comment><comment><USER59> Amazing----I've dreamed of having something like this ever since I started programming. Can't wait to try it out.

Mind if I share a couple ideas that might not be hard to implement with what you've got?

1) It would be nice to see \aggregate information about what has happened in function calls. The simplest would be: while the code is running, put and update a bar graph next to each function to show, proportionally to others, how many times it has been called so far.

2) More generally: record and associate with a function \all the inputs and outputs it has had. (Other commenters talked about having "context"). Then the programmer can scroll through these lists, calculate statistics for them if they are numbers, or choose one of them to plug into the function. (Often when you are refactoring code, some function lower in the code path gets 'orphaned' ----it took some kind of complex input you don't want to bother putting in by hand, and so now if you want to modify it you're deterred. If you had prior inputs, you could just 'wire it up' with one of those.)

3) Commenters talked about having different fonts. I think the \one area where this would be helpful in Lisp is with the parentheses. I've shared prior versions of this idea before, but what I think would be helpful is to vary both \color and \size of parentheses. You pick three or four colors, say red, blue, and black (more than that is hard to tell apart in context, especially with syntax coloring), and once you've varied that, you bump the size up. So if you had seven parentheses in sequence, there would be three sizes, with the outermost three the largest, the next three medium, etc.

</comment><comment><USER60> How long did it take you to build this prototype?

I'm interested because when I played with Clojure I didn't feel like you can make quick prototypes with it.

<comment><AUTHOR> 5-6 days, most of which had to do with me having to hack around in the compiler a little. That was new for me and the Java there is particularly weird, so that took longer than I would've liked.

</comment></comment><comment><USER61> I've unfortunately had to spend a great deal of time working with Labview (a graphical engineering software development environment that works based on data flow. Functions are represented by blocks with terminals for input and output data. You wire functions together to pass data between them). Some aspects are horrible (primarily the maintainability of anything more than a trivial application), but they also do some interesting things that I thought were quite parallel to this demonstration.

Documentation is quite well embedded into the software, and comes up with a similar box detailing the docs for every function you come across. The system also shows you the flow of data through a programme, allowing you to debug and see the data types moving between functions. You can dive into sub-functions and see what data's moving through them. Debugging can be fantastically quick if you constructed your programme carefully. If you didn't though, it's hell (see the point about maintainability).

<comment><USER62> If you wouldn't mind me (your friendly, neighborhood National Instruments programmer browsing HN) asking, could you expound a little more on other things you've found horrible with LabVIEW?

I completely understand your sentiment on debugging and maintainability. I've done my fair share of quick-and-dirty apps that did one little thing wrong and a million highlighted executions and five years later, I've finally got a handle on what's wrong (mind you, I'm nowhere near a LabVIEW expert).

I love our documentation tool as well. We call it Context Help, and as you highlight over different parts of your code diagram, it's handy to see a quick, readable summary with links to full documentation for every single node and system available in LabVIEW.

If only all IDEs had the same functionality and it's the reason why I'm super psyched to see Light Table come out. Ready to be blown away.

</comment></comment><comment><USER49> This fills me with hope.

Functionally striking, visually beautiful -- it makes me feel suddenly like things are coming together in a way that might stick this time around.

In form: Value placed on aesthetics -- beautiful & functional design -- is a concept that's taken root in the marketplace at large.

In code: Like gfodor commented, it feels like the doors are open wider than they've been in a long time to new ideas, and that we see some elegant language mechanisms being rediscovered and rising to the top.

In tools: The same pattern ... with lots of points of reference, a critical mass of seekers and open source contributors, and bootstrapped on powerful tools that allow rapid expression of new ideas, the good ones see the light of day and, if successful, can take an advantage of an unprecedented kinetics of this ecology to rise to viability and then prominence.

I hope you'll forgive me if I'm blowing this out of proportion to wax elegiac or whatever -- it just suddenly feels like a good day to be a programmer.

</comment><comment><USER63> Great work, and I'm impressed at how quickly Chris Granger created Light Table. I wonder how hard it would be to build an IDE for Meteor (EDIT: I mean get JS support in Light Table, since Meteor is just JS) - how amazing would that be. Or port Meteor to Clojure and wow ... these combined would be amazing.

I've believed for a long time that files were archaic and agree completely - and we should extend that idea to version control. If we version functions (and classes, stored procs, etc...) then you can create a type of failover to a last known good version down to that logical function.

As for the rest of the ideas - the table, organize and layout related code, the documentation and the interface are all terrific ideas and I can't wait to see where it goes. Imagine laying out all that code on a nice huge touch tablet with multi-touch support ... drool....

</comment><comment><USER64> This is great. I'm so happy someone finally started moving in a new direction. I've been thinking along these lines for a long time, but never found the time or energy to actually start implementing anything.

The most important thing is to do away with the concept of a file as a main structural unit in a project.

</comment><comment><USER65> Interesting... @Taligent we built a completely object-oriented dev. environment for C++ (borrowing a lot from various SmallTalk environments). There was no file system - everything was an object - comments were stored in the object system along with implementations. This allowed for some really cool self-documented versioning on classes. However the real magic was in the debugger where we were building runtime support for "edit/run" and "what if" so you can edit faulty code and rerun w/out the recompile (essentially patching the class as it was running). Seems easy now (w/dynamic languages) but at the time this was close to "rocket science..."

</comment><comment><USER66> A man after my own heart. Here's another concept to dramatically improve efficiency: Code Contexts. Enable the user to select (or add) a specific set of contexts. When coding under a specific set of contexts, differentiation of code applies only under the given context set. Or, after making a code change the user could add/remove contexts to which it applies. This would resolve a lot of the complexities of OO programming. Behind the scenes, context sets can be organized into a class hierarchy. But the programmer wouldn't have to search through the damn hierarchy to find out what version of a particular method is currently in play..

</comment><comment><USER67> Hi, I develop in Python and js. Idle is ok, but I'm sick and tired of Eclipse and I almost freaked out when I saw your article. The video seems pretty awesome and after taking a peep at the code, I'm thinking of learning Clojure just to be able to participate in the project. Visual Studio has finally proven itself useful (developing in it make you imagine better ways to develop software apparently) XD

My request is if you have some link for a let's say "decent" coder who wants to understand and maybe try to compile the code on his own computer (debian). Perhaps even recommend an IDE for Clojure until this one is ready.

</comment><comment><USER68> At least some of the features you've brought up in the article can be done with BugAid (for C#). For example, the ability to "visualize" the data in a function by replacing the variables with the actual values can be done, albeit in a different way (<http://www.bugaidsoftware.com/>). The other feature, like a documentation that shows whatever you're looking at, can be achieved partially with Visual Studio by itself and Resharper (<http://www.jetbrains.com/resharper/>).

</comment><comment><USER69> This looks fantastic! It also has the side effect of making me want to get back in to learning Clojure. The idea of the file not being the fundamental unit of code is especially intriguing, but hard to wrap my brain around - that's such a low-level, base assumption that it's difficult to picture truly challenging that.

What are some examples of other paradigm-shifting (argh, buzzword) ideas in the world of software development? Deviations from the norm often become the new norm, and I'm too young and inexperienced (I've only been out of college for 10 months) to remember the "old way" of things.

</comment><comment><USER70> Great concept. This is kind of similar to an editor we've been talking about for Overtone. How about,

* allow for render plugin functions so values can be rendered with images, rendered canvases, control elements, etc.

* treat the AST as the primary data for each function or form, and then make the source code one of multiple renderings of the data.

\- makes paredit type manipulations just operations on the ast

\- allow for decorating the ast with additional data, which can be rendered with plugins (for example, heat-up regions of code as a profiler runs)

<comment><USER71> Perhaps you could make comments part of the ast decoration. Hover over a function call and the IDE can popup a display showing comments for that function. The popup could be easily switched back and forth between comments, the parameter list, or possibly other info about the function. The comments could be plain-text, rendered HTML, or even crazier stuff like audio/video recordings for particularly important comments.

People could choose whether they wanted comments rendered inline with code like usual or displayed elsewhere.

</comment></comment><comment><USER72> I love the visualization aspect of this. I can think of multiple situations where popping this open to look at a couple of interactions would be helpful, especially when getting acquainted with a code base I didn't help build. I'd happily add it to my toolbox! Great thinking, great design.

Would I use it for everything? Nope. Most of the time I just want to type with the occasional jump into the command line. For that I use command-line vim, and I don't see jumping ship any time soon.

Thanks for the work!

</comment><comment><USER73> There's one thing I don't understand. When you execute code automatically, what do you do about side effects? If I have code that write, read or delete a file for example.

</comment><comment><USER74> Glad to see someone finally understands the limitations of files and folders in IDEs. Let me suggest that your next step might be cooperative development as opposed to solo development. Hiveware for SoftwareDevelopment (not yet developed) would let Light Table users develop a single project's functions cooperatively and simultaneously without merge. Check out www.grammarapps.com to get an idea of the technology.

</comment><comment><USER75> And here I was hoping for a 36 x 48" tablet type experience :-)

See also Jef Raskin's THE (now called Archy apparently [1]) as another take on how things could be different than they are today.

I find it interesting that different styles of thinking so profoundly affect peoples opinions on the quality of the tools they have available.

[1] <http://en.wikipedia.org/wiki/Archy>

</comment><comment><USER76> Very cool!

There is the part where he calls (x 3) and the number 3 percolates through the definition of x. What would have happened if x was recursive?

</comment><comment><USER77> I hate to be that guy, but where did you get the basis for the colorscheme. It (along with the rest of the editor) is beautiful!

<comment><USER78> Looks kind of like <http://ethanschoonover.com/solarized>

<comment><USER77> See I'm not sure if it draws much from Ethan's colors, the purple maybe, but that green is way different.

</comment></comment></comment><comment><USER79> The last example, where the code called within a block is shown to its right, is something that I've often tried to do statically, manually when first trying to learn a large code base. I would want this for that alone. The fact that what's shown is live-ish is a big, diabetic coma-inducing glob of icing on the cake.

</comment><comment><USER80> Very interesting concept and really pushes the idea of writing code beyond simply text editing. I'm in Visual Studio all day and I really wish I could do more with less panels and wizards. Or get a getter bird's eye view of my codebase without all those tree views. Sometimes I wish my class view was my code view.

</comment><comment><USER81> You would make Bret Victor proud! For a slight chance you have not seen this; check it out for additional inspiration <http://vimeo.com/36579366> <http://worrydream.com/>

</comment><comment><USER82> Oh this is so awesome. Would it be possible to create a VIM plugin that uses some of these concepts?

</comment><comment><USER83> Kudos on a job well done. I have been thinking about these things, and in case you haven't seen lisping(iPad app), check that out too.

One question though: Where do you store all your functions? Do you use a db or something like that? Or just one flat file or file/func?

</comment><comment><USER84> This looks great. I was talking about this with some friends who mainly use vim and they would be for using this if it incorporated vim key-bindings. Whenever they have to use other IDEs (usually Eclipse) they have a hard time not using vim commands.

<comment><AUTHOR> I'm the same way myself - I <3 vim.

</comment></comment><comment><USER85> Love it. However the thing that often keeps me away from rich IDEs is that they so often only support 1 or 2 languages: so I get used to the nice features, then I'm stuck as soon as I have to switch language. If this took off, it would be amazing.

</comment><comment><USER86> I love it, when can I use it, and for what languages? I would recommend Kickstarter over YC because I expect Kickstarter would result in something I can use sooner :)

Thanks for pulling the video together, there are a lot of really interesting ideas in there!

</comment><comment><USER87> Looks really interesting, would be great to have something like this for the web. I wonder how interested the author of Sublime Text would be in this as he seems to be very responsive with development, perhaps worth reaching out to him.

</comment><comment><USER88> WANT.

IE: Very, very neat.

As a Ruby/Objective-C developer, I've always wanted something like this for my ruby projects. Xcode is awesome, but this level of integration for our distributed projects would make things go so much faster. I cannot wait to use it :)

</comment><comment><USER89> I agree that sometimes files are not the best representation for code but languages gives them semantics. For instance, namespacing/packaging is based on files (which make dependencies based on files too).

</comment><comment><USER90> I always wonder how can live preview work with I/O statements, like selecting/inserting from/to database. Can you forbid REPL to execute such statements? And then somehow mock that data for live preview?

</comment><comment><USER91> This reminds me of Bret Victor's presentation <http://vimeo.com/36579366>. He presents a few demos with similar concepts and a great talk nonetheless.

</comment><comment><USER92> This... is fantastic. I want it. A lot. What are your plans for further development? How are you going to distribute it. I guess I'm really just looking for, can I have it, when, and for how much?

</comment><comment><USER93> I really like the idea of seeing multiple functions (which might be in different files) on the same page at the same time. In Textmate it would be great to see the whole MVC of one function at once.

</comment><comment><USER94> Wow, Code Bubbles (<http://www.cs.brown.edu/people/acb/codebubbles_site.htm>) for Clojure, and done right!

</comment><comment><USER95> This is a great idea. I can almost see my development time going down by a big factor and writing much more robust programs. I wonder, how hard it would be to do this in existing editors ?

<comment><USER58> As I said elsewhere, most of this would be very easy in Emacs. I think only the code-tracing stuff would be particularly difficult.

</comment></comment><comment><USER96> "There's an incredible opportunity to change the way we build, and as a result introduce tremendous value into the world."

There should be a name for this desire to create to contribute to society.

</comment><comment><USER97> What a great presentation. The concepts are very well detailed and seem intuitive and highly useful.

Am I missing the "what next" section? Is there a git repository or download somewhere?

</comment><comment><USER98> I would like to see the value-flowing features with recursion. Can't really imagine how this IDE will behave when the same function is called twice.

</comment><comment><USER99> This is exciting! We wouldn't be coding the same way in 50 years - I hope what we do now will be compared to punch cards of early computing by then.

</comment><comment><USER100> Looks really nice! I'm wondering how you provide instant feedback on loops, where each iteration would replace the variables with different values?

</comment><comment><USER101> Clear and concise video. You really did a great job here Chris. My only critique is that I am now aware of what I am missing for my Java projects.

</comment><comment><USER102> As a JS game developer, I can safely say this would revolutionize the way I work. Please make this an actual product, I would gladly pay for it!

</comment><comment><USER103> That's awesome - I usually have a few different windows, either in emacs or just other terminals open to look at different functions at once.

Good work!

</comment><comment><USER104> In my book, ibdknox is in the early lead for clojure hacker of the year. He has been putting out some very useful software. Thanks!

</comment><comment><USER105> This looks really exciting. I also like the way that it is presented as enormously simplifying a somewhat complex space. Great stuff!

</comment><comment><USER106> Hi Chris,

Why build an entire new IDE, while you can also integrate your brilliant bright new ideas into an already awesome editor like SublimeText?

</comment><comment><USER107> this is quite cool, I'm not much of an IDE person, I like to stick with good old vim, but this sparks my interest. If it's open source then I might seriously consider it, even contribute some vi keybindings. I just hope it goes more in the way of building upon vi/emacs and modernizing it rather than stripping down an IDE and modernizing it.

</comment><comment><USER108> I love the drafting table concept. In fact, I love the entire concept of this type of IDE.

And for some reason, this is screaming "Metro" at me.

</comment><comment><USER109> like was said in the article, a js in-browser implementation, if possible, would be great. Imagine being able to get back to your work from any computer of any kind, anywhere, without having to download any ides or set up remote debuggers or anything. a great idea that would be even better (and I think manageable) in the cloud

</comment><comment><USER110> Found a download!

<https://github.com/ibdknox/live-cljs/downloads>

<comment><AUTHOR> That's actually my live game editor - not the same thing, but also fun!

I haven't decided what to do about my prototype quite yet, got too excited about sharing the idea :)

<comment><USER111> This is so cool, that I think you'd get plenty of funding to further develop this via a Kickstarter project.

<comment><USER112> I'm far from a developer, but this got me excited. Actively watching code changes would make learning that much easier. I'd donate.

</comment></comment></comment></comment><comment><USER113> 'Smallest unit of code is the function.'

Those rectangulars - just visualized 'em few days ago, looking through some very long css files.

</comment><comment><USER114> This is really amazing ! Wonderfully explained . And i LOVE the documentation everywhere concept !

Cant wait to try this out :) Cheers !

</comment><comment><USER115> Many people have said this already, but as soon as you create any way to donate to this project, I'm definitely in.

</comment><comment><USER116> This could be simpler if the there was a service that parsed all languages like Steve Yegge proposes in that video.

</comment><comment><USER117> Would be nice to make a github with your sources, so we could try and/or work on a JS version (or other).

</comment><comment><USER118> Let's say I wanted to do a native, or JVM-hosted, version of this. Which toolkits could I turn to?

</comment><comment><USER119> that makes me want to learn Clojure.

</comment><comment><USER120> +1 for the most interesting thing I've seen all week. Bravo for thinking outside of the box.

</comment><comment><USER121> Very nice concept, haven't experienced any similar, so I got quite excited about it.

</comment><comment><USER122> Looks great. I´d love to have that REPL as a buffer in vim. "Search, search".

</comment><comment><USER123> Have the light table folks used a modern IDE? This looks so much like Emacs.

</comment><comment><USER124> Very promising. Curious if that is a particular color scheme for the fonts?

</comment><comment><USER125> This is my dream. I would love if someone, or a group, could develop this.

</comment><comment><USER126> This is really cool, I hope you are able to launch this in the future!

</comment><comment><USER127> Shutup and take my money.

</comment><comment><USER128> I'd love trying it, but couldn't find the code. Is it aviable?

</comment><comment><USER129> I really hope it's open source, I can't wait to give it a try.

</comment><comment><USER130> This is something that I might actually trade in Vim for.

</comment><comment><USER131> This looks great. What about code that has side-effects?

</comment><comment><USER132> all of this (except the wonderful idea for debugging) is available in intellij you should also take a look at their scala repl, which just rocks

<comment><USER123> Yep - have the Lighttable folks ever used IntelliJ IDEA?

</comment></comment><comment><USER133> I would pay to be able to use this on Rails projects.

</comment><comment><USER134> ibdknox: So this is sweet looking -- of course I want to know: when we can get our hands on a version?

</comment><comment><USER135> It looks like the Emacs revolution!

</comment><comment><USER136> Love the demo! Where to download?

</comment><comment><USER137> How do we get it? \O/

</comment><comment><USER138> This looks great =)

</comment><comment><USER139> i will gladly support this endeavor with donations.

</comment><comment><USER140> Is something like this out? If it is, take my money now.

</comment><comment><USER141> Really cool concept, can't wait to try it !

</comment><comment><USER142> Impressive!

</comment><comment><USER143> when can we have it for C++?

</comment><comment><USER144> I want a "buy now button", seriously.

</comment><comment><USER145> Freakin awesome.

</comment><comment><USER146> Ew

</comment><comment><USER147> What language is it? Is the language just specific to that ide or can other language be changed to work with this ide?

<comment><USER148> He's using ClojureScript. He states at the bottom of the page:

      It's no secret that I really like Clojure and as a lisp,
      it was the easiest language for me to start the prototype
      with, but there's no reason this couldn't be done for any
      language with a dynamic runtime. The rest is mostly simple
      analysis of an AST and some clever inference. So could
      Light Table have used JS instead? Certainly - <USER2>
      hopefully it will get there sooner rather than later.

</comment></comment><comment><USER149> Reminds me of the design and dynamic visualizations from IntelliPad (written for Microsoft's retired project 'Oslo') with several features from visual studio all incorporated into an elegant interface.

Nice job.

(Although better - this IDE is close enough to IntelliPad that I challenge your statment that it is a "new IDE concept.)

</comment><comment><USER150> There was a UX video a while back, quite a long video, and there were IDE features shown off that were slightly similar to this. You could trace code and modify it while it's running and visualize the results. I feel that it would have inspired or complement this concept very well.

</comment><comment><USER151> This is probably one of the most innovative ideas I've seen in a while.

</comment><comment><USER152> Amazing.

</comment><comment><USER153> okay. i have a comparatively small pet project i work on in my free time, it's close to 60k lines of c++ code. now, please, tell me, how your "ide" is going to help me organize things better?

> Smallest unit of code is the function.

for what particular reason?

> Able to get instant feedback on code changes.

i've got 200 threads of execution in my fcgi module, how do you intend to eval that?

> Multiple editors with just one function in it. Show code in an "area of > concern" not just in a file.

kinda interesting, but won't work really. usually you have quite a bunch of code, 100-200 lines in a function which is a regular business. put 10 of those on the screen and you've got enormous unmanageable pile of crap.

> The coding environment can show also results, app windows, graphics, other > tools.

any specifics? but yeah, i must admit you can put fancy widgets on window panes lol

> Can save the configuration of the above. WOW!

</comment><comment><USER154> SHUT UP AND TAKE MY MONEY!</comment>


Companies are moving staff to secret offices to evade Covid-19 - <AUTHOR> https://www.bbc.com/worklife/article/20200320-how-firms-move-to-secret-offices-amid-covid-19 <comment> aaron-santos How does moving offices help when the virus spreads through people?

<comment><USER2> If you read the article it's about separating people.

The more office spaces you have, the more you can divide people into isolated groups.

</comment></comment><comment><USER3> After 9/11 the company I worked for (Silicon Valley, 10.000+ employees) had a truck with desks for engineers in case of emergency. Own power supply of course. Like a full evacuation or fire or earthquake at the main campus. I've never personally seen it on the campus.</comment>


Google Play In-App Billing Library Hacked - <AUTHOR> http://sufficientlysecure.org/index.php/2013/10/29/google-play-billing-hacked/

<comment><USER2> From what I read on FD and here Google could have better credited the security researcher.</comment>


Did GitHub Suspend Egor Homakov account? - <AUTHOR> http://homakov.blogspot.com/2012/03/im-disappoint-github.html I hope this isn't the beginning of something ugly with GitHub. <comment><USER2> Suspending him only shows that if a vulnerability exists (and they always do) in the future people won't go about it so openly because what they'll get for their troubles will be an account suspension. The guy could have done real harm if he kept silent and used it maliciously, chose not to, and got suspended. Github should pay him for finding the vulnerability instead!

<comment><USER3> Actually now that they've suspended him, I kind of wish did some real damage. The whole 'get hung for a lamb' saying.

That is why I don't really believe in 'white hat hacker' label. Organization when humiliated by their vulnerability strike back and treat the white hacker as a criminal. Or I guess since he actually modified a file or to instead of just publicly commented about the theoretical vulnerability, he is now a gray hat hacker ... ? But if he just blogged about the vulnerability without proving it, he wouldn't have been taken seriously and less people would have believed him (did you know about this guy before this happened? I didn't).

That is why I think, as an individual, if you hack, always be a black hat hacker. Organizations do not have mercy and will not treat you with respect if you just break in to point out a problem to try to help them. So might as well do some real damage, hide and or profit from it, by selling it on a black market.

(Note, not saying that I condone, or personally agree with such activities, just proposing a better course of actions for those who do).

<comment><USER4> How does anyone know he hasn't placed a thousand backdoors elsewhere on GH? This could have been just the harmless shot across the bow. The real vulns being traded in the online underground market now (or in the near future)?

<comment><USER5> GitHub themselves acknowledged that he only compromised 3 accounts and none of them seriously: [https://github.com/blog/1068-public-key-security- vulnerabili...](https://github.com/blog/1068-public-key-security- vulnerability-and-mitigation).

Seeing the comments he made days prior to this and also knowing what an appalling security vulnerability attr_accessible is I'm very pleased he did this. The issue needs to be addressed and for some reason everyone's been sweeping it under the carpet.

The guy was clear and resonable in the earlier bugs and suggestions he posted and then simply escalated them (with no harm done) to illustrate the issue.

Frankly this is a whole less worrying than firesheep and way more easily addressable.

<comment><USER6> Are they assuming he only used one account?

<comment><USER7> Presumably Github is currently auditing their db for keys added to organizations by users who are not admins of those organizations.

</comment></comment></comment></comment></comment></comment><comment><USER8> Well, this is not exactly what I expected to find in the ToS:

 _GitHub, in its sole discretion, has the right to suspend or terminate your account and refuse any and all current or future use of the Service, or any other GitHub service, for any reason at any time. Such termination of the Service will result in the deactivation or deletion of your Account or your access to your Account, and the forfeiture and relinquishment of all Content in your Account. GitHub reserves the right to refuse service to anyone for any reason at any time_

That means my company's code can be wiped out by GH at any time, for any reason. Please don't hurt me :(

<comment><USER8> This other part is fun too:

 _Verbal, physical, written or other abuse (including threats of abuse or retribution) of any GitHub customer, employee, member, or officer will result in immediate account termination._

What if a GitHub employee cuts me in traffic and I shout _f--- you!_? My account could be lawfully terminated if the guy finds my twitter handle.

God, I hate law. I'm sure github folks have good intentions and operate on good will, but reading this stuff gives me shivers.

<comment><USER9> > God, I hate law.

Sure, but how do you feel about the alternative?

<comment><USER8> Honest, just, trustworthy, good, happy, well behaved humans? That would be great.

<comment><USER10> That's not the alternative to law, that's an alternative to humanity's current state itself.

The alternative to law is "I've got a bigger stick, you shut your face or I do it for you", where "stick" is not a metaphor for lawyers on retainer but an actual stick.

<comment><USER11> Isn't that the definition of how our laws are enforced? They have the bigger stick. So we do what they say.

<comment><USER12> That's an oversimplification. We have a big virtual stick, which we use to make some guys to register what we want on paper and give other guys real big sticks so that they will tell us to do what _we_ actually wanted. At least, that's how it's supposed to work, I guess. (And it's also oversimplification.)

<comment><USER11> "give other guys real big sticks so that they will tell us to do what we actually wanted"

I think you mean so that they will tell other people to do what we wanted. Also, that doesn't change the fact that those with lesser power will be in a worse position to enact change. They will usually be on the losing end of "the stick".

<comment><USER12> > they will tell other people to do what we wanted

No, actually I meant us, but more as a whole. We all vote for laws that are mostly applicable to ourselves (except foreign policy). This is, of course, in theory.

I agree, though, that it's harder to enforce change if you don't have any perceivable stick. People in power can control elections, after all, and there's not enough transparency about what happens 'at the top'.

</comment></comment></comment></comment></comment></comment></comment></comment></comment><comment><USER8> Remember when Zed Shaw took down GitHub for purely personal reasons, disturbing service for millions? I don't remember him getting suspended, his account is live and well at <http://github.com/zedshaw>

<http://sheddingbikes.com/posts/1306816425.html>

<comment><USER13> Did Zed do that on purpose, though? He was continuously added to a troll repo with no way to block the guy, so he spammed his repo with commits and fake branch merges, but I don't think he crashed GitHub on purpose.

</comment></comment><comment> T-Winsnes So if I got this right, this is the order of how things happened.

1\. Egor finds a vulnerability and reports it. <https://github.com/rails/rails/issues/5228>

2\. It gets ignored and he is being called a troll.

3\. He proves that he was right by doing a harmless commit to to the rails master repo.

4\. The vulnerability gets fixed quickly as it got the focus of the community.

5\. His account gets suspended

Not sure I agree with the suspension.

<comment><USER14> Except he also opened a closed issue, compromised 2 other accounts and impersonated another user, something he admits to in his blog.

<comment><USER15> Were his other actions (impersonating another user, compromising other accounts) also to demonstrate vulnerabilities or just unnecessary semi- malicious actions on his part?

<comment><USER14> They were not malicious but, imho, they crossed the line. It's not be too difficult to justify something simple like opening a closed issue but once he did things that interfered with other peoples accounts that's the point at which I feel no sympathy for for him being suspended.

</comment></comment></comment></comment><comment><USER16> He has a get out of jail free card.

<http://homakov.blogspot.com/2011/07/octocat-tattoo.html>

<comment><USER17> In his master commit he commented that next tattoo would be real :-D

</comment></comment><comment><USER18> Why is someone who can hack Github working for $30/hr on oDesk? @Egor, quit selling yourself short!

<comment><USER19> 4500 USD / month is great money for 18 year old in Russia. It's 10 times usual wage.

<comment><USER20> I wouldn't say 'great' but decent and ok.

</comment></comment></comment><comment><USER21> Not sure that's the call I would have made, but hacking into other users' accounts does seem like a pretty valid reason for account termination.

<comment><USER22> If I was in their shoes, I would have made the same call: he hacked into users accounts and threatened to do more damage, quick, bust out the bargepole

I would be very concerned about this backfiring, but, I would hack Rails a little to report when anybody attempts to use this glitch and wire that into Hubot(TM), so if he does attempt to use this same hole again, the devs are warned instantly

<comment><USER23> Suspending his account doesn't make any sense. He could easily sign up with another email account. Set up a new set of keys on another computer and he's back at it. GH should be working with him instead... he obviously knows what he's doing.

<comment><USER22> That's the purpose of sending attempted uses of this exploit straight to the highest place possible: so if he does, they know

Working with him to do what? He pissed about a little with WebInspector, it doesn't make him a security consultant

He threatened to do more damage to your site, why wouldn't you suspend someone like that?

</comment></comment></comment></comment><comment><USER24> What's to prevent Egor from setting up a new account and using it to exploit the vulnerability he's found?

<comment><USER3> That is why this just seems like petty bureaucratic revenge. It looks good for PR purposes and placates other users ("look we got rid of the problem, the hacker has been eliminated").

<comment><USER25> I think it is more likely they need to verify that he only did what is currently known about and nothing else (such as if he had granted himself access to some private repos, for instance). Much safer to suspend/terminate his account first just in case. They are likely combing access logs, etc. Maybe they will reinstate it later after a review. Who knows other than Github.

It could also be to reduce legal culpability. If they left his account enabled and he _had_ granted himself access, and later did more damage, they might be liable for negligence? Not sure. IANAL, etc.

<comment><USER3> > It could also be to reduce legal culpability.

Ok that makes sense. In light of that they most likely acted rationally and correctly.

</comment></comment></comment></comment><comment><USER26> His account has been reinstated, Github has patched their service, and the Rails team has committed a patch with new defaults. All in less than eight hours. Let's move on.

<comment><USER27> Move on? There's no lessons we can take away from this?

<comment><USER26> There are certainly lessons to be taken away, but this whole thing has devolved into a witch hunt.

Take away the good, move on from the bad, and get back to making software better instead of treating the OSS community like a soap opera.

</comment></comment></comment><comment><AUTHOR> Is this supposed to prevent him from doing further damage? I hope this isn't the beginning of something ugly with GH.

<comment><USER28> Can't say it is a douche move from GH since they are protecting their users' best interests. The facts are: Egor has a way to cause damage to GH. I don't think GH would sit there wondering whether he would do the ethical thing.

_If_ something had happened then the reaction would have been totally different. "Why didn't GH ban him when they could have before the damage was done?"

<comment><USER29> To be clear: we all had (past tense, as I'm assuming GitHub effectively fixed it) that "way to cause damage to GH"; it isn't a bug that Egor was hoarding, or that only he was in a position to exploit. You can argue all you want that he deserved to have his account banned (I might even agree with you, although I haven't come to a conclusion on that yet), but to claim that it was some kind of required protection that people would legitimately be able to complain about had they not done it is silly: he can still do the damage from a new account, and someone else can do that damage even if he didn't want to.

</comment></comment></comment><comment><USER30> I'm sorry but I have to defend Egor here. Here's how you actually report a vulnerability, demonstrated by dfranke here on HN -> <http://news.ycombinator.com/item?id=639976>

What Egor did was to violate sensible disclosure rules. He should have contacted GitHub in private, created a test repo and demonstrated his exploit there, rather than impersonate users and compromise multiple accounts.

If I was in Github's shoes and I was trying to figure out what damage was done, the first step would be to suspend the account doing the damage to make sure no further surprises were headed my way.

</comment><comment><USER31> They should be hiring him.

</comment><comment><USER32> What I would like to know is if this is permanent or just till github completes their security audit. It doesn't seem like homakov intended or caused any real harm, although it was a bit immature to draw attention to the vulnerability that way.

<comment><USER33> I think it's interesting how sometimes the "immature" course of action is what brings the greatest good.

</comment></comment><comment><USER34> In the future, if folks find vulnerabilities in GitHub, please report them via an Email to firstname.lastname@example.com or firstname.lastname@example.com.

<comment><USER3> Or if you want to keep your account, don't tell GitHub, but sell the vulnerability on black market and make some profit off of it.

<comment><USER35> We will never, ever suspend or ban accounts that follow responsible disclosure. Ever.

<comment><USER3> I think from a PR point of view with respect to the rest of the developer community you might have lost this one. You didn't eliminate the threat posed by him as an individual because he can create a new account.

(Note: as far as your enterprise or big-corp clients, you probably did the right thing, because that is what they would have done and that is what they expected. So if they are the clients who put bread on your table, then you have acted correctly)

What I think you could have done better (and I speak as a developer not a corporate client): issue a public note saying something to the effect of "Thanks for finding this out, maybe you'd like to interview with us. But please, everyone, do not do it this way, this is against TOS and most likely illegal. Here is is the email where to report these things and we will make sure to give you full credit after we fix the problem".

<comment><USER36> A lot of the fire could have been cooled with the suspension notice being accompanied with (ideally preceded by) a personal note to Egor. The absence of that is what makes this seem more like a GoDaddy firing-from-the-hip move than a rationally thought out one.

</comment></comment></comment></comment></comment><comment><USER37> His account has been unsuspended.

[https://github.com/rails/rails/commit/b83965785db1eec019edf1...](https://github.com/rails/rails/commit/b83965785db1eec019edf1fc272b1aa393e6dc57#commitcomment-1041295)

</comment><comment><USER38> Don't suspend him -- hire him.

</comment><comment><USER39> This is really childish attitude. Egor grow up.

<comment><USER40> In case you didn't see his bio, he's 18 years old. I'm not a fan of what he did, but frankly, his behavior is probably better than mine would've been at that age + circumstance.

<comment><USER39> In most countries (including Russia) this is considered a criminal behavior.

</comment></comment></comment><comment><USER41> He clearly violated their Terms Of Service. If you like and enjoy a service, exploiting it to prove a point is not the way to do it. It takes no time to spot the clause about exploiting the service.

Legally, it wouldn't be good to have a TOS and then not enforce it. You never how that could bite you later on if you get dragged into a dispute.

All this "they should give it back when they're done" is pointless. You can't reward stupid behavior.</comment>