DEV Community: Lemuel Ogbunude

Modern Java Programming Course For Beginners

Lemuel Ogbunude — Tue, 14 Apr 2020 09:17:07 +0000

Java is constantly adding new features and improvements to keep it at the top. Unfortunately, a lot of courses and learning materials are not up to date with the current trends.
If you are just starting out in Java or want a refresher course on Modern Java then this course would be beneficial to you.

🔗Modern Java Course

What's Inside?

In the course, we start with Jshell instead of using an IDE. This would help beginners because the simplicity of Jshell helps students focus on the code and not how to operate the IDE. An IDE would be introduced later in the course.

Programming concepts are explained with animations and real-life examples. You get to understand why certain things are done and not just how.

We introduce modern Java features such as the use of var for type inference.

A lot of programmers dive into Android development without learning the core fundamentals of Java thereby resulting in a rough learning experience. This course is designed to give you a good start in that learning journey.

🔗Modern Java Course

The course is available to you the Dev community 💙 at a 67% discount :)

Learn modern Java and add it to your toolbox ☕

Introducing Java 14 Records

Lemuel Ogbunude — Thu, 27 Feb 2020 10:13:53 +0000

There are a couple of nice features coming with the JDK 14 release, for now, we would just have a look at Records.

The six-month release cadence set for Java seems to be working and I think it was a great move by the team.

We shouldn't expect "cool" features with every release and should understand that the features added to Java are not to make it "shinny" or "cool" but rather to boost developer productivity and reduce bugs.

Consider the Java code below:

    public static void main(String[] args) {

        var json = """
                {
                "statusCode" : 404,
                "statusMessage" : "Not Found"
                }
                """;

        var gson = new Gson();

        //var message = gson.fromJson(json, );

    }

All we need is a Java class to be used while deserialising the JSON string. It's a class to just hold some data.

We might have to write something that looks like this:

public class Response {
    private final int statusCode;
    private final String statusMessage;

    public Response(int statusCode, String statusMessage) {
        this.statusCode = statusCode;
        this.statusMessage = statusMessage;
    }

    public int getStatusCode() {
        return statusCode;
    }

    public String getStatusMessage() {
        return statusMessage;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Response response = (Response) o;

        if (getStatusCode() != response.getStatusCode()) return false;
        return getStatusMessage() != null ? getStatusMessage().equals(response.getStatusMessage()) : response.getStatusMessage() == null;
    }

    @Override
    public int hashCode() {
        int result = getStatusCode();
        result = 31 * result + (getStatusMessage() != null ? getStatusMessage().hashCode() : 0);
        return result;
    }

    @Override
    public String toString() {
        return "Response{" +
                "statusCode=" + statusCode +
                ", statusMessage='" + statusMessage + '\'' +
                '}';
    }
}

Now we can use this class with our Gson library:

    public static void main(String[] args) {

        var json = """
                {
                "statusCode" : 404,
                "statusMessage" : "Not Found"
                }
                """;

        var gson = new Gson();

        var message = gson.fromJson(json, Response.class);

    }

While the Response class could easily be generated with our IDE, it could be an issue while reading. We shouldn't have to read through over 40 lines just to find out this class was built to simply hold data.

We could replace all that code in the Response class by using a Record:

public record Response(int statusCode, String statusMessage) {

}

A Record would automatically generate a constructor whose signature matches the state description, private final fields and getter methods for each state component.

Yes, the fields are final, a Record cannot extend other classes and a Record itself is final. You should begin to realise that Records are not here to replace mutable JavaBean classes.

Records also generate implementations of the methods equals(), hashCode(), and toString(). You, however, are still free to override those methods if you wish.

Records are useful in situations where we need to model plain data.

We can create Records in methods just like in the case of normal classes. This makes sense if we are only going to make use of the Record in that particular method:

    public static void main(String[] args) {
        record Response(int statusCode, String statusMessage) {

        }

        var json = """
                {
                "statusCode" : 404,
                "statusMessage" : "Not Found"
                }
                """;

        var gson = new Gson();

        var message = gson.fromJson(json, Response.class);

    }

Let's say you want to set some values in the constructor if the status code is 200, you have the option of working with the common canonical constructor:

public record Response(int statusCode, String statusMessage) {
    public Response(int statusCode, String statusMessage) {
        this.statusCode = statusCode;
        this.statusMessage = statusMessage;

        if(statusCode==200){
            //extra code here
        }
    }
}

The issue here is that we have to repeat the code that was already derivable from the state description. To avoid this we can use the compact version of the constructor:

public record Response(int statusCode, String statusMessage) {
    public Response {
        if (statusCode == 200) {
            //extra code here
        }
    }
}

With the compact version, we can focus on reading the extra code and not get distracted by boilerplate already generated by Records.

Summary

Records are one of the many nice features coming to Java and the six-month release cadence helps us access these features faster.

Newer programming languages are like young sportsmen who can afford to try new shiny stunts, get injured and heal quickly, whereas languages like Java are like more experienced athletes who have to avoid injury and make sure no move breaks anything.

So while there are many features you would love to see in Java, the priority of backward compatibility and avoiding a design mistake would affect what features are added and when they are added.

For the record 😉, JDK 14 is not an LTS release and Records would be a preview feature in JDK 14.

Records can be used in a wide variety of situations, I have just scratched the surface, I suggest you go through the articles below:

"Java 14 Feature Spotlight: Records" by Brian Goetz

JEP 359: Records (Preview)

Kotlin Sequences vs Kotlin Collection Functions

