Four ways Java Developers are feeling the impact of microservices

Wendy Firestone

June 12, 2015

This post was made possible by speaking with several talented local Developers: Matthew Smith (Product Manager/Architect at Pivotal Labs), David Kiss (Sr. Java Developer at Sysomos) and Jagtesh Chadha (Software Engineer at Bibliocommons).

With the increasing complexity of web applications and the rise of the cloud, DevOps and continuous delivery, there has been an increased move by software companies to using containerized microservices. We’re living in a world with a higher demand for performance and an expectation of reliable service available anytime, anywhere.

I turned to several experienced Toronto Java developers to ask: how have microservices changed the way you work?

A quick background: Microservices are a style of software architecture, loosely coupled and service-oriented with bounded contexts. Imagine a formerly monolithic codebase broken down into several separate products living on their own servers and interacting with each other through APIs. The services are focused on doing one thing well, allow teams to work relatively independently of each other on different products, and facilitate continuous delivery, allowing for frequent releases while keeping the rest of the system available and stable.

Here’s are four ways that local Java devs are feeling the impact of microservices:

1. Rapid prototyping & starting up smaller projects is faster.

Java isn’t considered the most optimal language for rapidly prototyping solutions and getting projects off the ground quickly. With microservices and frameworks (like Spring Boot) you no longer have to spend days or weeks figuring stuff out on your own or know how to code in another language (like Ruby, which is great for prototyping) in order to play with projects on the side.

2. A more current toolkit.

Frameworks, like Spring, can help Java devs stay current without having to wait for new Java standards to be released. For example, Spring has a lot of frameworks out of the box. If you want to use noSQL databases, Hadoop or messaging systems, there are support for these tools so you don’t have to go out there and build something yourself or feel as though you’re lagging behind newer languages.

3. A shift away from an overly language-specific way of thinking towards APIs.

Even if you’re a strong Java Developer, microservices increase the importance of understanding APIs. The move towards microservices might even render some Java-specific ways of doing things obsolete. For example, accessing databases with Java requires pulling in code from a library (like Hibernate). But with a service-oriented architecture and microservices you could just require an API, write URLs to save, read, write the data, and curtail the need to write code in Java or integrate with the Database.

4. A bigger need to understand how your entire system fits together.

Related to understanding APIs, working on large systems using microservices requires a better understanding of how every part fits together. For one, many different microservices talking to each other through APIs results in more points of failure and a greater need to run analytics to monitor what’s happening. Developers can also benefit from a more sophisticated understanding of security. With more public access to your APIs and integration with other services, your system can be exposed to greater security risks. Understanding how to build in resilience and safeguards against other services that aren’t working is a must.

Share Post