As I was reading through the SEPA specification, I found that it was not that simple to check if a UK bank account number was valid or not. If you’re not familiar with UK banks, they don’t use IBAN to transfer money within the UK, but a combination of a sort code and an account number. A sort code identifies the bank’s branch and each account has got an account number. A sort code is a 6 digits number and an account number can be between 6 and 11 digits, but most of them are 8 digits long.

For example, here is a valid UK bank account:

• Sort code: 107999
• Account number: 88837491

Algorithms to check if a UK bank account is valid

A very common way to check if a number (bank account, credit card, parking ticket…) is valid, is to apply a modulus algorithm. You perform an operation on each digit (addition, multiplication by a weight, substitution…), when you reach the end you divide by a specific number and you check that the remainder of the division is equal to something. Seems easy, right? Well, this is not that simple for UK bank accounts. In fact, if you want to go through the official specification on the Vocalink website, you will see that they use 2 algorithms, but they have also 15 exceptions to take into account (and some of them are weird or tricky to handle!). You will need to adapt the way you compute the modulus value according to a weight table also.

From the specification to a package

Reading the specification was interesting, but what really motivated me to code a Go package to solve this problem was the fact that test cases where provided in the specification! What a dream: the specification offers you 34 test cases, and they cover nearly all the exceptions. I jumped on the opportunity, it’s not that often that you are offered with a way to check that what you have done is actually right. In fact, I followed a Test Driven Developemnt aproach and it really guided me during the development and especially the refactoring.

Getting the code

The code is available on GitHub under the MIT license and should be well documented and tested. As always, pull requests and bug reports are welcome!

Here is an example:

package main

import (
    "fmt"

    "github.com/AntoineAugusti/moduluschecking/models"
    "github.com/AntoineAugusti/moduluschecking/parsers"
    "github.com/AntoineAugusti/moduluschecking/resolvers"
)

func main() {
    // Read the modulus weight table and the sorting
    // code substitution table from the data folder
    parser := parsers.CreateFileParser()

    // The resolver handles the verification of the validity of
    // bank accounts according to the data obtained by the parser
    resolver := resolvers.NewResolver(parser)

    // This helper method handles special cases for
    // bank accounts from:
    // - National Westminster Bank plc (10 or 11 digits with possible presence of dashes, for account numbers)
    // - Co-Operative Bank plc (10 digits for account numbers)
    // - Santander (9 digits for account numbers)
    // - banks with 6 or 7 digits for account numbers
    bankAccount := models.CreateBankAccount("089999", "66374958")

    // Check if the created bank account is valid against the rules
    fmt.Println(resolver.IsValid(bankAccount))
}

For the last few months, I’ve tried to do sometimes in my free time what is often called “code katas”.

A code kata is an exercise in programming which helps a programmer hone their skills through practice and repetition.

Basically, you try to solve problems by writing algorithms. If you don’t know what to solve, there are a lot of platforms you can look at to find exercises:
– CodinGame
– Prologin (in French)
– Rosalind (bioinformatics challenges)
– Kaggle (machine learning competitions)

On most of these platforms, you can “play” alone. You are given a problem with detailed instructions, a dataset and an example of the expected output. Your goal will be to solve this problem. You will know if you have successfully solved the problem when you will submit your solution (usually you can use the language of your choice) thanks to automated unit tests.

I like to solve unusual problems, and most of the time they are more difficult than what I work on on a daily basis (at least when you’ve done enough exercices). This is a great opportunity to discover advanced algorithms or to learn a new language. Because you do this in your time it’s always nice to know than these problems can usually be solved in less than 1 hour, and also that you will not need to maintain your implementation in the future! When you’ve successfully solved a problem, you’re done for real 🙂

If you wanna check what I’ve already done, and maybe to see how I’ve done it, I’ve got a public GitHub repository dedicated to this: github.com/AntoineAugusti/katas.

Google Apps Script. Wait…what?

A few months earlier, I discovered Google Apps Script and decided to play with it. Google Apps Script allows you to interact with many Google products (Gmail, Documents, Finance, Maps, Calendar) by writing some code for these apps. The amazing point is that the documentation for Google Apps Script is just awesome. I’ll write it again because it really is: it’s awesome. The documentation is really well written and the Google team provide useful (and so much powerful!) functions. And last but not least, it’s beautiful. Amazing.

An example with Gmail

Once again, a few months ago, I saw on Twitter that a guy was complaining about his Gmail Inbox. This guy received a lot of emails everyday (he said more than 300 if I remember well) and hadn’t enough time to read them all. So he asked on Twitter, “Is there a way to tell people that I just want to read short emails?” and someone gave him just a little script to do so. This script used Google Apps Script and especially the GmailApp class. You can read the documentation of this class here: developers.google.com/apps-script/reference/gmail/gmail-app.

I was excited about that: the code was really beautiful, simple and powerful. So I decided to rewrite it by myself, just to try writing my very first Google Apps Script. Enough talk, here is the code!

Okay, seems cool. How to use it?

Well, my goal was just to show how awesome Google Apps Script could be. I don’t think that you want to use this script for your personal use (unless you’re a very popular person!). But if you still want to use it for you, just go to script.google.com, create a new file, copy and paste the code and try executing it. Google will ask your approval before you’ll be able to interact with Gmail thanks to this code (thanks Google for this security).

Test it, and once you’ll like the way it works, run periodically this code (e.g. every 5 minutes) with a timer by selecting “Resources” > “Current project’s triggers…” in Google Script. Your Inbox will always be super clean 😉

Ressources

Your bible, the documentation for Google Apps Script: developers.google.com/apps-script/.