erj.me

Moving

Mon, 01 Feb 2016 21:39:59 +0100

It’s been a while since I wrote anything here. As usual, my inspiration for stuff like this is extremely periodical.

Since last time I posted, me and my wife have been in the process of moving from Sweden to the UK. We’re leaving for Bristol tomorrow morning, to be more specific. Our current plan is to live and work there for approximately half a year.

We’re going to be posting updates on a common blog I set up for that. My current idea is that I will cross post any interesting stuff here. We’ll see if I stick to that. The other blog will be in Swedish though so the cross posted posts are going to be in Swedish as well.

Thoughts on SpaceX

Tue, 30 Jun 2015 08:30:53 +0200

I’ve been wanting to write down my thoughts about SpaceX for a while now. More precisely, ever since I read Phil Plait’s article about visiting the SpaceX headquarters. The accident last Sunday, where a Falcon 9 burned up shortly after takeoff, triggered me into sitting down and actually write them down.

Plait’s article is really worth a read if you haven’t done so. In it, Plait summarized his discussion with Elon Musk about the reason for starting SpaceX. For the uninitiated, the goal of SpaceX is formulated as the following on their website (my bold):

The company was founded in 2002 to revolutionize space technology, with the ultimate goal of enabling people to live on other planets. spacex.com/about

Plait joked about Musk having founded SpaceX because he wanted to retire on Mars, which Musk quickly corrected. That was just something he said when a journalist was pressing him for a quote. When Plait asked what the actual reason was, Musk answered simply:

Humans need to be a multiplanet species. Elon Musk

Not “should be” or “it would be nice if we were”. No, we need to be a multiplanet species for our longterm survival.

This resonated quite strongly with me. Even if we set aside the blatant disregard we’re currently showing for the only Earth we have, there are still a multitude of natural disasters that can wipe us out from the universe’s timeline. Basically, we need an off-site backup for humanity in order to secure our longterm survival.

With this goal in mind, the work SpaceX is doing is extremely important on a larger timescale. Which is why I was saddened by Sunday’s accident (imagine then how Elon Musk is feeling, it happened on his birthday, really crappy birthday present). Currently, it looks like there was a problem just before the first stage separation was to take place. SpaceX hasn’t yet released any info other than Elon Musk’s tweet:

There was an overpressure event in the upper stage liquid oxygen tank. Data suggests counterintuitive cause.
— Elon Musk (@elonmusk) June 28, 2015

I hope this doesn’t hamper SpaceX’s progress too much. The work they’re doing is really important and the whole of humanity would be poorer for it, should they fail.

I'm An Average Programmer

Fri, 26 Jun 2015 21:21:46 +0200

Jacob Kaplan-Moss’ keynote at PyCon 2015 has got to be one of the best keynotes I’ve watched in a very long time:

As you’ll learn when you watch the keynote (yes when, not if, go do it now!), he is a core contributor to Django and an ultra runner. You really should watch the keynote before reading my thoughts — they will seem even more like incoherent ramblings if you don’t. (I blame the whiskey I’ve had tonight, or possibly the 90s music playlist Spotify suggested for me.)

The main point of his presentation is that there is a perception problem in the programming industry. We deify this highly improbable rock star programmer, we expect everyone to be all-knowing yet specialised, we are too fixed on the idea of programming as a talent and that most programmers are either awesome or crap. Naturally, this leads to, or at least contributes to, a number of problems:

Difficulty attracting new people to the programming industry.
The entire industry is full of misogyny and discrimination of minorities.
It promotes unhealthy working habits and bad work life balance.
It promotes the image of a programmer as a young, white dude.

Pretty much all of what he said resonated with me, although I hadn’t really thought about it in those terms before I watched the keynote. I’ve had personal experience with the unhealthy working habits. The expectation that I should be available for work calls at 9PM on a Sunday evening bothers me immensely. Valuing free time highly should be okay.

Part of the problem is probably that programming is a very young industry, most of the people I know that work in older industries are not expected to work evenings or weekends. Being an okay employee is accepted, as long as you perform your duties.

The misogyny and discrimination problem deserves an article all on its own (and indeed I’m trying, and currently failing, to write one). I recently purchased the essay collection Your Startup is Broken from Model-View-Culture, which I decided tonight I’m going to read this weekend. It’s obviously a problem, the fact that my office has 3-4 women (not including secretaries) among 30-40 employees is a horrible disparity.

Quotes

These are some quotes I particularly liked.

There’s a voice in the back of my head that’s telling me: “You don’t deserve to be here. Look at the amazing people you shared this stage with. Who are you? What did you do to get up on stage with them? You don’t belong in this company. You don’t deserve this success.”

This definitely felt familiar to me. It made me think about impostor syndrome, which I most definitely suffer from.

