DEV Community: Oscar Ablinger

The Objectively Best Way to Indent your Code

Oscar Ablinger — Fri, 01 Apr 2022 16:33:35 +0000

Tabs or spaces?

Every programmer was at some point confronted by this career-defining choice. But with this post today I'll expand the horizon and finally settle the debate.

So let's go over the different ways to indent your code and their pros and cons.

All of the pretty code images here were made using carbon.

Tabs

Indenting as ASCII intended.
The pros of this technique are plenty:

Every reader of the code can decide how much space it wants the IDE to attribute to one tab: 1, 5 or even 7 (sadly fractions are not supported by most).
The resulting file size is smaller, ensuring that you can stay as productive as possible.
You feel good giving purpose to the 10th ASCII character.

An image of code with tabs.

Spaces

Ah, the default for most editors.
And also slightly more common than tabs in my objective experience.

The main advantage of this style is that you can force the reader of your code to use the same length of indentation that you used.
I know I listed the opposite point as an advantage of using tabs, but we all know that in the end you cannot trust users – not even the users of an IDE.

Developers new to the discussion often bring up that this style requires you to press the space bar repeatedly.
But of course noone actually does that – that's what auto-clickers are for.

An image of code with spaces.

Mixing tabs and spaces

Okay, hear me out: You can use tabs and spaces for different kinds of indentation.

For instance you could use tabs to indent blocks and then use spaces when you need something at a specific position, like when aligning the second parameter with the first.

An image of code with tabs and spaces.

This allows other people to still choose their own length for the tabs, but ensure that elements are still aligned when you want them to be.

Personally I also advocate to use tabs instead of spaces in between parameters, because that will create more visually pleasing code.

An image of code with tabs between parameters.

Mixing and mashing

For those that hate to be restricted by style guides and want to rebel against the bourgeoisie of coding, you can just do whatever you want and sometimes use tabs and sometimes use spaces.

This might seem weird, but if you look at the first projects of software engineers, you'll find that this is pretty common before they learn otherwise.

So it might just be the most natural of all of the indenting methods.

Plus, it turns programming into a small game, when, in every line, you'll wonder whether spaces or tabs were used.

And gamification improves cognitive, motivational and behavioral learning, so this method will also make you a better programmer in the long run.

An image of code with one line using a tab and the other using spaces. Can you guess which is which?

Lastly, you can actually fit two programs into one: Since the whitespace is ignored by most programing languages, you can use them to implement a separate program.

That makes for a great easter egg!

Comments

Instead of adding another program, you could also just try to use the space more efficiently.
Since you'll likely decide to indent anyways, why let that space go to waste?

You can use block comments to add more useful information about what's happening in each line.
That's especially useful for beginners so you don't forget to comment your code.

Since you don't want to use up too much space with full text comments all the time, I'd recommend using some well-defined short names.

Here are some suggestions by me:

Short Name	What it describes
`=`	Variable assignment
`^`	Function call
`↑`	stdout output
`⏎`	Return statement
`}`	End of a block
`π`	π
`∫`	Function definition
`λ`	Lambda definition

An image of code with indentation comments.

This also increases searchability of your code since you can just search for "⏎" and find all of the returns in the file.

Semicolons

More and more language now move to a cleaner no-semicolons-required style.

Sadly some languages still haven't caught up.

But when you're using semicolons as indentation, you'll never have to worry about seeing one at the end of your statement ever again.

An image of code with semicolons as indentation.

Sadly some languages set (in my opinion) unreasonable restrictions on code when using this indentation style.

Java for instance will only allow you to use one indentation level for the line after a return statement.
Otherwise it will complain about "unreachable code".

In those cases I'd recommend using a pre-compiler job that runs all of the files through a simple sed -r "s/;+/;/g" call, which will fix some of the errors.

Most languages also won't let you chain calls over multiple lines anymore.

I do see this as an absolute win, however, since I believe that no method should consist of more than one statement, anyways.
That's usually a code smell.

Other languages will outright refuse to compile code indented like this completely.

While I don't believe that languages should unnecessarily restrict programmers, we're sometimes forced to work with such archaic languages.
In that case, you could try to write a simple pre-compiler, publish it and then never maintain it for 3 years while racking up over a hundred thousand weekly downloads on NPM.

Right-to-left indentation

With i18n becoming more and more important, more any more programs introduce a RTL mode in which the text changes to be aligned from right-to-left.

Maybe it's time to also make that move in the code itself and indent to the right side instead?

The main advantage of this is that the maximum line width now becomes more than a suggestion and actually has to be respected.

An image of code with RTL indentation.

No Indentation

An often overlooked way of indentation is simply not indenting.

Has anyone ever checked if indentation actually improves readability? I know I haven't.

