- The Role of the WAN in Your Hybrid Cloud
- Top Six Things to Consider with an Identity as a Service Solution
- IT and LOB Win When Your Business Adopts Flexible Social Cloud Collaboration Tools
- Big Data and Customer Interaction Analytics: How To Create An Innovative Customer Experience
The soon-to-be-released version of NetBeans 7.3 builds upon the above, but also integrates the JavaFX Scene Builder inside the IDE, improves REST development, and spruces up support for other JVM languages such as PHP and Groovy. Eclipse continually streamlines its collaborative development features, and now features an improved UI for multi-monitor support and high-resolution displays.
But I still wonder, what's next? What will be the next sea change in the area of IDEs and application development? I have some ideas, generally revolving around the transition from straightforward coding to building and debugging. For the most part, the popular IDEs have done a good job of blurring the lines between coding and compiling. You don't need to explicitly build your projects anymore. But the same cannot be said for debugging.
I often find myself launching an application in debug mode, stepping through some code, and then entering a series of repeated steps where I stop debugging, make a change, and then resume debugging. Rinse and repeat, and repeat. I know that some IDEs support changes while you're debugging, even if you're running a Java EE application within an application server, but it's not always reliable, and sometimes the changes are too drastic for it to work.
I propose that the next generation of IDEs create an environment of continuous debugging, to be integrated into the continuous integration paradigm. In other words, from the moment I begin coding in an editor, I want the IDE to enter debug mode, attempting to execute the project and update its execution state while I type. You don't think this is possible? It already happens with the compiler. Sure, I get little red lines in the editor and compiler errors in the output window until I modify and fix the code. All of this updates in real time, so why can't the execution state do the same? This way, as I code, I can set breakpoints, see them get hit, and then write new code and modify existing code all at the same time.
As a result, there would be a continuous flow of coding/testing/debugging, with no need to stop my current workflow to start or re-start a debugging session. In reality, the IDE would need to perform those steps behind the scenes, but it could go a long way towards making it look seamless, and appear to execute/debug continuously as I write code.
Total Continuous Integration
Going forward, I'd like to see the IDE merge its capabilities with continuous integration software such as TeamCity, and issue tracking software such as Jira, to more easily enable the Agile development process. Add to this the continuous debugging I've described above, and developer productivity and code quality would increase tremendously as continuous debugging and testing occur seamlessly. Imagine never having to interrupt your state of coding to achieve all of this. Is it possible? What else would you add or change in your favorite IDE?