Because programming is something you are in this myth, not something you do. The truth is that programming isn’t a passion, it isn’t a talent. It’s just some things you can learn.

No doubt this is true, he points out that this is one of the few fields where this is the case. No one assumes that people are born with the ability to run a marathon – that’s what training is for. Why would we think it’s different for programming? It’s a set of skills to learn and improve.

If we embrace this idea that it’s cool to be okay at these skills, that being average is fine, it’ll be less intimidating for newcomers. If we set the bar for success at “okay” rather than at “exceptional”, that bar seems a lot easer to clear for people new to our community.

Wrap up

All of this is presented much more eloquently by Jacob Kaplan-Moss during the keynote, so really, watch it if you haven’t yet.

Without further ado, here’s the reason I started writing this post. I’m joining Jacob Kaplan-Moss’ call to action: I’m an average programmer. I’m okay at programming and that’s okay.

UK vs. Swedish Voter Representation

Mon, 18 May 2015 15:10:44 +0200

I listen fairly religiously to the Hello Internet podcast with Brady Haran and CGPGrey. In the most recent episode, they discussed the recent UK election and how badly the UK voting system works to fairly represent the actual distribution of votes. This piqued my interest so I thought I would investigate how well Sweden performs in this regard.

Right off the bat (after refreshing my memory on how our voting system works…), I realized this wouldn’t really be a fair comparison. In order to understand why, get ready for a…

Crash Course in the Swedish Voting System

If you’re not interested in this part (why wouldn’t you be?!), you can skip down to the actual comparison. Although it might not make as much sense if you skip this.

Sweden’s allocation of seats in the Riksdag¹ is explicitly designed (with some minor caveats) to be proportional to the number of votes each party has received. The UK on the other hand, uses First Past the Post voting which is what causes their representation disparity.

The basic system we have is fairly easy: The country is divided into a number of constituencies (historically there have been different number of constituencies but we currently have 29). There are 349 seats in the Riksdag, 310 of which are fixed constituency seats. These 310 seats are divided between the constituencies in relation to the number of people eligible to vote in each constituency. The remaining 39 seats are adjustment seats which I’ll explain a little later. To be in the running for any seats at all, a party needs at least 4% of the national votes or 12% in any single constituency.

In order to understand how seats are appointed to the different political parties, we need to make a …

Detour to the Sainte-Laguë method

The method used to calculate how many seats each party should receive is called the Sainte-Laguë method. Actually, Sweden uses a modified Sainte-Laguë method but the basics are the same. I’ll just explain it briefly here so if you’re interested in the specifics, read the Wikipedia article.

Sainte-Laguë is an iterative method. For each iteration, you calculate a quotient for each party according to the following formula:

quot = V / (2*s + 1)

Where V is the number of votes the party has received and s is the number of seats the party has been appointed so far. The party with the largest quotient is awarded the seat in this iteration. Looking at the equation, it’s obvious that the quotient is equal to the number of votes in the first iteration. This is where the modification Sweden has made comes in: For parties that has received zero seats, their vote count is divided by 1.2 instead of 1.

It’s important (for the charts later in the article) to note that there was a recent change to the election law in Sweden. Previously, the vote count in the first iteration was divided by 1.4 instead of 1.2. However, this change was voted into law after the 2014 general election so the results I’ve looked at below uses the old value.

Appointing seats in Sweden

When votes are counted in each constituency, the Sainte-Laguë method is used to appoint the seats in the constituency.

When all the votes are counted and all constituencies have appointed their seats, the number of seats each party has received over all constituencies is tallied up. Next, the Sainte-Laguë method is used to simulate assigning all 349 seats but this time with the entire nation as a single constituency. The number of seats each party has received in the two different assignment processes is compared to see how good the representation is at a national level.

This is where the 39 adjustment seats come in to action. The parties that have received too few seats when the 310 fixed seats were appointed are given an adjustment seat in the constituency where it’s quotient is still largest after the 310 seat appointment. Conversely, if it has received too many seats, one is returned in the constituency where the party has the smallest quotient. One interesting note is that the appointment of the adjustment seats is done using the non-modified version of Sainte-Laguë.

Also, to preempt any comments about it: Yes, we can vote for specific persons in each constituency as well. I’m not going to dive into that process though, I’ll have to save you some rabbit holes to go down over at Wikipedia.

Wow! If you’re still here, you must be at least as much of a geek as I am. Now, onto the promised comparison between the UK and Sweden:

Comparison

Without further ado, here are the charts for Sweden:

You can look at the full Google Spreadsheet here. For reference, below are CGPGrey’s original charts for the UK. You can also look at his Numbers spreadsheet.

