At some point in your coding career you may be unlucky enough to encounter code that looks somewhat like the following:

try {
  int i = 0;
  while (true) {
    items[i++].process();
  }
} catch (ArrayIndexOutOfBoundsException ignored) {
}

Likely what this code is doing doesn’t immediately jump out at you, especially compared to a similar function that performs the same function written like this:

for (Item item : items) {
  item.process();
}

Not only is the first function more code, it is harder to grok and actually less performant. The unfortunate thing is that apparently some developers that write code…

Java has been around for a long time. In its long history, certain conventions have been created. An official set of conventions, reasonably called The Java Language Specification, stands as the official language conventions. These conventions cover both appearance and grammatical conventions.

The first item to cover is that of the package structure. Packages form a hierarchical organization of components separated by periods. Components are written in lowercase letters and rarely digits. Packages should begin with the organization’s domain name with the components reversed (ex: com.google, org.apache, etc.) Two exceptions to this are the java and javax packages. Package components…

There are a number of sayings that have grown in popularity in the technical industry:

We should forget about small efficiencies, say about 97% of the time: premature optimization is the root of all evil

Donald E. Knuth

We follow two rules in the matter of optimization:
Rule 1: Don’t do it.
Rule 2: (for experts only) Don’t do it yet — that is, not until you have a perfectly clear and unoptimized solution

M. A. Jackson

It’s pretty clear that there are major concerns with optimizing applications early. A root of a lot of these concerns is that when…

Java provides the Java Native Interface (JNI) that allows Java programs to call into native methods written in native programming languages such as C, C++, or Rust. Historically this capability has been used for three different things:

1. The ability to call into platform-specific features such as registries.
2. Access to existing native code so that you don’t need to re-implement it.
3. For writing performance-critical parts of your application.

As stated above it is valid to use native methods to access platform-specific functionality although that is seldom needed. …

Java provides a very powerful capability in its reflection system. Reflection allows us to have extreme flexibility when calling classes, their constructors, and methods. These classes that we are interacting with may not even exist at the time that our reflexive code is written. This flexibility is not free, however; there are downsides to its use. Some of these are the following:

• You lose out on compile time checks. Issues that would be exposed at compile-time when coded in non-reflexive style turn into runtime issues when coded via the reflexive APIs.
• Related to the above, static code analysis tools have…

This topic of today is focussed on flexibility. When defining parameters, return types, or variables it is encouraged to define them as the interface that the concrete types implement. So instead of something like:

LinkedHashSet<String> stringSet = new LinkedHashSet();

we should instead implement something like:

Set<String> stringSet = new LinkedHashSet();

What writing our code like this allows us to do is change out the implementation of our variables as long as they meet the same interfaces. So maybe instead of using a LinkedHashSet like defined in the first example we could change it to a HashSet without having to change…

Types in Java come in two flavors, primitive types (int, long, etc) and reference types (String, List, etc). Each primitive type has a corresponding reference type called a boxed primitive. Java does have autoboxing and unboxing which can abstract away the difference between these types but not completely as we will see. Let’s look at a few examples of where we can get in trouble with using primitives and reference types together.

To start off we need to consider the main differences between primitive and reference types:

1. Primitives identity and values are the same. …

This chapter dives into a fun computer science based topic. When we have a need to represent numbers that include a decimal point we will often reach for either a float or a double. These primitive types facilitate the representations of approximate floating point values over various magnitudes. A key part of the previous sentence is that it's an approximation. We must not use floats or doubles when we need exact answers, especially when dealing with numbers.

Let’s briefly go over why this is the case. The goal of floating point types is to allow the representation of any number…