UberMongoose

Building a Blockchain

Thu, 03 Aug 2017 16:23:12 +0530

There has been a lot of discussion around blockchain in recent times. It’s been touted as a solution for everything from the financial system to aviation maintenance records, but the details of how it works has always been hidden under a haze of magical technomancy. In this article I take a deep dive into what a blockchain is and build a simple (but actual) blockchain from scratch.

The first problem you need to overcome in any research into blockchain is that most of it is mired in the feverish discussion around Bitcoin (or other AltCoins). Bitcoin uses a blockchain implementation for its ledger, but the idea of a blockchain itself is more general. You could use a blockchain for your grocery lists (remember to wear your tin foil hat to the supermarket though).

How Compilers Work - The Problem of Parsing

Mon, 17 Apr 2017 19:51:43 +0530

Parsing is the second stage of compilation, it comes right after lexical analysis. While lexical analysis focuses on breaking down the input text into a set of tokens, parsing focuses on ensuring that the relationships between those tokens are valid. Lexical analysis is about valid words, parsing is about grammatically correct sentences.

The problem with parsing, is that at this point during most discussions, the text moves headfirst into theory - and there is quite a bit of it. To make matters worse, it’s quite abstract and quite disconnected from much of what comes afterwards (namely parser generation). So instead of going theoretical, let’s jump straight into implementing a parser by hand and then come back to the theory. Let’s take a look at an example of the Cunning language.

C# Value Types are Objects

Sun, 12 Jun 2016 16:12:24 +0530

Value types in C# are Objects, but they don’t behave exactly like Objects do. A part of the reason for this is that all value types are implicitly derived from System.ValueType.

public abstract class ValueType
{
    protected ValueType();
    public override bool Equals(object obj);
    public override int GetHashCode();
    public override string ToString();
}

But wait! Structs can’t derive from classes!

At first glance, this seems true. You can’t for example do this:

public class Animal { }
public struct Rat : Animal { }

The compiler wont let you. Yet if MSDN and the C# language specification itself is to be belived, all value types inherit from object across System.ValueType, but Int32 doesn’t seem to mention this fact in its definition.

A Short History of Sorting in C#

Sun, 20 Mar 2016 09:37:24 +0530

Recently, while reading Jon Skeet’s excellent book“C# in Depth” I came across the long and varied history of sorting in the C# language. It provides a tantalising view of how the language has evolved over the years. Apart from being a great example on C# in particular it’s also a good example on how languages have improved over the years to become more expressive, while maintaining backward compatibility with earlier versions.

C# Abstract Properties, Virtual Properties and Access Modifiers

Sun, 21 Feb 2016 16:14:33 +0530

Properties in C# are first class citizens, this means that they can be declared as abstract, virtual, private and protected. This is not the general use case though, most of the time properties are used to encapsulate fields.

class Customer
{
    public int Number { get; set; }
    public string Name { get; set; }
}
 
Customer customer = new Customer();
customer.Number = 9;
customer.Name = "Mrs Lovett's Pie Shop";

n the example above, auto implemented properties are used to aid encapsulation. The C# compiler automatically generates the fields used to store the properties and also the methods used for access. Externally, the properties look just like public fields but are actually implemented as methods. The setters and getters of a property can have different access modifiers.

A Concise Guide to Hiring Good Programmers

Mon, 03 Aug 2015 17:12:14 +0530

The best way to hire a good programmer is to be invested in his or her results. It’s like getting married. You want to be careful to choose the right kind of girl, the kind of girl that you’d want to spend the rest of your life with. Just like marriage, it can make your life as close to heaven or hell as it can get on earth. Here’s how I about it.

How Compilers Work - Lexical Analysis

Thu, 12 Feb 2015 08:20:12 +0530

Compilers are wonderful, if somewhat under appreciated programs. Like the foundations of great buildings, they form the latticework on which modern computing is built. Unfortunately, they have been a bit neglected of late. Writing code tends to be more about innovating and creating exciting new businesses than the actual pleasure of knowing how things work, how to break them and how to fix them again. The modern day queen of compilers, Grace Hopper[1] , started life by taking clocks apart and trying to put them back together.

