Support for multiple IDEs in Java for a single command

Question

What is the best way to let a team of programmers use Netbeans, Eclipse, and IntelliJ in the same project, thereby eliminating the question "which IDE is better."

Which files should or should not be checked in the source code?

Answer 1

I think the best way is to make the build process independent of the IDE. This means that your project should not rely on any IDE files to build, but rather use an external build system, such as Apache Maven , Apache Ant, or even create or customize scripts. Maven is supported by most popular Java IDEs, either directly or through plugins.

If you do not want to use external build systems, you should at least simplify project setup (i.e. have standard folders for shared libraries and other dependencies). When I worked on teams with several IDEs in the past, I spent more time resolving dependencies on this, because the prerequisites for creating a project have changed over time. In the worst case scenario, you may even end up with developers who haven’t bothered to get the latest version from the version control repository, because they think that creating a new project is so difficult.

If your project has many dependencies in the library, I think it is a good idea to make them available in binary form in the version control repository. Thus, people do not need to resolve all dependency dependencies, etc. Just to create a single project. However, this requires that you have someone in charge of updating the “official” binaries with every change. (This is almost the same philosophy used by the Maven repository, but the principles can be applied manually, even if you do not use Maven.)

Answer 2

Ok, that's a pretty answering machine.

Files that are not checked against the source control are files that are associated with the IDE itself.

Let the developers generate these files.

If you use Maven, it can generate files like Eclipse .project and .classpath for you. Eclipse as a whole is very easy to use with a basic file structure (with the new Java Project option).

I think Maven has Netbeans support, but not sure about IntelliJ.

Website Maven maven.apache.org .

Answer 3

For each IDE that has more than one developer, register all supporting files. Why reinvent the wheel on every table.

I did this with many different IDEs and I have not yet been able to see the file name conflict.

In fact, even if only one developer uses a specific IDE, the version of supporting files is for his / her advantage for the same reason as the version of other files in your development environment: history, difference, comments, etc.

Answer 4

For Eclipse, these will be .classpath and .project files.

My team uses Maven, and developers are not advised to check Eclipse-dependent files. Since they can be created from Maven, these files are redundant.

In addition, checking files related to specific projects seems to save time, but as a rule, this leads to pain due to differences in workstations of different developers, which leads to useless resolution of conflicts in files specific to the IDE. The only way around this is to get everyone to set up their environment in the same way, which contradicts the IDE-agnostic approach.

Answer 5

There are many considerations when using multiple toolkits in a single project team. For example, my team has Java developers using IntelliJ and most developers (JSP / CSS / HTML) using eclipse. We are in the process of migrating Eclipse users to IntelliJ due to some of the IntelliJ plugins that we have developed that provide enhanced support for our environment. We are not going to develop plugins for several platforms, therefore we standardize IntelliJ in all directions.

In terms of specific files, I can talk with IntelliJ. We checked our .ipr files and our .iml files. Do not check .iws files. If you also have Eclipse users, configure the IntelliJ project to read / store dependency information in a .classpath file and pass it on to your VCS.

Answer 6

We intentionally support multiple IDEs from the same SVN repository. Our thinking was that we want to ensure that if a new person joins the team or someone needs to start working on a new machine, we want them to be able to verify the code, import it into the IDE and get a job right away ,.

What does this mean that the developer should not transfer his changes to the IDE files. Everything else (e.g. src, test, lib, etc.) becomes a set that we usually update and do every day.

A side advantage is that we completely destroyed the IDE wars here: the Netbeans and Eclipse people live in perfect harmony (looking at the IntelliJ people, but hey ... ;-).

Answer 7

For more comments and answers on this topic, see this question (how do you handle different Java-IDEs and svn?)

Answer 8

We are renaming our IDE files for verification with the optional extension .deletethis or similar. When a new person checks the project, they simply remove the additional extension and go well. In this way, we avoid version control conflicts with project files as people customize the environment. And you don’t have to worry about educating new developers so that they don’t check these files.

Answer 9

As a rule, I consider this a bad idea. I'm not sure what kind of environment it is (maybe open source?), But it really sucks to support multiple IDEs. One thing I would recommend if this is unavoidable is to standardize your builds in ant scripts. If you have a large set of dependencies, this might be the easiest way to get a predictable build on all platforms.

If one of the IDEs turns out to be RAD (based on eclipse), there is a whole folder called .settings that you do not want to include in SCM.