Java Annotated Monthly – November 2016
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.
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 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.
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.
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).
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.
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).
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)?
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.
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.
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.