Emacs - Debugging Code under Linux with GDB

Sun, 04 Jan 2015 10:42:12 +0530

Visual Studio provides a very nice developer experience when debugging code. Emacs, on the other hand, doesn’t really shine in this area. It relies heavily the on strong debugging tools that ship with Linux, particularly GDB. While GDB is powerful and extensive, it’s command line interface is dated, and can come as a shock to a developer used to the Visual Studio way of doing things. Let’s take the play program below, which introduces an obvious bug involving an array overflow which causes stack corruption.

Emulating Classical Inheritance in Javascript

Sun, 13 Jul 2014 11:03:43 +0530

Javascript isn’t a classical language. It’s prototypal, which is a bit like every object being a class in waiting. You can create graphs of objects where one object inherits from another, but the idea of classes doesn’t really exist.

This can be a drawback, specially with code encapsulation. It becomes difficult to hide private implementation details from public interfaces to the object because Javascript provides no native access modifiers. There is however a number of methods for simulating classical inheritance and encapsulation in Javascript while things nice and clean

C++ Constructors and Move Semantics

Sat, 12 Apr 2014 10:12:06 +0530

In order to do almost anything with a class in C++, you need to define a few constructors. If you don’t, depending on usage, the compiler will generate those constructors for you. For example, consider the following code:

class Person
{
public:
    string name;
    int age;
};

The above class does not explicitly define a constructor of any kind and if you don’t use the class at all, the compiler will just ignore it. However on the other hand if you do the following:

CMake Platform Specific Actions

Sun, 22 Dec 2013 10:13:40 +0530

Sometimes you need to link one library on Windows and another on Linux (or vice versa). CMake has a number of variables that allow you to do this easily:


UNIX	TRUE on all UNIX-like OS’s including Apple OS X and CygWin
WIN32	TRUE on Windows including CygWin
APPLE	TRUE on Apple systems. **
MINGW	TRUE when using the MinGW compiler in Windows
MSYS	TRUE when using the MSYS developer environment in Windows
CYGWIN	TRUE on Windows when using the CygWin version of cmake

** Note this does not imply the system is Mac OS X only that APPLE is #defined in C/C++ header files. Obtain more specific system information via CMAKE_SYSTEM_VERSION. I.e. IF(${CMAKE_SYSTEM_NAME} MATCHES “Darwin”) then it’s Mac OS X

Pessimistic vs Optimistic Concurrency

Sun, 15 Dec 2013 07:20:02 +0530

Concurrency is when multiple jobs see incremental progress within the same time period. It may be that the concurrency is parallel where both jobs progress together at the same time or time sliced wherein parts of both jobs are done one after the other by a single processor. Whichever the case concurrency creates problems for shared resources. When there is only one job executing at a given point in time the resource can be viewed as consistent on any access. However when there is more than one job executing then care must be taken to ensure that the resource is consistent across both jobs. Consider the classic example of 2 jobs which both increment a single counter.

CMake find_package

Wed, 04 Dec 2013 10:05:36 +0530

In the last scroll on CMake we discussed adding libraries that you write to your own code. This time, we look at using third party libraries out of the box. This turns out to be fairly easy with CMake - though there are exceptions (alternatively spelled “bugs”). Adding a third party package such as the precious Boost libraries for C++ is fairly easy with CMake. In your CMakeLists.txt file add a call to FIND_PACKAGE like so:

Redis vs Azure

Sat, 12 Oct 2013 09:32:22 +0530

Redis and Azure table storage have a lot in common. Both have no schema’s enforced on the objects that they store. Both have limited complex query capabilities and both are touted as being “post SQL” storage. However there is one major difference between the two that tends to dampen comparisons and that is how they deal with concurrency.

Redis deals with concurrency by queuing requests and handling them one at a time. This allows for single instance Redis servers to deliver impressive performance and a bunch of nice features like set intersections and unions. On the down side this limits the scalability of a single Redis instance because you are stuck with just 1 thread doing the actual work.