Lemuel Ogbunude — Mon, 08 Jul 2019 21:57:16 +0000

It's good to know the difference between using the Kotlin Collection functions and Kotlin Sequences when working with Collections.

Java has some common Stream API functions like Map(), Filter(), FlatMap() and Sorted() . We need to call the Stream API in order to perform these operations on a Collection in Java, not so in Kotlin.

Here is a Java program to filter through a list, get the even numbers, multiply the even numbers by 4 and then print them out.

//Java
var scores  = Arrays.asList(1, 2, 3, 4, 5);
scores.stream()
        .filter(integer -> integer % 2 == 0)
        .map(integer -> integer * 4)
        .forEach(System.out::println);

Let's try to do that in Kotlin:

//Kotlin
val scores = listOf(1, 2, 3, 4, 5)
scores
    .filter { it % 2 == 0 }
    .map { it * 4 }
    .forEach { println(it) }

If my intention was to write the Kotlin code that would execute just as the Java streams did then the above code is not really correct ☹️

Let's prove that the outputs would be different by adding a little text to tweak it:

Java Sample

//Java
var scores  = Arrays.asList(1, 2, 3, 4, 5);
scores.stream()
        .filter(integer -> {
            System.out.println("Filtering " + integer);
            return integer % 2 == 0;
        })
        .map(integer -> {
            System.out.println("Mapping " + integer);
            return integer * 4;
        })
        .forEach(System.out::println);

Output:

Filtering 1
Filtering 2
Mapping 2
8
Filtering 3
Filtering 4
Mapping 4
16
Filtering 5

Kotlin Sample

//Kotlin
val scores = listOf(1, 2, 3, 4, 5)
scores
    .filter {
        println("Filtering $it")
        it % 2 == 0
    }
    .map {
        println("Mapping $it")
        it * 4
    }
    .forEach { println(it) }

Output:

Filtering 1
Filtering 2
Filtering 3
Filtering 4
Filtering 5
Mapping 2
Mapping 4
8
16

Hmmm 🤔 ... something doesn’t seem right here

Collection Functions

When you call Collection functions on a List in Kotlin, each operation returns a new collection with the desired values.

Each operation in the pipeline works on all the elements in the List before going to the next function.

Example:

//Kotlin
val numbers = listOf(1, 2, 3, 4, 5)

val evenMultipliedNumbers = numbers.map {
    println("Initial Map $it")
    it + 3
}.filter {
    println("Filtering $it")
    it % 2 == 0
}.map {
    println("Mapping $it")
    it * 5
}

evenMultipliedNumbers.forEach { println(it) }

When we run the above code we get the output:

Initial Map 1
Initial Map 2
Initial Map 3
Initial Map 4
Initial Map 5
Filtering 4
Filtering 5
Filtering 6
Filtering 7
Filtering 8
Mapping 4
Mapping 6
Mapping 8
20
30
40

It takes the whole List and runs each element through map() then filter() then map() again.

Kotlin Sequence

Depending on your situation, this might not be the code execution you desire. Kotlin Sequences might be what you need.

When using Kotlin Sequence, the values are evaluated lazily.

Let's tweak the above code a little to use Kotlin Sequence:

//Kotlin
val numbers = listOf(1, 2, 3, 4, 5)

val evenMultipliedNumbers = numbers.asSequence().map {
    println("Initial Map $it")
    it + 3
}.filter {
    println("Filtering $it")
    it % 2 == 0
}.map {
    println("Mapping $it")
    it * 5
}

evenMultipliedNumbers.forEach { println(it) }

All you need to do is to call asSequence() before calling on the operations.

Here is the output:

Initial Map 1
Filtering 4
Mapping 4
20
Initial Map 2
Filtering 5
Initial Map 3
Filtering 6
Mapping 6
30
Initial Map 4
Filtering 7
Initial Map 5
Filtering 8
Mapping 8
40

When using Sequences, each element goes through the entire pipeline of functions before progressing to the next element.

Let's take the first element (which is 1) in the above List as an example.

The Sequence takes 1 and then prints out "Initial Map 1". After that command, it adds 3 to 1.

The next function called is filter() so it executes the first command which prints "Filtering 4" (at this point current value is 4 and no longer 1, 3+1 = 4).

Since 4 is even (4%2==0), it moves on to the map() function. Which prints out "Mapping 4" and then multiplies 4 by five.

The value is now 20, and then the forEach() call immediately prints out the first element received by evenMultipliedNumbers.

Return Value

Each Collection function returns a collection of the same type, a quick example:

//Kotlin
val numbers = listOf(1, 2, 3, 4, 5)
val greaterNums = numbers.filter { it > 3 }
println("Variable value $greaterNums")
println("Class Type: ${greaterNums.javaClass.name}")

Output:

Variable value [4, 5]
Class Type: java.util.ArrayList

The value from the operation was assigned to the variable greaterNums, which was of Type ArrayList!

Let's run the exact same code but with Sequences instead:

//Kotlin
val numbers = listOf(1, 2, 3, 4, 5)
val greaterNums = numbers.asSequence().filter { it > 3 }
println("Variable value $greaterNums")
println("Class Type: ${greaterNums.javaClass.name}")

Output:

Variable value kotlin.sequences.FilteringSequence@4eec7777
Class Type: kotlin.sequences.FilteringSequence

It returns new sequences which could mean a lot more efficiency in terms of memory-consumption because no additional collections are being allocated as the Sequence is being processed.

Should you use Sequences in all cases?

Though Kotlin Sequences look shiny, that might not be the best solution for all cases. Sometimes you might just be fine using the Collection Functions. I would put some great articles below for further reading and research on the Sequences.

