seen from China
seen from China
seen from China
seen from Netherlands
seen from United States
seen from China
seen from China
seen from United States
seen from United States
seen from Italy
seen from China
seen from Malaysia
seen from China
seen from China
seen from Italy
seen from Finland
seen from Italy
seen from China
seen from Netherlands
seen from Italy
Upgrading a major version is always a pain. Although from java 9 up it’s supposed to be easier. In this post I discuss the obstacles I encountered.
Upgrading a major version is always a pain. Although from java 9 up it’s supposed to be easier. In this post I will give some examples of the obstacles I encountered. The use case is a Spring Boot application, so we need to upgrade to Spring Boot 2 if we wish to be on java 11.
Anya is live and ready to show you everything. Watch her strip, dance, and perform exclusive shows just for you. Interact in real-time and make your fantasies come true.
Free to watch • No registration required • HD streaming
Java is a widely-used programming language for developing system software and web applications. To set up a Java development system, you would need to install
Java is a widely-used programming language for developing system software and web applications. To set up a Java development system, you would need to install the Java Development Kit (JDK) and Java Runtime Environment (JRE). This tutorial will walk you through Oracle Java 11 Installation on Ubuntu 18.04 LTS (Bionic)
Intellij IDEA: download and install Download Intellij IDEA Download IntelliJ IDEA Install Intellij IDEA
Java 11: Download, Install and Test
Java 11: Download, Install and Test
Download Download Java 11 Install Install Java 11 Test Test Java 11 Installation
View On WordPress
Groovy 2.5 & 3
If you have followed me for any time, you know I'm a big fan of Groovy, the super-Java-like language that runs on the JVM. You've probably heard of it, maybe you even use it, but what is less known is that it's constantly evolving and has some great new features coming soon (or already here). Inspired by some recent news, here's all about Groovy 2.5 and 3. Updates in Groovy 2.5 Groovy 2.5 added support for JDK9+, added 11 new AST transformations, and added the macro feature which makes writing AST transformations much easier. The annotations added in Groovy 2.5 include: @AutoFinal, @AutoImplement, @ImmutableBase, @ImmutableOptions, @MapConstructor, @NamedDelegate, @NamedParam, @NamedParams, @NamedVariant, @PropertyOptions, and @VisibilityOptions. - @AutoImplement: Automatically implements missing abstract methods (such as those from an Interface). You can specify an Exception to throw from those methods such as UnsupportedOperationException. It can be useful for generating test stubs or when you only need to implement a subset of inherited abstract methods. - @AutoFinal: Automatically adds final modifier to method parameters. - @MapConstructor: Adds a constructor to your class that has one Map parameter and expects field-names as keys and sets the corresponding field values. Also many annotations were improved with additional attributes. For example, @TupleConstructor now includes seven more attributes. The @Immutable annotation was updated to recognize the Date/time classes added in Java 8 are immutable, and to handle Optional. Updates in Groovy 3 Groovy 3 sports a completely rewritten parser that brings Groovy up to parity with the latest Java 11 syntax along with new Groovy-only features. It runs on JDK 8 minimum and has better support for JDK 9/10/11. The Java-like syntax now includes Java-style lambda expressions and method references, array initialization, and do/while loops, which have eluded Groovy for many years. Edit: There is hope that in the near future after working out some issues* The new parser also compiles to "indy" by default which uses Java's invokedynamic feature. This has been available for years, but was not the default before. This, along with other changes, makes Groovy code more performant. New Operators Identity: === can now be used to express identity-equal and !== and not identity-equal. Since Groovy interprets == as ".equals", it used ".is" for identity-equals in the past. The support of "===" should avoid some confusion. This is similar to JavaScript's === operator. Negative variants of operators: !instanceof and !in are now supported. This will simplify the syntax in these situations. Before you would have to type !(x instanceof Date) whereas now you can simply type x !instanceof Date. Elvis Assignment: You may be familiar with the elvis operator (?:) in Groovy. In many cases you would use this operation to provide a default when assigning a value. For example: name = name ?: 'None'. Now you can shorten this expression to have the same meaning in Groovy 3 with the following: name ?= 'None' Safe indexing: Much like the safe-reference operator, there is now a safe-indexing operator, ?. This allows you to access an index of an array (or List), but if the array is null, it will return null instead of throwing an exception. For example the following would set the value to the first value of the array, or null if the array is null: value = array?[0] Java Parity Groovy 3 support new features added from Java 8 to 11, such as lambda expressions, method references, constructor references, and even local variables (var). All flavours of lambda expressions are supported (and currently compiled to Closures): - No parameters: () -> expression - Single paramter: x -> expression - Explicit return is optional: (x, y) -> { x * y } - Types are allowed: (int x, int y) -> { return x + y } - Default values are allowed: (int x, int y = 10) -> x+y There's much more..... in fact, I'm working on updating my book, Learning Groovy, and releasing a second edition later this year, so stay tuned! Conclusion As you can see there's a ton to be excited about with Groovy 3. Groovy 3.0.0-alpha-4 is available right now so go check it out. Learn more: groovy.apache.org
Anya is live and ready to show you everything. Watch her strip, dance, and perform exclusive shows just for you. Interact in real-time and make your fantasies come true.
Free to watch • No registration required • HD streaming
Reactive Streams in Java
It’s been a long journey but it’s finally here!
My book “Reactive Streams in Java” is finally published (and I have copies!)
It’s taken a while (about two years) from start to finish and it is gratifying to finally hold the book in my hands.
Here’s a small excerpt:
“Reactive Streams provide an abstraction for highly concurrent, asynchronous applications with support for backpressure. While they can be used along with any of the above models of concurrency, they attempt to provide enough functionality to be fully sufficient for any implementation (over and above the other models of concurrency). However, since they run in a multi-threaded way, you must ensure thread safety in your code if you modify shared state. Try to avoid using other methods (for example, using a LockingTransaction or synchronized block) and instead stay within the Reactive Streams model. Reactive Streams use the concepts of publisher and subscriber, along with various strategies for backpressure to model concurrency. We will cover these concepts. A publisher emits events at some rate. A subscriber observes those events on possibly a different thread and does something with them. Some frameworks use other words (such as Source and Sink) to mean the same thing as publisher and subscriber. As we will see, many reactive stream frameworks allow inter-operation with other existing models of concurrency, such as futures, to allow a smooth transition between the two.“
Thank you to Apress and the whole team that helped me polish this book, Manuel Jordan Elera, Steve Anglin, Mark Powers, and everyone else that helped!
Upgrading to Java 11
So you want to upgrade to Java 11?
Maybe you’ve put off upgrading Java for a while but are realizing that Oracle soon plans to stop supporting Java 8. Have no fear, since you’ve procrastinated, other people have gone through the pain already and shared what they learned!
First of all, what’s new in Java 9, 10, and 11? The big things are JShell, modularity, local variable declarations (var), and in 11 the removal of JavaEE, xml, and corba among other things. Davide Angelocola shared a good summary of the new features, as well as his notes on upgrading to Java 11 here in this tweet (pdf).
In another post by Giacomo Veneri gives a good overview of features from 8 to 11 including creating immutable collections, new String methods, and more and comes with a handy chart.
Finally, Benjamin Winterberg gives a great overview of how to upgrade to Java 11 with Maven. The main takeaway is to update all your dependencies and add any missing libraries like jaxb and javax.annotations.
Due to Oracle’s change in licensing it is highly recommended you use OpenJDK in production now (it’s mostly identical to Oracle Java and Oracle now charges for Oracle JDK in production). Other editions of Java exist or will exist in the future such as Amazon Coretto due to the changes.
Happy upgrading!
Beyond Java 9
I’m at UberConf this week - it’s going great. Last night I sat through a talk by Venkat Subramaniam called “Beyond Java 9″. I’ve always been curious about what’s coming up (and already here in Java 10) and Venkat always is a great speaker so I was excited to go to this one. Here are my notes:
CompleteableFuture was added in Java 8. Many of us missed it because we were so focused on Streams. Java 9 added modules.
Oracle has decided to start releasing a new major version of Java every 6 months.Not so much for the end developers, this is to make adding new features to language easier and less stressful for the teams behind Java. At the same time, Oracle is changing their support of previous versions to some degree. If you do not pay for service, this doesn't effect you except that if you want to be using a "supported" version of Java at all times, you will have to upgrade every six months.
If you do pay for standard support, you can get up to three years of support for long-term-service (LTS) versions of which Java 11 is the next one.
The standard reliability of Java is not changing. Despite the appearance of faster releases, the actual development of the Java the language is not getting much faster. By changing to a major release every six months, the Java language features that are in development for years (sometimes more than ten years) don't have the added pressure of fitting into one release every three or four years. This way each release can add one or two major features, rather than cramming tons of new features into each major release - as has been the case in the past.
At the same time, Oracle is continuing to release OpenJDK as open source. This allows other companies, such as Azul, to modify it and provide their own support contracts, effectively creating a marketplace for JVMs (which is a good thing for many reasons). This allows some competition and is a force towards innovation.
Which comes to one of the most important points I took from this talk: "Java will not innovate on language features. It will innovate on Implementation."
Java has never been on the cutting edge of language features, instead the people behind Java take a long look at what works in other languages and takes time to implement these features in the best way possible. For example, Java 8 lambdas expressions use invoke-dynamic. The behind the scenes implementation allows lambdas to be extremely performant and at the same time allow for future improvements.
Venkat then went on to talk about upcoming projects in Java: Project Panama, Project Valhalla, Project Amber, and Project Loom, which I will not go into right now. This talk was both entertaining and informative (Venkat uses metaphors and jokes sprinkled throughout his talks).
Although this is a large change in the Java language development cycle, in the end this is a good thing because it will encourage Java developers to update more often and spread out new features over more time, not bundling them all at once.
