Hi, Spring fans! And welcome to another, very special installment of This Week in Spring where we look not only at the last week’s news but also the highlights of the year behind us. 2018 was one of incredible tumult on the technology landscape, one that the Spring community has been able to deftly navigate. In this special year-end wrap-up, we’ll do what we always do — look at the latest and greatest in the ecosystem, but we’ll also revisit the things that I, your friendly neighborhood @starbuxman, feel most positively impacted the Spring developer in 2018.

Now, let’s get through our usual weekly roundup — and there are tons to look at! Then, we’ll review the year in Spring.

• I’ve got a new Bootiful Podcast! Subscribe on SoundCloud or on iTunes. The podcast is a discussion of all the latest and greatest in the Spring ecosystem and beyond through the lens of those who make it wonderful. If you want to join in the discussion, then please follow us on Twitter (@BootifulPodcast)
• Spring Session for Apache Geode/Pivotal GemFire 2.1.2.RELEASE
• Spring Cloud Open Service Broker 3.0.0.M3 Released
• Spring Cloud Open Service Broker 2.1.0 Released
• Spring Cloud Data Flow and Skipper 2.0 M1 Released
• Spring Cloud for Alibaba 0.2.1 released
• Spring Cloud Greenwich.RC2 is now available
• Spring Tools 4.1.0 released
• Spring Tool Suite 3.9.7 released
• Spring Cloud Task 2.1.0.M2 is now available
• Check out the 2019 Software Trends review from the Pivotal blog
• In last week’s installment of Spring Tips, we looked at Reactive SQL Data Access with Spring Data R2DBC. Check it out!
• JUnit 5.4 M1 is almost here. Check out all the new features.
• Check out these very promising first few steps at an OAuth 2 token relay using Spring Cloud Gateway.
• Want a very full example of how to describe and deploy a multi-module Kubernetes and Helm-packaged Spring Boot microservices system? Check out Kenny Bastani’s distributed system that deploys an HA cluster of Apache Kafka and Prometheus IO.
• InfoQ’s 2018, and What We Expect to See in 2019 is a very good read, indeed!
• Want a digest, more or less, of what happened in the Spring ecosystem in November? Check out the December installment of This Month in Spring
• Great discussion on the latest Screaming in the Cloud podcast with Andrew Clay Shafer, whose insight I always find valuable. The points made on what is driving bad decisions in enterprise IT are right on the mark.
• A nice video on Many-to-Many Relationships with Spring Data JDBC
• Eclipse IDE 2018-12 has been released

This year was an interesting year, one that saw existing practices refined in remarkable new ways. Here are the things I’ll remember from the year that was 2018.

• Reactive Programming: We touch on specific aspects of this in other items on this list, but 2018 was, if nothing else, the year of reactive. In 2018, we delivered the GA versions of all of our reactive integrations where it makes sense. 2018 saw us release, among other things, Spring Boot 2 and Spring Cloud Finchley, which aggregate other projects like Spring Data Kay, Spring Security 5, and, of course, Spring Framework 5. These releases brought parity, where appropriate, to existing use cases in the blocking and synchronous world. It was also the year that saw us begin the work of providing options that are reactive-only; things that go beyond what was possible and that are better for their basis on reactive programming, like R2DBC and RSocket.
• RSocket Systems integration is hard. Integration is hard. HTTP is a strong protocol for document retrieval, but it lacks application-level semantics that each developer must re-imagine on top of the HTTP verbs (REST). It is geared towards request-response architectures but lacks the ability to handle other message-exchange patterns like request-response, fire-and-forget, and streams (in either the request, the response or both). We know that the reactive streams specification provides a nice mental model for dealing with integration. In it, boundaries are assumed asynchronous and decoupled. Components support flow-control through the notion of backpressure. Additionally, HTTP is text-encoded. Sure, you can conduct binary data, but you need to encode it as such. RSocket is a new, binary protocol with built-in support for the reactive streams specification from the minds of folks from Netflix and Facebook. It supports all the above message-exchange patterns. As it’s a protocol, there are different client libraries supporting different platforms and languages including JavaScript, C++, and Java. The Java implementation is based, naturally, on Project Reactor. We announced formal support for RSocket in the upcoming Spring Framework 5.2 release train at our tentpole SpringOne Platform 2018 conference.
• R2DBC: A question we always get when people look at reactive programming is “should I use JDBC?” or “Can I use JDBC?” Or, more bluntly, if there is no reactive JDBC option, “should I even bother with reactive programming?” And the answer was always, distressingly, fairly pessimistic: you’re not going to get the vaunted scale benefits of reactive programming if at any point in the stream you need to block to handle the scale. If you end up spinning up new threads to scale out the interaction with JDBC, then you’ve limited your systems scale potential. But this isn’t to say that there’s no way to achieve reactive SQL. It’s just not JDBC. There are options on the horizon that might make for a very interesting alternative to JDBC for those database vendors whose drivers natively support asynchronous IO and reactive programming. One option is R2DBC, which we announced at our tentpole conference SpringOne Platform 2018. The integration is three-tiered: first, there’s the lower-level R2DBC SPI, on top of which are built database bindings. At this point, there are bindings for H2, Microsoft SQL Server, and PostgreSQL. At this level, you’ll find a DatabaseClient, more or less equivalent to JdbcTemplate, which makes using low-level R2DBC as convenient as it gets. Then, finally, at the top of the proverbial stack is Spring Data R2DBC. I look at all of this and more in last week’s Spring Tips installment, too!
• KNative Serverless, a term that is in of itself almost meaningless these days, is all the rage. It describes this idea that we should let the platform handle increasingly more of the work of moving software into production. In a function-as-a-service platform, the unit of currency is a function. It’s something that the platform invokes on a request. Everything else — routing, dispatch, scale up and out — is handled by the platform. The output of one function can be the input to another function. This composition means that interesting things can happen. Functions can be connected ad-hoc one to another to yield results. In addition, functions can be attached to event sources, responding to events in the ecosystem of functions on whatever platform the functions happen to be running. Here, their prowess as integration code becomes evident. We at Pivotal announced Project Riff in 2017. It was, as we originally envisaged it, a function-as-a-service platform built on Kubernetes. But this was only the first step. A few months after we introduced it at SpringOne Platform 2017 event, the Riff team started work with Google in developing KNative. KNative is a further abstractification of Kubernetes. It provides built-in primitives that something like a Project Riff could conceivably be built on. This is exactly what we did. In 2018, Google and Pivotal announced KNative at Google NEXT, and I became the first non-Google employee to do a KNative demo in my joint-presentation with Ray Tsang at Google Next. KNative is a big deal — not just for Project Riff, but for the Kubernetes ecosystem in general, and I’m excited to see where it goes.
• Spring Cloud Supremacy: This year cemented Spring Cloud’s role in the distributed systems toolkit for developers. Spring Cloud core itself became reactive. It introduced new oft-asked for features like Spring Cloud Gateway. It also saw the release of GA versions of Spring Cloud for Google Cloud and Spring Cloud for Microsoft Azure. It also saw the debut of Spring Cloud for Alibaba (that’s tomorrow’s Spring Tips installment!) This year, more than ever, we saw large organizations make the move to microservices and even vanguard technology companies like Netflix, which were already integrating Spring Cloud, doubled-down on Spring Cloud this year.

What a year indeed! And next year is already looking to be bigger and better! That’s a wrap for 2018. We’ll see you next year!