High Performance Code - Make No Assumptions

Sun, 18 Aug 2013 09:40:51 +0530

Concurrent bear – parallel fish

Often when writing high performance code one can fall into the trap of making assumptions about the nature of the problem. Donald Knuth said “Premature optimisation is the root of all evil”. If that is the case then prejudiced optimisation is the seed.

I learned the bitter lesson myself. Recently while building an architecture to support crunching what I thought was a moderately large amount of data I made the mistake of designing it with multiple threads of execution. At the beginning my rationale seemed quite sound as many have postulated that the performance gain to be had from single threaded execution of code is limited. The architecture that I was building involved a fast in memory key value store called Redis as one of it’s pieces. Unfortunately in the case of Redis the opposite was true. Because it’s often expensive to synchronise between threads and because in the normal use case for Redis the bottleneck was the network and not the CPU it’s authors decided to make it a single threaded application taking and serving requests off the wire one at a time. However it can handle multiple clients at a time, that is it is a program that supports concurrency but that’s not the same thing as parallelism.

Emacs - Frames, Windows and Buffers

Mon, 29 Jul 2013 16:10:20 +0530

First for some terminology. What Emacs called “frames” is what everyone else now calls windows. This is because Emacs started out as a full screen terminal tool and GUI’s came along later and because of that what Emacs calls windows is now what most visual studio programmers would know as split views. You can experiment with creating new frames, which are by default bound to [C-x 5 2] and deleting the created frame by selecting it and pressing [C-x 5 0]. It’s like opening a new instance of visual studio except that your on the same project as you were when you opened it.

CMake add_library

Mon, 29 Jul 2013 09:57:52 +0530

In the last post we built an executable from a source file and a header only library. However, sometimes we need to build shared library binaries that can be linked into an executable. This is fairly simple with CMake. Instead of using add_executable like the last time we now simply need to use add_library like so:

# Sources 
file(GLOB Library_SOURCES *.cpp)
file(GLOB Library_HEADER *.hpp) 

# Executable
add_library(LibProject ${Library_SOURCES} ${Library_HEADERS})

CMake will now get the build system that you choose to create a shared library that can be linked into an executable one. You would end up with .lib files with Visual Studio and typically .a files with Unix make. Note that the name Library_SOURCES is chosen for clarities sake. The variable can be named anything.

CMake Include Directories

Sat, 20 Jul 2013 11:19:39 +0530

To do almost anything today with C++ requires the use of a number of different third party libraries. Some of these come in the form of header only libraries containing only include files (.h and .hpp). The references to these libraries are easy to resolve with CMake, let’s contrive an example.

Consider the following folder structure.

[CMakeHome] [CMakeHome]\src
Contains all the source code for the project

[CMakeHome]\headerlib\
Contains a small header only library with a number of different applications

CMake The Beautiful Beast

Wed, 17 Jul 2013 09:17:29 +0530

CMake is a mix of things. It’s a cross platform makefile generator that makes porting your C/C++ code from one OS to another or from one compiler to another inside the same OS really simple. However it complicates things a bit as well as now you need to write an extra “CMakeLists.txt” file for each of your code directories in order to allow CMake to generate those files for you. It doesn’t really help that the CMake documentation is rather dense and that there are a number of caveats that you really don’t see until you get to actually implementing it. Learning CMake therefore can be a harrowing experience and sometimes you might be tempted to give up half way and stick to the warm consolation of the Visual Studio IDE. That’s where this guide will hopefully help you as a starting point in your CMake journey that is not too steep to learn.

World War and Economic Unions

Wed, 03 Jul 2013 16:13:26 +0530

It’s interesting that when the European project kicked off it was against the backdrop of the end of the second World War. Europe had seen two world wars within a generation with much resultant suffering and destruction. There must have been an urgency therefore to stop a third from happening on the continent by creating a pan national entity that binds many nations together.

Perhaps the thought was that if one nation desires to start a campaign of aggression against another – if the cost of the aggression would hit home very quickly because of mutual economic dependence then the desire for such an aggression would quickly fizzle out in the home nation.

