I’m currently finishing up my semester of university in Sweden, and will have some musings about that shortly (by “shortly” I mean in the next couple of months.. hopefully).

In the meantime.. Grant may have been photographed by a Google van on Hindley Street in Adelaide, which is both hilarious and upsetting – hilarious for the obvious reasons, but upsetting because this means they could be replacing their current street view images of Australia. And there are some good images on Google Street View, there’s one image in particular that I’m quite fond of and wouldn’t like to see replaced…

Without any further ado, here’s my mother on Google Street View:

Check out that seamless exit from the vehicle. Fantastic.

That’s all for now. Bring on LCA!

We begin with a look at problem 1 from assignment 3:

The market for tickets to the symphony can be described by the following demand and supply curves:
D = 20000 – 90P
S = 10000 + 110P

1. What are the equilibrium price and quantity in the ticket market?
2. Lovers of classical music persuade the government to impose a price ceiling of $40 per ticket. How many tickets are now sold in the market?

This problem maps fairly directly to Minizinc code, we pretty much just write out the equations already given to us:

%Include standard definitions:
include "globals.mzn";

%From variables described in problem statement:
var int: P;
var int: D = 20000 - 90*P;
var int: S = 10000 + 110*P;

%To solve for equilibrium supply and demand, simply remove this constraint.
%The government imposes a $40 ceiling:
constraint P  < = 40;

%Solve for as close to equilibrium supply and demand as possible:
solve minimize abs(D-S);

%Print our solution:
output["The price is $", show(P), " per ticket and the quantity sold is ",
    show(min(S,D)), " tickets.\n"];

with the output for respective cases being:

The price is $50 per ticket and the quantity sold is 15500 tickets.
The price is $40 per ticket and the quantity sold is 14400 tickets.

This problem was very straight-forward to solve in Minizinc, emphasizing just how great this language is for the typical supply-demand problems you come across in an introductory economics textbook. However, I feel that by using Minizinc to solve a problem as simple as this, we do not achieve much of a productivity gain compared to the traditional approach of solving through algebraic manipulations.

Furthermore, there does not seem to be any way to solve for two or more subtly different cases of the same problem, one after the other. One solution to this short-coming is to rely on the user to conditionally comment-out some constraints for different cases and run the program multiple times. This is not ideal. There may be some feature of Minizinc (that I am not aware of) that simplifies this situation but as one of the design goals is to create a minimal language, this is unlikely. Keeping the rationale behind Minizinc in mind, not being able to solve for different cases in the same program is hardly something to feel sore about.

Moving along, we want to solve assignment 3, problem 2:

Suppose the demand curve for pizza can be represented by the equation D = 20 – 2P, where D is the quantity demanded and P is the price. The supply curve for pizza can be represented by the equation S=P-1, where S is the quantity supplied.
Suppose the government imposes a $3 tax per pizza. How much more will consumers now pay for a pizza?

which can be mapped to Minizinc as:

%Include standard definitions:
include "globals.mzn";

%From variables described in problem statement:
var int: PD;
var int: PS;
var int: D = 20 - 2*PD;
var int: S = PS - 1;

%Without a tax:
%constraint PD = PS;
%With a $3 tax:
constraint PD = PS + 3;

%Market is at equilibrium:
constraint D = S;

%Solve for equilibrium supply and demand:
solve satisfy;

%Print our solution:
output["Consumers will pay $", show(PD), " per pizza.\n"];

with the output for the respective cases being:

Consumers will pay $7 per pizza.
Consumers will pay $8 per pizza.

Again, the process of mapping the problem to Minizinc code is fairly straight-forward. Unlike the previous problem, this problem was actually easier for me and quicker to solve with Minizinc than doing algebra. Especially since I had a bit of a template to go off by using the code I wrote for the previous problem. Yet again, we rely on the user to conditionally comment certain constraints but this is fairly trivial for a savvy user.

Now, on to assignment 4, question 1:

The Pristine River has two polluting firms on its banks. Acme Industrial and Creative Chemicals each dump 100 tonnes of glop into the river each year. The cost of reducing glop emissions per tonne equals $10 for Acme and $100 for Creative. The local government wants to reduce overall pollution from 200 tonnes to 50 tonnes.