I must say, I was pleasantly surprised that our representation is as good as it is. You can see the fact that smaller parties are punished somewhat while larger ones are rewarded (which is the system working as intended) but overall, the representation is really good. Since parties need to be above the 4% mark to even be considered for the seats, I really should have removed the ones below that line in the left chart but I don’t really feel like it.

People naturally have opinions about the Swedish system as well. There is some legitimate criticism that smaller parties are punished while larger ones are rewarded. This comes from a combination of the 4% barrier and the modification we have to the Sainte-Languë method. I can see the merit of this criticism but I think the system has to promote larger parties. A legislature with too many small parties could be problematic. In my opinion, this system strikes a good compromise between fair representation and practicality. At any rate, it’s definitely better than the UK system!

Reference

If you want to have a boring evening of reading, I would recommend the Swedish election law, that’s where I got my information from. Unfortunately, there are no English translations of the current law so you have to be able to speak Swedish to understand it.

If you want to discuss any of this with me, you can find me on Twitter.

The national legislative body of Sweden. ^[return]

My Problems With Photos For OS X

Tue, 28 Apr 2015 07:21:18 +0200

I’ve had a really bad first impression of the new Photos app for OS X. My scenario is a bit of a corner case but it shouldn’t be a hard problem to solve if Photos were even a tiny bit less stupid about a couple of things.

Scenario

I don’t want to use Photos to actually organize my pictures on the file system. I also don’t want to use Photo’s iCloud sync. The reason is that I have a heterogeneous set of devices and computers at home and as a result, I already have a system for managing my pictures that works on all these devices. If I would go all in on Photos, I would have a hard time using the same library on my Linux, Android and FreeBSD systems. (I also have a bit of a philosophical issue with trusting my entire library to a single program.)

So if I already have a system, why would I want to use Photos at all? Basically, there are two things I want from Photos:

Marking photos I love as favourites.
Tagging photos with faces so I can find for example pictures of me and my fiancée for the calendar my family does every year.

These features are nice enhancements to my library but not so crucial that I want to give my entire library over to Photos.

My current system involves manually creating folders for my pictures, grouping them by capture date and naming the folder with something descriptive. It’s fairly easy to maintain and since I don’t use any special program, I can simply rsync my pictures between my different computers (and server) and all of them are able to display them natively. The only part I’m missing is the two points above.

I’ve thought about actually copying the Masters directory in the Photos library to the other systems but the problem is that the pictures in that directory are arranged according to import time. This means that I would loose the ability to easily list all the pictures taken on a particular day or event on the non-Apple systems — a deal breaker for me since that’s how I usually look at my pictures.

Photos does support referenced libraries which I thought I could use to achieve what I wanted (and I could if it wasn’t such a brain-dead implementation). In a referenced library, no pictures are actually copied to the library during an import. Instead, Photos keeps a reference to where in the file system the pictures actually exist.

Problem

I launched Photos, opened its preferences and unchecked the “Copy items to the Photos library” check box. I then began importing all my pictures — a modest 66GB. At first everything seemed to go well so I left the computer and went to help some friends who were moving. When I got back a couple of hours later, Photos was done importing and had finished running facial recognition on all pictures. I opened Finder, curious to see how big the library had become (it’s just references, shouldn’t be more than a couple of gigabytes, right?).

Before I even got to the ~/Pictures folder, I noticed something wrong: I was down to under one gigabyte of disk space left. With suspicion, I clicked on the Photos Library.photoslibrary file (a fairly annoying name for a file that isn’t even a file) and waited a second for Finder to tell me how big it was.

60GB?! What on earth happened here?

After some research, I found that some other people had had the same issue. The conclusion they came to was that it seemed to be related to facial recognition in some way. The directory in the Photos library that had expanded uncontrollably was resources/modelresources. The folder contains a lot of full-size copies¹ of my pictures but cropped in some way, often cropped on peoples faces².

I don’t know how things are implemented behind the scenes but apparently, none of the Apple engineers are constrained by disk space (or alternatively, have significantly smaller libraries than I do). It’s especially frustrating since it would be fairly resonable to assume that a person that chooses to use referenced libraries already have a copy of their pictures and doesn’t necessarily have that much disk space left. Uncontrollably gobbling up disk space seems like a bad design decision in this case.

Until this rectified, Photos is basically useless for me. I don’t want to give up that much disk space just to have the convenience points listed above.

Thoughts About a Space Efficient Alternative Solution

As a programmer, I began thinking about the least amount of information I would need to store in order to keep track of which people are in which pictures. Note: This is a rough idea and undoubtedly, someone will find a problem with it. It also only handles face detection and doesn’t concern itself with thumbnails and other things needed in the library.

