Java Annotated Monthly – March 2017
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.
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:
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
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…
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
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.
- 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.
Complete this form and get Java Annotated Monthly delivered fresh to your email.
Subscribe to Blog updates
Thanks, we've got you!
Java Annotated Monthly – December 2023
The December edition of Java Annotated Monthly is here! As usual, you’ll find all the latest Java and Kotlin updates as well as details of key industry events for networking and learning. This issue also features the latest release candidates and targeted JEPs alongside Java tutorials and articles a…
Java Annotated Monthly – November 2023
Welcome to the Java Annotated Monthly – November 2023! As the Java world keeps on spinning, we've gathered a treasure trove of articles, talks, and insights to warm your Java developers’ hearts. This month's edition features a delightful blend of the latest technological advancements and the ever…
Java Annotated Monthly – October 2023
Welcome to the October edition of Java Annotated Monthly! In this issue, we're plunging into the world of Java and tech. We'll explore the latest and greatest in the recent release of Java 21, share exciting news about the new EAP for IntelliJ IDEA 2023.3, and bring you a handpicked selection of …
JPA and React Plugins: From Buddies To Full Members of The JetBrains Family
We are excited to announce that JPA Buddy and React Buddy have joined the JetBrains family. Positioned as powerful plugins for working with JPA data and React applications, respectively, they will offer even more functionality for IntelliJ IDEA and WebStorm developers moving forward. With this ac…