1. If the government knew the cost of reduction for each firm, what reductions would it impose in order to reach its overall goal? What would be the cost to each firm and the total cost to the firms together?
2. In a more typical situation, the government would not know the cost of pollution reduction at each firm. If the government decided to reach its overall goal by imposing uniform reductions on the firms, calculate the reduction made by each firm, and the total cost to the firms together.

Which we write in Minizinc as:

include "globals.mzn";

%Adapted from all_different
predicate all_same(array[int] of var int: x) =
	forall(i,j in index_set(x) where i  j) ( x[i] = x[j]);

%Set the number of companies involved:
int : n = 2;
set of int: companies = 1..n;

%Arrays for data on each firm:
array[companies] of int : reductionCostPerTonnes = [10, 100];
array[companies] of int : pollutionTonnes = [100,100];
array[companies] of var int : reductionTonnes;
array[companies] of var int : reductionCost =
   ([ reductionTonnes[c] * reductionCostPerTonnes[c] | c in companies]);

%The sum of the differences in reductionCost between
%one firm and the consecutive firm in the array for each firm:
var int : reductionCostDelta = sum
   ([ abs(reductionCost[c] - reductionCost[c+1]) | c in 1..(n-1)]);

%The sum of each firms reductionTonnes:
var int : totalReduction = sum ([reductionTonnes[c] | c in companies]);

%The sum of each firms reductionCost:
var int : totalCost = sum ([reductionCost[c] | c in companies]);

%We want to reduce our current pollution down to 50 tonnes.
int : pollutionGoal = 50;
var int : reductionGoal = (sum
   ([pollutionTonnes[c] | c in companies])) - pollutionGoal;

%Cannot reduce pollutionTonnes beyond pollutionTonnes we are currently producing.
constraint forall ([ reductionTonnes[c]  < = pollutionTonnes [c] | c in companies]);
%PollutionTonnes must not be reduced by a negative amount, this does not make sense.
constraint forall ([ reductionTonnes[c] >= 0 | c in companies]);
%The total reduction in pollutionTonnes must meet our reductionGoal
constraint totalReduction = reductionGoal;

%If we know how much reducing pollution costs each firm,
%we minimize the difference in pollution reduction costs between firms.
solve minimize reductionCostDelta;
%If we do not know how much reducing pollution costs each firm,
%we simply get them to reduce pollution by the same amount regardless of cost.
%constraint all_same(reductionTonnes);
%solve satisfy;

%Print our solution:
output ["reductionGoal = ", show(reductionGoal), "\n",
	"reductionTonnes = ", show(reductionTonnes), "\n",
	"reductionCostPerTonnes = ", show(reductionCostPerTonnes), "\n",
	"reductionCost = ", show(reductionCost), "\n",
	"totalCost = ", show(totalCost), "\n"];

with the output:

reductionGoal = 150
reductionTonnes = [100, 50]
reductionCostPerTonnes = [10, 100]
reductionCost = [1000, 5000]
totalCost = 6000
reductionGoal = 150
reductionTonnes = [75, 75]
reductionCostPerTonnes = [10, 100]
reductionCost = [750, 7500]
totalCost = 8250

This problem was actually the hardest for me to write in Minizinc. It certainly demonstrates that Minizinc can be used for solving less trivial problems but more effort is needed. I really like that array comprehensions are possible in Minizinc and have used them way more than what is really advisable.

And finally, assignment 4, question 2:

Suppose that 10 people live on the street and that each of them is willing to pay $2 for each extra streetlight, regardless of the number of streetlights provided. The cost of providing L streetlights is given by c(L)=L*L. What is the most efficient number of streetlights to provide from the point of view of a central planner?

which we solve with:

%Include standard definitions:
include "globals.mzn";

%From the problem statement:
int: numberOfResidents = 10;
int: contributionPerLight = 2;

%The 0..10000 is to stop integer overflows resulting from the solver,
%this is not a limit given to us in the problem statement.
%The number of streetlights on the street:
var 0..10000 : numberOfLights;

%The cost for a particular number of streetlights:
var int: cost = numberOfLights * numberOfLights;
%The contribution from a single resident:
var int: contribution = contributionPerLight * numberOfLights;
%The aggregate contribution from the whole street:
var int: aggregateContribution = contribution * numberOfResidents;

%Adding 0 extra streetlights could be a solution, but not the one we are after.
constraint numberOfLights > 0;

%Maximize the central planner's profit realized by providing extra streetlights:
solve maximize aggregateContribution - cost;