Let’s assume our facial recognition algorithm returns a list of the positions (x1,y1,x2,y2) of faces in each picture it processes. We then ask the user to identify which person belongs to which face so we can attach a name (and some form of unique identifier) to each face. This would give us the following information to keep track of for each detected face:

A UUID representing the person this face belongs to.
A tuple (x1,y1,x2,y2) representing the rectangle of the location of the face in the picture.
A reference to the picture.

This would allow us to:

List all the pictures a specific person is in.
Show the location of each face in each picture.
List all faces in a particular picture.

This covers all the functionality Photos provides for faces. We’ll assume a UUID is 128 bits and each position coordinate is 64 bits (a bit overkill, yes). The reference could be an absolute path to the picture which would make it hard to estimate its size. Lets say its 32 bits for each character and max 500 characters long (the paths to my pictures would easily fit in half of that). This would mean a maximum of 128 + 4 * 32 + 32 * 500 = 16 256 bits for each face.

Allowing for an average of 3 faces in each picture (probably high for my library), this would mean that the library would take up 3 * 5400 * 16253 = 263 298 600 bits ≈ 32 MB with this method.

Caveats

Note that this (deliberately) doesn’t say anything about the data structures used to store the information. In reality, we would need to keep it in some sort of database with indexes that allows us to look up rows by UUID or picture reference quickly. This would undoubtedly mean a larger library than I have calculated above but it would probably still be possible to stay under 1GB.

Yes, copies, not hard links as some forum posts claim. The inode count for the files in that directory is 1, meaning those files are the only reference pointing to that inode.
^[return]
This is what lead people to think that modelresources has something to do with facial recognition. Although not all pictures in my modelresources were of faces.
^[return]

Why I Don't Hate Git: Hidden Consistency

Wed, 08 Apr 2015 12:39:11 +0200

This post resonated quite well with me and explains why I have a harder time learning Mercurial than I had learning Git.

This Industry Is Still Completely Ridiculous

Tue, 07 Apr 2015 10:59:12 +0200

This is a great article on TechCrunch about how the technology industry is a bit weird. A lot of stuff made me laugh throughout the article.

And we we were all faced with the hilariously terrifying possibility that technology is now moving so fast that the US government can no longer distinguish a rogue state with nuclear weapons from a gang of trolls in it for the lulz.

Another one:

Maybe this kind of florid bureaucratic surreality from their online guardians is why both the US president and the UK’s prime minister have called for math to be banned, lest their surveillance states be blinded. No, really. Encryption is just math, folks. And making math illegal will obviously stop terrorists. Right?
ISIS guy 1: I know, let's use cryptography to hide our messages! ISIS guy 2: We can't, it's against the law in the UK. ISIS guy 1: Oh, OK.
— Mustafa Al-Bassam (@musalbas) January 12, 2015

Thoughts About Moto 360

Thu, 02 Apr 2015 18:13:04 +0100

When I graduated from university last summer, my fiancée and her family were very nice and bought me a smart watch as a graduation present. Knowing that I’m a bit picky about my technology items, instead of buying one directly, they gave me the money to buy the watch I wanted. I had my eyes on the Motorola Moto 360 which meant that I had to wait for a a couple of months since it wasn’t available here in Sweden at the time. As soon as I could, I ordered it and I’ve been wearing it daily since mid-January.

This post is a collection of my thoughts about the watch interspersed with images of it when I unboxed it.

Replacing a Regular Watch

I was wearing a regular watch before buying the Moto 360. The regular watch is actually better at two things: battery life and displaying time (really?). I’ll get to the battery life later in the post but the reason the Moto 360 is worse at displaying time is that the screen is turned off after a while. This is slightly annoying since it takes the Moto 360 a fraction of a second to wake up when I look at it which isn’t a problem the regular watch has.

Even more annoying is that sometimes, the watch face doesn’t wake up at all when I look at it. This happens so infrequent as to be tolerable though, I simply flick my wrist again to wake it up. I also enabled Ambient Screen recently which seems to alleviate the problem completely. I’m hoping it won’t eat too much battery so I can leave it on as my new default. Speaking of battery…

Battery Life

Some early reports on the Moto 360 were complaining that the battery life was terrible. That couldn’t be further from my experience—I often take it off when I get home after a whole day with 60–70% left. That’s with Ambient Screen turned off though. For reasons you’ll see below, I usually sleep with the watch on me as well and usually only charge it in the morning while I do my morning routine. It charges incredibly fast (possible because the battery is small) and is usually fully charged when I leave home.

Most Useful Features

The rest of the article is a list of the most useful features of the watch from my perspective, ordered by their usefulness.

Silent Alarm