CMake Trickery - Platform Specific Linking

Wed, 26 Jun 2013 08:52:57 +0530

Quite often when your working on cross platform code you need to build applications that use one set of libraries when compiled under Microsoft Windows and another set when compiled under Unix/Linux. Fortunately CMake is a cunning tool to help you on your way. It has a bunch of predefined constants that you can use to switch libraries based on the platform like so:

# SomeCoolLibrary
IF (WIN32)
   message(STATUS "Building on Microsoft Windows.")
   set (SomeCoolLibrary someCoolWindows.lib)
ELSEIF (UNIX AND NOT MINGW)
   message(STATUS "Building on Linux/Unix.")
   set (SomeCoolLibrary someCoolLinux.so)
ENDIF()

Notice we check for the enviorenment being Unix but not MinGW. This is because CMake reports the enviorenment as Unix even if it’s MinGW running on Windows (which I suppose makes sense), but it pays to be specific. Finally you can target the generic link library that you’ve mentioned here:

Unicode on Linux

Sun, 26 May 2013 14:52:45 +0530

At first the place of Unicode in Linux looks simple. It is deceptively so. Linux C/C++ has support for both char and wchar_t. Let’s take a look at the char version:

#include <cstring>
#include <iostream>
 
int main(int argc, char* argv[])
{
    const char text[] = "Άλφα";
    std::cout << text << std::endl;
    std::cout << "sizeof(char): " << sizeof(char) << std::endl;
    std::cout << "sizeof(text): " << sizeof(text) << std::endl;
}

This results in the output:

Άλφα
sizeof(char): 1
sizeof(text): 9

Notice that the console prints out the characters correctly and that the size of a char is 1 byte. On the other hand the size of the text buffer is 9 bytes, though manifestly it only contains 4 (+1 for the null terminator). The reason for this is that each character is encoded as a couple of UTF-8 characters. This is important. All char buffers in Linux supports Unicode by default because GCC by default encodes literal text as UTF-8 streams. On the down side now some of the old string handling functions – for example strlen – which are not UTF-8 aware start returning bovine excrement as results and require replacement but we will return to that.

The Configuration of Emacs

Wed, 08 May 2013 16:14:33 +0530

Emacs can only be configured naked by moonlight.

I kid, I kid – the moonlight is optional.

Emacs has a number of “modes”. Much has been said about them on the interwebs so I’ll take the easy way out and link to a such an article.

There are as you would have seen two kinds of modes, major modes and minor modes. Major modes change what Emacs believes is the content, for example there’s a major mode for C and a major mode for Python. Minor modes allow small changes in behavior in any content. CUA-Mode is a minor mode that does some trickery to allow C-c and C-v copy and paste like on the venerable Microsoft Word. It can be enabled by the command M-x followed by typing cua-mode in the mini buffer at the bottom of Emacs. However you don’t want to be manually typing that in every time you start emacs so you put some initialization settings in your Emacs init file.

Emacs Key Bindings

Wed, 01 May 2013 16:14:33 +0530

Emacs is like your average dragon, very cranky before breakfast and set in its ways. Take for instance the key bindings. For you to do anything – and I mean anything at all you need to type in an arcane set of shortcut keys, like for instance the basic Control Meta X, Control Sacrifice Goat, Enter Enter, Control F command which launches the built in dishwasher. You might be tempted to change the key bindings to better suite the feel of your windows environment but that is not a very good idea for the vast majority of cases.

The Bumpy Road to Emacs

Sat, 20 Apr 2013 16:14:33 +0530

The Road goes ever on and on
Down from the door where it began.
Now far ahead the Road has gone,
And I must follow, if I can,
-Bilbo Baggins, The Fellowship of the Ring

Sometimes the completely respectable Visual Studio programmer is called upon to follow the arduous road to places unknown where danger and dragons await him at every turn. One such dragon is called Emacs the Keybinder and subduing this beast requires a great deal of effort to those who have lived in the relative comfort of Visual Studio land.

