Java Annotated Monthly – November 2016

Trisha Gee

The froth of JavaOne has died down (already!) and it’s almost back to business as usual. Although here at JetBrains we’re working hard on our latest product releases, and gearing up to see some of you at Devoxx this week. This month’s annotated monthly looks outward to more than just things that impact Java and the JVM, and pulls together content that affects all developers, like design, architecture and security.

Community

In news that will surprise no-one, Oracle is appealing again. Meh.

Regardless of the behaviour of the steward of Java, the community as a whole is more collaborative and forward-thinking than ever, working actively to showcase mentors and role models and share technical and less-technical stories (videos).

And if you want to be a part of it, consider contributing to this year’s Java Advent blog series, or just read the previous years’ posts.

Java 9

Java 9 is officially going to be 4 months later than we expected, but it continues to move forward (and Java 10 is still in progress). We’re now on build 143, with build 142 for Jigsaw. As we get closer (probably) to release we should keep an eye on the feature list – although modularity is the Big Ticket Item, it’s not all about Jigsaw.

Reactive Streams

Java 9 introduces Flow for Reactive Streams. The Reactive Streams API is heavily influenced by RxJava, so it may be a good time to get up to speed, learn how to test RxJava, read about some RxJava frustrations, and check out what’s new in RxJava2 and give it a try. Specifically for mobile developers, there’s RxJava meets Android Data Binding and RxJava for Android animations.

Or take a look another Reactive alternative, Reactor 3.0, which provides Spring 5.0’s Reactive programming.

Java 8

There’s always new content on getting to grips with the features in Java 8, luckily IntelliJ IDEA 2016.3 offers more suggestions than ever for refactoring to Java 8 patterns. Of course, some things need a change in developer mindset, like learning to think in parallel (video).

Kotlin

Java people may find this Java-to-Kotlin cheatsheet useful, and if you are on the Kotlin journey, go on a whirlwind tour of the Kotlin Type Hierarchy. It’s also useful to read cautionary tales about misusing features like extension functions, and their counterexamples.

As you can see from these articles, learning a new language is more than just understanding syntax, so this reference on Design Patterns in Kotlin is really useful, as are these detailed examples of the Builder pattern and Delegation.

If you do want to learn Kotlin, Hadi Hariri gives an in-depth Introduction to Kotlin, (paid content, but 3 chapters are for free), or you can look at Kotlin with Spring Boot (video).

Kotlin 1.1-M02 is now available and brings some nice new features.  For more Kotlin news, follow KotlinWeekly.

Design

Seeing design concepts in practice isn’t just for learning new languages or the latest version of a mature language. Concrete examples of the Liskov Substitution Principle in Java may help remind us of the value of the SOLID Principles and how to identify their use (or violation).

Architecture

Speaking of SOLID, when you’re designing, architecting and implementing Reactive Microservices you should remember the Single Responsibility Principle helps determine the “size” of your service.

There are lots of options for implementing Microservices in Java, although larger organisations may consider service-based architectures as a step towards microservices.  But before moving in that direction you’ll want to check: do Reactive APIs and Microservices deliver what they promise (video)?

If Netflix is on the journey towards non-blocking asynchronous event-based APIs, it must be A Good Thing, right? After all, event driven architectures can make testing and simulation much simpler.

On a different buzz-word topic, apparently IoT is becoming mature enough to talk about standardization and reference architectures and concrete architectures and implementation ideas.

Architecture isn’t just about understanding a new technology or framework, it’s often about understanding the problems it’s supposed to solve and how that fits into the organisation, and there are techniques for trying to identify and address these areas.

Security

We all know security is a super important topic, yet vulnerabilities continue to plague us. Find out how to secure the modern software delivery lifecycle, and remember that security checks have a place in your code reviews.

And finally…

IntelliJ IDEA 2016.3 Public Preview is ready for you to try.

Incidentally, if you are using the EAP, especially if you’re using it at the same time as the regular release, you may find the JetBrains Toolbox App really simplifies the management of multiple versions and keeping them all up-to-date.  This is even more useful if you use more than one of our IDEs.

Subscribe

Subscribe to IntelliJ IDEA Blog updates

Subscribe form

By submitting this form, I agree to the JetBrains Privacy Policy Notification icon

By submitting this form, I agree that JetBrains s.r.o. ("JetBrains") may use my name, email address, and location data to send me newsletters, including commercial communications, and to process my personal data for this purpose. I agree that JetBrains may process said data using third-party services for this purpose in accordance with the JetBrains Privacy Policy. I understand that I can revoke this consent at any time in my profile. In addition, an unsubscribe link is included in each email.

Submit

Thanks, we've got you!