This is by far the most useful feature for my fiancé (and me). I use Sleep as Android as my alarm clock app. It features some nice sleep tracking capabilities which uses the watch’s accelerometer but the real killer feature is the silent alarm. A couple of seconds before my alarm is about to go off, the watch starts to vibrate slightly on my wrist. This wakes me up so I can turn off the alarm just before it makes any sound.

My fiancé is very thankful for this since I’m a heavy sleeper and she’s not. I used to have fairly loud alarm signals which almost woke her up with heart palpitations in the mornings (not a nice way to wake up). Now, she doesn’t even wake up before I (stupidly) step on the creaky floor board as I’m tiptoeing out of the bedroom.

Runkeeper

I track my runs with Runkeeper which is an awesome app. However, it’s a bit cumbersome to get the phone out of my pocket every time I want to see how far I’ve run. With the watch, I can see the distance, duration and pace of the run on my wrist. This has been even more useful since I had an accident with my old Nexus 4 and bought a Nexus 6—it’s much harder to get the Nexus 6 into and out of the pocket of my running tights.

Pocket Casts

I like that Pocket Casts displays a persistent notification on the watch when I’m listening to podcasts. The notification has controls for pausing, skipping and changing volume. Having these controls easily accessible on the wrist is very useful when I’m walking to the train with the phone in my pocket or when I’m out running.

Wrap Up

I love my new watch! It took the place of my existing watch effortlessly. If anyone is worrying about the size of the watch, don’t. It’s perfectly sized and looks like a nice, big, regular watch.

This American Life: Cops See It Differently

Sat, 21 Feb 2015 18:04:37 +0100

The radio-show-turned-podcast This American Life recently did two episodes on how the views of police officers and civilians can differ. This American Life usually produce very good podcasts but these episodes really struck me as extraordinary. Everyone should probably listen to them.

I’ve embedded the SoundCloud player with the two episodes below so you don’t even need to search for them.

Parsing Polynomials in C

Thu, 08 Jan 2015 07:15:58 +0000

This autumn, I worked as one of the teaching assistants in EDAA25, the C programming course at Lund University’s Computer Science department. This mainly involves grading the programming assignments the students are required to hand in during the course. After grading a lot of solutions, I’m amazed by how many students have difficulties structuring their code in a reasonable and readable way. Many solutions barely work, or rely on undefined behaviour to work, but even the correct ones are extremely difficult to read and understand. A lot of students write functions that span multiple printed pages. The students are mostly fourth or fifth year students pursuing a master of computer science and engineering degree. I believe they ought to be able to do better.

One could probably draw some conclusions from this regarding how much programming the students have actually learned during their first 3–4 years of studying. However, that’s for another post. In this post, I’m presenting a solution for part of the third programming assignment which I think is ideal and easy to understand.

Before continuing, allow me to state the obvious: If you are taking the course, stop reading now and solve the assignment on your own! You will learn nothing from copying this solution and it will only hurt you during the exam (which is usually pretty excruciating). Also, the parsing function that I’m presenting here is not the must difficult part of the assignment.

Problem Description

The assignment consists of implementing a couple of function that can parse, multiply and print polynomials. The format of a polynomial is fairly simple:

x^2 - 2x + 1

I will only present an implementation of the parsing function.

Structure of a Polynomial

Below is a simplified (but hopefully complete) EBNF notation of a polynomial (optional whitespace is left out).

polynomial  = term , { sign, term } ;
term        = coefficient
            | [ coefficient ] , variable
            | [ coefficient ] , variable , exponent ;
sign        = "+" | "-" ;
coefficient = number ;
variable    = "x" ;
exponent    = "^" , number ;
number      = digit , { digit } ;
digit       = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7"
            | "8" | "9" ;

That is, a polynomial consists of a number of terms separated by a sign. A term consists of three cases:

Only a coefficient, e.g. 2
An optional coefficient and a variable, e.g. 2x or x
An optional coefficient, followed by a variable and an exponent, e.g. 2x^2 or x^100.

Here are some example polynomials:

 1
 x^2 + 3
 x^1000 - 6x + 2

Implementation

The students are given some handout code that specifies which functions and data types should be implemented:

typedef struct poly_t poly_t;

/* Parse the input string and return a new poly_t. */
poly_t* new_poly_from_string(const char*);
/* Free the input poly_t. */
void free_poly(poly_t*);
/* Multiply the two input poly_t's. */ 
poly_t* mul(poly_t*, poly_t*);
/* Print the input poly_t in the same format we parsed above. */ 
void print_poly(poly_t*);

Thus, the students need to implement one data type (poly_t) and four functions (new_poly_from_string(), free_poly(), mul(), print_poly()). The only error checking the students are required to do is to detect the error, print a message about it and call exit(EXIT_FAILURE).

