The trend toward software being architected in which components are loosely coupled, interactions are performed reliably and asynchronously through the use of message-based systems, and access to backend systems is achieved by communicating with microservices isn't new. But what might catch some observers by surprise is that this approach to system development and software architecture design might transition from a popular trend into a full-blown software development standard, according to the latest Typesafe developer survey entitled Going Reactive 2016.
The most interesting finding from the survey was that 80% of respondents believed that reactive systems will be adopted by successful enterprises by 2018.
product marketing lead, Typesafe
Reactive systems are designed and built according to the tenets of the Reactive Manifesto, a document that promotes architectures that are responsive, resilient, elastic and message driven. Of course, enterprise systems aren't built upon buzzwords, but there are plenty of technologies available to developers working within the Java stack to bring the Reactive Manifesto's buzzword-driven ideas to fruition. Projects like Apache Karaf and Apache Spark often provide the infrastructure for the development of microservices and large-scale data processing. Big data players like MongoDB and Cassandra can provide the responsive and elastic data systems, and languages like Scala, along with the use of the Actor pattern in frameworks like Akka, can provide the resiliency and reliability reactive systems demand.
The future of successful system development
"The most interesting finding from the survey was that 80% of respondents believed that reactive systems will be adopted by successful enterprises by 2018," said Oliver White, Typesafe's product marketing lead. It's an interesting conclusion, and it's one that bears examining. The response doesn't imply that 80% of all companies will be developing reactive systems by 2018; it says respondents felt that 80% of successful ones will. Across the industry, it's becoming an accepted belief that successfully developing enterprise software is tied tightly to the tenets of reactive design.
With the tide so heavily in favor of microservices, asynchronous messaging and the use of big data technologies that rely on the concept of eventual consistency to deliver speed and minimize latency, selling organizations on the benefits of a reactive approach to system design isn't hard. What is hard is taking an existing organization that has taken more traditional approaches to system design and steering the ship into a new, reactive direction. It's easy to get an organization to buy into a concept, but it's an entirely different challenge to change the culture and completely revamp the way systems are designed. These types of transitions are never easy, but according to the Going Reactive 2016 survey, respondents recommended four separate strategies:
- Refactor a legacy system module by module.
- Completely rewrite the project in question. Start over, greenfield it and reproduce the functionality of the existing system.
- Shave the existing stack and start by replacing bottlenecks.
- Create a new frontend in a responsive manner and integrate it into an existing back end.
Asynchronicity, microservices and stable software architecture
There's no denying that the use of technologies like messaging and microservices are becoming the standard for developing flexible, elastic, resilient and loosely coupled systems, all of which are central concepts of the Reactive Manifesto. And as we look to the future, as Typesafe's survey confirms, successful software projects will more likely than not be reactive ones.
To learn more about what people are saying about developing reactive systems, listen to the full audio podcast with Cameron McKenzie and Typesafe's Oliver White.
Do you believe that reactive systems design is the future of enterprise software architecture? Let us know.
Moving microservices off of AWS
What is the difference between SOA and microservices?
Increasing app efficiency with microservices