Kotlin Sequence Tutorial

Kotlin Sequences: An Illustrated Guide

A video tutorial on Kotlin Sequences: Kotlin Sequences

The funny Java vs Kotlin battle

Lemuel Ogbunude — Tue, 14 May 2019 18:39:21 +0000

Scrolling through Twitter I found this Tweet which I kinda agree with:
// Detect dark theme var iframe = document.getElementById('tweet-1128026975694536704-853'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1128026975694536704&theme=dark" }

I went on to check out the Reddit Post spoken of.

Here is my take on what I saw.

In the Android community, there is this constant battle of Java and Kotlin which, in my opinion, is very unnecessary.

I use both Java and Kotlin and can say that Kotlin is a wonderful language.

But here is the issue, to uplift a language, you do not need to talk down on another. If a tool is solid and stands the test of time, people would adopt it.

Another mistake I see is when people compare Kotlin's current features with Java's past issues.

What do I mean by that?

When people compare Kotlin with Java they, sometimes unknowingly, are comparing Kotlin with Java 7.

In case you are not aware, the latest Java version is Java 12.

The Java used on Android is mainly Java 7 and a little of Java 8. Java 8 features are now being added to Android for developers to make use of.

If you are familiar with Android development you would know that in order to use Java Streams, which was a feature in Java 8 (2014), you would need to be on API level 24 or higher to use it on Android.

For clarity sake, API level 24 is Android Nougat.

Another Java 8 feature (which you can now access on Android) is CompletableFutures which could replace all the lines of your AsyncTask Class with just a few lines of code.

If you have noticed, I haven't spoken of the current Java 12 features. It is possible to see Java 12 code and mistakenly think it is Kotlin, that's how much Java has improved.

I am also a Kotlin fan. If you would like to know more about Kotlin check out the Kotlin in Action ebook.

But being a fan of one language shouldn’t make you an enemy of another.

The common arguments I hear are readability and productivity. If you want to read a great article on why Kotlin does not instantly mean readability and productivity read this article.

Adopting Kotlin does not guarantee you would have happier developers, fewer bugs and skyrocketing profit. In the end, the users/clients might not even know or care about what an If Statement means.

If you are using Java on Android, Awesome!
Also check out RxJava for Android Developers.

If you are using Kotlin, keep it up!

If you wrote the app using C++ and it works fine as expected, great!
If you wrote it using React native, wonderful!
If you wrote it with Flutter, marvellous!

We like shiny new tools. We should also focus on getting the job done and maintainable.

Shorter lines of code (especially when not significant) do not guarantee the project would be delivered faster. Readability is subjective and any statistics on productivity should be based on facts.

Happy coding!

OpenJDK Providers To Take Note Of

Lemuel Ogbunude — Fri, 03 May 2019 19:01:55 +0000

Recent production support changes to the OracleJDK have forced organizations to rethink which Java distribution will support their Java applications moving forward. OpenJDK is a great option.

The good news is that you have OpenJDK options that are well supported and functionally interchangeable with Oracle JDK.

Below are a few:

AdoptOpenJDK

AdoptOpenJDK is a community of Java User Group (JUG) members, Java developers and vendors who are advocates of OpenJDK.

They recently reached 25 million downloads and have a growing community of supporters and users.

// Detect dark theme var iframe = document.getElementById('tweet-1121919635425775616-701'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1121919635425775616&theme=dark" }

RedHat OpenJDK

RedHat recently took over stewardship for the OpenJDK 8 and OpenJDK 11 projects from Oracle, so you can guess they mean business.

// Detect dark theme var iframe = document.getElementById('tweet-1118506813652074496-556'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1118506813652074496&theme=dark" }

Red Hat has been a member of the OpenJDK community since 2007 and is one of the largest contributors to the project.

A quote from Mike Piech, vice president and general manager, Middleware, Red Hat
"Java is in a renaissance moment. It continues to evolve and be a key component of new, emerging architectures. There is a developer hunger to bring Java into the next generation of development, and Red Hat is a leader in this movement through our involvement in the OpenJDK project. We are helping to lead the way in our efforts to enable users of JDK to have support and innovation in their existing environments. Red Hat remains committed to Java and is excited to have the opportunity to help steward the OpenJDK community."

Amazon Correto

Amazon Corretto comes with no-cost long-term support from Amazon, so you can upgrade versions only when you need to. Amazon is committed to Corretto, running it internally on thousands of production services.

Amazon will distribute security updates to Corretto 8 at no cost until at least June, 2023, and to Corretto 11 until at least August, 2024. Corretto includes targeted backports from newer releases, as well as newly-developed enhancements from the OpenJDK community.

The release process includes testing on thousands of Amazon services, which makes it possible for fixes to be released within days of finding issues.

// Detect dark theme var iframe = document.getElementById('tweet-1091542773906386944-899'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1091542773906386944&theme=dark" }

Zulu

Zulu is a widely available binary distribution of OpenJDK. Zulu distributions are fully tested and compatibility verified builds of the latest versions of the OpenJDK 12, 11, 8 and 7 platforms. Zulu is available free of charge for Linux, Windows, and MacOS platforms, with commercial support available upon request.

Zulu is built, tested, supported and made available by Azul Systems.

In case you want commercial support you can check out Zulu Enterprise which is cheaper than what Oracle charges and also adds the advantages of cost-effective world-class, subscription-based Java support plans.

Liberica

Liberica is a 100% open-source Java 8, 9, 10, 11 & 12 implementation. It is built from OpenJDK which BellSoft contributes to, thoroughly tested and passed the JCK as provided under the license from OpenJDK.