%Print our solution:
output["Most efficient number of streetlights is ", show(numberOfLights), "\n",
   "As cost is ", show(cost), "\n",
   "And contributions is ", show(aggregateContribution), "\n"];

with the output:

Most efficient number of streetlights is 10
As cost is 100
And contributions is 200

In this example, we have run into another problem: certain constraints or definitions can result in overflow when the program is executed. Luckily, the compiler can detect these situations, giving the programmer sufficient notice that the code needs to be altered. Whilst this is commendable in a compiler, in my opinion, a ‘smarter’ solver would be able to avoid overflow for the problem above. Admittedly, solvers are hard enough to implement, especially given performance, soundness and other concerns, without trying to make them ‘smarter’.

For this example, we have managed to get around integer overflow by restricting the domain for numberOfLights. This could probably be done automatically but even then, it would still be prudent to alert the user that the domain of variables in the problem and thus, their potential solutions have been restricted.

In conclusion, Minizinc is a fantastic language to use for constraint type problems and is true to its minimalist design goal. At times, this minimalism can be trying; especially if you simply want to piece together a quick solution to a given problem. However, this minimalism also makes a thorough analysis of the language much easier. Many types of problems would be unsuited to constraint programming and Minizinc, and therefore quite difficult to solve with Minizinc code. As always, it is important to identify which tool is the right one for the task at hand.

Instead of doing either of those tasks, I’ve knocked up a solution to the eight queens problem using the Minizinc constraints programming language. The eight queens problem simply is, how to arrange eight queens on a chessboard so that none of them are in check.

Not sure if it works correctly – did it in about two seconds flat – so bonus points if you can find problems with it.

include "globals.mzn";

array[1..8] of var 1..8: xpos;
array[1..8] of var 1..8: ypos;

%no two queens can have the same xvalue
constraint
    forall (i in 1..8) (
        forall (j in 1..8 where j!=i) (
            xpos[i] != xpos[j]
        )
    );

%no two queens can have the same yvalue
constraint
    forall (i in 1..8) (
        forall (j in 1..8 where j!=i) (
            ypos[i] != ypos[j]
        )
    );

%none on the diagonals
constraint
    forall (i in 1..8) (
        forall (j in 1..8 where j!=i) (
            (xpos[i] - xpos[j] != ypos[i] - ypos[j]) /\
            (xpos[i] - xpos[j] != ypos[j] - ypos[i]) /\
            (xpos[j] - xpos[i] != ypos[i] - ypos[j])
        )
    );

solve satisfy;

output [ "X: " ++ show(xpos[i]) ++ " " ++
         "Y: " ++ show(ypos[i]) ++ "\n" | i in 1..8 ];

The output that I get is:

X: 4 Y: 8
X: 2 Y: 7
X: 7 Y: 6
X: 3 Y: 5
X: 6 Y: 4
X: 8 Y: 3
X: 5 Y: 2
X: 1 Y: 1

Now to find something else to procrastinate with..

Now, one of my courses at uni this semester is Operating Systems. I don’t mind the course; I realised with slight shock while reading over the lecture slides for the upcoming exam that I actually found most – if not all – of the content of the course quite interesting. I like it.

But, one of the lectures was a bit interesting in another way. Towards the beginning of the course we were given a lecture entitled “System Software”. A very ambiguous title. As it turned out, the aim of this lecture was to convince any proprietary-software-loving folk in the audience that their views were wrong.

The lecture was incredibly biased, here are a spattering of memorable quotes from the lecture, (Module 2 – System Software, Operating Systems, University of South Australia):
“Free software is… the freedom to use your computer, the way YOU want, not the way the marketing and legal department wants” (Very colourful words there, yeah, screw the system!)

(Regarding the EULA for Windows XP) “.. you have the right to do not all that much. You are barely allowed to even run it [the operating system]” (Barely allowed to even run it? If you install and run Windows on the average home computer, you are not breaking the EULA – and yes, I have read it).

“Most vendors do not give you source code, so you cannot make changes to it or inspect it for security flaws” (Okay, I consider myself a decent programmer, average at the least – and I have never, ever even felt the need to go through the source code of an open source operating system to “inspect it for security flaws”. Who does that? Not me. If that’s one of the reasons to use open source, we must be scraping the bottom of the barrell..)

This is a third year Operating Systems lecture slide. No joke.