Big Data and Intelligent Machines

Thu, 31 Jan 2013 16:12:25 +0530

Big data has been getting a lot of attention lately as a field in computing that could significantly increase the value of the vast amounts of data that are captured by digital networks and devices. Phrases like “Data is the new oil.” has been flying around glibly for a while now but it’s difficult to extract the truth from the vast amount of data on big data that’s out there. It sounds like a job for Big Data… but I get ahead of myself.

The pImpl Idiom – Hiding Private Implementation Details

Thu, 17 Jan 2013 16:16:31 +0530

One key principle behind the design of classes is that of the encapsulation of the implementation from the clients using the code. Here a client is any bit of source code that uses the classes that you write. C++ provides an imperfect implementation of this idea in the way it defines rules for classes. Consider the following class which is declared in event.hpp.

#include "system_clock.hpp"
 
class Event
{
 
private: 
    SystemClock mClock;
    std::string mMessage;
 
public:
    Event(std::string message);
    ~Event();    
};

The Event class models an event that can happen at some point in time. It uses “system_clock.hpp” which defiles a class called SystemClock to see what time it is. Notice that both the message and the current time as defined by the member variable mClock in Event is private. This should mean ideally that any changes to the variables in the private section of the class is not exposed to the client code and indeed to an extent it is. No client can create an instance of Event and then access it’s private members like so:

Sociable Programming

Mon, 10 Dec 2012 10:42:43 +0530

Programmers are not known to be social creatures. It’s an unfortunate reputation really, considering that programmers spend most of their lives writing their thoughts to each other - they should be right up there in the social landscape with Paris Hilton and Lady Gaga. The problem of course is that programmers never recognise the social aspect of their work. They think they write code for computers. Nothing could be further from the truth.

Step on that Code

Sun, 02 Dec 2012 16:09:10 +0530

In Sociable Code I mentioned that an often overlooked consideration when writing code is the strain that it puts on the programmers who end up reading it. Difficult to read code tends to mash the wetware and end up causing more bugs and longer resolution times. One way to reduce that effort is to write code that would make control flow explicit when being stepped through with a debugger. Take a look at this bit of code. I came across it during a foray into a rather well known programming site. I have endeavoured to anonymise the code but the key piece has not lost it’s form.

Unicode and Windows

Tue, 06 Nov 2012 13:46:55 +0530

Unicode string support in Windows is a strange beast.

When Microsoft hired Dave Cutler and others to write a new OS for them they were thinking about writing a new version of OS/2. In fact the new Microsoft OS was a combined effort by Microsoft and IBM that would have resulted in OS/2 version 3.0 if not for the success of Microsoft’s own Windows 3 which made them reconsider that approach. At the eleventh hour they shifted their API from the extended OS/2 API that was to be the way things got done on the new OS to an extended version of the Windows API. This last minute change was possible due to some clever trickery on the part of the programmers who wrote the new Windows OS but it resulted in a strange API, especially when it came to string handling in the new OS known to history as Windows NT 3.1.

Unicode

Fri, 12 Oct 2012 09:32:22 +0530

For many years programmers and strings existed in a state of balance, as much balance as could have been possible under the constant threat of undefined behaviour that sociopathic string functions threatened in any case. It was not to be however for their lives of relative stability was forever changed with the advent of Other Languages into string buffers. In this part of our continual study of strings we delve into intriguing world of internationalisation, multi byte character sets and Unicode.

The Private Lives of Strings

Sat, 15 Sep 2012 16:14:33 +0530

Ah, Strings. Surprisingly simple for most C# and Java programmers yet so complex for those of us left behind in the world of C and C++, Strings are perhaps one of the strangest beasts in the programming landscape. Yet they began so simple, perhaps deceptively so like a chameleon on a plain coloured leaf waiting to deceive the observer with its next background. Yet I have tracked this beast down through the ages, yea, verily I have identified its habits and its lair and here I present to you in true Attenboroughish fashion the Private Life of Strings. To understand the habitat of strings one must go back to their distant ancestors. The typewriters.