To make the upcoming major release feature-rich, we keep adding new features almost every week.
Force Early Return in Java Debugger
The Java debugger in the new EAP build got a new action called Force Early Return. Now you can force the return from the current method without executing any more instructions from it:
If the method returns a value, you’ll have to specify it (smart code completion provided):
If the method has try-finally blocks, you’ll be able to choose whether to execute them or not:
Rebase Action in Git Branches Menu
Another improvement is the Rebase action, now available in the Branches menu on equal terms with Merge: supporting multiple roots, automatic stash/unstash and conflict resolve:
We hope you’ll find these two enhancements useful. Your feedback is always welcome. Share your impressions and concerns in the EAP discussion forum, and submit found reports to our issue tracker.
For a complete list of changes, check our the release notes.
Develop with Pleasure
September is off to a busy start for many Java developers, and no busier than right here at JetBrains. Sweeping the chimney and stacking the wood, patching the roofs and packing the goods, we’re making our lists and checking them twice. Each month, we collect the best Java recipes, and each month we find new ingredients to use. Food for thought, from our kitchen to yours – compliments of developers like you.
A fresh IntelliJ IDEA 15 EAP build is ready and out. Among the bugfixes and enhancements it ships with, you’ll find a small, but useful new feature.
Now you can change the scope of your Exclude from Import and Completion preferences from IDE to Project:
This will allow you to have different exclusion preferences per project, and share them with your team via Version Control.
Download the new EAP build right away, and don’t forget to share your feedback with us on our discussion forum or in the issue tracker.
Develop with Pleasure!
In the new IntelliJ IDEA 15 EAP build released yesterday Perforce users may notice a new action in the Local Changes tab in the Version Control tool window:
Now you can shelve your changes not only locally but also in Perforce, which might be more convenient and safe in some cases. When you invoke this action, IntelliJ IDEA will ask you to select files to shelve, and provide a description: Continue reading
Earlier we mentioned that we’re working to make our IDE more friendly for people with color blindness.
In the latest IntelliJ IDEA 15 EAP build, we’ve changed the appearance settings, so now when enabling the Adjust for color deficiency option you have to choose the form of color blindness:
To ensure that our adjustments work well, we’d like to ask you to share your feedback with us.
Currently, we support only the red-green color deficiency. If this is what you have, you’ll greatly help us if by downloading the latest IntelliJ IDEA 15 EAP build, enabling the corresponding option in Settings → Appearance and behaviour → Appearance → Adjust for color deficiency, and sharing how it works for you.
Among other bugfixes and enhancements in the new build you’ll also find support for Freemarker 2.3.23.
You’re welcome to share your feedback any way you prefer: here in comments, in our EAP discussion forum or issue tracker.
Develop with Pleasure!
After writing a post for the Upsource blog about evaluating tests during code review, I found myself compelled to write something more general on why we should be writing automated tests. If you already know the value of tests, you might find something here that will help convince your colleagues who are less sold on the idea.
Why do we write automated tests?
In my first post about code reviews, I mention that a lot of activities we often do in a code review can be automated – checking style, formatting, code coverage etc. The nice thing about automating these things is that, once automated, you no longer need a human to give you confidence that your code meets certain criteria.
Tests provide us with a similar level of security. Once you’ve written some automated tests that prove your code behaves in a particular way, provided they are running in some sort of Continuous Integration environment like TeamCity, they continue to give us confidence in the code well into the future, as long as they are passing.
Another reason to have automated tests is that often the tests can be easier to reason about than the production code – they should state the desired functionality clearly, they should be readable, and they should provide insight into which things the author of the code has
considered (and possibly hint at areas they have not thought about).
What sort of tests are we talking about?
From what we usually hear, the fans of Vim, Emacs, Sublime and other nice editors often explain their choice by performance concerns. IntelliJ IDEA for example may feel laggy (comparing to a text editor) when you type, and the usual justification for that is some variation of “an intelligent IDE thinks while you’re typing to provide smart coding assistance”. While this is true, should it really be the case? We’ve tried to figure this out.
Those who use Groovy in their projects will be glad to know that the new IntelliJ IDEA 15 EAP build comes with the long-awaited support for the @Builder annotation, introduced in Groovy 2.3:
The support includes code completion and quick navigation for all 4 strategies.
Apart from that we’ve also added the Undo action support in the Merge dialog to make editing of the resulting code easier.
Download the latest EAP build right away, and don’t forget to share your feedback with us in our EAP discussion forum or issue tracker.
Develop with Pleasure!
At 20 years old, Java remains the world’s most popular programming language this August, with nearly 10 million active developers. If accurate, this figure puts Java slightly ahead of Swedish. While only slightly easier to read, Java has a number of compelling features, including lambdas and streams, intersection types, multiple inheritance, and unrivaled tools and frameworks. If you haven’t seen Java lately, you haven’t seen what Java can do. Join us each month, and stretch your idea of modern Java development.
It’s been a while since we added the Analyze → Locate Duplicates feature. If you’ve had a chance to use it, you know how helpful it is: by eliminating duplicates in your code, you make it more concise and stable. If you’ve never used it, you definitely should; it’s truly surprising how many duplicates an average codebase usually contains.
The fresh IntelliJ IDEA 15 EAP build released today takes the duplicates analysis to an entirely new level by allowing you to spot them on-the-fly. Now, if you stumble upon an existing duplicate, or somehow create one either by writing or pasting code, you will know it instantly:
The analysis comes with quick-fixes, so you can navigate to duplicates or have them shown in a tool window: Continue reading