Java 20 🥱#postThe list of big new features that can be used in production with Java 20 is rather short: . (That was it already.) Pretty boring, these six-month releases. We really don't need to take a closer look ...
How To UseSince Java 14 introduced switch expressions, using
switchIn Modern Java#post
switchisn't as straight-forward as it used to be: colons or arrows, statement or expression, labels or patterns? Here's how to best use
switchin modern Java.
Configuring Maven For Compiled And Tested Code In Javadoc#postFor JDK 18's / JEP 413's embedded snippets to be compiled and tested by your Maven build, they need to be added to a source set, Surefire needs to pick them up, and Javadoc needs to know their location - here's how to do that.
More Opinions OnHow much work is it to wrap
Optional? Do you need to
Optionalarguments? What about serializability and framework support? And why consider the type in the first place? Answers in here!
Better Random Number Generation in Java 17#postJava 17 expands the API for random number generation to make it more usable, extensible, and robust with
RandomGeneratorFactoryat its core.
Visitor Pattern Considered Pointless - Use Pattern Switches Instead#postIn modern Java, the visitor pattern is no longer needed. Using sealed types and switches with pattern matching achieves the same goals with less code and less complexity.
Why Java's Records Are Better* Than Lombok'sWhile all three remove boilerplate, the similarities don't go much further. Records have stronger semantics with important downstream benefits, which makes them better*. (* not always; depends on circumstances; excuse the clickbait)
@Dataand Kotlin's Data Classes#post
Definitive Guide To Java 16#postA detailed guide to Java 16: records, type patterns, sealed classes;
Streamand HTTP/2 additions, Unix domain socket support; Project Panama previews, packaging tool, performance improvements, and more
Code-First Unix Domain Socket Tutorial#postJava's socket channel / server-socket channel API can use Unix domain sockets for faster and more secure inter-process communication on the same host
Type Pattern Matching withType patters with
instanceofare Java's first step towards pattern matching. Motivation, syntax, details, and future applications - here's all you need to know.
Pattern Matching in Java#postJava takes its first steps towards pattern matching but the topic is much larger than
instanceof. Goals, terminology, flow scoping - these apply to all kinds of patterns.
Sorting A React App Into Java's Folder Structure#postHow to use react-app-rewired to sort a React app into a Java folder structure with
package.jsonat the root, and sources in
Java 2077#postThe year is 2077, the Java version is 128. It's not LTS. Here's how Loom, Valhalla, Panama, Leyden, Amber, and Jigsaw pushed humanity to the brink. And how you can save us.
BrokenJava 16 adds a new method
Stream::groupwith Java 16's
Streamand it can be abused to simulate a reverse-
groupoperation (with shortcomings).
FasterJava 16 adds a new method
Stream::mapMultiin Java 16#post
Stream. It fills the same role as
flatMap, but is more imperative - and faster.
Java Modules Cheat Sheet#postA cheat sheet for building and running Java modules from the command line with
JUnit Pioneer 1.0#postYesterday we released JUnit Pioneer 1.0 🥳 - here's a quick rundown of its features
Definitive Guide To Java 13#postA detailed guide to Java 13: text blocks, switch expressions with yield, ZGC, dynamic AppCDS archives
Improve Launch Times On Java 13 With Application Class-Data Sharing#postOn Java 10+, you can use application class-data sharing to reduce launch times, response time outliers, and memory footprint. By archiving class data with -Xshare:dump and loading it with -Xshare:on, the JVM's class loading workload can be reduced considerably.
Definitive Guide To Switch Expressions In Java 13#postJava 13 finalized switch expressions. Together with a new lambda-style arrow syntax, this makes switch more expressive and less error-prone.
The JPMS Maturity Model#postJava's module system requires consistent support by libraries, frameworks, and tools. This maturity model classifies a project's support for the JPMS.
Evolving Java WithUse
––enable –previewaka Preview Language Features#post
--releaseduring compilation) to experiment with Java's preview features
Definitive Guide To Text Blocks In Java 13#postJava 13 introduces text blocks: string literals that span multiple lines. Learn about syntax, indentation, escape sequences, and formatting.
Immutable Collections In Java - Not Now, Not Ever#postThe JDK contains immutable collections, but no type
ImmutableCollection. Here's why that's so and why it won't change.
Jakarta EE, javax, And A Week Of Turmoil#postDuring a week of turmoil, many people have written about Jakarta EE and javax. This post summarizes the community's opinions and gives you plenty of links.
Definitive Guide To Java 12#postDetailed Java 12 guide: migration, versions; switch expressions, teeing collectors, indenting/transforming strings (and more); default CDS, Shenandoah, G1.
Teeing Collector in Java 12#postThe teeing collector, available since Java 12 as Collectors::teeing, forwards its input to two other collectors before merging their results with a function.
Eleven Hidden Gems In Java 11#postEleven small but shiny additions in Java 11 to classes like
Optional, and others that make coding a little more elegant.
Scripting Java 11, Shebang And All#postOn Java 11+, you can run a single source file without compiling it. Beyond experimentation, you can write scripts this way. Even shebang is supported!
Reactive HTTP/2 Requests And Responses In Java 11#postWith Java 11's new reactive HTTP/2 API, request and response bodies can be handled with reactive streams: you can throttle, stream, and cancel early.
Java 11 HTTP/2 API Tutorial#postTutorial for Java 11's new HTTP/2 API with HttpClient, HttpRequest, and HttpResponse at its center. Shows synchronous and asynchronous request handling.
All You Need To Know For Migrating To Java 11#postMigrating from Java 8 to Java 11? This has got you covered: licensing, long-term support, preparations, version requirements, migration challenges, and more.
JUnit 5 Architecture or "What's Jupiter?"#postThe JUnit 5 architecture promotes a better separation of concerns than JUnit 4 did. It also provides clear APIs for testers (Jupiter) and tools (Platform).
JUnit 5 Basics:The Basics of JUnit 5: How to use
@Test, Lifecycle, Assertions, Assumptions, And More#post
@AfterAll, assertions, and assumptions. How to disable, name, and tag tests.
JUnit 5 Conditions:A detailed look at JUnit 5's
@DisabledOnJre, etc. and how to create custom conditions to flexibly disable test methods.
JUnit 5 - Dynamic Tests#postWith JUnit 5's dynamic tests, we can create tests at run time, for example to parameterize tests, create hierarchical test plans, or define tests with lambdas.
JUnit 5 Extension Model: How To Create Your Own Extensions#postThe JUnit 5 extension model enables detailed, flexible, and powerful additions to JUnit 5's core features. For that it provides specific extension points.
JUnit 5 - Parameterized Tests#postThorough introduction to parameterized tests in JUnit 5 with @ParameterizedTest, argument sources (eg @MethodSource, @CsvSource), and argument converters.
JUnit 5 Setup in IntelliJ, Eclipse, Maven, and Gradle#postHow to set up JUnit 5 so tests run in IntelliJ, Eclipse, Maven, Gradle or, if all else fails, via JUnit 4 or on the command line.
Unlocking Traits WithIn Java 10,
varmakes it is possible to ad-hoc combine traits into an instance that matches your exact requirements. Alas, it has some downsides.
Tricks withLocal-variable type inference with
varand anonymous classes (that you should never use at work)#post
varmakes it easier to work with anonymous classes, e.g. for ad-hoc fields and methods. Don't do it, though!
Unlocking Intersection Types WithJava 10's
varmakes intersection types in Java more approachable. Generics tricks are still needed, but
varmakes it easy to declare such variables.
How To Use Multi-release JARs To Target Multiple Java Versions#postMulti-release JARs allow you to create a single JAR that contains bytecode for several Java versions with jar --version 9 (or 10, or...). Presented with a multi-release JAR, JVMs version 9 and later will load the code that was included for their version.
Code-First Java 9 Tutorial#postShowing code for the most important Java 9 features: private interface methods, stream and optional APIs, collection factories, reactive streams, stack walking, multi-release JARs, redirected platform logging, unified logging, the module system, and more. If you're new to Java 9, start here.
Goodbye 2017, Hello 2018#post2017 draws to a close and 2018 is knocking. My annual review and preview went to my newsletter, so subscribe or head over to Medium to read them.
Maven on Java 9 and later - Six Things You Need To Know#postHow to use the compiler executable, toolchains, and mavenrc to run Maven on Java 9 and how to use mvn/jvm.config and profiles to configure your build.
First Contact With 'var' In Java 10#postJava 10 introduces the
varkeyword, which lets the compiler infer local variable types. Here's how var works, why it exists, how it impacts readability.
Making JSR 305 Work On Java 9#postUsing annotations from JSR-305 (
@PostConstruct) on Java 9 causes a split package. Here's the fix.
Code-First Java Module System Tutorial#postTutorial of Java 9 module system basics: declare modules with module-info.java, compile, package, launch them, learn of module path and readability graph.
Unified Logging Of JVM Messages With TheJava 9 introduces unified logging, a central mechanism configurable with
-Xlogto observe class loading, threading, garbage collector, module system, etc.
Five Command Line Options To Hack The Java Module System#postGet your code running on the Java 9 Module System with the command line options
Planning Your Java 9 Update#postA Java 9 update is not always trivial; quite the opposite, migrating to Java 9 can be challenging. Here's how to gather and categorize problems.
Java 9 Migration Guide: The Seven Most Common Challenges#postSolutions to the seven most common challenges for a Java 9 migration. Each of them explained with background, symptoms, and fixes.
A JDeps Tutorial - Analyze Your Project's Dependencies#postJDeps is a dependency analysis tool for Java bytecode (class files and JARs). Learn how to use filters, aggregate results, and create diagrams.
Java 9 Resources - Talks, Articles, Repos, Blogs, Books And Courses#postJava 9 draws and the number of posts and talks about it skyrocketed in the recent months. Here's a list of recommended talks and articles but also further resources where new, high-quality content will pop up.
Optional Dependencies withThe Java Platform Module System allows optional dependencies with
requires static. They are accessible at compile but can be absent at run time.
Repackaging Exceptions In Streams#postHow to repackage checked exceptions that get thrown in a Java stream pipeline so that they can be thrown without the compiler complaining about it.
Why Elvis Should Not Visit Java#postThe desire for the Elvis operator for easier null-handling echoes through the Java community. But due to Java's type system, it should never be introduced!
SPJCN IV: Quo Vadis Scala#postIn the fourth issue of SitePoint’s Java Channel Newsletter (from October 21st 2016) I summarize the discussion of Scala's presumable demise.
Reflection vs Encapsulation#postReflection wants to break into all code; encapsulation wants to give modules a safe space. How can this stand off be resolved?
Hello 2017!#postTo finish all the projects I started in 2016, I will have to be disciplined and focused in 2017. Discipline and focus, what delightful words to start 2017.
Goodbye 2016, Sorry For Fucking Up#postBesides humanity as a whole fucking up 2016, it went well for me professionally. Maybe because I only cared about me? Possible...
SPJCN III: JavaOne 2016#postIn the third issue of SitePoint’s Java Channel Newsletter (from October 7th 2016) I summarize JavaOne 2016 and recommend interesting talks to watch.
Publishing Snapshots With Gradle's maven-publish Plugin#postA step by step tutorial how to use Gradle and the maven-publish plugin to publish snapshots to Sonatype's Maven snapshot repo.
SPJCN II: What's Taking So Long?#postIn the second issue of SitePoint’s Java Channel Newsletter (from September 23rd 2016) I wonder why Java 9 takes so long.
What Future Java Might Look Like#postJava's future is full of cool advances: data classes, value types, generics over primitives, pattern matching, etc. Let's peek into Java's future!
SPJCN I: Hello World#postIn the first issue of SitePoint's Java Channel Newsletter (September 9th 2016) I babble about community and conferences.
Code Reviews At Disy - Observations#postAfter reviewing almost all code we wrote for 18 months, completing some 1'500 reviews, we want to share some recommendations.
Code Reviews At Disy - How We Review#postAfter setting out to create a peer review culture we came up with a workflow and picked a tool (yes, Crucible) that would help us get there.
The Ultimate Guide To Java 9#postJava 9 is coming! Besides Jigsaw it brings new language features and many new and improved APIs. Check out the ultimate guide.
Rebutting 5 Common Stream Tropes#postArticles about Java 8's streams often repeat a bunch of tropes: succinctness, ugly mechanics, anemic pipelines, weak exception handling. This is a rebuttal!
Code Reviews At Disy - Where We Were And What We Wanted#postAt Disy we review almost all the code we write. Here, we want to share why that was not always the case and how we started with code reviews.
Goodbye Disy, Hello SitePoint#postI worked for Disy for about 2 years. Now I said goodbye to become the editor of SitePoint's burgeoning Java channel and have more time for other projects.
Oh No, I ForgotIn Java 9
Streamgets a couple of new methods - one of them is an overload of
iteratethat takes a predicate and returns a finite stream.
Java 9 Additions ToJava 9 is coming! One of the changes are new methods on Optional:
ifPresentOrElse(), which considerably improve Optional's API.
Java 9 Additions ToJava 9 is coming! One of the many changes are new Stream methods:
ofNullable. For more fun with streams!
How To Implement hashCode Correctly#postSo you wrote a nice
equalsimplementation? Great! But now you have to implement
hashCodeas well. Let’s see how to do it correctly.
How To Implement equals Correctly#postA fundamental aspect of any Java class is its definition of equality. It is determined by a class's
equalsmethod. Let's see how to implement it correctly.
JEEConf 2016#postMy take on JEEConf 2016: showing the talks I liked the best, raving about the community, romanticizing Kiev, and giving some feedback. Summary: awesome!
CodeFX Leveled Up#postA lot of things are happening right now: I'm writing a book, I'll speak at conferences, you can hire me, and to top it off, I gave this blog a new look.
A Doomed Code Review#postCode reviews should be brief, short, and focused. This is the story of how I fucked up on all those accounts and we still made it work.
Seven Reasons Against Blogging#postMany people will tell you how great blogging is but there are downsides, too, and they are rarely discussed. So let me share some reasons against blogging.
Costs And Benefits Of Comments#postAs with most things in software development the ultimate currency for comments is time. This is an analysis of the costs and benefits of comments.
Implied Readability WithIn Java 9 a module must read another to use its API. With implied readability a 3rd module passes the dependency on, allowing the 1st to read the 2nd.
Beware Of findFirst() And findAny()#post
findAny()work with any number of elements in the stream. Make sure to
reduce(toOnlyElement())if there should be at most one.
Hello 2016!#postIn 2016 I want to continue blogging, branch out into new areas, work on my private projects, learn me a Haskell, and prevent exhaustion.Wow, so much to do.
Goodbye 2015!#post2015 is over and I'm looking back.How did it go, which things worked out and which didn't. And how come I'm feeling so tired recently.
Jigsaw Hands-On Guide#postA Jigsaw tutorial explaining how to create modules, state dependencies between them, and use the module system as a service locator to decouple modules.
JDeps Maven Plugin 0.2 Released#postWith v0.2 the JDeps Maven Plugin allows the creation of flexible exceptions from build-breaking for a self-paced preparation for Java 9 and Project Jigsaw.
Six-Month Delay Of Java 9 Release#postMark Reinhold proposed a six-month delay of JSR 376 / Project Jigsaw and thus of the Java 9 release. According to this JDK 9 would come out in March 2017.
JUnit Lambda - The Prototype#postJUnit Lambda will eventually bring us JUnit 5. This is a discussion of the recent prototype, its features, core principles and compatibility considerations.
JavaOne 2015: Under The Hood Of Project Jigsaw#postJavaOne 2015 saw a series of talks by the Project Jigsaw team about modularity in Java 9. This one gives a peek under the hood discussing layers and class loaders.
JavaOne 2015: Advanced Modular Development#postJavaOne 2015 saw a series of talks by the Project Jigsaw team about modularity in Java 9. This one details different migration scenarios.
JavaOne 2015: Introduction to Modular Development#postJavaOne 2015 saw a series of talks by the Project Jigsaw team about modularity in Java 9. This one introduces the basic concepts.
JavaOne 2015: Prepare For JDK 9#postJavaOne 2015 saw a series of talks by the Project Jigsaw team about modularity in Java 9. This one explains how to prepare for it.
Will There Be Module Hell?#postJava 9's Project Jigsaw promises to solve JAR hell but falls short when it comes to conflicting versions. Will there be module hell instead?
JAR Hell#postA list of the problems that make up JAR hell (classpath hell, dependency hell) and how they relate to development tools like Maven and OSGi.
Apache JMeter Tutorial#postWant to load test your web app? Then you should know about Apache JMeter! This tutorial explains the basics and how to create & execute a test plan.
A Taxonomy Of Comments#postA taxonomy of source code comments that enables further discussion about clean code and comments.
Stream Performance - Your Ideas#postAnother post about stream performance - this one implements your ideas about how else to approach the topic.
Stream Performance#postA close look at stream performance. How do they compare to for and for-each loops oder arrays and lists. And what role plays boxing?
Java 8 SE Optional, a strict approach#postStephen Colebourne presented his pragmatic approach to using Optional. I argue for a stricter one that gets us further without considerable downsides.
Interview About Comments On DZone#postMatt Werner from DZone interviewed me about my stance on comments.
Impulse: "Adventures On The Road to Valhalla"#postA summary of Brian Goetz' talk "Adventures On The Road to Valhalla" given at JVMLS in August 2015. Focused on generic specialization and the two prototypes.
All About Project Jigsaw On InfoQ#postMy posts about Project Jigsaw got polished and published on InfoQ.
Thoughts On Comments#postMy rant to comment your fucking code sparked some interesting conversations. Here we discuss some of your and my thoughts on the topic of comments.
Comment Your Fucking Code!#postYou think your code is so clean that it doesn't need comments? Then this rant is just for you!
Casting In Java 8 (And Beyond?)#postProposal to implement new casting methods on Java's
Class. They aim to fulfill the need for improved ways to cast which was created by Java 8.
The Features Project Jigsaw Brings To Java 9#postA detailed presentation of the features Project Jigsaw brings to Java 9: modularization, encapsulation, configuration, performance, and more.
Motivation And Goals Of Project Jigsaw#postA look at how Project Jigsaw (coming in Java 9) aims to solve JAR/classpath hell and at its goals to improve security, maintainability and performance.
LibFX 0.3.0 Released#postRelease post for LibFX 0.3.0 including pointers to GitHub, feature descriptions, Maven coordinates and the Javadoc.
Transforming Collections#postTransforming collections are a view onto another collection, making it appear to be of a different parametric type. They are available in LibFX 0.3.0.
JavaFX, Project Jigsaw and JEP 253#postJEP253 aims to prepare JavaFX for Project Jigsaw by defining public APIs for functionality that will become inaccessible due to modularization.
First Release of JDeps Maven Plugin#postThe JDeps Maven Plugin will break a project's build if it contains dependencies on JDK-internal APIs. This helps to prepare for Java 9.
Impulse: "Crafted Design"#postSummary of the architecture described by Sandro Mancuso in his talk "Crafted Design", held at GeeCON2014.
LibFX 0.2.1 Released#postRelease post for LibFX 0.2.1 including pointers to GitHub, feature descriptions, Maven coordinates and the Javadoc.
How Java 9 And Project Jigsaw May Break Your Code#postWith Java 9 comes Project Jigsaw - a modularization of the JDK - which will break existing code. An overview over the planned changes lets you see whether yours is affected.
Getting Rid Of Anonymous Classes#postAnonymous classes are verbose and obfuscating. Functional implementations can oust them from their last strongholds (mainly abstract classes).
Interface Evolution With Default Methods – Part II: Interfaces#postWhy interface evolution with default methods does not work for whole interfaces - at least not smooth enough to be practical.
Impulse: "Agile Architecture"#postA summary of the talk "Agile Architecture" given by Molly Dishman and Martin Fowler as the keynote at the O'Reilly Software Architecture Conference.
Roll Your Own Pirate-Elvis Operator#postJava has no Elvis operator (or null coalescing operator / null-safe member selection) but with lambda expressions / method references you can roll your own.
Test Collection Implementations with Guava#postHere's how to use Guava-Testlib to easily and thoroughly test your own Java collection implementations.
Interface Evolution With Default Methods - Part I: Methods#postPatterns for interface evolution with default methods: gradually add, replace and remove interface methods without breaking client code.
Value-Based Classes#postAn explanation of value-based classes in Java 8. Why do they exist? What are their limitations? How (not) to use them?
Running Android Emulator With HAXM On Thinkpad T440p#postQuick guide to how to use the Android emulator with HAXM (based on VT-x) on a Thinkpad T440p.
Everything You Need To Know About Default Methods#postCovering literally everything there is to know about Java 8's default methods.
New Javadoc TagsThere are new Javadoc tags used in Java 8:
@implNote. Take a look at their history, meaning and use on command line and with Maven.
Goodbye 2014!#postI'm taking a look at my open source contributions and blogging achievements in 2014.
Instances of Non-Capturing Lambdas#postSee how Java's creation of instances of non-capturing lambda expressions can lead to unexpected and possibly bug-inducing behavior.
Multiple Return Statements#postAn argument for using multiple return statements in a method (as opposed to adhering to the single return myth).
Don't Remove Listeners - Use ListenerHandles#postKeeping references around to remove listeners is a hazard. ListenerHandles encapsulate the complexity and LibFX has an implementation.
LibFX 0.2.0 Released#postRelease post for LibFX 0.2.0 including and pointers to GitHub, Feature descriptions, Maven coordinates and the Javadoc.
JavaFX Sources in Eclipse#postA quick step by step guide how to use the JavaFX sources in Eclipse by attaching them to the current JDK.
Impulse: "Lambdas In Java: A Peek Under The Hood"#postDiscussing the talk "Lambdas in Java: A peek under the hood" given by Brian Goetz at the goto; conference 2013 in Aarhus.
SerializeA summary of why you can't serialize
Optionaland what can be done to deal with that limitation if necessary.
The Serialization Proxy Pattern#postA presentation of the Serialization Proxy Pattern as defined in Effective Java. It defines the pattern, describes its implementation and gives examples.
Concepts of Serialization#postA close look at serialization and a presentation of some key concepts of Java's serialization system.
Why Isn'tDiscussing the reasons for not making Java 8's new type
The Design ofA digest of how
Optionalwas introduced in Java 8, summarizing the many discussions about it and their key points based on the mail archive of JSR-335.
Intention Revealing Code WithWrite intention revealing code with Java 8's new type
Optionaland prevent most NPEs. This is not optional!
Impulse: "Architecture - The Lost Years"#postDiscussing the talk "Architecture - The Lost Years", which Robert C. Martin held on several occasions.
The Decorator Pattern With Default Methods#postUse Java 8's default methods to make the decorator pattern even more beautiful, which results in more concise and readable code.
Impulse: "Workflows of Refactoring"#postDiscussing the keynote "Workflows of Refactoring" by Martin Fowler at OOP 2014, where he categorizes different reasons for and ways of refactoring.
How The Decorator Pattern Saved My Day#postA real-life example how the decorator pattern enables future changes and improves code quality by upholding the Single Responsibility Principle.
CodeFX Up And Running#postSummer recess is officially over and shit got done! Finally, CodeFX is ready to take on the world.
LibFX 0.1.1 Released#postRelease post for LibFX 0.1.1 including a description of
Nestingsand pointers to GitHub, Maven and the Javadoc.