Programming on dlow's blog

bubble sort and tetrahedral numbers

Wed, 14 Apr 2021 10:17:36 +0100

Today I had a very simple problem in one of my Golang side projects. I have a server that retrieves a JSON array of objects that have the same schema and I want to display them in a server side rendered HTML table on a web page¹. If I had unlimited time, I would probably have started a Create-React-App project and stick in a popular table library that takes care of rendering this JSON object. However, that workflow requires building the Single Page App and then I probably have to embed it in the server. That’s a bit too much effort for me as I wanted something more php-esque.

Using the reflect package

Tue, 15 Sep 2020 22:54:19 +0100

An example of how to use reflect package to access fields of unexported structs in golang

Anti pattern: turning struct into interface

Sun, 24 May 2020 12:44:55 +0100

Previously I wrote about using struct embedding to achieve pseudo inheritance for code reuse. In this post, I want to explore an example of what I think is an anti pattern as a result of the lack of inheritance and how I think it could be better.

In the absence of inheritance in golang, it is very tempting to turn fields into functions of an interface.

As an motivating example, consider the following:

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.

Monadic Boolean 2

Thu, 04 Jul 2019 23:04:54 +0100

Previously, I concluded that using Either[String, Unit] is quite a nice way to compose predicates. Since then I have noticed some other patterns in my code that I would argue is an improvement.

We will still keep the “for-comprehension” style as I find that it makes the code more readable due to the shorter indentation compared to nested if else blocks.

The main difference is rather than defining functions that take the input and produce the monad, we use implicits to turn a boolean (or any other types as we shall see) into the monad we want for composition.

Confusing syntax sugar

Fri, 10 May 2019 22:15:48 +0100

A grave misunderstanding

When I started using Scala, I was very confused by “for comprehensions” for a very long time. My mistake was to treat <- as an “unwrapper”. For example, in the following, <- “unwraps” the collection/container/monad, as expected.

 def main(args: Array[String]): Unit = {
 for { x <- Option(1) } { println(x) } // prints 1
 for { x <- List(2) } { println(x) } // prints 2
 for { x <- Try(3) } { println(x) } // prints 3
 }

We also know that for comprehension is sugar for flatMap, map and withFilter¹. So we can combine enumerators like the following to produce very succinct and elegant code.

Monadic Boolean

Mon, 25 Mar 2019 21:42:51 +0000

The following task is quite common: do something if all given predicates are satisfied and if some predicate fails, make it obvious which failed.

Consider the contrived scenario where we are asked to save a number to the database if it satisfy all our conditions:

def isGood(x: Int): Boolean = isConditionA(x) && isConditionB(x) ...

def usage(x: Int): Unit = if (isGood(x)) saveNumber(x) else doNothing()

Some time later, we notice that some numbers are being rejected, and we have no idea why, so we decide to add logging when a number is rejected. How should we go about it?

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.

Comprehension with filtering

Sun, 25 Mar 2018 18:18:09 +0000

Problem

From 2018 IMOK Cayley Q1:

How many 6 digit numbers are there where the digits are increasing, divisible by 6, and has the digits 3, 4 and 5?

Note that an increasing number is one that is not strictly decreasing. Hence, 11123 is also an increasing number.

Attempt

Let’s start with a procedural code:

def count1():
 res = []
 for i in range(100000, 1000000):
 if i % 6 != 0:
 continue
 if not increasing(i):
 continue
 if not contains345(i):
 continue
 res.append(i)
 return res

def increasing(x):
 c = 0
 for y in str(x):
 if int(y) < c:
 return False
 c = int(y)
 return True


def contains345(x):
 for i in '345':
 if i not in str(x):
 return False
 return True

Filtering

Previously we saw how to combine map into the comprehension. Now we combine filter predicates.

Kata: count in order

Tue, 20 Mar 2018 20:36:25 +0000

Introduction

Problem: Given a list of words, return the list of numbers which represents the number of letters in that word that is the same as its position in the alphabet. Source

Final solution:

def solve(arr):
 return [sum(i == ord(c) - ord('a') for i, c in enumerate(s.lower())) for s in arr]

First attempt:

def solve(arr):
 letters = "abcdefghijklmnopqrstuvwxyz"
 
 def f(word):
 c = 0 
 for (i, j) in enumerate(word):
 if i > 25: return c
 if letters[i] == j: 
 c+=1
 return c
 
 arr = map(lambda x: x.lower(), arr)
 res = list(map(f, arr))
 return res

solve(["encode","abc","xyzD","ABmD"]) // 1, 3, 1, 4
solve(["abode","ABc","xyzD"]) // 4, 3, 1

The lessons

Get rid of lambdas and map

arr = map(lambda x: x.lower(), arr)
# can always be replaced by
arr = [x.lower for x in arr]

A counter can be replaced with sum

c = 0
...
if cond: c+=1
...
# Can be replaced by
sum(cond for ...)

# e.g.
def f(word):
 return sum(letters[i] == j for (i,j) in enumerate(word))

Trick for finding distance of letters

# Instead of hard coding letters, or numbers
letters = "abcd..."
letters[i] == j
# Replace it with
i == Ord(j) - Ord("a")

Conclusion

We have seen how we can use list comprehension to simplify our problem.

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.

Getting started with scala again

Thu, 01 Mar 2018 06:35:29 +0000

Introduction

I started a new job, and I have to write scala. The last time I touched the language was two years ago, for about 2 weeks. My main takeaway then was disgust at the existance of something called the cake pattern.

This series is about me having to start embracing scala, coming from a primarily golang background.

Getting started

I started looking through my book repository, and found a book called Atomic scala. It goes through language features with example, more than the tour provides in my opinion.

More about struct allocation

Wed, 14 Dec 2016 00:17:52 +0000

In Go, instantiating a struct in a function doesn’t always result in heap allocated memory. If you create a struct and it never leaves the function, Go can stack-allocate it. If you create a struct and pass it to another function directly, Go can copy the struct in place, which means it can still be stack-allocated. If you reference it then pass the pointer, now Go has to heap-allocate it, which means more GC.

Getting around generics in Golang

Sat, 20 Aug 2016 10:49:30 +0100

Introduction

Go programmers would know about the lack of generic in the language (even at 1.7 at the point of writing). Technically, Go has generic, append, make, … are some examples. It’s simply not accessibly to normal programmers. The website says that generics are convenient but come at a cost in complexity in the type system, and that it is possible to write code that does what generics would enable. In this article, I want to explore how to replace generics.

The case for typed variables

Thu, 18 Aug 2016 23:00:00 +0100

The case of typed variables

Go has short assignments and the compiler can infer its type.

import "fmt"

func AddOne(a int) int {
 return a + 1
}

func main() {
 x := 1
 fmt.Printf("%v", AddOne(x)) // 2
}

One could have also written

func main() {
 var x int = 1
 fmt.Printf("%v", AddOne(x)) // 2
}

or even

func main() {
 var x = 1
 fmt.Printf("%v", AddOne(x)) // 2
}

So which should we prefer?

In normal cases, x := 1 is preferred as it is concise and clear. However, there is a case for using the latter.

A slice gotcha in golang

Mon, 28 Mar 2016 09:55:20 +0800

Slices gotcha

s := []int{1,2,3}
t := s[:2]
t = append(t, 100)
Println(t) // {1,2,100}
Println(s) // ?

If you’ve said {1,2,100}, good on you! You can just quickly skim through this section.

In go, an array is a contiguous piece of memory that has a fixed length. However, dynamically sized arrays are often more useful for a programmer. Go’s solution to this is slices. A slice is another datastructure that contains a pointer to the underlying array, and two values for the length and capacity.