adamldavis

[adamldavis]

Gr8Conf EU 2019

I had the great privilege of leading a workshop and two talks at Gr8Conf EU 2019 in Copenhagen, Denmark. This was also my first time attending Gr8Conf EU (I did attend Gr8Conf US 2017). My life has finally quieted down enough now that I can write about my experience.

The conference was, in a word, great. I saw a few familiar faces, like Paul King, Jeff Scott Brown, Michael Carducci, Sergio del Amo Caballero, and Jeff Beck (all of whom I've seen before, mostly as just another audience member), and met some great new people whom I've never seen before but who certainly left a lasting impression that I won't soon forget like Vladimír Oraný, Szymon Stepniak, Jennifer Strater, Charlotte Mays, and others. For an extremely introverted person such as myself, I don't often talk to so many people at one time, and I'm grateful for the opportunity to converse and openness of everyone at this conference. (The coffee and food was great too!)

There were too many great talks to list, but some highlights for me were Paul King's keynote on Groovy 2.5, 3 and 4 (which is available online), Jesper Steen Møller's talk, "Reactive Web APIs with Micronaut" (which brilliantly showed how to use Reactive Streams within a micronaut based microservice including a demo of how to use a backpressure strategy), and the "Running a developer's blog" talk by Szymon Stepniak (I hope to use some of his suggestions in the future if I ever get the time).

Oh and I did some talks too. Eventually these should make it onto youtube, but it might be many months. For now you can check out my github repo (https://github.com/adamldavis/2019-gr8conf) which has all of the code related to my talks/workshop plus a bit more. I tweeted out the slides at some point but it's up to you to find them. Just kidding. Here (https://www.slideshare.net/adam1davis/).

It was a really great conference and Copenhagen is beautiful. I hope to return again next year (or maybe in two years if not next year).

Meanwhile, I'm finished with the final updates to "Learning Groovy 3" which should be released later this year! I worked on this for several months this year and my technical reviewer gave me some great feedback so it should be a good one. In addition to updating the book for Groovy 3.0 and Grails 3.3, I've also updated and polished additional areas of the book based on my personal understanding of Groovy and things that have changed over the years.

[adamldavis]

Micronaut

Micronaut was built by many of same people behind Grails. It uses compile-time annotation processing to build an application with a deadly fast startup time, has support for reactive streams, netty, and a reactive http client, among other things.

It's open-source (Apache 2) and supports applications written in Java, Groovy, or Kotlin.

Due to it's non-reflective nature, it naturally enables applications to run on the GraalVM, which is described:

   GraalVM is a new universal virtual machine from Oracle that supports a    polyglot runtime environment and the ability to compile Java    applications down to native machine code. --https://micronaut.io/

GraalVM compiles applications to native code allowing for incredibly fast application start-up speeds even for large applications, which makes it best suited for "serverless" applications, like AWS Lambdas or the like.

Even running on a vanilla JVM, Micronaut has very low overhead (in both memory and processor time) and has profiles for targeting different platforms: server, function (like AWS Lambda), or command-line applications.

It came out not too long ago and I've only made a few applications with it but so far it looks really great!

I've added an example of using micronaut with groocss and the asset-pipeline. Check it out.

https://github.com/adamldavis/groocss/tree/master/micronaut-example

[adamldavis]

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

[adamldavis]

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!

[adamldavis]

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!

[adamldavis]

Test Driven Design (TDD)

When I first started to learn programming, first on a TI-89 calculator and then QBASIC, and even later in Java, I had no idea what testing was all about. I thought testing was running the program and making sure it worked. Maybe even put some debug print statements here and there. It was years later I learned about automated testing and test frameworks like JUnit.

As the years went by, mainly after starting to work, I learned the benefit of writing tests - not only to ensure the correctness of code, but also to enable future changes without the fear of breaking things. This is the strongest quality of tests: to enable change.

Writing tests also helps you think the problem you're trying to solve and clarifies your thinking. As you write the test you have to figure out what exactly your code does, what are the edges cases, and what could go wrong. With TDD (Test Driven Development), it simply goes one step further: you write the tests first, then the code. Instead of blindly typing out the code for a solution you vaguely hold in your head, you specify what you want your code to do - the solution space - then go about making it happen - the implementation. It has the added benefit that your code is always well tested, since you wrote the tests first, rather than an after-thought.

The last D in TDD could also stand for "Design" since when you write tests you are often forced to design the code to be more easily testable. This helps keep code clear and concise with a good separation of concerns. You should divide you logic into the smallest units possible and TDD helps you do this.

I don't always do TDD - many times the code is so simple that writing tests feels like repeating yourself - but when I do I find the resulting code to be clear, correct, and well designed. If you haven't tried it, I highly suggest trying TDD today.

[adamldavis]

The Ultimate Programmer Super Stack

As you may know, my goal with this blog is to help you enhance your skills as a programmer. That’s why I’m always on the lookout for great new tools and resources that will help you level up your skills and keep you on the cutting edge of our industry so you’re always in demand.

Well, today I’m excited to share my most recent find: It's called: The Ultimate Programmer Super Stack, and it comes courtesy of my friend Cary Richards over at Infostack.io. The Ultimate Programmer Super Stack is a hand-curated collection of 25+ premium ecourses, bestselling ebooks, and bonus resources that will help new programmers:

Learn a wide range of today’s most popular (and lucrative) languages and frameworks, including everything from Python, JavaScript, and Ruby, to HTML, CSS, and Kotlin, and more…

Discover how to build APIs, websites, and iOS and Android applications from scratch.

Uncover the ‘Business of Software’ (how computer programs work, how computer programmers think, and how to start your very own computer programming business)

Master the soft skills you need to become ‘Coder Complete’ (this stuff will have a huge impact on your career, believe me) And much more.

Click here to learn more about The Ultimate Programmer Super Stack.

Because there’s so much great content jammed into this bundle, I can’t cover it all in one post.

Instead, I will highlight just a few of the things you’ll find inside the Stack:

“Python Tricks: A Buffet of Awesome Python Features” by Dan Bader (retail value: $29.00). Dan is the founder of Realpython.com, where his articles, videos, and trainings have reached over one million developers around the world. This is one of his bestselling books a great place to start whether you’re brand new to Python, or looking to master the craft and become a certified Pythonista.

“Build APIs You Won't Hate” by Phil Sturgeon (retail value: $26.99). Phil is an API designer and systems architect, currently helping WeWorK to scale their APIs to handle more traffic, be more resistant to change, and not fall like dominoes when one of them has a bad time. Phil is regarded as one of the leading experts on API’s, and this book is like a deep dive into his brain.

“The Top 1% Developer - iOS Edition” by Grant Klimaytys (retail value: $197.00). Grant is the founder of Learn App Development, where he’s coached over 120,000 students worldwide on how to become professional app developers. Inside this premium course, you will learn how to code for iPhone from scratch, understand the basics of software creation (applicable to any language), and even create your own apps to start earning passive income on the App Store (winner winner, chicken dinner!)

And I could keep going, but this post is already getting long... The point is:

These are just 3 of the over 25+ top-ranked, premium resources inside The Ultimate Programmer Super Stack. Typically, you’d have to spend over $600+ to get your hands on everything packed inside this Stack… But this week, you can get everything for over 90% off. Click here to learn more about this limited time deal.

Last thing before I wrap up this post:

As you know, I very rarely make offers in my blog. I only share things that I feel are of tremendous value that you can’t miss. When I learned about The Ultimate Programmer Super Stack, I knew immediately it was a winner. Seeing the final lineup of ebooks, ecourses, and more - it’s clear that this bundle is well worth the insanely low price you pay to get access. So that’s why I’m sharing it with you this week.

My hope is you’ll take a look, and, if it feels like the right fit for you, you’ll take action before the deal ends (the deal expires next Tuesday, so gotta get a move on if you’re interested). That’s it for today.

Take care!

-- Adam L. Davis

P.S. / tl;dr: The Ultimate Programmer Super Stack is a hand-curated bundle of more than 25+ premium ecourses, bestselling ecourses, and additional tools and resources that will help you learn new languages, discover programming best practices, tips, and tricks, and level up your skills so you stay sharp (and in demand). It’s a total value of over $600+ but you can get 90% off today. Click here to check it out.

[adamldavis]

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.

[adamldavis]

Reactive Streams

So... I’m working on a thing, Reactive Streams in Java. This has been on my back burner for a long time, and I started work on it for real early this year. 

Here’s the description from the book’s landing page:

Reactive Streams are a standard approach to handling concurrency in modern applications. The Java 9 release includes new support for reactive streams. This book attempts to provide an easy introduction to Reactive Streams in Java including in depth introductions to RxJava, Akka Streams, and Reactor and how they can be used.

This book will cover everything you need to know about existing projects and how they translate in Java 9 (and 10 and 11). Mainly in Java 10 they’ve introduced “var” and this can be used for intermediate variables.

This book uses a progressive publishing model. As the book grows, so does the price. This encourages early adopters, so... maybe think about buying it. I’m not expecting a lot of sales so I appreciate every reader. Feel free to ask me questions (or pester me to keep writing).

This book has been picked up by a publisher - I’d rather not say who because I’m not sure I’m allowed to :) - and will be published in a complete, edited, and polished version later this year (winter 2018). However, the only way to get it right now is from leanpub. Thanks!

[adamldavis]

Modern Java: 2nd Edition

In case you didn’t know, I’ve been working on Modern Java: 2nd Edition for more than a year now. Over that time I’ve decided to add Java 9 and cover more libraries and frameworks like Hibernate and RxJava. I’ve also fleshed out some existing sections more fully. After many distractions and other projects getting in the way, I finally feel like I’m coming close to finishing it!  It’s now more of a full introduction to Java and the Java ecosystem from features of Java 8 and 9 all the way to testing, building, web frameworks, reactive streams, and a lot more.

In the Christmas spirit, I’ve added a coupon so you can now get it for only $18. It makes a great present. Get one for your boss, your co-worker, your good friend, and even yourself!

[adamldavis]

RxJava

(This is an excerpt from Modern Java: Second  Edition)

RxJava is the open-source library for reactive programming that is part of the ReactiveX project. ReactiveX includes implementations in several different languages including rxjs, RxRuby, RxSwift, RxPHP, RxGroovy and many more.

RxJava 2 was rebuilt to be compatible with the Reactive Streams specification and is preferable to RxJava 1.x since it is scheduled for end-of-life. There were many changes from version 1 to 2 that could be confusing. To avoid confusion we will focus on RxJava 2.

Flowable

The basic entry class in RxJava is `io.reactivex.Flowable`. It implements the Reactive-Streams Pattern and offers factory methods, intermediate operators and the ability to consume reactive dataflows.

The following example demonstrates using RxJava to do a simple calculation on a range of numbers:

   public static List doSquares() {        List squares = new ArrayList();        Flowable.range(1, 64) //1            .observeOn(Schedulers.computation()) //2            .map(v -> v * v) //3            .blockingSubscribe(squares::add); //4

       return squares;    }

1. Create a range from 1 to 64. 2. Call the method `observeOn` to determine which `Scheduler` to use. This determines on which Thread the flow will run. 3. The `map` method transforms each value. In this case we calculate the square. 4. Finally, we initiate the flow by calling a "subscribe" method. In this case, `blockingSubscribe` blocks until the entire flow has completed. This means that the `squares` list will be populated before the return statement. Otherwise the flow would run on a different thread and the values in the squares list would be unpredictable at any given time.

Parallel Computing

If you tie a Flowable to one Scheduler as in the previous example, it would run in succession, not in parallel.To run each calculation in parallel, you could use `flatMap` to break out each calculation into a separate Flowable as follows:

   public static List doParallelSquares() {        List squares = new ArrayList();        Flowable.range(1, 64)            .flatMap(v -> //1              Flowable.just(v)                .subscribeOn(Schedulers.computation())                .map(w -> w * w)            )            .doOnError(ex -> ex.printStackTrace()) //2            .doOnComplete(() -> System.out.println("Completed")) //3            .blockingSubscribe(squares::add);

       return squares;    }

1. Call `flatMap` with a lambda expression that takes in a value and returns another Flowable. 2. Call `doOnError` to handle errors that occur. 3. Call `doOnComplete` to execute something after a Flowable has completed. This is only possible for flowables that have clear endings, such as Ranges.

Schedulers

For some heavy computations, you may want to run them in the background, while rendering the result in a separate thread so as not to block the UI or rendering thread. For this case, you can use the `subscribeOn` method with one Scheduler and the `observeOn` method with a different Scheduler.

   public static void runComputation() throws Exception {        StringBuffer sb = new StringBuffer();        Flowable<String> source = Flowable.fromCallable(() -> { //1            Thread.sleep(1000); //  imitate expensive computation            return "Done";        });        source.doOnComplete(() -> System.out.println("Completed runComputation"));

       Flowable<String> background = source.subscribeOn(Schedulers.io()); //2

       Flowable<String> foreground = background.observeOn(Schedulers.single());//3

       foreground.subscribe(System.out::println, Throwable::printStackTrace);//4    }

1. Create a new Flowable from a Callable (functional interface (SAM) which simply returns a value). 2. Run the Flowable using the "IO" Scheduler. 3. Observe the results of the Flowable using a single threaded Scheduler. 4. Finally, subscribe to the resulting `foreground` Flowable to initiate the flow and print the results to standard out.

Publishers

For non-trivial problems, you might need to create your own `Publisher`.

For the following example, imagine you want to write to a file or read from a file using a custom Publisher in RxJava.

First, we write a range of numbers to a file using the following method:

   public static void writeFile(File file) {        try (PrintWriter pw = new PrintWriter(file)) {            Flowable.range(1, 100)                .observeOn(Schedulers.newThread())                .blockingSubscribe(pw::println);        } catch (FileNotFoundException e) {            e.printStackTrace();        }    }

Here we use a try-with-resources block and `blockingSubscribe` to write the range to the file.

Second, we want to read from a file. In this example, the contents of a file are printed to standard out using the "IO" Scheduler:

   public static void readFile(File file) {        try (final BufferedReader br = new BufferedReader(new FileReader(file))) {

           Flowable<String> flow = Flowable.fromPublisher(new FilePublisher(br));

           flow.observeOn(Schedulers.io())                    .blockingSubscribe(System.out::println);

       } catch (IOException e) {            e.printStackTrace();        }    }

A Publisher implements the `subscribe` method that takes a `Subscriber`. The `Subscriber` interface has several methods on it, the first of which to call is `onSubscribe(Subscription)`. To implement back pressure in reactive streams, the `Subscription` interface was created which has only two methods, `request(n)` for requesting the next `n` elements, and `cancel` for cancelling the subscription.

   static class FilePublisher implements Publisher<String> {        BufferedReader reader;        public FilePublisher(BufferedReader reader) { this.reader = reader; }        @Override        public void subscribe(Subscriber<? super String> subscriber) {            subscriber.onSubscribe(             new FilePublisherSubscription(this, subscriber));        }        public String readLine() throws IOException {            return reader.readLine();        }    }

   static class FilePublisherSubscription implements Subscription {        FilePublisher publisher;        Subscriber<? super String> subscriber;        public FilePublisherSubscription( FilePublisher publisher,         Subscriber<? super String> subscriber) {            this.publisher = publisher;            this.subscriber = subscriber;        }        @Override        public void request(long n) {            try {                String line;                for (int i = 0; i < n && publisher != null                 && (line = publisher.readLine()) != null; i++) {                    if (subscriber != null) subscriber.onNext(line);                }            } catch (IOException ex) {                subscriber.onError(ex);            }            subscriber.onComplete();        }        @Override        public void cancel() {            publisher = null;        }    }

This example shows how you might implement a Publisher for reading files including back-pressure support. A similar approach could be used for any Publisher/Subscription implementation.

(This is an excerpt from Modern Java: Second  Edition as it currently stands. It is available for purchase on Leanpub and is in development but should be finished within the next few months.)

[adamldavis]

Gr8Conf US and other things...

I just back from Gr8Conf in Minneapolis last week and I had a great time. In case you missed it, I led a three hour workshop on Groovy and the slides and code are available (I did some practice screen-casts on youtube as well). Although I was pretty nervous leading up to it, I think it went really well. To those who attended: Thank you for listening and asking such great questions, I hope you enjoyed it! This was my first such workshop and everyone was super nice, so thank you again. I look forward to doing talks and/or workshops again in the future.

There were tons of great talks at Gr8Conf and although I didn’t get to go to all of them (I wish I could) I learned a lot and loved the energy from the conference in general. The “hallway discussions” and lunches were great as well. 

In other news, “Learning Groovy” is now featured on the official Groovy website, and was featured in “Groovy Calamari”! I can’t stress enough how thrilled I am about this!  Meanwhile, thank you to my company the SDG for supporting me in all these endeavors as well as just being a great company.

Modern Java: Second Edition is still in the works and I’ve expanded it to include Java 9. I’m sorry this one has been in production for so long. I hope to get it wrapped up before the final release of Java 9 in September. :-) There’s been a lot going on in the past year ...but I won’t make excuses. The good thing is the final product is going to be great. With all the new stuff in Java 9, plus more experience with Java 8 and other things, it should be interesting. I’m also mulling over next books, but nothing to announce yet.

I met and talked with tons of people at Gr8Conf, but one in particular is Eric Helgeson @nulleric. If you’re at all interested in Grails 3, check out his book, Practical Grails 3. The cool thing about it is he’s selling his book completely on his own and the book covers the app he wrote to sell the book.

Also, I’m still working on GrooCSS and have tons of ideas for it.

Thanks for reading! Hopefully I’ll write again soon...

[adamldavis]

Groovy News!

Great news everyone! 

I can now announce, Learning Groovy is available for pre-order on Apress! They have been great to work with and it is much improved from the original version due to their feedback and the technical editor.

Modern Java: Second Edition is available in beta-mode on Leanpub! This book joins together my original Modern Java book, with all of the stuff on Java 8 and some new stuff will be coming soon!

I’ve launched GrooCSS, a little pet project of mine. More to come on this later. Check it out!

[adamldavis]

A Sad Day

Like many people, I was shocked, sickened, and saddened to learn of the shooting that happened on Sunday near downtown Orlando. We have since learned that this was the worst mass shooting in US history and that it was an act of hatred, targeting a gay night club.

As you may or may not know, I live and work in central Florida. The shooting occurred not too far from my place of work. This was like a punch in the gut. My heart aches for everyone affected by this tragedy. Unfortunately these acts of violence have become all too common, but it does not diminish the fact that 49 people lost their lives in a senseless act of hatred.

I have been humbled and comforted to see the reaction of this community – tons of people volunteering, giving blood, and wanting to help in any way they can. There have been tons of responses and ways to help, here’s just one article about what you can do to help.

[adamldavis]

Learning Groovy done!

Last week I finally finished Learning Groovy and sent it on to publishing. It’s been a long process. Hopefully it’s mostly right. ;)

You can now purchase Learning Groovy in the following ways:

- Paperback on Amazon.

- Kindle on Amazon

- Paperback on Createspace.

- And of course, Leanpub: Learning Groovy

The last few touches were mostly with Ratpack and Gradle which are great open source projects. I’ve learned a lot about them and the other wonderful OSS in the Groovy universe. Thank you to everyone that helped out and encouraged me to keep going, especially Dan Woods (author of Learning Ratpack) Thanks!

[adamldavis]

I wrote this Groovy DSL for computing the percentage by weight of elements in compounds for a little project I’m doing and decided to share it. Also includes names of all elements in periodic table.

[adamldavis]

The Meaning of Life, the Universe, and Everything... and Java

About two weeks ago I was privileged to create bundles with two other authors, including Modern Java Career Bootcamp and How to Craft Interpreters. (You might notice the minimum price is a famous number)

It contains four ebooks that cover everything from Java 7 and 8 features, to programming a compiler, to details about profiling the JVM that could come in handy during an interview. 

But aside from what you see, it’s useful to think about what you don’t see. You don’t see pictures of the authors on the covers. Contrast this with books by Tony Robbins for example. You don’t see the author names in huge print. You don’t see pages and pages of autobiographical content. It’s just about the technology and how to use it.

You also don’t see a lot fluff content. Since these books are coming directly from the authors, we don’t have publishers forcing us to fill up more pages just so the books appear longer.

You also don’t see any hidden agendas. We’re not trying to push other products. Each book should stand on its own and any reference to commercial products is completely unrelated to the author (other than references to other books by the author of course ;-)

Anyways, I hate self-promotion which is why you will seldom see a blog post like this. But if you are so inclined, check out my other books and bundles.