// Detect dark theme var iframe = document.getElementById('tweet-1059833007299837952-114'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1059833007299837952&theme=dark" }

SapMachine

SAP is among the biggest external contributors to the OpenJDK project and is committed to ensuring the continued success of the Java platform.

SapMachine is supported on Windows, Linux, and MacOS. Docker images are available for most versions. Releases have passed the Java Compatibility Kit, for certifying compatibility with OpenJDK.

Conclusion

As you can see, there are different OpenJDK providers who you can choose from. These providers have the engineers to provide you with production-ready, battle-tested JDKs.

Thank You 😊!

Java In 2019 And Beyond

Lemuel Ogbunude — Tue, 25 Dec 2018 23:01:52 +0000

What comes to your mind when you hear the word Java?

For some people, they remember a very verbose programming language taught to them in their CS class, for some others, they have heard of it probably because of its popularity.

Some... just hate Java.

Amongst all these, Java is still currently one of the top hot languages today, why is this so?

The Java You Know

A lot of people learnt Java in their early years of programming, some went on to love it while others went on to hate it.

Unfortunately, people use the Java they previously learnt years ago to judge modern Java.

Quoting the words of Venkat Subramanian he said "Java development has been by far the best in the past 5 years compared to the past 20 years, and I am going to put my money on this, the development in the space of Java would be the biggest in the next 3 to 4 years than we have ever seen"

I would try to show you some areas where Java has improved though Java has improved way more than I would show here.

Let us use some examples, in this example, I would use the old Java you probably know and then I would show you how you might solve the problem using Modern Java.

Let's say your lecturer told you to create a program to create a list of integers from 1 to 10 and then loop through it to print out the even numbers, using old Java your code might look like this:

      ArrayList<Integer> myList = new ArrayList<Integer>();

        for (int i = 1; i <= 10; i++) {
            myList.add(i);
        }

        for (int num : myList) {
            if (num % 2 == 0)
                System.out.println(num);
        }

If you have used other languages then the code above might make you desire a simpler and less complex solution.

Using modern Java, I could make the code above easier on the eyes by writing it using the style below:

      rangeClosed(1, 10).boxed().collect(Collectors.toList())
                .stream()
                .filter(integer -> integer % 2 == 0)
                .forEach(System.out::println);

I think that's better looking.

Java has been known to be a language where you have to state every single detail before you can get a little thing done, so using the Java you know, creating a Hashmap would look like this:

HashMap<Integer, String> myMap = new HashMap<Integer, String>();

Well, I would like that to be more concise.

Fortunately, Java currently does not need all that boilerplate code:

var myMap = new HashMap<Integer, String>();

I am not here to convince you that Java is the most concise language, but I am here to tell you that Java is probably way less verbose and way more concise than you last met it.

Modern Java

I would list out some improvements in Java, take note, this is nowhere an exhaustive list and there are way more improvements than I would mention here.

If I tried to mention all the improvements, I would have enough content to publish a book about it.

JShell

The Java Shell tool (JShell) is an interactive tool for learning the Java programming language and prototyping Java code.

JShell is a Read-Evaluate-Print Loop (REPL), which evaluates declarations, statements, and expressions as they are entered and immediately shows the results. The tool is run from the command line.

You can test individual statements, try out different variations of a method, and experiment with unfamiliar APIs within the JShell session.

It was added in JDK 9, it's quite a useful tool, might be a lifesaver one of these days.

Switch Expressions

Switch expressions are expected to be in JDK 12+, they simplify the traditional switch statements we know, for example, the code:

switch (day) {
    case MONDAY:
    case FRIDAY:
    case SUNDAY:
        System.out.println(6);
        break;
    case TUESDAY:
        System.out.println(7);
        break;
    case THURSDAY:
    case SATURDAY:
        System.out.println(8);
        break;
    case WEDNESDAY:
        System.out.println(9);
        break;
}

Would be written as:

switch (day) {
    case MONDAY, FRIDAY, SUNDAY -> System.out.println(6);
    case TUESDAY                -> System.out.println(7);
    case THURSDAY, SATURDAY     -> System.out.println(8);
    case WEDNESDAY              -> System.out.println(9);
}

CompletableFuture (The Promises of Java)

CompletableFuture allows the creation and execution of chains of asynchronous tasks.

CompletableFuture works the same way Promises work in JavaScript.

    public static void main(String[] args) throws InterruptedException {

        CompletableFuture.supplyAsync(() -> longProcess()).thenAccept(System.out::println);
        Thread.sleep(4000);
        System.out.println("Done!");
    }

    private static int longProcess() {
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return 1;
    }

CompletableFuture was introduced in JDK 8, though people focused on the shiny new Java streams and didn't notice the wonderful tool.

If you are interested you could go watch and learn about it:

Project Loom

Project Loom, which is not yet fully implemented, will introduce fibers as lightweight, efficient threads managed by the Java Virtual Machine, that let developers use the same simple abstraction but with better performance and lower footprint.

Fibers are much more lightweight than kernel threads in terms of memory footprint, and the overhead of task-switching among them is close to zero.

Millions of fibers can be spawned in a single JVM instance, and programmers need not hesitate to issue synchronous, blocking calls, as blocking will be virtually free.

Records (Data classes for Java)

Records, which is also a feature yet to be implemented, is going to help make creating POJO classes easier. For example a class such as:

class Point {
    double x;
    double y;

    Point(double x, double y) {
        this.x = x;
        this.y = y;
    }

