Java on dlow's blog

Struct embedding as implicit composition

Fri, 22 May 2020 11:26:33 +0100

In programming, the principle “don’t repeat yourself”, DRY for short, recommends that we try to reuse the same implementation where possible. In this post, I will cover what it’s like to do it in golang through struct embedding and my personal thoughts on that pattern.

Golang struct embedding

One common way of code reuse is inheritance. In Java, we can do this by implementing a method on the parent class, then subclasses will inherit this implementation.

Logging in scala and java

Fri, 05 Jul 2019 23:29:27 +0100

A logging framework is superior to just using println because it can support

Log rotation (for daemons)
Configurable log format
Configurable log level

There are several libraries to use when it comes to logging in Java. For the practical programmer, the important things to note are

What to include in the dependency resolution tool. e.g. sbt, pom, gradle.
How to configure the logger. By default the configuration is usually found in the resources directory. e.g. src/main/resources.

Java

Java util logging

This is included in the JRE. Configuration is done by setting the system property java.util.logging.config.file=logging.properties. Docs

Class Design for Maintainability

Sat, 23 Mar 2019 10:44:17 +0000

In this essay, I want to explore the topic of how to write classes that can be easily extended/maintained for the future. We would like to design classes in a way such that it is easy to implement a new class as well as add functionality. We shall explore some of the common patterns for this.

The problem of extending classes

Suppose we have the following model:

abstract class Animal{}

class Cat extends Animal {}
class Human extends Animal {}

You are asked to count the legs of a collection of animals:

Strategy Pattern

Thu, 07 Mar 2019 20:53:55 +0000

Goals:

When the number of strategy changes, we want to minimize change. When the implementation of a strategy changes, we want to minimize change.

Case study:

Mode of transportation
Representation of a data
Behaviour of an actor
Trading algorithm

Entities/Objects involved

There is a strategy interface encapsulating the behaviour
There is a context which wraps the strategy and is responsible for getting the data to apply the strategy on.
There are implementation of the strategy interface.

Motivating problem

Suppose you have a set of datapoints, and you want to visualize them. You can either visualze them as a frequency graph, or as a time chart.

8 Weeks into Java and Scala

Sun, 15 Apr 2018 02:19:36 +0000

This post contains some thoughts I have after working with Java and Scala professionally for 8 weeks. The content assumes the reader has some experiences writing Java/Scala code.

Starting from scratch

There are several components a learner must understand before he/she can get productive.

An easy installation process, preferably something along the lines of download something, extract or run an installer, modify the user path if necessary. I think anything more than that is asking too much from the user.
An intuitive package manager. Golang comes with go get and go install. Node has npm, Python has pip, and Java has maven, ant, gradle. In my opinion, Java is probably the least beginner friendly for setting up.
The syntax (literal or not) for initializing common datatypes such as list/array, map/dictionary, and for manipulating data.

Java

Java requires good mastery of the IDE

From compilation to running the program, the IDE is immensely important.¹ The IDE, I use intelliJ, have probably generated more code than I what I physically typed. I feel that half of knowing Java is knowing which shortcuts to press in the IDE. The following are the shortcuts that bring me pleasure when I use them.

Java variance, covariance

Wed, 28 Mar 2018 23:50:26 +0000

Introduction

Many langauges support subtyping - this allows us to express that a type Apple is a subtype of Fruit. Notationally, we say T < S. Subtyping manifest itself as subclass in most programming language concepts.

Suppose we have the following:

class Fruit {}
class Apple extends Fruit {}
class Orange extends Fruit {}
class GreenApple extends Apple {}

Then we have Apple < Fruit. In simple English, we can think of this as whenever we expect a type Fruit, we can use the type Apple. Or think of it as an Apple is a Fruit.

How to do common tasks in Java

Mon, 19 Mar 2018 21:49:03 +0000

Gulf of execution

In his book The design of everyday things, Norman introduced the terms gulf of evaluation and gulf of execution. The latter is the difference between the intentions of the user and what the system allows them to do or how well the system supports those actions.

This describes perfectly my experience as I moved from Golang to Java.

I find myself asking questions like:

What is the least painful way of iterating over a map?
How do I make lazy functions?
How do I run something in a different thread?
How to get the path of folder and files?

This post documents my learning through my struggle.