I’ve been asked at times why I approve unplanned personal leaves in my team even if it affects our project timelines. It’s quite simple — People are more important than timelines.

Timelines aren’t real. People are.

Even our best laid plans are at the mercy of life’s chaos. If my teammate tells me they need to take a leave for a few days, I trust that whatever they need to do is important. …

If you’re a tech lead or manager finding yourself suddenly having to run your team remotely in the middle of a global pandemic, this is for you.

I’m not going to bore you with the usual stuff. Here are some tips specifically for leads and managers based on my two-and-a-half years of remote working experience. I won’t be giving recommendations about which specific tools to use because it really doesn’t matter.

Writing Is Your New God

There is only one way to successfully work remotely, and there is no way around it — a culture of quality writing. …

If you’ve ever hung out with a bunch of designers at a party, you’d have probably heard them say something like “Man, things would be so much easier if engineers knew how to design” (Engineers probably harbour similar sentiments about designers, but it’s harder to observe this since they do not have friends and are not invited to parties).

Just imagine for a second though…what if engineers and designers worked together?

What if we taught engineers the basics of software interface design and leveraged their experience in creating systems and abstractions to make design easier?

What if engineers and designers…

This is a caterpillar:

This is a butterfly:

In the last post, we learned about higher order functions and closures. In this one, we’ll talk about functional error handling.

If you haven’t read part 3, please read it here.

Functional error handling

If you’ve been following this series so far, you might have noticed a recurring theme in FP: Everything is a computation or a value.

We create functions which can optionally take some values. They then perform some useful computation and return other values.

In most OOP programming, we treat errors as exceptions — things that are not part of the computation result. The big difference in FP is that…

In the last post, we learned about immutability and concurrency. In this one, we’ll look at Higher Order Functions and Closures.

If you haven’t read part 2, please read it here:

Higher Order Functions

Higher Order Functions are functions that can take functions as parameters and returns functions as results. Cool, huh?

But why would anyone wanna do that?

Let’s take an example. Suppose I want to compress a bunch of files. I want to do this two ways — using ZIP or RAR format. To do this in traditional Java, we would use something like the Strategy Pattern.

Firstly, I’d make an…

In the last post, we learned about Purity, Side effects and Ordering. In this part, let’s talk about immutability and concurrency.

If you haven’t read part 1, please read it here:

Immutability

Immutability is the idea that a value once created can never be modified.

Let’s say I have an Car class like this:

Java

public final class Car {
    private String name;

    public Car(final String name) {
        this.name = name;
    }

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

    public String getName() {
        return name;
    }
}

Kotlin

class Car(var name: String?)

Since it has a setter in…

Lately, I’ve been spending a lot of time learning Elixir, an awesome functional programming language that is friendly to beginners.

This got me thinking: why not use some of the concepts and techniques from the functional world in Android programming?

When most people hear the term Functional Programming, they think of Hacker News posts yammering on about Monads, Higher Order Functions and Abstract Data Types. It seems to be a mystical universe far removed from the toils of the daily programmer, reserved only for mightiest hackers descended from the the realm of Númenor.

Well, screw that! I’m here to tell…