Java EE or .NET - An Almost Unbiased Opinion
Arguments pro Java EE:
- Java EE has better OR-support than .NET. JPA, Hibernate etc. .NET comes with Entity Framework, but it isn't as lean as JPA. In .NET land there are some ports from Java available like e.g. NHibernate. .NET seems to more rely on stored procedures, whereby in Java we prefer (sometimes are obsessed) to keep everything in domain objects outside the DB.
- Build systems and CI tools in Java are more advanced. Hudson + Maven / ANT is a really nice and lean solution. On .Net side you can use NAnt or a proprietary MS tool.
- Community: Java community rocks - in .NET you have to rely on MSDN. However - this can be considered as advantage and disadvantage as well. You will (always) find an answer for your question for free.
- Java is the most popular language #1.
- Java IDEs: If you are thinking about .NET vs. Java EE you have already allocated some budget for tooling (otherwise the choice would be obvious). In that case you should look at IntelliJ first. It is the best, commercial IDE. If you are looking for free IDEs, start with NetBeans (best out-of-the-box experience) and Eclipse (the most popular one). Java tool ecosystem is remarkable.
- Integration: Java integration story is excellent. You get connectors for SAP, AS400, files etc. for free. ESBs, LDAP servers are free.
- Framework / Libraries: If you need a specific library - you will find everything in Java. Before you are going to write a single line of code you should do some research first.
- Strategic consideration: with Java EE you are truly vendor-neutral. This is very handy in the price-negotiation phase. You can even go into production without any costs (subscriptions, licenses etc). Java EE apps are very portable. Java EE is not even dependent on Sun - it was developed by all major vendors.
- Stability: Java language is stable for ages. There are no breaking changes. Java EE 5 and 6 platform is backward compatible as well. So you can deploy your legacy J2EE 1.X app to a Java EE environment and smooth-migrate it (if you like to).
- Best practices: Java EE / J2EE are about 10 years on the market. There are many applications out there. The most mistakes are already made - the best practices / patterns are very mature.
- In most of the .NET projects you will find opensource extensions, as well as, commercial .NET tools. Such a mixture can be very "interesting" (regarding support issues)
- Operating System: you can choose whatever operating system you want to for production and development.
- Opensource: 80% of Java applications in production are built on opensource tools. This is your ultimate insurance.
- You get everything from one vendor.
- C# develops very fast. It has nicer features, than Java. C# shines in the DSL area. LINQ is very nice for database (and tree-like) queries (however you should look at Scala and Groovy if you need similar features).
- You don't have to search for a given solution. The choice is clear. It can save you a considerable amount of time.
- You will find most of the tools at MSDN - there is no need to evaluate tools and IDEs in advance.
- Visual Studio .NET is a very good environment with very good DB and team extensions. With a commercial plugin (like e.g. Resharper), it gets a good, as IntelliJ.
- The UI best practices are more consistent, than in Java. ASP.NET MVC is e.g. the way to go in .NET. In Java EE you will have to choose between JSF, Wicket, GWT, Struts 2....
- The language integration in .NET is seamless. You can easily call methods from C# to VB.NET. In Java it is hard to call Scala functions from Groovy.
- SharePoint, Exchange and Office Products are very well integrated with .NET. You can access them with Java, but will need third-party libraries.
- Continuous Integration comes already with Visual Studio Team System.
I forgot some arguments for sure - what is your opinion?
Posted at 12:27PM Sep 10, 2009
by Adam Bien
| Views/Hits: 4431
NEW Special Events: From HTML 5 over Java EE App Building and NoSQL / Distributed Computing to Microservices
A book about rethinking Java EE Patterns