Since the students aren’t given any limit on the number of terms their implementations should handle, it is expected that their solution should build on a linked list (I believe this is mentioned during one of the lectures). I.e. each term in a polynomial is represented by a node in the linked list. The data structure looks like this:

/* Represents a term in a polynomial. */
struct poly_t {
	int	e;	/* Exponent of this term. */
	int	c;	/* Coefficient of this term.*/
	poly_t*	next;	/* The next term. */
};

This seems like a fairly straight forward and simple, yet still flexible, way to represent a polynomial. However, many students try to define the data structure in much more creative ways which often involve multiple arrays and a guinea pig. (By the way, do a Google Image search for guinea pigs, they are absolutely adorable!)

Next, we’ll get to the point of this post: The implementation of the new_poly_from_string function that parses a string containing a polynomial. This solution is split into a couple of small and easily understood helper functions. The students seem to have forgotten that you don’t need to implement all functionality in a single function.

The legibility is especially important since the students are required to print out their solutions and we (as teaching assistants) have to grade these printed versions¹. After realizing that basically all implementations of this function span at least 1.5 pages, I found myself wishing that the students would think about readability for even one second before handing in their solutions.

The idea of my implementation is to do a simple one pass parse of the string and implement an accept_* function for each part it parses. We’ll use a top-down approach so let’s start with the finished function that parses the polynomial:

/* Struct to keep track of the position in the string. */
typedef struct parser_ctx_t {
	const char*	str;
} parser_ctx_t;

poly_t* new_poly_from_string(const char* str)
{
	poly_t*		poly;
	poly_t*		term;
	parser_ctx_t	ctx;

	poly	= NULL;
	term	= NULL;
	ctx.str	= str;

	while (*ctx.str) {
		if (term == NULL) {
			/* Parse the first term. */
			term = accept_term(&ctx);
			/* Keep a pointer to the first term. */
			poly = term;
		} else {
			term->next = accept_term(&ctx);
			/* Advance to the new term. */
			term = term->next;
		}
	}

	return poly;
}

Look how clean and easy to understand that function is (and it would print nicely)!

OK, let’s go through this code a bit. The first thing we do is to define a type called parser_ctx_t that holds a pointer to the current position in the string. An instance of this type will be passed around to the accept_* functions in order for them to advance the string pointer. This could be done by passing around a pointer to the pointer to the string directly, but frankly I like this better. Mostly because it looks nicer.

The rest of the function is fairly straight forward. As long as there is anything left to parse from the string, we parse another term by calling accept_term(). The loop simply builds up the linked list one term at a time and keeps a reference to the first term. The poly pointer will point to the first term (and thus be returned at the end) while term will point to the last parsed term. Next, let’s look at accept_term():

static poly_t* new_term(int c, int e)
{
	poly_t*	poly;

	poly	= malloc(sizeof(poly_t));
	if (poly == NULL)
		error(__FILE__, __LINE__, __func__,
		      "Failed to allocate poly.");

	poly->c		= c;
	poly->e		= e;
	poly->next	= NULL;

	return poly;
}

static poly_t* accept_term(parser_ctx_t* ctx)
{
	poly_t*	term;
	int	c;
	int	e;

	c	= accept_coefficient(ctx);
	e	= accept_exponent(ctx);
	term	= new_term(c, e);

	return term;
}

Well, that’s simple. We have a helper function to allocate a new term and perform error checking on the memory allocation. The error() function is provided to the students in the handout code. It simply prints the message in a nicely formatted way and exits the program with exit code EXIT_FAILURE.

The accept_term() function is not very interesting. It uses two helper functions to parse the coefficient and exponent of a term and then creates and returns a new term. Let’s continue to the two helper functions accept_term() uses:

static int accept_coefficient(parser_ctx_t* ctx)
{
	int	c;	/* The coefficient to parse. */
	int	sign;	/* The sign of that coefficient. */

	sign	= accept_sign(ctx);
	c	= accept_number(ctx);

	return c * sign;
}

static int accept_exponent(parser_ctx_t* ctx)
{
	int	e;	/* The exponent to parse. */

	e	= 0;	/* Default exponent to zero. */

	accept_space(ctx);
	if (*ctx->str == 'x') {
		e = 1;
		ctx->str++;

		if (*ctx->str == '^') {
			ctx->str++;
			e = accept_number(ctx);
		}
	}

	return e;
}

accept_coefficient() is fairly uninteresting as well, we accept a sign (i.e. a plus or a minus) and then a number. accept_exponent() on the other hand is a bit more interesting. For good measure, we use accept_space() to discard any whitespace before the actual exponent. Now we have a couple of cases:

If we have no variable (i.e. an x), we default the exponent to zero.
If we have a variable but no caret, we set the exponent to one.
If we also have a caret, we parse the number succeeding the caret.

