Java Annotated Monthly – March 2017

Trisha Gee

We’ve taken on board suggestions from last month’s experiment and this month we’re trying to please everyone – what could possibly go wrong? February is a short month so you might expect a shortage of news, but far from it!  It’s a big year for releases, with Java 9 and Java EE 8 on their way, and it’s never too early to get up to speed on what’s coming.

Java 9

For anyone who doubted whether we’d ever see Java 9, it’s finally entering the First Bug Fixing Round. That means it’s “complete” enough that we can more-or-less rely on which features will be in it, and start playing with them – IntelliJ IDEA 2017.1 supports Java 9.  Since Java 9 introduces the Reactive Streams API as part of the language, there is some overlap in conversations around Java 9 and Reactive Programming, a theme I will be presenting on next week at QCon London.

• Early Access documentation for Oracle JDK 9 has been released
• Programming with Modularity and Project Jigsaw. A Tutorial Using the Latest Early Access Build
• Automating The Creation of JDK9 Reduced Runtime Images in NetBeans (or in other IDE of choice!)
• The Non-Jigsaw Improvements of Java 9
• Inside Java 9 – Performance, Compiler, and More
• Date and Time Formatting in Java 9 Will Get Closer to Unicode Locale Standards
• Java 9 Will Adjust Memory Limits if Running with Docker

The release is close enough that conversations around current Java includes overlap between features from 8 and 9:

• DZone’s Guide to Modern Java
• Java 9 and Streams API

Of course development on the language doesn’t stop at Java 9, we can get a heads-up on possible features for future releases too:

• Java 10 Could Bring Upgraded Lambdas
• The Last Frontier in Java Performance: Remove the Garbage Collector

Java In General

New and interesting is all very well, but it doesn’t help us in the day job.  It’s arguably more important to get better at what we do all the time.

• Filter Incoming Serialization Data – JDK 9 goodness available now in 6, 7 and 8
• Further Updates to ‘Moving to a Plugin-Free Web’ (Applets are basically not supported anywhere any more)
• Deterministic Execution on the JVM (in the context of blockchain)
• Java Memory and CPU Monitoring Tools and Techniques
• The Surprising Truth of Java Exceptions: What Is REALLY Going on Under the Hood?
• JVM Options Cheat Sheet
• The Top Differences Between Java, Scala, Groovy, Clojure, and Kotlin
• From Microservices to Distributed Systems – Survival guide for Java Developers

As usual, we’re still finding out plenty about Java 8 features, including embracing a more functional approach to development:

• Making Apps With JavaFX
• Java 8 Streams and error handling?
• How Lambdas And Anonymous Inner Classes Work
• A Java 8 Streams Cookbook
• Java 8 Lambdas limitations: closures
• An Introduction to Functional Programming in Java 8: Part 1 – Functions as Objects
• An Introduction to Functional Programming in Java 8: Part 2 – Optionals
• Functional Programming in Java 8 (podcast, featuring me talking about how function Java is, or is not)

Reactive Programming styles really are here to stay with Java 9, so it’s worth getting up to speed now:

• Understanding Reactive types
• RXJava2 by Example
• RxJava for easy concurrency and backpressure
• Building Reactive Applications with Akka Actors and Java 8

Enterprise Java

2016 certainly was an… interesting… time for Java EE, leading to a lot of speculation about the Future of Java in the Enterprise. Microprofile certainly seems to be gaining momentum, but then Java EE 8 is also back on the move.  Exciting times…

Android

This month I’m blatantly showing my preference for a focus on automated testing, design principles and self-improvement rather than showcasing any specific frameworks or libraries. But I am throwing in RxJava, since this seems to be well-used in the Android space, and I included Reactive Streams in the vanilla Java section.

• Want to move into Android? Here’s a set of self guided resources
• Write awesome unit tests
• Your Unit tests might not be as reliable as you thought
• Stress-testing Android apps
• Airplane Mode: Enabling Trello Mobile Offline
• Android Things – Electricity Monitoring App
• Towards Godless Android Development: How and Why I Kill God Objects
• Composite Views in Android: Composition over Inheritance
• Making RxJava code tidier with doOnSubscribe and doFinally
• How to leak memory with Subscriptions in RxJava

Design and Architecture

Yes, we need to stay up to date on technologies and so forth, but understanding architectural patterns and design approaches will be valuable regardless of current trends. Probably. Except the Singleton pattern, you can just go ahead and ignore that.

• GoF Design Patterns Using Java (Part 1)
• GoF Design Patterns Using Java (Part 2)
• Dead code must be removed (the code is dead, long live the code)
• How to Avoid Messy Code
• Functional Programming Is Not What You (Probably) Think (worth understanding probably before following the earlier functional programming links)
• Layered Architecture Is Good
• but Hexagonal Architecture is Powerful
• Lesser known Git commands (OK fine, not design or architecture, but may be useful and doesn’t fit into any of the other categories either)

It feels like Microservices has crossed the chasm and we’re now talking about when and why to use it, not just what it is. There’s a trend of talking about Event Sourcing and Domain Driven Design in this context, familiarity with these topics is important:

• Virtual Panel: Microservices in Practice
• The Future of Microservices: Functional Service Design and Observability
• Start with Events and DDD When Building Microservices
• The Importance of Patterns in DDD

Events

JetBrains is going to be at several events this month. Firstly, QCon London next week: we’ll have a booth there (come and say “Hi”!), I’m running the Java track and speaking on it, and I’ve outlined an example conference schedule for Java developers. Secondly, we also have a booth at the very first DevoxxUS, and I’ll be presenting on Java 9 features and how they’re supported in IntelliJ IDEA.

And Finally

• The 2017.1 Public Preview is available, and you can try out the aforementioned Java 9 support.
• My Refactoring to Java 8 webinar recording is available.
• Kotlin 1.1 was released this week, with JavaScript support, coroutines, and more.

Subscribe

Complete this form and get Java Annotated Monthly delivered fresh to your email.

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!