Ever since Gary and I started the Git Questions video series, we've been asked to talk about merging.  We're also frequently asked about rebasing - what is it, and when should I do it? In this week's video, we take a look at how to use IntelliJ IDEA to merge a branch back into the "main" development branch.  We also talk about rebasing - not only showing how to do it in the IDE, but what it means and when you should do it. We don't show how to deal with merge conflicts in this video, but they are discussed, and a more complete conflict-resolution video is definitely high on the TODO list

In this week's Git video, Gary and I look at how you can Annotate your code to see who made which changes.  We also show how you can use this information to understand a bit more about the context of a particular change.

In this week's Git questions we take a look at a simple but rather important step when you're working on a GitHub Open Source project - how do you get started? In the video, Gary and I demonstrate how to fork and clone a project (I chose some Spring example code and Gary chose a JavaScript framework) and how to set up additional remotes so that you can easily keep your fork up-to-date as per our last video. This time Gary's demonstrating the functionality in WebStorm while I stick with IntelliJ IDEA, as usual the features we demonstrate are common to all the IntelliJ Platform IDEs.

Carrying on our series of Git Questions, this week Gary Hockin (PhpStorm Advocate) and I look at the question: how do I make sure my GitHub fork is up to date when the open source project it forked has moved on? GitHub's help does, of course, cover this question. But not everyone is comfortable working from the command line, and even those who are, sometimes prefer to use the IDE if they're already working in it. This video shows an answer to this question which uses Git's fetch, pull and push from within IntelliJ IDEA.

We regularly get questions about how to achieve a particular thing - as developers there are parts of our workflow which trip us up, that our tools can help us with if we understand how.  So we've decided to start answering these real world questions with videos showing what to do. The first video features me, Trisha Gee (Developer Advocate for IntelliJ IDEA) and Gary Hockin (Developer Advocate for PhpStorm) answering the question "How do I switch branches without losing the code I was working on?". Through frequent battles with Git I have learnt there's always more than one way to do thing

A new IntellIJ IDEA 2016.3 EAP build is out and ready to try. Other than the usual amount of bugfixes, it brings a couple of noticeable improvements. More Refactorings to Java 8 First of all, we continue with tuning the inspections that help refactor regular code into idiomatic Java 8. (more…)

Hooray! Fresh IntelliJ IDEA 2016.3 EAP build is out! Among the numerous bugfixes, this build addresses one of the issues that prevented it from being used on macOS Sierra. Users of macOS Sierra, we're kindly asking you to thoroughly test this build and let us know if the problem is gone. Faster Search in Git Log The new build brings a dramatic speed improvement to searching thru Git Logs, particularly for the Text, Author and Path filters. Now, after the project has been opened (for the first time) and all the important startup tasks are completed, IntelliJ IDEA scans all reposito

As you may know in IntelliJ IDEA 2016.2 EAP we've finally fixed a very annoying issue that didn't allow to commit case-only renames in IntelliJ IDEA. For a number of reasons, the solution was not so trivial, we decided to share some of its implementation details with you. When you are on a case-sensitive file system (Linux), case-only renames are just like any other renames, so you're all good. However, when the file system you're using is case-insensitive (like Windows or Mac), some of many Git commands will treat changing the file name case as a change, while others won't. Because of that

A fresh IntelliJ IDEA 2016.2 EAP build is out and ready to test. Besides usual bugfixes it brings improvements to the Git/Mercurial Log viewer. The Log viewer now loads in the background on every change (a commit, fetch, rebase, etc). As a result, it's always ready when you open it. Also, we've reworked the way we show the loading progress. Now, when refreshing, there's a thin stripe shown under the toolbar. We hope you'll enjoy these minor improvements. If you experience any problems, feel free to file issues directly to the issue tracker. Develop with Pleasure!

Today we've released a fresh IntelliJ IDEA 2016.2 EAP build which, among other improvements, finally fixes a very annoying (and highly voted) issue with case-only renames in Git for Windows and OS X. We hope this will make your work simpler when it comes to committing case-only renames from IntelliJ IDEA. Later this week we'll also share the story behind this issue and how it was fixed, so if you're interested, stay tuned. Also, we're excited to confirm that now we officially support font ligatures (another highly voted request). This feature has been available for some time as experimental