    public void setX(double x) {
        this.x = x;
    }

    public double getX() {
        return x;
    }

    public void setY(double y) {
        this.y = y;
    }

    public double getY() {
        return y;
    }

    @Override
    public int hashCode() {
        return super.hashCode();
    }

    @Override
    public boolean equals(Object obj) {
        return super.equals(obj);
    }


    @Override
    public String toString() {
        return super.toString();
    }
}

Would be rewritten as:

record Point(double x, double y);

There are some other very interesting Java features which I would leave to your curiosity to find out.

Release Cycle

Recently, it was announced that Java would be using a 6-month release cycle, so we would expect a release every 6 months. The good news is that you can expect to get new features faster.

Java on Android

Google announced Kotlin as an official language and since then it has seen huge growths.

I do like Kotlin, I use Kotlin, but I am of the opinion that Kotlin isn't here to replace Java.

Now, you might have heard some Android devs complain of Java. I usually like them to be specific.

What they actually complain of is the verbosity of Java 7 whereas the latest to be released at the time of this writing is Java 12.

Kotlin looks cool on Android partly because Android developers can't access the latest Java features and are stuck using Java 7 ~ Java 8.

Nevertheless, most Android applications are still currently written in Java. Probably a lot of professional developers are fine using Java 7 :)

We all shouldn't make the mistake of comparing Kotlin to Java the way Swift was compared to Objective C.

Unfortunately, a lot of Android developers aren't aware of how far Java has come as a language because they still use the Java of their CS class.

By the way, I am an Android developer and I also think Kotlin is cool ;)

Java Is Still free

Oracle recently announced that they would be charging for the commercial use of Oracle JDK and long-term support. Well, it got to the headlines and people wrote a lot of factually incorrect articles.

To whom it may concern, Java is still free.

Most big companies who use Oracle JDK for their development wouldn't be so bothered by the change.

For people who are worried, there is no need to be!

As at JDK 11, OpenJDK has feature parity with Oracle's JDK. Hence, they are interchangeable.

Moreover, Amazon recently announced Amazon Corretto which is a no-cost, multiplatform, production-ready distribution of the Open Java Development Kit (OpenJDK).

Corretto comes with long-term support that will include performance enhancements and security fixes.

You could also go for other OpenJDK providers such as AdoptOpenJDK, there is actually no cause for alarm.

Java is still free.

Java's current rank as a language

Currently, Java is #1 language for the TIOBE index programming language ranking. It was also #2 in the GitHub's State of the Octoverse.

This isn's a sales pitch

This article isn't a quit your job and go learn Java article. Instead, I am here to tell you how far Java has come and where it is heading as a language.

Java's ability to keep on adapting has helped it remain one of the top languages for a very long period.

Using Codacy for automated code reviews

Lemuel Ogbunude — Thu, 15 Nov 2018 10:06:15 +0000

Whether you are a solo developer who wants to improve your code quality or a team of developers who want to have automated code reviews and standards, Codacy could just be the right choice.

With Codacy you could automatically identify issues through static code analysis. Get notified on security issues, code coverage, code duplication and code complexity in every commit and pull request.

Integrating Codacy into your workflow is quite simple:

1) Add your git repository

2) Codacy automatically detects issues with every push

3) Get notified of the issues and suggestions which you could take action on

Here are some extra goodies you get with Codacy:

You could define your quality threshold and make sure all teams and projects are publishing healthy and consistent code, Identify exactly which lines of code are being covered by your test suite and which aren’t.

Pricing

Once I like a product, the next thing I rush to is pricing 😂

Codacy has a developer and startup-friendly pricing scheme.

Opensource plan

Codacy is forever free for all opensource projects.

Pro plan $15-$18/month

This plan allows you have Private and public repositories, gives you higher priority and faster analysis and you get priority support.

Enterprise plan $$

For this you get a custom plan tailored for your business with first-class security on your servers, you would have to contact Codacy for pricing details

Startup 0$ (yep, you read that right)

For teams up to 4 users, you get everything in the Pro plan for free! This plan was not available before but was just recently added, you could take advantage of this opportunity if you're interested.

Supported languages

Here are the officially supported languages:
Scala
Java
JavaScript
Python
Ruby
PHP
Apex
JSP
XML
Velocity
VisualForce
C#
JSON
Kotlin
Markdown

Here are the community supported languages (languages added to Codacy by one of their users):
CoffeeScript
CSS
C/C++
Dockerfile
SASS
Shell Script
Swift
TypeScript
LESS
Go
SQL
Elixir
Powershell

Amazon Corretto, a no-cost, production-ready distribution of OpenJDK

Lemuel Ogbunude — Thu, 15 Nov 2018 08:31:35 +0000

In case you are looking for a secure and up to date distribution of the Open Java Development Kit, look no further.

Introducing Amazon Corretto, which is a no-cost, multiplatform, production-ready distribution of the Open Java Development Kit (OpenJDK). Corretto comes with long-term support that will include performance enhancements and security fixes.

Amazon runs Corretto on thousands of production services. Patches and improvements in Corretto enable Amazon to address high-scale, real-world service concerns, meeting heavy performance and scalability demands.

The Corretto 8 preview corresponding to OpenJDK 8 is available at this time for Amazon Linux 2, Microsoft Windows, and macOS platforms and Docker image. Preview builds can be downloaded by visiting aws.amazon.com/corretto.

Amazon will distribute security updates to Corretto 8 at no cost until at least June 2023, and to Corretto 11 until at least August 2024.

