What is still missing in our programmer toolbox?

Question

Currently we've got

• Good IDEs, with code completion, compilers, plug-ins, embedded servers... "The Works"
• Good build tools
• Nice unit testing frameworks
• Pretty decent application servers
• Lots of books about Design Patterns and XP (if only we had time to read them)
• Fast CPUs and virtually unlimited storage (looking at YouTube ;-)
• Decent network performance and coverage around the globe
• Good version control systems
• A great support network via http://stackoverflow.com (and I really mean this!)

But what is still missing in our "programmer toolbox"?

[Note: The list above is not an exhaustive list... I'm not suggesting you should append this list so that we have described all the tools in our box nowadays, but what is simply missing currently and what would benefit you greatly in the future... if you could make a wish ;-)]

Answer 1

You forget a good version control system.

Answer 2

Some sort of automatic validation of the code from some easy specification/contract (a working and easy Design-by-Contract possibly?).

Answer 3

A good process for managing the project. Scrum and XP are my personal favorites (really any flavor of Agile) but not everyone has the luxury.

Answer 4

Debuggers, and similar tools for peeking into an application (like Valgrind)

Answer 5

An issue tracking system, aka Bugzilla, JIRA, etc.

Answer 6

Focus and concentration to use the tools/knowledge I have (or can develop)... eeeek :/

Answer 7

I also like using a profiler

Answer 8

Better bridges to end users; bug trackers are a good start, but it would be nice if lots of end users could directly and effectively influence a product and add their own ideas.

Answer 9

• Dual Monitors
• good source control program
• Customers with realistic expectations

Answer 10

A good list of stuff.

Now, assuming you have the following other things:

• Motivated team
• Good leadership
• Open communications and buy-in from the customer
• A clear understanding of the problem(s) to solve

I'd say you'd have a good, well-rounded development situation.

Answer 11

A simple, integrated TO-DO list (I favor Mylyn for Eclipse, but the easy way you can handle TO-DO tags in your code out-of-the box is quite good actually).

Answer 12

Not sure if you have these or not, but you could be missing:

• Version control
• Automated Continuous Integration
• Virtual Environments: For quickly standing up a new dev environment (VM Ware, VPC)
• Multiple monitors for each developer
• Documentation tools (Generated API doc tools, wiki, portal, etc.)
• Offsite backups

Answer 13

A working framework/paradigm for concurrent programming that works without the programmer that uses knowing how it's implemented. OpenMP let me thinks to much about the real implementation. I think more about something like Object-Oriented-Programming. I write classes and the compiler do some stuff, so that it works. I wished such a tool would exist for concurrent programming.

Answer 14

I really think we have a lack of static analysis tools.

The recent duck-typed languages like Python and Ruby bring a lot of great advantages to the table -- quick development time, easy prototyping, functional techniques, etc. but they fall very short in regards to the software quality evaluation dimension.

Testing for dynamic / duck-typed languages is much, much harder than it is for more traditional and (more) strongly typed languages such as c#, Java, or haskell (if I can dare to utter that name here..). Since the same degree of static analysis is not available, the burden of detecting type errors, (some) reference errors, and scope errors falls to the testing phase of the project. This greatly increases the required degree of test coverage needed to obtain a similar level of 'testedness' (or, software quality, if you like that term better).

This is definitely a trade-off: static analysis, when done by the compiler, puts a burden on the programmer and the initial coding stages. I think it drastically helps with the maintence phases; however, because incorrect assumptions about the code are more immediately brought to the maintainer's attention.

One approach is as Steve Yegge suggests: The next big language will probably have optional type annotations. I think this is a step in the right direction, and the popularity of Generics in java / c#, and templates in C++ seem to support this.

Another approach is to build on tools like lint, pychecker, etc. so that they are easier to use in a production environment, and to incorporate dynamic aspects so that the tools are even capable of catching some of the errors possible in dynamic languages (eg: referencing variables/attributes that just don't exist at compile time).

Answer 15

I think we're missing the spirit of the question. It could be edited to add version control to the list of things we have, but what about things we don't have, or are not commonly used? I can think of a couple; they seem to mostly boil down to IDE improvements, but I think that makes sense since we live in the IDE and the browser these days, no?

• Better refactoring tools
• Snippets from dynamic sources. Imagine a server with snippets for common languages & frameworks that editors could hook into.

Answer 16

I think that all depends on what your development environment is, what (if any) RDBMS you're using, etc.

One thing I see missing (and it could be an oversight) is source code control. Along with that (or potentially tied to it) is an issue tracking system. I'm thinking a Subversion/Trac setup, or Jira, or MS Sharepoint with Visual Studio Team Services. It all depends on what your dev. needs are, really.

If you've got all that stuff, then I'd say you're looking at more intangibles, like management that believes in realistic and reasonable deadlines, support at all levels, solid development processes, etc.

Answer 17

A language for writing program specs, and IDEs that read and maintain them.

Whenever I start a project in Visual Studio, I don't want it to ask me if I want to make a Console App, or a GUI app, or a class library, etc. I want it to always start with a spec, and when I add "Console interface" to the spec, the project for it gets created automatically. And if I remove that project, then "Console interface" is flagged as an unsatisfied requirement (like unimplemented methods of a class interface) and prevents building until the requirement is removed or re-implemented.

The Spec is also where the unit tests and test data are organized, so when you add "PDF report generation" to the spec, there's a way to specify which unit test proves it, with tab-completion and skeleton generation just like the way event handlers can be created.

The spec language would be a markup language, and when rendered to the screen or printer it produces a human-readable description of the program's requirements, use cases, and even the manual.

The Spec could also tie together other kinds of requirements that can be tested programmatically, and either prevent a build or display warnings after the build. For example: a performance and memory requirement that is proven by the output of a profiler (post-build warning), or coding style proven by FxCop (prevent build).

Update: Somasegar has been writing about "Application Lifetime Management" for the next version of Visual Studio, and it sounds a bit like specs integrated at the code level.

Answer 18

Really great visualization/expression tools. We know how to express highly complex, highly abstracted notions in terse language (code), and we have some ways to express those things in a shorthand or visual way (UML, flowcharts, perhaps), but it takes an awful lot of effort to create those expressions because each is imperfect and incomplete.

To express important ideas sufficiently, it takes multiple UML diagrams that all have to agree with each other, flow charts that match the execution flow of the software, and documentation to match. Doing all this often takes more time and effort than writing the code itself.

We need something better, but the lowest common denominator is a pencil and paper, which tends to be what people fall back on.

Answer 19

I believe that we are missing design tools.

Code design is great, but what about visual and functional design? I know I spend way too much time re-writing code because the designers didn't have time to create a complete design before code began to be implemented.

This goes to the old saw, "I just got the final requirements for a five month project, and this is month four."

Answer 20

Source code metric tool (good for getting a high level sense of the code) like SourceMonitor: http://www.campwoodsw.com/sourcemonitor.html

Answer 21

Technically savvy management who appreciate the issues involved in software development.

Answer 22

Good concurrency support. We're getting close to having this. But nonetheless, programming with threads is still a pain aside from maybe starting a separate thread to do something and still be able to respond to the user.

Answer 23

I miss DWIM from Lisp

Answer 24

A Decent UI Editor - Coding UIs by hand sucks. All UI generators currently suck

A Decent Way of Storing Data - You put data in flat files, but flat files are slow and you need to repeat your data. Then you get a relational database, and it's nice and fast, but now you have to create all sorts of code to map your objects into the database and vice versa. I want to create an object, call object.store() or whatever and have it be fast, efficient, and reliable.

Answer 25

A good way to share knowledge such as an internal blog or wiki system. Without that, the tenth time your senior programmer has to explain to someone your system's database schema he might just decide that its easier to take a nap in the middle of the nearest high traffic thoroughfare.

Answer 26

Spell Check

I'm serious. I spend most of my time in Visual Studio and other MS tools, but I am sure this applies to all IDEs, etc. I have run across a couple of spell checkers that integrate into Visual Studio, but nothing that is comprehensive. I want a spell-checker that:

1. Spell-checks my source code and understands Camel, Pascal, and all the other notations. I don't know how many times I have misspelled a public property name, column name, or a directory name and then ended up with a ton of code using it. I want VS to warn me that variables like "acountName" are spelled wrong.
2. Checks strings for regular spelling errors.
3. Checks resource files. In .Net you can use resources files for localization. Almost all the publicly-visible text in my current project is contained in resource files for this project. These should be spell-checked.
4. Run-time spell-check. I can start-up a program in debug mode and break on exception. Why can't the debugger be watching for string rendered to the screen with bad spelling?
5. Spell-check my SQL DDL in SQL Management studio.
6. My code repository should warn me if I am committing files or directories that look like they are spelled wrong. In CVS it is a real bear to rename files, and you simple cannot rename a directory without administrative effort.

Answer 27

I don't know where to start, there is so much awaiting us in the future:

• dynamic UI linking, with language independent interface (bit like HTML forms, but with suport for memory sharing and custom widgets), ability to change most of UI without any programming
• (smart) reversible architectures and debuggers
• automatic data structure selection by compiler, based on runtime usage; whole field of new optimizations based on this paradigm
• more features from functional/academic languages in mainstream, such as type inference, multiple dispatch, pure functions, flow-based programming and many many other things
• more separation between specification (what affects the correctness of result) and implementation (what affects performance) in programming languages
• reconcilation of OOP and relational data model, and extensions of this
• automatic generation of assertions, based on runtime data; these assertions can be confirmed or rejected by programmer, and can be used for optimization by compiler

Simply, the future is bright!

Answer 28

Process In Can.

Something like a CMMI compliant everything system that comes as a box, you plug it in and then your whole company ( and clients) are all using processes that are provent to reduce costs and improve results.

A magical system that has intgerated specification, requirements engineering, systems engineering, integrates down to code control and bug tracking and feature tracking. It does proejct manangement, and computes when milestones will be hit using evidence based scheduling.

And it makes releases and does version control.

Then we'd just do the creative bit, and the paperwork (and most of the management) would all be automatic.

Not like Rational Rose... sort of the opposite. LESS work for all tech staff.

Answer 29

Tools for managing fixed-point algorithms. I know how to convert algorithms manually from floating-point to fixed point, and to make the right tradeoffs so there aren't underflow or overflow problems, and I do the same things over and over again. I just can't figure out how to automate the process. (& please don't point me at MATLAB + Simulink + autocode generation)

Answer 30

One thing that's still missing is a good way to reason about dependencies, in a way that's integrated with the code itself.

For example, let's say someone has written this code in my project:

import org.awesome.SuperclassFromSomewhere;
public class MySubclass extends SuperclassFromSomewhere {
   ...
}

Where does the superclass come from? Is it in my project? Is it being imported from a library? What if there are multiple libraries providing a class with the same fully qualified name? What if there are multiple versions of the class, within multiple versions of the library?

After doing a little refactoring, maybe I get rid of the dependency on the superclass.

Can I remove any libraries from my classpath? And when I remove those libraries, do I also get rid of other dependencies?

Current solutions (like maven) only simplify the process of over-cluttering a project with dependencies. They don't address the challenge of reasoning about and eliminating dependencies.

I'm working on a project right now that has over 60 libraries in its classpath, and it's very hard to understand where all the code comes from and how all those different libraries interact. I think I only have 10 or 15 direct dependencies, but then each of those libraries requires its own list of dependent libraries.

And thanks to dependency injection, and reflective class-loading, it's virtually impossible to figure out what the REAL dependencies are, short of running the code and inspecting the guts of the JVM.

It's entirely possible that some of those dependent libraries are only being used in one or two places within my project (or zero, for all I know), and I could eliminate thousands of dependent classes, from dozens of libraries, just by rewriting a method or two. But without any good tools for reasoning about dependencies, I don't really know.

Answer 31

I want a kind of blue-pill that loads Linux underneath windows. All we need to tell our customers is our software requires x GB of unpartitioned disk. We'll provide backup tools for the data and all they see is the Windows Server they started with.

Answer 32

It looks like you have all the tools you need in terms of coding but there is a lot more to a successful project than the coding phase.

A smart application of software engineering and project management best practices to your specific work environment and corporate culture with a software development project life cycle management solution that supports those best practices is what I believe might be missing.

Answer 33

The next level of virtualization. I want to be able to spin up a new virtual machine ("VM") in seconds, run tests or whatever on it, and throw it away.

Today I can do this, but it takes forever. The VM is slow, unless I have Hyper-V or equivalent, and then we're talking about expensive hardware. I want this on all hardware, including a $300 netbook that keep in my backpack, just in case.

We'll get it; it's just a matter of current high-end technology getting cheap, and current cheap technology getting fast. Which is exactly what will happen.

Also, I want to be able to run VMs inside VMs, so I can automate testing on a variety of platforms, have those tests use VMs for that variety, and have the whole enchilada run in a VM.

Answer 34

Debuggers that can go backwards. This would help soooo much when trying to fix a problem, imagine just putting a breakpoint in a catch clause and just going back in time? Now that would be awesome. Some people are already doing research in this area, but it isn't really that well developed yet, or very widely spread.

Answer 35

I18n & Localization need to get easier.

Today I have to program carefully to make sure that my strings live outside my code. That makes my code harder to understand ("What message will the user see here?"). It makes manipulating the strings harder ("How do I format this message with runtime-generated data?"). I have to remember which strings are not for users, and therefore should go elsewhere (e.g. parts of a wire protocol). Formatting may not be typesafe.

I also have to remember to do the right kinds of string comparisons and case conversions, depending on what the string means.

That's just strings. The rest of the UI needs loc help, too, and it's really hard to do well.

I want this all to get really, really easy.

Answer 36

The ability to create a new programming language & get a complete tool experience around it.

If I have some ideas for a programming language, it's much easier today to compile it to .NET than it was to compile to native code years ago. But there's so much that's I still have to write. I want to be able to design a language and then get Colorization, IntelliSense, Refactoring, and rich Debugging with a minimum of effort.

There are few things we already see which could help:

• The model for adding features to the VS editor in VS 2010 should be an improvement here, but I want things to go much further.

• Perhaps we just need well-designed libraries that a language "vendor" can use to build this support quickly & easily.

• Perhaps extensibility in existing tools is the key.

• Perhaps there are ways to design a language so as to make these things easy.

• Perhaps I should just stick to "internal DSLs" instead, keeping the richness of my host language & associated tools.