“There are lots of software engineers out there that do not have a clue, do you trust them with your airplane/life? Someone could put spying tools into the software they give you” (Scare tactics, much?)

“Copy protection can stop you from using software you have legally purchased. What if the next version of Windows prevents a hardware dongle from working because there are no drivers. You may need to illegally crack your software to use software you are legally allowed to use!?!?!” (There really was that much punctuation, and the lecture failed to state the actual intent of copy protection).

“The cost is free and you are not held to ransom by other companies who seek to control you for your money” (What…? Very colourful words again).

The lecture also gives a run down on Richard Stallman and names him as a visionary. But, of course, there’s no mention of the Steves, or Bill Gates, have they not contributed anything to operating systems over the years? Anything pre-Linux doesn’t exist.

The lecture continues to hammer in the point about free software being amazing, but why is there no mention of any other alternatives? Instead of the colourful words, why not give people some facts and figures, and some info about this horrible, deathly “proprietary software” thing, which is barely mentioned?

I’m all for open source, but I’m also for people being free to make their own decisions.

Enter BASH scripting.  With a few lines of BASH code, it is possible to save the current web-cam shot at a set interval for an indefinite period.

#!/bin/bash

#A short script to download timed snapshots of a file that undergoes regular updates.

#The url of the file
url="http://www.adelaidecitycouncil.com/netcatapps/webcam/images/rundle.jpg"
#This expression extracts the suffix part of the url from the url
suffixpart=${url##*.}
#The interval at which the file is fetched.
#N.B. Some sites may not take kindly to short intervals.
interval=5s

#Determine which command should be used for downloading given the current platform.
systemname=`uname -s || uname`
case $systemname in
    *Linux)
        cmd="wget $url -O"
        ;;
    *Darwin)
        cmd="curl $url -o"
        ;;
    *)
        cmd="wget $url -O"
        ;;
esac

#Infinite loop that does the downloading.
#The script must manually be interrupted to halt. 
while [ 1 ]
do
    datepart=`date "+%H%M%S"`
    $cmd $datepart.$suffixpart
    sleep $interval
done

The URL of the web-cam feed that the script downloads is easily changed by setting url (line 6) to a different URL string.  Changing the interval at which snapshots are taken is similarly simple.  I’ve made an effort to ensure that the script is compatible with a variety of platforms by performing a run-time check but it is likely that the script may not work on platforms other than Darwin (Mac OSX) as this was the testing platform.

Now all that remains is to leave this script running on a friend’s computer with web-access whilst visiting Rundle Mall.  By syncing a watch to the system time on the computer, it will even be possible to know which shots are relevant without viewing all the snapshots individually (as the filename for each snapshot reflects when it was taken).

This 2600 is referred to as a "Vader" console, you can also get another 2600 which is black/gray and looks quite different (but plays the same cartridges, however).

This was the first gaming console that I ever played. I’d even go as far as to say that this machine allowed me to play the first video games that I’d ever played – PC, console or otherwise. I believe this Atari 2600 was selling in the early eighties, and I remember playing it when I was around three – five years old in 1990-1992, so it would have been a little outdated when I had it.

Unfortunately, the console that I’ve got now, the one pictured, isn’t the one I played as a kid, but rather just another one that I purchased of the exact same model that I had. The one I had as a kid was taken to a pawn shop to make way for the next console that my family purchased (the Sega Mega Drive, and I do still have that very one)

I had to get my hands on one of these, there’s just something so cool about it to me – and I’m probably one of the only people who get excited about stuff like this – but how cool is it that this was once the best gaming console out? I played this for hours on end the same way that kids today play the PS3, and it seemed really exciting for the time – it’s a piece of gaming history! But even if you don’t think that’s as cool as I do, the games are still pretty wicked. Space Invaders still remains too hard for me, despite me being at least five times the age of when I first played it.

Here’s a shot of the games I have for it at the moment:

Games: Berzerk, Pacman, Bowling, Space Invaders, Othello, Missile Command, Basketball, Combat, Sprintmaster, Asteroids, River Raid II, Outlaw, Human Cannonball, Indy 500, Freeway, Slot Machine, Seaquest, Asteroids (again), Crystal Castles. And Kung-Fu Master, Summer & Winter Games.