Amazon Corretto is certified to meet the Java SE standard and can be used as a drop-in replacement for many Java SE distributions. Also, Amazon Corretto lets you run the same environment in the cloud, on premises, and on your local machine.

Amazon Corretto sounds wonderful and is available for download and use at no cost.

For further reading:
Introducing Amazon Corretto, a No-Cost Distribution of OpenJDK with Long-Term Support

Re-affirming Long-Term Support for Java in Amazon Linux

Java is still free!

Lemuel Ogbunude — Sat, 10 Nov 2018 00:36:58 +0000

I see a lot of posts lamenting about how Java is now being paid for. I feel a lot of people are getting it wrong...and right.

Oracle JDK

Perhaps when you started coding in Java, you were asked to download the JDK (Java development kit). By default what you went for was the Oracle JDK. Oracle isn't the only provider though they are the most popular, so when they make a move everyone feels it.

Oracle JDK now has a feature release every six months, this new versioning scheme which was previously announced in 2017. Previously that took about 3+ years. For example, look at how long it took for Lambdas to get to Java in Java 8. So the six months feature release is good news!

Oracle JDK is free for use in development and test environments but would be paid for in commercial settings.

In other words, updates will generally be provided for 6 months before they are stopped upon release of the next version. If updates/support are required for a longer duration, or for production use, then it must be purchased from Oracle.

Now it actually makes sense for Oracle to charge if they are going to be moving at such a rate, there are hard working developers that are behind this and not robots.

Moreover, it isn't a new thing for companies to charge fees for enterprise support.

Now if you are a developer just learning Java, this does not affect you any way because you probably are using Oracle JDK in development and test environments.

Now, what if you intend to use it commercially what should you do?

You have some options, but I'd list a few-

Your company could go for the commercial plan and Long-term support:

-$2.5 (USD) per month per user (desktop) or Less
-$25 (USD) per month per processor (Server) or Less

With Significant discount for large deployment support requirement, for example, 50% discount for 10k-20k processor units.

OpenJDK

Oracle contributes heavily to OpenJDK, and it is the basis for both Oracle OpenJDK builds and Oracle JDK. OpenJDK is free and opensource. In fact, as of Java 11, OpenJDK has feature parity with Oracle's JDK. In other words, you shouldn't see Oracle JDK as "better" than the OpenJDK build. That's great news, isn't it!

You certainly do not "need" to go with a paid support option.

Though if you're in a large organisation that needs a fix in a timely manner, someone to respond to your user requests, or if you want the reassurance that the binary you use is being backed by a vendor, then you could go for the commercial support.

It's worth thinking though about how you, the end users, can support the Java SE ecosystem to ensure it has a long lasting future!

Summary

I have given the overview of this situation, there are more detailed articles and documents you could go and check out if you are still interested in understanding what it entails in more detail.

In our world where we have a lot of wonderful languages with wonderful features, Java needed to speed up its releases and add new features faster. Hence Oracle has decided to invest in moving Java forward.

Here are some good articles I highly recommend you to go check out if you are interested in learning more:

Java Is Still Free

Java is still available at zero-cost

Article by Trisha Gee

Interesting JDK 12 features to watch out for.

Lemuel Ogbunude — Fri, 09 Nov 2018 01:51:51 +0000

With the new 6 months Java release cycle, you should expect cool features to get to developers at a faster rate. I have seen some cools features which you could expect to see in the JDK 12 release next year. You can get the Open JDK 12 early access build and try these preview features out.

Switch expressions

For example, you have an enum for the days of the week and you want to use switch statement to return the number of letters in the string. There are better ways to do this but we are going to use Switch statements to demonstrate this.

Here is the enum:

enum DayOfWeek{
MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

With what we know in Java this would probably be the solution:

      int numLetters;
        switch(day){
            case MONDAY: case FRIDAY: case SUNDAY:
                numLetters=6;
                break;
            case TUESDAY:
                numLetters=7;
                break;
            case THURSDAY: case SATURDAY:
                numLetters=9;
                break;
            case WEDNESDAY:
                numLetters=10;
                break;
            default:
                throw new NoSuchDayException(day);

        }

This could really trigger some bugs as it could make the code hard to maintain.
With Switch Expressions, you could write the Switch as an expression. No default is needed in the Switch statement.

Here is how the code would look like:

int numLetters=switch(day)
        {
            case MONDAY, FRIDAY, SUNDAY -> 6;
            case TUESDAY -> 7;
            case THURSDAY, SATURDAY -> 8;
            case WEDNESDAY -> 9;
        };

Records

We all know our POJOs (plain old Java object), they come with a lot of boilerplate code, for example here is a classic POJO:

class Point {
    double x;
    double y;

    Point(double x, double y) {
        this.x = x;
        this.y = y;
    }

    public void setX(double x) {
        this.x = x;
    }

    public double getX() {
        return x;
    }

    public void setY(double y) {
        this.y = y;
    }

    public double getY() {
        return y;
    }

    @Override
    public int hashCode() {
        return super.hashCode();
    }

    @Override
    public boolean equals(Object obj) {
        return super.equals(obj);
    }


    @Override
    public String toString() {
        return super.toString();
    }
}

Well, Records (currently not targeted to JDK 12 at the time of this writing) replace all that POJO code with just one line:

 record Point(double x, double y);

There are other cool features to expect in JDK 12 and beyond, I personally appreciate the fact that the Java community is responding and aiming to move Java forward.

In case you are interested in learning way more you could check out this video:

What tools are in your toolbox?

Lemuel Ogbunude — Fri, 13 Jul 2018 23:41:24 +0000

What tools do you use? Apart from programming languages, the next set of items in our toolbox are usually productivity tools, stuff that helps us get things done quickly, with fewer errors.

I am going to share a list of tools I use, I got to know about some of them through either a friend or probably an article I read. So the purpose of this article is to get the information to others who might not know about some of these tools.

This isn't an exhaustive list, so feel free to mention some of those you use also, I would love to know 😉.

Git

You probably are using Git for your version control, I strongly advise you to check it out if you have not used it before.
You probably might be copying and pasting your code in location and tagging them with dates, to be honest, I did this before I started using Git 🙄.

When you are comfortable with Git you could go on to check out GitHub where you can host your code. There are other alternatives to GitHub (in case you're wary of Microsoft 😅) such as GitLab.

Git Kraken

After using Git for some while you might need a tool to help you visualize your Git commits and help you perform your Git operations in a more user-friendly way. There are different Git clients which are really great, one of which is GitKraken. If your aim is to become more productive, check out GitKraken :).

Visual Studio Code

I guess there are a lot of "VS code advocates" reading this, the funny truth is that I was not really a fan of VS code. Haha, Hold on! Don't close the browser yet! The story has a good ending :)

It's not that I didn't like VS code, I just didn't see anything special. Well, that was until one of my friends properly introduced it to me. I have added VS code to me toolbox ever since.

I use Android Studio for my work, so I don't really need VS code, but it is so good that I had to add it as part of my work tools. I really appreciate those who put an effort into making great extensions for VS code.

Fabric

Fabric is a platform that helps your mobile team build better apps, understand your users, and grow your business. I use it primarily as a crash reporting tool.

With Fabric you could get powerful, yet lightweight crash reporting so you can fix issues fast, streamline and automate your beta distribution and app deployment process, get insight into your users and what actions they're taking inside your app, uncover behaviours that correlate with healthy and unhealthy users, drive app installs and monitor active users.

In summary, it is awesome!

InstaBug

There are many crash reporting tools which you can choose from, however, if you want more than just a crash reporting tool InstaBug might be your solution. Users can report bugs and have the ability to chat with you through the app, send feedback and even perform in-app surveys which would help you better understand your users.

RollBar

RollBar, similar to Fabric, helps me resolve errors before my users get affected. From my personal experience, I do really like RollBar, you have the choice of integrating it with the tools you already use. You could also use webhooks and their full-featured REST API to create custom integrations, export data, and more. I use RollBar and I do recommend you to check it out.

Bugsnag

Bugsnag is an alternative to the other error reporting tools I have previously mentioned, with Bugsnag you can for web, mobile, and backend, automatically collect diagnostics and group errors by root cause. You could also assess the impact of each error, track release health, spot regressions and spikes.
In addition to all that, you can see the crashing line of code, dig deep into difficult errors and track progress on fixes.

In summary, it is an awesome error reporting tool.

Codacy

Codacy is awesome, it helps you with automated code reviews and code analytics, if you haven't checked it out before, I also strongly advise you do so 👨‍💻👩‍💻. You can automatically identify new static analysis issues, code coverage, code duplication and code complexity evolution in every commit and pull request. It's awesome and it's good.

Code Climate

Code Climate is another tool you could use for automated code reviews, these kinds of tools help you ship better software, faster.
Code Climate gives you detailed analysis such as the cognitive complexity of your code, code churn, maintainability and similar analysis. It is an awesome and very useful tool.

Circle CI

If you have a team which desires to build things fast, deliver products at record time, you would need a tool to help with fixing issues early and fast. CircleCI is Continuous Integration, a development practice which is being used by software teams allowing them to build, test and deploy applications easier and quicker on multiple platforms.

You could integrate CircleCI with your project on GitHub so that tests are run on every commit, therefore errors are discovered early and easier. There are other continuous integration tools such as Travis CI and Jenkins.

Blender 3D

Yes, I just had to put Blender 3D here in case you wanna check 3D design out, it is free and open source :)

This isn't an exhaustive list like I said, it's just to create awareness of some awesome tools available. Are there some awesome tools you would like to share with the community, mention them in the comments :).

Intro to Realm Database

Lemuel Ogbunude — Thu, 31 May 2018 22:02:50 +0000

Nowadays we have a lot of options when deciding to choose a database solution. We have different attractive options each of which has it's strengths and weaknesses. One I have found to be outstanding is Realm database. Realm database can be used by Android, IOS, React and even Xamarin developers.

What Realm 🤔

Most applications today will need some sort of persistent data, sorting that out usually involves making the application more complex and adds more lines of code. Many engineering organizations are all too familiar with the pain of increased development complexity that results in longer cycles, overburdened resources, and an unwieldy code base. Realm, alongside other new database solutions, is solving this issue of complexity.

Realm simplifies your application architecture while giving you very powerful features. The Realm Platform is actually made up of two major components. The Realm Database and the Realm Object Server. According to the official documentation, these two components work in conjunction to automatically synchronize data enabling a lot of use cases ranging from offline apps to complex backend integrations. I am not going to cover the Realm Object Server in this article, therefore, you can read more about the Realm Object Server here.

One of the key factors that makes Realm so special is the fact that it was built for our modern mobile development demands, a lot of the solutions we use were not actually designed for phones, tablets or wearables:

For a very long time SQLite has been our main choice for persistence on mobile and even if it is not used directly it is used by many libraries that provides a convenience wrapper around it such as Couchbase Lite, Core Data, ORMLite, etc.

Realm also boasts of speed, according to the documentation, Realm is faster than even raw SQLite on common operations, while maintaining an extremely rich feature set.