I should probably point out that the students are not required to handle negative exponents although it would be trivial to add in my solution.

The last helper functions are accept_space(), accept_sign() and accept_number():

static void accept_space(parser_ctx_t* ctx)
{
	while (isspace(*ctx->str))
		ctx->str++;
}

static int accept_sign(parser_ctx_t* ctx)
{
	int	sign;	/* The sign to parse. */

	sign	= 1;	/* Default to positive sign. */

	accept_space(ctx);

	if (*ctx->str == '-') {
		sign = -1;
		ctx->str++;
	} else if (*ctx->str == '+') {
		ctx->str++;
	}

	return sign;
}

static int accept_number(parser_ctx_t* ctx)
{
	int	num;	/* The coefficient to parse. */
	char*	end;	/* The end pointer returned by strtol. */

	num	= strtol(ctx->str, &end, 10);
	if (ctx->str == end) {
		/* No number to parse, default to 1. */
		num	= 1;
	}
	ctx->str	= end;

	return num;
}

accept_space() simply discards any whitespace in the string. accept_sign() parses a sign and returns +/- 1 which allows us to multiply it with a number when parsing the coefficient.

accept_number() is a bit more interesting and I’m pretty satisfied with the implementation. It leans heavily on strtol() but using functions in the C standard library is obviously OK in the course. strtol() discards any whitespace and then parses a number from the string, stopping at the first non-digit. It stores the location at which it stops in the pointer provided as the second argument. If the pointer it set is the same as the one we provided, it didn’t parse any number. If this is the case, we default the parsed number to 1. This works in both our cases when we need to parse numbers:

If we try to parse a coefficient and doesn’t have a number to parse, we have a term with only a variable (e.g. x or x^23) which should have the coefficient 1.
If we try to parse an exponent and there’s no caret, then we know we should skip calling accept_number() since there’s no number to parse. If we do have a caret in the string, there will be a number to parse and accept_number() will succeed in parsing it.

And that’s it! A simple implementation which is easy to understand and follow.

Finishing thoughts

While there are most likely some minor problems with this solution, it is simple to understand and parses well-formatted polynomials which is what the assignment requires. The main point I wanted to make here was that it is possible to implement this function in a way that doesn’t require complicated lookahead/lookbehind or multiple passes through the string while making it readable at the same time.

I have my reservations about this system as well but it’s the one we’re stuck with for various reasons ^[return]

Run Free - The True Story of Caballo Blanco

Thu, 01 Jan 2015 13:00:53 +0100

A while ago, I found the Kickstarter campaign for the documentary about Micah True and decided to contribute to it. As part of the pledge, I was given preview access to the film and I just watched it. It’s a great film that commemorates Micah True’s life and the race he arranged in the Copper Canyon in Mexico beautifully. The documentary should be coming out later this year so keep your eyes on its website if you’re interested.

"Öppenhet" på SD:s villkor

Mon, 15 Dec 2014 16:33:08 +0000

SD:s Björn Söder, nu vice talman i riksdagen, har hamnat i blåsväder efter att ha vädrat sin ganska obehagliga människosyn i en intervju i DN. Efter att ha sett kommentarer flyga runt lite på Twitter bestämde jag mig för att bryta min sedvanliga regel att inte läsa om politik (jag har högt blodtryck så det räcker redan) och ögna igenom artikeln. Jag reagerade speciellt på ett svar han gav:

Om många Malmöbor inte är en del av den nationella gemenskap som du och ditt parti vill bygga – vad vill du göra med dem?

– De får anpassa sig och bli en del av den svenska nationen. Vi har en öppen svenskhet, en individ kan bli svensk oavsett bakgrund. Men det kräver att de assimileras….

Intressant sätt att definiera “öppen svenskhet” på. “Öppen” betyder tydligen numera “öppen (med begränsningar, på SD:s villkor)”. Att ens kalla det för “öppenhet” känns bara som ett sätt att försöka måla över deras vanliga politik med ett positivt ord.

Och anpassa sig till vilken grad? Räcker det med att lära sig svenska? Och vilken nivå av svenska ska folk behöva lära sig i så fall? Ska vi kanske tvinga alla att konvertera till kristendom också? För säkerhets skull borde vi nog även lagstifta om sill och nubbe på midsommar. För allt som är främmande är ju obehagligt och förmodligen även farligt.¹

Ja, det där var sarkasm. ^[return]

Rust Skåne Meetup

Mon, 17 Nov 2014 18:48:11 +0000