A fresh EAP build for IntelliJ IDEA 2016.2 is out and, being a good EAP build that it is, has something new for you to try: General A new inspection that warns you when you instantiate new objects inside equals, hashCode, compareTo or Comparator.compare methods. This helps to avoid significant performance problems when, for example, objects of classes with such constructs are added to Set or Map, where these methods will be frequently invoked. Coding assistance for Regex has been extended with better error reporting and added code completion for named group references. T

Great news, everyone! A fresh weekly IntelliJ IDEA 16 EAP is out and ready, packed with bugfixes and new features as usual. The noticeable changes affect the debugger, VCS integrations, and user interface. Debugger Now when debugging a Java application, you can use Groovy expressions with Evaluate Expression and Watches. Previously you could do that only when debugging Groovy code. This is good because Groovy expressions are much shorter and more expressive (especially when you work with collections.) This feature requires a Groovy runtime library in the classpath. Also, we've

Every week we publish a fresh IntelliJ IDEA 16 EAP. Today's build, among bugfixes that address issues you reported, brings a few improvements to Git integration and IntelliJ IDEA heart, the code editor. Move elements right and left We already have a way to move code statements up and down: Ctrl + Shift + Up/Down (Cmd + Shift + Up/Down for OS X.) They come in handy when you're rearranging code statements. Sometimes, however, it might be useful to move them left or right (when you're, for example, changing the order of attributes of an XML element, method parameters, or elements in an arra

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 Rebas

Today we have just released a fresh IntelliJ IDEA 14 EAP build, as always packed with new features and enhancements. Everything what's new is listed on the download page, but we'd like to highlight several improvements and explain them with a little bit more detail here. First of all, the Reset Current Branch to Here action now available from the Git Log: Then, the Find in Path is improved a bit: you can now opt to skip occurrences in comments and/or string literals: (more…)

It happens quite often, that version control is used by people working on different platforms. This is why problems with line endings may appear. If you ever read the article from GitHub, you might already know, that Git can automatically address these problems. You just need to set git config --global core.autocrlf true on Windows or git config --global core.autocrlf input on Linux and OS X. However not everyone follows the instructions and setups VCS correctly. That's why we have made a couple of improvements in IntelliJ IDEA 12 to make life easier. (more…)

Sometimes there is a need to have multiple Git repositories within a single project. Since long ago IntelliJ IDEA is able to execute many Git operations on all roots at once: Commit, Update Project, Push. Now multi-repository support has come to branches. In IntelliJ IDEA 11.1 we have implemented two different approaches for multi-root branches. (more…)

Lightweight and fast branches are one of the major features and advantages of Git. We in Jetbrains want to make workflow with branches even more convenient and simple than it is in command line. You might have noticed that in IntelliJ IDEA 11.0 we've added new interface to checkout branches from Git. In IntelliJ IDEA 11.1 we have polished the look and feel, and made it more functional. The main goal of new interface is to concentrate on the most common use cases. Let's take a look at the features which the IDE offers to manage Git branches. (more…)

The most exciting news for me is that now in forthcoming IntelliJ IDEA 11, we show Git revisions graph! Now that IntelliJ IDEA can visualize commits links, we've added context actions to tag a commit, create (and checkout) new branch, and checkout a selected revision. I want to specifically mention the highlight actions — now you can see what commits are in "ancestors subgraph" for a selected commit. By default, IntelliJ IDEA shows HEAD subgraph, i.e. you see what commits you have in your working tree now. It is really convenient when you are checking what commits went into some tag (or

Helo guys, We know that many of you are keen on GitHub and use gists in your everyday work. We are excited to tell you that now you can share your code instantly from the IDE. Here is a small demo of how it works. Open any file you want to share with others or even a selection within this file, invoke the context menu and select Create Gist... menu item. At first you'll be asked to login to GitHub to be able to create personal gists. The IDE stores your GitHub password inside a built-in secure password storage, so you can be asked for your master password to access the storage. Anyway if