I've spent a lot of time recently thinking about things I want my programming tools to do. Some of these things are just improvements to existing concepts, and some are entire categories of functionality that don't exist in common toolkits. (To be honest, though, most of the ideas are implemented out there, just not popular or widely available.)
Fileless code organization
I'd love to stop thinking about my code in units of files. Give me a way to arbitrarily group code, maybe index it in several different ways, and I'll be much happier. I want to be able to organize on my own axes that don't always overlap with file divisions.
Semantic version control
Kind of in line with the above, I'm tired of version control that's just text-based. I want my revision history to understand that I moved a function from one module to another, or renamed a couple of variables, or whatever. Just thinking of programs as text is too limiting.
Better REPLs
The idea of a REPL (Read Eval Print Loop) is old and well-tested, but I'd like a GUI-based version. Smalltalk is the closest thing I know of to my ideal, wherein I can build arbitrarily complex data structures and run arbitrary code on them. Imagine a system where you can build entire test cases of data using a simple visual editor to lay out the data structures, and then feed that data into a module to get instant unit testing.
Better contracts
I hate the way I have to specify interfaces and contracts in most languages. More accurately, I hate the way that interfaces are everything and contracts are second-class citizens. Aspect-oriented programming is almost a step in the right direction, but most implementations are really clunky and verbose. Why can't I just say something simple, like "this function never returns null", and get automatic optimizations and sanity checks from my compiler?
Responsiveness
Visual Studio is a hog, and the other IDEs I've used are all worse. I want something slim and fast, so I can get all my coding goodness at a reasonable pace. Taking two minutes to load a project that comprises only a few dozen KB of XML on disk is just stupid.
So that's my wishlist. What's yours look like?
What do you want in your development tools?
Taking two minutes to load a project that comprises only a few dozen KB of XML on disk is just stupid.
That’s just Visual Studio 2010. The rest aren’t terribly fast, but not 2 minutes slow.
In Xcode you can drag a folder into the project and it will add all files recurvisely and create an internal folder tree to match that of the disk.
I would like to see this in Visual Studio. I’m getting tired of having to manually create groups in Visual Studio and then drag the headers into the Headers section and the .cpp files into the Source section manually and separately.
Come on Visual Studio! Just let me drag a folder into the project and you recreate the folder tree and put all the headers over there and the source files over there.
L. Spiro
id like to document my code without having to adhere to something ugly like doxygen formatting..something like a built in functionality on your ide that reads your code, creates a template and let you select and tag any comments to make it appear correctly on the documentation.
Coming from a C++ background, separate class interface from implementation. Automatically pre-declare what it makes sense to predeclare, and include what it makes sense to include.
Bread-crumb style Project->Module/Namespace->Class->Function navigation in the IDE.
IDE built-in documentation. The rich-text documentation description for a function is visible and editable right above where the function itself is is visible and editable. Includes embedding images (for graphs and graphical demonstrations of GUI appearances or blend modes), tables, things like that.
As soon as I stop typing, I want the program to invisibly and automatically start recompiling the single file-fragment that changed. If it fails, fail silently (and put a little red "not compilable" icon next to that file-fragment's link). I might go and change other pieces of code... but if project compiling was spread out while still working on code, and while moving the mouse pointer about the gui, and when every piece of code compiles fine, automatically and invisibly begin the final linking step, by the time I finally click "Run", the compile should already be a good step along, improving productivity.
Obviously this isn't as big a deal for large projects that take hours to compile, but it helps smaller projects that only have (incremental) compile times less than 10 minutes.
That's what makes the editor chug though. I want responsiveness when I am typing not "please wait" thinking about tings while I'm trying to type code.
Regarding the Semantic version control, i know a few engines that use JSON for level data/etc, and have written 3-way merge tools that understand JSON, which can then be plugged into existing version control tools to enable semantic version control within a text-based system.
If you had a sensible way to "serialize" your code/project to a structured format like JSON, you could do the same thing. This fits in perfectly with the Fileless code organization idea 
The LightTable IDE has some nice features that hopefully will be emulated by others soon 
There was some great stuff in Bret Victor's Inventing on Principle presentation that used coding to demonstrate some concepts. The gist was that having "live code" allows rapid exploration, refinement, and discovery of both the problem and design space. It might be kind of out there, and perhaps a lot to lay the groundwork for, but in a lot of ways, what he shows strikes me as a thoroughly modern REPL.
Coding Horror's Jeff Atwood had some things to say about it.
My wish list :
-unlimited version control : version control which can handle unbounded branch management and code variations on a complete system wide level. Can guarantee 100% stateful restoration of code and support classes and platform, allowing for unfettered experimentation and code sharing.
-smart code auto-generator : using advance AI heuristics analyze user code library and does code auto-complete not at a basic syntax level but higher level.
-meta everything : all code, support tools, interfaces, api are meta-tag and allowed for meta-analysis and offline refactoring.
-runtime visualization tools : advance visualization routines allow user to see allocation, process, information flow, higher order logic, etc.. of their program in action.
-smart syntax coloring : just better versions of what we have now
-ddn
Debugging experiance.
Most other things I can live with or work around but if debugging is a pain then I tend to get very stabby about life in general. While not perfect VS seems to get this right (mostly anyway, Android guys were complaining yesterday about having to look at memory as the watch window wasn't sane, but that's just Android dev all over it seems).
Most other things I can live with or work around but if debugging is a pain then I tend to get very stabby about life in general. While not perfect VS seems to get this right (mostly anyway, Android guys were complaining yesterday about having to look at memory as the watch window wasn't sane, but that's just Android dev all over it seems).
In the IDE? Extract Variable, Extract Method, Extract Class, Inline Variable, Inline Method, Rename, Change Namespace
When the IDE provides comprehensive refactoring tools like that, the speed gains in development are exponential and not having those tools at hand soon feels like a chore in comparison.
This topic is closed to new replies.
Advertisement
Popular Topics
Advertisement