Realm is also simple to use, here are some sample codes of how basic Realm transactions would look like:

For Java:

public class Dog extends RealmObject {
  public String name;
  public int age;
}

Dog dog = new Dog();
dog.name = "Rex";
dog.age = 1;

Realm realm = Realm.getDefaultInstance();
realm.beginTransaction();
realm.copyToRealm(dog)
realm.commitTransaction();

RealmResults<Dog> pups = realm.where(Dog.class)
                               .lessThan("age", 2)
                               .findAll();

For Swift:

class Dog: Object {
  @objc dynamic var name = ""
  @objc dynamic var age = 0
}

let dog = Dog()
dog.name = "Rex"
dog.age = 1

let realm = try! Realm()
try! realm.write {
  realm.add(dog)
}

let pups = realm.objects(Dog.self).filter("age < 2")

For Javascript:

class Dog {}

Dog.schema = {
  name: 'Dog',
  properties: {
    name: 'string',
    age: 'int',
  }
};

let realm = new Realm();
realm.write(() => {
  realm.create('Dog', {name: 'Rex', age: 1});
});

let pups = realm.objects('Dog').filtered('age < 2');

For Xamarin:

public class Dog : RealmObject 
{
  public string Name { get; set; }
  public int Age { get; set; }
}

var realm = Realm.GetInstance();
realm.Write(() => 
{
  realm.Add(new Dog
  {
    Name = "Rex",
    Age = 1
  });
});

var pups = realm.All<Dog>().Where(d => d.Age < 2);

Getting started 😁

We are going to build a very simple application using Realm database. It is going to be an Android app. I will try to make it as simple as I can so anyone can relate to it and implement it on whatever platform they wish.

The app we are going to make just does basic database operations, this is just to give you an overview of what to expect when working with Realm.

We have an Edittext view for the name and age of a user to be inserted into the database. Then below those is an add button which inserts the user name and age into the database. There is also the filter button which queries the database for specific users.

First step 🔥

Add the class path dependency to the project level build.gradle file.

buildscript {

    repositories {
        google()
        jcenter()
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:3.1.2'

        classpath "io.realm:realm-gradle-plugin:5.1.0" //todo (1) add realm dependency

        // NOTE: Do not place your application dependencies here; they belong
        // in the individual module build.gradle files
    }
}

Second step 🔥

Apply the realm-android plugin to the top of the application level build.gradle file.

apply plugin: 'com.android.application'

apply plugin: 'realm-android' //todo (2) add realm plugin

android {
    compileSdkVersion 27
    defaultConfig {
...

Define Model Class

Define your model class by extending RealmObject. It is similar to your everyday POJO classes.

import io.realm.RealmObject;

//todo (3) Define your model class by extending RealmObject
public class User extends RealmObject{
    private String name;
    private int age;

    public User() {
    }

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

Initialize Realm

To get started, you will need to initialize Realm, this is needed just once per application, so a good place to do this is in onCreate.

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        ButterKnife.bind(this);

        //todo (4) Initialize Realm (just once per application)
        Realm.init(this);

        //todo (5) Get a Realm instance for this thread
        Realm realm = Realm.getDefaultInstance();
...

Writes 🔥

So now all is set and ready. The next step is to add a new user with a name and age. They are added by clicking the 'ADD' button as shown in the diagram above. The ID's for the Edittext views name, age are name_txt and age_txt respectively, while the ID for the button is add_btn.

   add_btn.setOnClickListener(v -> {
            // write operations in Realm must be wrapped in transactions.
            realm.beginTransaction();
            User user = realm.createObject(User.class); //todo  Create a new object
            user.setName(name_txt.getText().toString()); //todo get user name from Edittext and store in user object
            user.setAge(Integer.valueOf(age_txt.getText().toString())); //todo get user age from Edittext and store in user object
            realm.commitTransaction();
            // commit transaction

            Toast.makeText(this, "User added", Toast.LENGTH_LONG).show();
            clearText();
        });

When beginning a Realm write operation, it has to be wrapped in transactions. Basically, at the end of a write operation, you can either commit the transaction or cancel it. Committing a transaction writes all changes to disk. If you cancel a write transaction, all the changes are discarded.

If you noticed, the first samples in this article used copyToRealm() to add a new Object, both methods will insert data into the database.

In the code above, we simply created a new object from the User class which extends RealmObject, we set the values and voila! we have inserted that data. I haven't hidden any extra code or class from you, that is really all it takes to perform a write operation.

Queries🔥

So now that we can insert our lovely data, the next question is how do we get it out 🤔.
Well, if you thought the process of inserting data looked cool, wait and see how we retrieve it. Supposed you wanted to get all the users whose age was less than 45 this is how that query would look like:

        RealmResults<User> result = realm.where(User.class)
                            .lessThan("age", 45)//find all users with age less than 45
                            .findAll();//return all result that reach criteria

Now ain't that splendid? After doing that you could loop through the realm results and get the values for example:

    StringBuilder stringBuilder = new StringBuilder();
                    for (int i = 0; i < result.size(); i++) {
                        stringBuilder.append(result.get(i).getName() + "  ");
                    }

I have just scratched the surface, Realm can do much more than I have demonstrated, this was just meant to be an introduction. You can check the documentation for more information on queries, filtering, multi-threading, testing and much more.

You can find the full source code of the sample app above here:

LEMUBIT / RealmExample

A simple project demonstrating how to use Realm database for Android development.

RealmExample

A simple project demonstrating how to use Realm database for Android development.

View on GitHub