JVM, Kotlin, and where Java is going beyond 2020

Image for post
Image for post
Photo by Javier Allegue Barros on Unsplash

There’s always been a considerable level of criticism against Java from a big sector of our industry. This criticism has been mostly focused on Java’s verbosity and the amount of boilerplate code it generates in many cases without need. Although I’ve always liked Java, I couldn’t say that these allegations are wrong. It’s indeed true that Java’s verbosity and its amount of clutter can become very annoying on multiple occasions. However, most of the time, we have to accept that we don’t live in a perfect world, and in most cases, we have to accept the lesser of two evils. …


One of the most interesting features introduced with Java Streams is the ability of grouping collections easily by using the groupingBy collector.
Although in some cases it could be pretty straightforward, there are different combinations of groupingBy and some of them are not so obvious to understand for many developers, so that’s why I’ve decided that it’d be beneficial to take a deep look at them together.

First of all, let’s start by looking at what the Java API offers to us in Collectors class.

Introduction

Java offers a combination of collectors to group elements of a Java Stream, let’s list them all before we…


We are all well aware of all the fancy new features that JDK 8 brought to us and probably it’s hard to find a Java developer that doesn’t know what Java Streams, Lambdas or CompletableFutures are. So all these nice features came a few years back with JDK 8, but what happened a bit earlier with the release of JDK 7?

If we check the new features in the JDK 7 release, it’s still a bit difficult to spot one of the most important new features introduced in this release. …


Why you’re likely wrong about what makes great programmers

Image for post
Image for post
Photo by ThisisEngineering on Unsplash

Multiple times many of you might have wondered what makes someone a good software engineer. In most cases, there’s a tendency to think that having an intelligence way above the average is the only way to be a good software engineer. I’ll tell you one thing, that’s totally wrong!

I’ve been in this sector for almost 15 years and I can strongly affirm that intelligence doesn’t guarantee being a good software engineer or developer.

Intelligence gives you the ability to solve problems quicker than others, seeing things that others won’t see or maybe be able to foresee some problems earlier than others, but that won’t make you good at writing code. Let’s say that all the benefits that someone could get by being intelligent could be largely overshadowed by all the disadvantages brought by not being a good developer: writing ugly and unmaintainable code, poor design choices, poorly tested code, etc. …


How to use different design patterns with functional programming in Java

Image for post
Image for post
Photo by Adrian Swancar on Unsplash

Recently we started a journey through functional programming in Java with my articles “A new functional Java style” and “Mastering the new functional Java.”

Now that we have a basic understanding about functional programming and what Java brings to us, I think it’s time to see how we can apply this in order to improve our existing code.

The introduction of functional programming in Java has brought new possibilities to the way we write code. We now have much more flexibility. …


These two are not the same thing

multi-threading
multi-threading

I’m aware that for many of you, these two concepts probably mean the same thing, or maybe you’d struggle to explain the differences between them. However, they’re actually two very different concepts. This is quite important to understand the way in which we process data nowadays.

In both cases, we try to solve a problem faster by increasing the number of workers dedicated to a given task, but the way in which they distribute the work to do is where their biggest difference stands.

You’ll be able to see why it’s so important to understand their differences for an efficient, safe, and error-free processing of data. …


In my last article, we talked mostly about how Java Streams work and we also had an introduction to Functional Programming in the article “ A new Java functional style “; now it’s time to take these learnings and see how we can use Streams and take all their benefits.

We’ll go through a set of examples with different complexities to try to show how Java Streams and functional programming can help us solve complex problems that we could face in our day-to-day work as developers.

Image for post
Image for post

Let’s see how can we use Java Streams then!

How to use Streams

As you could expect, to start using Streams the first thing we need to know is how to create a stream! Let’s see the different ways of creating a Java Stream. …


After having had a deep introduction to functional programming in my last article “A new Java functional style”, I think it’s now time to look at Java Streams more in depth and understand how they work internally. This can be something very important when working with Streams if our performance is going to be impacted.

You’ll be able to see how much easier and efficient is processing sequences of elements with Java Streams compared to the “old way” of doing things and how nice is to write code using fluent interfaces.

You can now say good-bye to error-prone code, full of boilerplate code and clutter that was making our lives as developers much more complicated. …


It’s been a while since JDK 8 was released, bringing plenty of new features to the Java language; among them the most expected feature was ,with no room for doubt, the introduction of Lambda expressions.
The release of Lambdas supposed one of the biggest quality jumps in the Java language in its history; mainly due to the fact that it opened a wide new range of possibilities to the language. Without them it’d be impossible to have the more flexible, expressive and simpler language that we can enjoy nowadays.

Functional Programming
Functional Programming

However, despite of having been available for a few years, I still see many developers struggle with them. That’s why I wanted to give a thorough explanation about them and more specifically about the biggest benefits in using them in our day-to-day as developers. …


After having had an introduction to the new concurrency paradigm in Java in my previous article “ A new concurrency model in Java”, I’ve considered that it’d be beneficial to show a more realistic and practical example with CompletableFuture.

So what we’re going to do is to implement a component responsible for fetching posts from different social media platforms and we’re going to do this in an asynchronous way.
For the sake of brevity and simplicity, we’re going to hide the details of how we call these external APIs. …

About

The Bored Dev

💻

Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store