• Advertisement
Sign in to follow this  

What do you want in your development tools?

This topic is 1467 days old which is more than the 365 day threshold we allow for new replies. Please post a new topic.

If you intended to correct an error in the post then please contact us.

Recommended Posts

Advertisement

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.

Share this post


Link to post
Share on other sites

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.

7i7i.png4ruw.png

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.

Share this post


Link to post
Share on other sites

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.

Share this post


Link to post
Share on other sites

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 wink.png

 

The LightTable IDE has some nice features that hopefully will be emulated by others soon laugh.png

Share this post


Link to post
Share on other sites

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.

Edited by Ravyne

Share this post


Link to post
Share on other sites

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

Share this post


Link to post
Share on other sites
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).

Share this post


Link to post
Share on other sites

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.

Edited by MorleyDev

Share this post


Link to post
Share on other sites

A decent refactoring tool, no more tab as n-spaces as default, a decent formatter.. You know, make readable the code of someone else with just a pair of click...

Share this post


Link to post
Share on other sites


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.

 

For this there is a "Show all files" button in the solution explorer that will display the tree with actual folder structure. You can also include/exclude files in the project, or add items directly to some folder in this mode. I think the default mode is hardly useful, but this mode is somehow "well hidden".

Share this post


Link to post
Share on other sites

A debugger that:

  • Works.
  • Doesn't lie to me.
  • Presents variable content in a legible manner.
  • Knows about STL.

Basically the VS debugger.

Edited by Scarabus2

Share this post


Link to post
Share on other sites

Some of the things I love about doing C# in VS 2013:

  • Resharper: Good refactoring tools are the best.  It's very liberating to be able to easily extract functions, rename variables and transform code without breaking everything and doing tedious find and replace by hand.
  • Nuget: Beats the pants off trying to integrate third-party libraries by hand.
  • VS Graphics Debugger: It's not perfect, but it's pretty handy to get dumps of per-pixel history, as well as being able to see all of the textures in memory.  

Share this post


Link to post
Share on other sites

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?

 

I mostly find myself despairing at programming languages themselves, so this one would definitely be on my list. Except rather than opting out of nulls, why on earth isn't it something to opt-in for?! Like Haskell's Maybe type (I actually feel OO languages should be drawing more inspiration from functional languages than they currently seem to be doing; lambdas are not enough tongue.png).

 

Similarly constness by default would be nice, with a compiler able to recognise and optimise usage of fully immutable objects.

Also, a class should be able to implement an interface in terms of a member variable using a one-liner; NOT being forced to actually implement a trivial pass-through for each method in that interface. Composition is definitely better than inheritance, but languages don't half make it difficult.

Algebraic types.

Pattern matching with support for structure decomposition and implicit casting to subtype.

Multiple dispatch.

 

Slap 'em into any mainstream language and that would be great, thanks biggrin.png

Edited by dmatter

Share this post


Link to post
Share on other sites
Sign in to follow this  

  • Advertisement