I’m on my way home from tonight’s Rust Skåne meetup in Malmö. There were two presentations, one by Jakub Bukaj about Rust’s road to version 1.0 and one by Jens Nockert which dug into the worker queue implementation in Servo. Jakub’s presentation contained a lot of good information but was unfortunately a bit time constrained. Jens’ presentation was a bit more free-form, he basically highlighted different parts of the file implementing Servo’s work queue. It’s interesting to see some real world Rust code with comments from someone who actually understands it.

I’m exited about Rust’s future development, it borrows a lot of great features from e.g. Haskell and has some innovative ideas itself. I will try to make time for some Rust development in the near future.

Usually presentations at FooCafé (where the meetup took place) end up on YouTube so keep an eye at FooCafé’s YouTube channel if you’re interested.

Writing Regularly

Tue, 04 Nov 2014 21:19:50 +0000

I have been wanting to get into the habit of writing more often, mostly just to improve my own writing (since I doubt anyone would read what I write anyway). I also have some ideas about writing some form of fiction but that will probably not happen in the near future (if at all).

I will basically follow the same rules that Gina Trapani’s post about short-form blogging laid out. I might add to those rules later if I actually do keep this habit up (I know myself and I try to be realistic).

Reply to Humans Need Not Apply by CGP Grey

Mon, 03 Nov 2014 19:11:39 +0000

I recently watched CGP Grey’s video titled Humans Need Not Apply and I have some nitpicking to do. While I agree with his general premise, robots will take over more and more jobs and as a society we need to discuss the consequences of this, I disagree on some specific points about the robots he mentions. Particularly about self-driving cars (or autos as Grey calls them, which I will adopt for this post).

Autos

My main problem with the video is basically this: Watching the part about self-driving cars makes it seem like they are basically done and are waiting for legislative approval before going into mass production (I might exaggerate slightly for dramatic effect). This is far from true. Let’s look at some quotes from the video.

Self-driving cars aren’t the future, they’re here and they work.

Well, yes and no. Quite a few prototypes exists and it depends on your definition of “work”. I’ll get back to this.

Self-driving cars have traveled hundreds of thousands of miles up and down the California coast and through cities, all without human intervention.

Ah! Well I guess that’s technically true: There is no human intervention while they are driving. However, there is quite a lot of human intervention before they drive (and I’m not just talking about programming them). The problem with all of the existing autos being developed right now can be summed up in two words: No SLAM.

SLAM stands for Simultaneous Localization and Mapping which basically means that a robot (or auto in this case) starts with an unknown environment and via sensors construct a map of the place while simultaneously keeping track of its location in it. Few (if any, I couldn’t find any when searching) self-driving cars currently do this.

Take Google’s self-driving car project for example, it cannot navigate on its own without a human first having driven the same route and built a map of the area. And a Google Maps map is not sufficient. The map basically needs to contain much of the same information as the auto has access to while driving. This essentially means that a human must drive the auto (or a vehicle with similar sensors) once initially to create the map before it can do any navigation of its own.

The astute reader will probably have realized the consequence of this: In order for these autos to succeed in replacing human drivers, essentially all roads will need to be mapped in this manner. This also means that the maps has to be kept up to date continually. What if intersections move? If roads get built or shut down? While it is possible for the auto to detect and cope with such problems when they arise, they can for example make route planning sub-optimal.

The alternative solution is SLAM, if autos could just draw a map and localize themselves in it while driving, we wouldn’t need to hand them prefabricated maps. The problem is that SLAM is a hard problem. And by hard, I mean hard. Like people-have-been-cutting-their-teeth-on-this-problem-since-the-eighties-hard. The Wikipedia page I linked to above has some details about what makes it so difficult.

The question is not if they will replace cars but how quickly.

Nothing to argue against there. I agree it’s inevitable that autos will replace cars eventually. What I basically disagree with is the timeline I perceived from the video.

They don’t need to be perfect, they just need to be better than us.

Again, I agree, but in order to even begin to replace human driven cars, autos first need to master navigating in new environments at all.

Final Thoughts

I’m not saying there isn’t some awesome research being done regarding autos (because there is) and I would be the first person in line (budget permitting) to buy one when they do get mass produced. I’m also not complaining about Google’s research into self-driving cars. They had to do some trade-offs in order for the project to move forward at all and I can see why they chose to down-prioritize SLAM.

Tangential Side Note

I just wanted to point out that Baxter is a cool robot built on ROS which I regularly work with in the robot lab at Lund University. Without getting too technical, ROS provides lots of ready-made functionality and communication primitives which allows you to get started quickly when developing new robots.

That said, there are some design issues with ROS that makes it more or less impossible to use for critical real-time tasks, effectively limiting what robots build on ROS can do. Unfortunately, this means that much of the awesome functionality in ROS (such as geometry calculations, localization, mapping etc.) can’t be used for more demanding tasks. Oh well, can’t have it all.