“Why can’t we just make the button smaller?”

“Well, it’s not that simple.”

“What do you mean? Just make it smaller!

“What about the layout re-flow?”

“The layout what?”

“Yeah. The layout is designed to adjust itself to fit the constraints of the screen its running on. If the button changes its size, the elements around it would change their positioning.

“Can’t we just make it non-responsive for the button or something?”

“We could hack something together but it might break the layout in certain screens. …

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. …

For many of us, this is the first time we’ve all been remote. Here’s how to get by

Photo by Johnson Wang on Unsplash.

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…

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 is the idea that a value once created can never be modified.

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


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;


class Car(var name: String?)

Since it has a setter in…

Credit — julian255 on reddit

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…

MVP is the new black in AndroidDev and there’s about a billion ways to do it.

One common mistake that is oft repeated is that developers keep including way too many activity/fragment lifecycle events inside their presenters ending up destroying the separation between the view and presentation layers. The benefits that MVP provides us — testing, agility and separation of concerns can only be achieved if we keep our presentation and UI layers decoupled.

My fellow developers, You must try your darndest to keep those presenters Android free.

So here’s what I propose

Let’s have only two lifecycle related methods inside your presenters. One will…

Anup Cowkur

Head of UX Engineering at GOJEK

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