Berzerk remains my favourite game; it’s just a classic running around with a gun shooting mindless robots kind of game. It used to scare me a bit as a kid, but it’s quite fun. It’s also noted as the first video game that someone has died playing (I think two did, actually). Another version of Berzerk on another console (don’t remember which one) was also one of the first (if not, the first) games to have voices in it.

Anyway, that’s enough mindless babbling for now.

*Other consoles I own include Sega Mega Drive II, Super Nintendo, Gameboy Color, Nintendo 64 and GameCube.

If you don't know what it is, then you don't belong here.

I should have been sleeping an hour ago, but it was worth it.

Note the clear plastic still over the screen; no screen scratches!

I always wanted a coloured one when I was younger, instead of that grey one, and I’ve finally got one. The pocket is much more handy than the original one, too; much lighter and easier to hold. With little to no scratches on the actual console, and none on the screen because of the protective plastic, I think I’ll hang on to this for a while – it’s in great condition, and I’m having fun playing games with it. Five games came with the console, and I managed to find one around the house. So the games I have are:

L-R, T-B: Bill and Ted's Excellent Adventure (I found that in our pantry, there's all kinds of crazy stuff in there), Lamborghini American Challenge, Super Mario Land 2: Six Golden Coins, Donkey Kong Land 2, Warioland 2, Yoshi's Cookie.

I know there’s at least another two games around my house, but I can’t find them. I blame my younger siblings for that.

But anyway, I’m so glad I found Bill and Ted’s Excellent Adventure, I used to watch those movies over and over as a kid, and I never owned them, just borrowed them excessively from the local video store (way back when they actually had videos and not dvds, woah). So, of course, I also played Bill and Ted’s Excellent Adventure on Gameboy quite a bit. It didn’t tie in heaps with the movies, but it’s still a decent game – just collect all of the coins in a level and a telephone booth will spawn, go to that and it’ll take you to the next level. Not too bad at all.

My plan is to look around at pawn shops and at Cash Converters around Adelaide in search of some of the cooler games on Gameboy. Some that I would like to get are Paperboy, Lemmings, NBA Jam, and just anything that seems awesome, really.

I don’t think this is the last old console that I’ll get. I also would love to get my hands on the Atari 2600 – the first console I ever played. There’s a few drifting around Ebay so I will try to get my hands on one for some awesome Space Invaders and Frogger action. I also have a Sega Mega Drive and a Super Nintendo. I wouldn’t mind getting a Sega Saturn – I never had one as a kid (I don’t think many people did, it kinda didn’t take off) but I was always a bigger fan of Sega rather than Nintendo so owning one would be awesome.

Thankyou, Ebay, for allowing me to spend my hard earned cash on old consoles.

Among the changes that are most irksome aesthetically are the rounded corners on thumbnails and the now overly large wall font.  These changes can be negated with the following CSS over-rides:

.UIRoundedImage_Corners{display:none !important;}
.UIIntentionalStory_Message{font-size: 11px !important;}

There are a lot of other changes to Facebook that I find annoying, and when I find the spare-time, I’ll probably find ways to overcome these.  In the mean-time, check-out userstyles.org for more comprehensive user style-sheets.

It’s a very simple game that I completed in first year uni. Basically, you move around some rooms and try to kill a monster called a wumpus and avoid it and other monsters.

There’s  20 or so rooms and they each connect up to three of the other rooms. For example, from room 0 you can get to rooms 1, 4 and 7. When in a room, if there’s a monster in a joining room, then you’ll get a warning (eg, “I smell a Wumpus”).

There’s three monsters -  a wumpus that’ll eat you as soon as you set foot into the room it’s in, a bottomless pit (maybe not so much of a monster, but still) which you’ll fall into and die if you step into that room, and a Superbat, which will move you to another random room if you enter the room that it’s in – and that random room may be a room with another monster in it! The wumpus also moves around occasionally, you’ll get warnings if it’s moved into another room, too.

You’re armed with two arrows. The goal is to shoot and kill the wumpus by shooting into a connecting room, so for example, shooting into room 1 from room 0, if you think that the wumpus is in that room. You’re supposed to work out which room he’s in from the warnings when he’s in an adjacent room. Shooting him with two arrows gives a better chance of actually killing him than shooting him with just one.

Grab all the class files in a zip from here. The HuntTheWunpus class the one to be run. All files created by me except for the map generator, created by Adam Jenkins. Contact me if you really want the source. I’m a bit hesitant to put it up until I find out for sure if I have the rights to it.