In fact, having no indentation forces you to read every line and ensures that you don't miss anything, reducing errors in the process.

Of course, we also save precious disk space.

An image of code with no indentation.

Blank space

What's better than no indentation?
Nothing!

Blank space is the null to your empty list.

While most editors don't yet support this style, the up-and-coming OSS editor MEPaintIDE is pioneering this brand new way of styling your code.

Instead of doing the cumbersome, arduous, laborious work of inserting characters, you should take your code and push it somewhere else.

Code indented using blank space. I got a blank space, baby.

Summary

I think after this in-depth analysis we can agree that Paint is the best tool for beautiful indentation.

And I hope I could convince you that, at the very least, you shouldn't let people choose their indentation completely freely.

What are some good email providers?

Oscar Ablinger — Fri, 29 Oct 2021 23:08:27 +0000

So, I've got my own domain now. Does anyone have a recommendation for some email providers that give me that sweet …@oscarablinger.com email address?

A catch-all email would be pretty important to me – other than that only maybe that I can export my emails easily so I don't loose stuff when I'm not happy with it.

You already know Monads

Oscar Ablinger — Mon, 21 Jun 2021 19:54:06 +0000

Instead of explaining the abstract theory behind monads, I’ll just show you some Java code that you already understand. And using this practical approach you’ll realize that you’ve in all likelihood already used monads a few times.

Oh and if you prefer to listen to me instead, this post is based on a lightning talk I gave, where I (try to) explain them in 7 minutes.

What are Monads?

Monads are just classes that implement the following two methods:

of (in explanations usually called unit or return) and
flatMap (usually called bind)

of should simply take some values and return a wrapper for it (the monad). flatMap then allows accessing those values by applying a function to all of them, taking the monads returned by those functions and combining (aka “flattening”) them into one again.

Using that, the simplest possible monad is the following:

public class Monad<T> {
    private T value;

    private Monad(T value) {
        this.value = value;
    }

    public static <T> Monad<T> of(T value) {
        return new Monad<>(value);
    }

    public<R> Monad<R> flatMap(Function<T, Monad<R>> f){
        return f.apply(value);
    }
}

So that’s it?

Mostly, but obviously you can’t just name the methods a certain way and have a monad. There are rules for how these two methods need to work together.

The good news is that if you implement those methods as described above (and as they are commonly understood), you’ll already fulfill all of them. But here they are anyways:

The of method is a left-identity for flatMap,
the of method is a right-identity for flatMap and
the flatMap method is associative.

Or, in code:

// using
Monad<V> m;
V x;
Function<V, Monad<V>> f;
Function<V, Monad<V>> g;

// rule 1: of is left-identity of flatMap
of(x).flatMap(f)
    .equals(f.apply(x))

// rule 2
m.flatMap(Monad::of)
    .equals(m)

// rule 3
m.flatMap(f).flatMap(h)
    .equals(m.flatMap(v -> g.apply(v).flatmap(h)))

Why should I care?

Now you know what monads are and how you can create one, but why is there even a name for it?

If you were using a heavily functional language, then this wouldn’t even really be a question since the tools and problems you’ll have when programming functionally will likely naturally result in you creating some monads¹. That’s where monads are from originally.

That being said, they can also be tremendously useful outside of those languages and in fact many new APIs feature monads.

Include (error) states in your domain

The best APIs try to stop you from making mistakes. One of the ways that this is done is explicitly including the error state in its return values. When multiple function calls in a row could return an error, this also has the added bonus of making the resulting code prettier.

Let’s look at an example using Optional:

public Optional<Integer> doSomething(Stream<Integer> stream) {
    return stream
        .findFirst()
        .flatMap(this::integerHalf)
        .flatMap(v -> Optional.of(v*5));
}

public Optional<Integer> integerHalf(Integer i) {
    if (i%2 == 0) {
        return Optional.of(i/2);
    } else {
        return Optional.empty();
    }
}

In this example, we not only had the option to return an “error” at any time, but afterwards we don’t immediately have to check for it. Instead this can be done at a later point.

Monads can also be used to take care of non-error states. This is often used in collections or asynchronous programming (see CompletableFuture), where it also prevents callback-hell.

Allow the use of more generic functions

Take the above function integerHalf for example: We can use this on plain integers and also on any monad like Optional or Stream using the flatMap method.

This ease of access to the underlying information while not leaving the domain of the Monad can create amazing APIs that prevent many errors.

Do you know some monads?

I’ve already mentioned the three most common monads in Java:

Optional,
Stream and
CompletableFuture

but I’m sure you’ve encountered a few more already. Leave a comment if you know another good example.

Further links

P.s.: The title image is a photo by Nicole De Khors and was chosen because monads are often described as boxes since they simply wrap some stuff.