There would be no java developers without spring

Java dependence on Spring framework.

What the audience can generally agree on is that software development is an extremely dynamic domain. Architectural trends, as well as programming languages, come and go. There are, however, some languages that stay on top for years. According to the TIOBE index, Java is one of them. The index takes multiple factors into consideration:

  • Number of specialists on the market
  • Availability of courses and vendors
  • Trends in searches.

Even though nowadays mostly scripting languages are gaining popularity, Java seems to be still keeping up with the top of the pack. Have you ever wondered why?

What makes languages stand out?  

There are several features of the programming languages that help them stay on top of the competition. One of them is definitely flexibility and the ability to adjust to the newest architectural trends. Let’s take microservices as an example. Languages that enable rapid development and deployment of micro-components would definitely be favored over ones that require a lot of overhead and maintenance. Of course, one might argue that the explosion of interest in containers mitigates these issues, but in reality, it does not fully solve the problem as you still need to build up and maintain your containers throughout their lifecycle.

The same argument is valid for serverless computing. When using e.g., AWS Lambdas developers would normally value the language with less overhead more than the ones requiring a lot of classes and components – that is also the reason why scripting languages are far more popular in serverless solutions than the compiled ones. 

Is the Java backend flexible enough?

One of the Java traits that are promoted the most is its transferability. Users are supposed to be able to run it on millions of different devices. This, of course, is true. However, it does not mean that it’s flexible. Java, at its core, requires a lot of around programming activities like configuration, compiling and jar/war packaging. Not to mention the volume of classes and interfaces that java developers need to use. That does not sound very flexible. The truth is, however, that developers do not really use Java without its frameworks. Whether it’s the web, desktop or command line development, you will most likely reach for a framework that will facilitate your work. 

What java frameworks do we have?

There are a multitude of Java frameworks out there, most of them focusing on java web development. According to Raygun, the 17 most notable ones:

  • Blade (lightweight web framework)
  • Dropwizard (REST web services)
  • Grails (groovy based web framework)
  • GWT (web framework for client-side apps)
  • Hibernate (persistence layer framework)
  • JSF (component-based ui framework)
  • JHipster (bootstrapping/archetyping framework)
  • MyBatis (persistence layer framework)
  • Play (web and mobile framework)
  • PrimeFaces (component-based ui framework)
  • Spark (lightweight web framework)
  • Spring (army-knife framework for all appliances) 
  • Struts (web framework for enterprise grade applications)
  • Tapestry (component-based ui framework)
  • Vaadin (component-based ui framework)
  • Vert.x (event driven application framework)
  • Wicket (component-based ui framework)

Among which, judging by the amount of java developers jobs, Spring is definitely the most popular one. Particularly a Spring’s sub-project – Spring Boot. 

What is Spring Boot?

Spring boot is a utility framework for Spring-based applications that simplifies the creation and deployment of a production-ready java backend. It implements a concept of convention over configuration by auto-configuring modules, making it extremely easy to include third-party tools into your app. Apart from that, it provides out-of-the-box tools and metrics but most importantly it bundles your code with self-executable servers.

On top of that, there is a tool called Spring Boot Initializr, which allows developers to initialize their applications in a WYSIWYG manner. Spring Boot (with Spring at its core) introduces a lot of evolutionary concepts, like reactive programming, to the Java ecosystem. What is really important is that Spring Boot does all that without any automatic code generation!

Is Spring important for Java?

Spring is for Java what wind is for wind turbines – it just doesn’t work without the first. Spring gives a lot of fresh breeze to the language that could otherwise be a little clunky. Inversion of control being at the core of Spring allows developers to focus on what matters – coding. 

Spring boot starters with autoconfiguration make it much easier to connect third-party libraries like Hibernate or Feign. All of this, in regards to the example of microservices given earlier, makes up for a pretty good environment for rapid development. But that’s not all, the Spring team reacts much faster to the ever-changing environment than Java creators. One great example of such upfront thinking is the introduction of Reactive programming in Spring 5, which was never to be found in the core language.

What about other frameworks?

Of course, one might argue that there are different frameworks (e.g. Play) that are also very important in the Java universe. That is partially true. However, none of them has the impact of Spring. Even if we take out the fact that Spring is by far the most popular java framework (thus having the biggest community), other frameworks are just solving one problem, e.g.

  • Vaadin addresses UI
  • Hibernate addresses the persistence layer
  • Struts targets enterprise-grade applications

Whereas Spring, with all of its sub-projects, tackles a multitude of issues. That itself in my opinion moves Java forward.

Should java programmers be worried?

Java developers can sleep well, their language is not going anywhere. The Spring team is keeping very much up to date with all the new trends and reacting to the newest developments. The direction set by Spring, forces Java to follow its steps and update legacy parts of the language. Thanks to all of the work that Spring is doing, it is still viable to start your custom projects in Java. Also, if you’re a Java developer, don’t worry. There is a multitude of great teams that you could join to pursue your development career. The moment the Spring team decides to pack bags is when you should start worrying.