Why not become a lifetime supporting member of the site with a one-time donation of any amount? Your donation entitles you to a ton of additional benefits, including access to exclusive discounts and downloads, the ability to enter monthly free software drawings, and a single non-expiring license key for all of our programs.

You must sign up here before you can post and access some areas of the site. Registration is totally free and confidential.

So, most IDE's are pretty much the same. Other apps get better and change paradigm, but with the IDE, it's more of an evolution rather than a revolution.

Chris Granger came up with a new concept, and created a decently successful kickstarter campaign around it. It sort of morphed during the process - he actually got real investors in addition to using crowd funding (though he was quite open about it). But the concept still remains, and even though my language of choice is still C#, I have been looking with interest at Clojure for a while, and the concepts that he's putting forward are really cool and hopefully imply that there's still some level of innovation out there in IDE development.

Quote

Light table is based on a few guiding principles:

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 instantaneous results

We can shine some light on related bits of code

There's more on the kickstarter, and he has a playground on his site that you can download and play with. But I really like the promises of what he's trying to deliver.

And one last quote - the one that really got me on board:

Quote

We built drafting tables for a reason

Towards the end of my time on the Visual Studio team, I came to the conclusion that windows aren't a good abstraction for what we do. Other engineers have large tables where they can scatter drawings, tools, and other information around. A drafting table is a much better abstraction for us. We shouldn't need to limit ourselves to a world where the smallest moveable unit is a file - our code has much more complex interactions that we can better see when we can organize things conceptually.

Currently, Light Table has plans to support Clojure, JavaScript, and Python, but I'm hoping for much more than that. I think the reason that people keep creating the same thing over and over with iterative improvements is that Granger is right. We're developing in a paradigm that limits us, rather than frees us. At the end of the day, advanced coding/programming/whatever you want to call it is about solving problems. And our tools aren't really geared towards that purpose: no matter how many ways we can split and slice our windows, they just aren't built for what we need. Maybe this can start a revolution in our tools, and make us much more productive.

Also, though this thread was started about Light Room, I welcome other discussion on the topic. I've been quite dissatisfied with IDEs and what's been out there for a while...this just sort of crystallized a lot of what I have been feeling towards the tools that are available.

Very interesting, thanks for the share!I like how the IDE takes full use of the space available by displaying several functions.In terms of functionality, this does sound very interesting.

The only thing that gripes me a bit is the "live preview" of executions. Even though it sounds interesting, it looks like for large projects it might be impossible to configure the IDE to run it decently enough to get the live preview. Also, I'm not sure how that works if the functions take a lot of time to run (think of factorial with 400 as an argument ), does it timeout or does it hang up the editor?

The only thing that gripes me a bit is the "live preview" of executions. Even though it sounds interesting, it looks like for large projects it might be impossible to configure the IDE to run it decently enough to get the live preview. Also, I'm not sure how that works if the functions take a lot of time to run (think of factorial with 400 as an argument ), does it timeout or does it hang up the editor?

Good questions. It seems that perhaps in practice now that he's released the playground, some of those same questions have occurred as he's put in a way to turn off live execution, and to perform it only for certain areas on demand, i.e. if you're in a bit of code you can run it on demand for that code.

I agree that it's interesting. I also think it's important for our trade that new tool ideas are explored. I doubt though that something like Light Table would be much of an improvement over VS for the software we write in our company today (UI and control SW for complex machinery). Most of our SW is C++, some is in C#, some is in scripting languages like Ruby or JavaScript. IDEs like Light Table primarily seem to target scripting languages.

To be honest, I'm quite happy with the evolutionary advances Visual Studio makes. VS 11 comes with features which are really supportive for the way we write SW in our company and will probably increase productivity quite a bit (e.g. auto-completion for #includes). I only wish advances would go much faster! There are tons of things which would have the potential to boost productivity. I'm thinking of things like:

Better keyboard navigation and selection within the code editor (things like Ctrl + D in Sublime, or code navigation similar to VI (but not like VI ))

Documentation-preview like Light Table would be possible just as well in VS (some of it is already done with a tool tip). But it should be better and support more formats (e.g. Doxygen-style documentation, which seems to be kind of a de-facto standard for C++ code)

Possibility to hide docked windows with the keyboard (not only show them)

The things I really like about Light Table are actually in VS (or add-ons) in a different format that is not as helpful to productivity. But you don't really notice that there's a better way to do things until you think outside the box.

A couple of examples:

1. Ever wanted to do some scratch work on a method or just a snippet of code without affecting your main project? Engineers do this by having scratch workspace... why don't we? Snippet compilers or such inline - able to be moved about the workspace.

2. The instant compile is a big turnoff in general... but what if you could turn it on for certain methods... takes the snippet compiler to a different level. I'm working on this method, and I want to give it inputs and see if the logic works... walk through it without compiling and running the entire solution.

3. I'm in a method- where are the other references? What else does it reference?

4. What about help for the different parts of said method? Why do I have to mouse over the bits of code to get the help for the method called? Why can't it be to the side, especially with landscape monitors?

Break the paradigm of windows- especially docked windows. They break up the flow, especially if you have to interact with them.

1. We use scratch projects, often having no more than main() to try out stuff. Or we just checkout to a different working folder. And the degree of modularisation in our system is very high, so we can work on just a specific part of it.

3. VS has Find All References (Shift + F12) which works very well. Its more the presentation of the information that is lacking.

4. Totally agree. That's what I meant with 'some of it already done'. Again, it's the presentation of the information and the way to get to it that doesn't work.

I'm not against innovation, quite the contrary actually. Nevertheless, I think VS still has potential for huge improvements with real productivity gains, without having to throw everything over board. But with release cycles every two years I just think the improvements don't come fast enough.

1. We use scratch projects, often having no more than main() to try out stuff. Or we just checkout to a different working folder. And the degree of modularisation in our system is very high, so we can work on just a specific part of it.

I do that too. But what if you didn't *have* to? What if you could write the code in place and test it in place? I've used scratch projects (and my drive is littered with them) and there's a whole overhead involved in even writing the simplest ones- especially when you consider references. I was using Snippet Compiler (but it's not supported anymore) but references were a pain, especially as a lot of things that I want to test require a lot of references to get off the ground. I've been using LINQPad as of late... but again with the references.

My references are already in my project- if I could just code a bit there and evaluate it (especially if I'm planning to use it if it works) it would save *so* much time!

3. VS has Find All References (Shift + F12) which works very well. Its more the presentation of the information that is lacking.

But what if you didn't have to find all references? I don't even have to use shift+f12 - I have an add-in that allows me to mouse over the method name, and find them from the overlay that appears. But that's still something that I have to do- I'd rather it be there when I need it - like it happens in Light Table.

4. Totally agree. That's what I meant with 'some of it already done'. Again, it's the presentation of the information and the way to get to it that doesn't work.

The devil's in the details- and sometimes that 80/20 rule leaves a lot on the table, i.e. deliver 80% of what you need... but the 20% that's the details and implementation could really make our lives a lot easier.

I'm not against innovation, quite the contrary actually. Nevertheless, I think VS still has potential for huge improvements with real productivity gains, without having to throw everything over board. But with release cycles every two years I just think the improvements don't come fast enough.

Truthfully, with VS, I'd be happy if they'd just fix the damn thing. It crashes less with each iteration, but it still crashes way too much just doing the simplest thing. When you need a checkmark to restart the application on exceptions- that might let you know that you're planning on it crashing too much.