Creating my simple XML setup file

At the end of the last blog post I said that it’d be a good idea to create some kind of config file in order to change the functions that the program could provide without having to keep recompiling the program. To fulfill this hastily decided upon requirement I’ve created XML config file with each of the queries encapsulated within their own tag (as seen in the example snippet immediately below) and a method which creates a XAML button for each query stored. The appropriate query can be run upon this button’s click.

<SQLQuery name=”…” query=”…” result=”…”/>

There are a few problems to overcome for this to work. Since the number of queries provided isn’t known until run-time, each button click must run the same method since the code to create the buttons doesn’t iterate a set number of times. Since each SQL query returns a different mix of columns (and consequently types) this has to be accounted for when retrieving the rows.

Upon successfully loading in the XML query element a ‘StoredDynamicQuery’ object is created to store the query, its name, and the format of the results. To make it simpler the content of the button is set as the query name; once the button is clicked its content is used to retrieve the necessary ‘StoredDynamicQuery’ object.


To account for the changes in the end-results I’ve come up with a results mechanism that could generously be described as JSON-like (as seen above). They’re written in key-value pairs separated by colons, and the results string can contain any number of these with individual pairs split by commas. The code to account for this can be seen below.

StoredDynamicQuery RetrievedQuery = RetrieveStoredQuery(QueryName);

using (SqlConnection connection = new SqlConnection(DataString))
     using (SqlCommand command = new SqlCommand(RetrievedQuery.QueryCommand, connection))
          List IndividualResults = RetrievedQuery.Results.Split(',').ToList();

          using (SqlDataReader reader = command.ExecuteReader())
               if (reader.HasRows)
                         string ConcatenatedString = "";
                         for (int i = 0; i < IndividualResults.Count; i++)
                              string QueryPart = IndividualResults[i].Split(':')[0];
                              string ResultType = IndividualResults[i].Split(':')[1];

                              switch (ResultType)
                                   case "string":
                                       ConcatenatedString += QueryPart + ": " + reader.GetString(reader.GetOrdinal(QueryPart)).TrimEnd() + " ";
                                   case "int":
                                       ConcatenatedString += QueryPart + ": " + reader.GetInt32(reader.GetOrdinal(QueryPart)) + " ";

In the above code the QueryPart and the ResultType each represent the column name and type of the key-value pairs of the results string. In this way I can basically add in any new query methods without the need for recompilation. For examples see the below two images.

LoadedQueriesExample1   LoadedQueriesExample2

Figure 1. The initial functionality.

Figure 2. The expanded functionality based upon the updated XML file.

Figure 1 (on the left) is created with the first XML layout below. The layout in figure 2 (on the right) is an extension of the first layout. In my implementation it was possible to add an entirely new piece of functionality by just adding an additional XML line.

More work would have to be put in to account for queries that insert and update data (some way of knowing which visual element provides which bit of data for the query would have to be agreed on), but overall it provides what I wanted.


Using SQL connections in C#

Last time I used an SQL database with C# it all went through the LINQ plugin. It’s useful, but it always takes a good while to setup and requires me to remember a good chunk of code (like where to put the NotifyChanging and NotifyChanged parameters, what attributes are needed, etc). One of the things I discovered courtesy of this page  (accessed 13/06/2017) is that the .NET framework provides some APIs to link to a back-end database.


Using these I’ve created a simple database management system in order to query and update a database through a WPF GUI application. The database I’ve created is comprised of 3 tables: a customer table, an order table, and a product table. The application allows the user to query the data in the database, update the data, and insert new records.

The actual code involves first creating a data connection, then a command, and finally executing the command. It’s the ability to manually stick in the SQL string you want to execute that makes it the most useful to me, but since each row being returned is comprised of different rows it means having to come up with some alternate mechanism to account for the results of each row. This means that the finished program is lot longer than a LINQ alternative.

I think I like this approach over the LINQ option; it means writing the SQL queries in by hand, but I think this is a fair trade-off for having a simpler setup. I suppose if I’d known about this simple API beforehand then I’d probably used back-end databases in some of my older projects.

One possible change to be made to this program would be to store the SQL queries in some external file so I don’t have to recompile the thing every time I want alternatew functionality. The idea I’ve come up with is to use an external XML file and then use some kind of regular-expression replacement mechanism (this has become something of a go-to thing for string replacement lately (worrying maybe, but if it works)) in order to programmatically alter the subject of the search. This would be necessary as most of the queries inherent in the project require either data insertion or mild changes of the same query.

Creating a simple Chrome extension

Working Extension

Image 1. The current popup frame for my extension

With the help of some online tutorials and pretty good documentation I’ve managed to make a simple Google Chrome extension. Built more to experiment with the kind of functionality that can be built, my extension does some pretty basic stuff, but it’s interesting to know how these things can be built to target multiple web pages.

My extension currently has 4 bits of functionality: get the page to display a simple alert, remove all of the images on a page, replace all of the images on a page, and display all of the hypertext links on the page in an alert.

Before  Removed Images

Image 2. The original image search.

Image 3. The image search with sources removed through my extension.

Replaced Images LinkRetrieval

Image 4. The images replaced with a separate PNG image through my extension (original image here)

Image 5. The links retrieved from each <a> tag on the page

As it turns out, you can make the prompt with a simple HTML file. This was a pretty nice surprise as HTML and CSS are simple enough and I can make a fairly nice interface using them. The problem is that an extension doesn’t support inline JavaScript (so StackOverflow says) meaning that you have to add event handler’s to each different button.

One interesting mechanism I’ve had to learn about is the message passing mechanism chrome extensions have to implement for communication between content-scripts (ones that are embedded into the page) and the scripts running in the extension. The messaging code involves sending an appropriate code to the recipient, it is up to the recipient to pick an appropriate action based upon this code. It reminds me of Android’s intent mechanism.

I’ve used messaging in two places in this extension: to trigger the functionality necessary from the extension, and to initially update the extension with the number of images and links on the page.

This hasn’t been a bad experiment, now I just have to think of some kind of missing functionality to base an extension around.

I learnt a significant deal how to get started from this helpful tutorial (Getting Started, accessed June 6th 2017), without which I wouldn’t be able to create the manifest file, and based most of my messaging around the tutorials found on the official messaging page (Message Passing, accessed June 6th 2017).

3 Thing Game 2017 Entry

Every year the University Of Hull’s Computer Science department host a game where teams get assigned three random words and then have to create a game around those words. This year team Error 303 (a holdover name from our first year) created Mine of Aether, which Kristian has made available here.

Mine of Aether 1  Mine of Aether 2

Why Mine of Ather? The three words we got were: miner, ethereal, and caution. Since the point of the contest is to base the game around the words the overall concept was as follows: you play as a miner navigating his way through tunnels in an attempt to find jewels (or treasure chests in this case), all the while avoiding the enemies present in the mines and using the temporary ghost mode to reach areas that would be otherwise inaccessible.

The entire thing was created in Unity, which, thankfully, the other members of the team have far more experience with, and, miraculously, has its own kind of source-control mechanism so you can work across machines.

Unlike our usual 3 Thing Game performance where we stay up most of the night and get too tired to make much progress at about 8 or 9am, this year we managed to last the full 24 hours. It would be fair to say that the game still needs work and we didn’t get to put in everything we wanted, but its definitely worth a play through.

Android’s Gyroscope

Learning to use the sensor’s in an Android machine is something I should have done a while back. One of the things I’m liking about the Android system is that it seems to provide access to what I assume is pretty complex technology with simple sensor classes (even if Android Studio still bugs me to a great extent).

The application I’ve made uses the change in the gyroscope’s angle in order to draw onto the canvas. Basically, a tilt of the tablet changes the direction in which the controller on screen moves and consequently the direction in which the line is painted.

Building this involved a couple of interesting little tricks: inheriting from the android view class, overriding the onDraw method, and learning to register and unregister android services. Actually figuring out how to stick a compiled application directly onto a device was a bit of a pain; that tap the model number 7 times to get the developer mode trick is very strange.

The main goal of this was to learn how to use the built in android sensors, so the drawing implementation is not exactly efficient. In order to correctly draw the line, the view I’ve implemented stores a list of previous positions and draws a circle the same size of the character at that point; at the moment there’s no limit on the size of the list so it will inevitably cause a crash if there are too many changes in the screen’s orientation.

One of the things I didn’t consider when making this program was that I’ve set the speed of the character based upon the change in rotations (with the addition of some threshold values to make sure it can continue one direction and doesn’t just travel forward and back), but because of differences in the screen size I can turn on one axis a lot quicker. That’s something to consider for the future, should I ever put this to use.

The gyroscope sensor code I’ve used in this code can be found in the below videos (neither of which are my own content). The first targets the gyroscope sensor explicitly, the second is targeting an accelerometer, but I think it gives a better insight into the event values array that the sensor events provide. These are the X, Y, and Z rotations in the case of the gyroscope, and that took a while to wrap my head around.

Video 1 – Last accessed 21/05/2017

Video 2 – Last accessed 20/05/2017

As an afterthought, it wouldn’t be a bad idea to monitor the change in angle to calculate acceleration. This is more physics work than anything sensor-based, but it’d be a cool way to improve the app.


It probably isn’t a great idea to rely on Visual Studio and WPF for everything. That’s what I decided at the beginning of the week as a thin excuse to take another crack at trying GTK#. I’d considered using this as part of my final year project, but ultimately decided that it was too unfamiliar and that I could get a lot more done a lot sooner by using something I knew.

Now I’ve decided to take another look at it because I want to write something for the Linux OS I have on my computer. I’ve took a crack at some little, console-based things before, but I knew that eventually I’d like to make something with a GUI (I should probably take a look at installing Java on there sooner or later). Apparently you can run anything you make on the Windows OS on a Linux or Mac installation if you run it through the Mono Project software; it’d be nice to have some familiar libraries available when I get back to it.

It’ll be interesting if it works. Still, new framework, so baby steps. I’ve been writing everything in a new editor (Xamarin Studio) for a new framework so it’s not the most technically impressive thing I’ve ever made; so far I’ve got a simple box to store a list of strings.


Seems simple enough, but GTK# (a wrapping of GTK according to the website) doesn’t seem to have the same kind of simple layout as other frameworks. I spent a good while yesterday trying to figure out how to programmatically add data to and from the combobox; you can insert text, but try to get the text back and you find a CellView object (as I say, early days).

In fact I think it would be fair to say that most of the time it took me to build this (far longer than I expected for something that I could knock together in any framework I’m familiar with) was spent trying to puzzle out which of the strangely named features accessed the data I wanted. I’m a little disheartened at my progress to tell the truth. Still, I do intend to get it running on my Ubuntu installation, that was the point after all.

This is hardly the most interesting of posts, but, like with my recurring project, my reasoning (if that’s what were calling it) is that I should try and document as much of what I do as I can; it’ll stop me repeating the same projects over again. From this I think the take-home is that new frameworks will bug you if you don’t take the time to learn them properly (or if all the documentation for them is written in another language from a couple of versions back).

Simple Route Traversal

So a while ago, during a university module, we all had to make a design data structures that could support bi-directional travel. It was a fairly interesting task, and I’m happy to say I did very well.

The problem with this was that the implementation wasn’t very fun to look at; the purpose of the task was to build efficient data structures in C++. I’ve decided to build a similar sort of thing, but instead of just re-uploading my old code (which feels a bit like cheating) I’ve built a new system complete with a GUI.


Figure 1. My program displaying a simple network

The system currently works as follows. Add a node, create a link between two nodes, and find a path between the two.


Figure 2. A highlighted route in my program based upon input criteria

The data object

One of the reasons I decided to do build this is that I’ve recently being writing C programs with data structures. Since these only had to be tiny things to demonstrate functionality I kept finding myself writing a simple list implementation that can be searched by recursively checking each node and accessing its ‘Next’ node. This project finally puts this structure to some use.

Each ‘node’ in this project contains an identifier, X and Y coordinates, and a list of other nodes that connect to it. Algorithms in this project work by recursively calling each connected node from the current. The root node is accessed first.

Infinite loops

Creating this the first time was infuriating! Create a system in which you can only visited a place once and you’re fine, but add the ability to travel backwards and you have to start keeping track of where your going.


Figure 3. A simple recursive loop that would cause a stack overflow if previously visited nodes were not taken into account

Take the above example. You’d think that a simple square route wouldn’t be too much of a hassle, but trust simple logic to outfox the lazy programmer. You start at Route, which goes to 1, then to 2, 3 follows, and then since you don’t remember that you went to Route already you visit again. This continues until your program throws a scary exception, chastising you for not thinking ahead.

Which isn’t to say that this is a particularly difficult problem to solve once you put some thought into it, but it does mean you have to pass another list of nodes to whatever function you want to make sure you don’t visit them again. In the past coursework when I did this I created route objects and node objects; the route objects would hold the node objects it connected. This might be a better way to do this; have each route object have a flag denoting whether its been traversed yet. It would be more complicated (something I’d rather avoid when an overly-complex spec isn’t provided), but it would be more elegant, and would stop me iterating through the entire list of past nodes every time a new node is checked.

Drawing the network

WPF doesn’t have a HTML like canvas, but if you inherit from a ‘UserControl’ it will let you override the OnRender method you can access the basic visual methods: DrawLine, DrawRectangle, etc. Apparently this doesn’t do particularly well when the visual element has to refresh quickly, so my hope of making this scroll-able might have to wait a while (I’m sure I’ll try it, though I’ll feel a tad less proud if I wind up with a sluggish mess).

Saving and loading

It never occurred to me that this would be so time-consuming. As with all other software I want to be able to save what I’ve made so I don’t feel like the 2 hours I’ve spent looking at a screen could have been spent lazing around on the couch for all the effect it’d have on my productivity.

The problem with saving the state of this program was that you have to create load in links between nodes that might not have been loaded yet; you can save out a node with its list of connections, but when you load it in you can’t recreate that connection until you recreate the necessary nodes. My solution: create a simple structure to store the node and its list in string format and then evaluate each once they’ve all been created. I know, hardly splitting the atom is it? Nonetheless, I’m pretty happy that I’ve got an extensible solution that could be applied regardless of the size or structure of the route put in.

Improving the program

Right now the route that the program suggests when prompted is based upon the order in which the nodes were attached to each other. This was all I wanted for the time being, but it’s not the best way of finding a route. There are many different algorithms, and I want my program to tout at least some variety. What would make this really great would be the ability to calculate the shortest path between nodes, or fewest individual routes.

Creating a person life-cycle with C# events

I’ve made a basic simulation. It’s not overly complex, but I think it’s a pretty good use of the C# events. In my tiny simulation people are born, taxed, and die. It’s a bit of a morbid outlook on life, but then I suppose these aren’t real people so they can’t have any greater purpose or profound insight so I can dispose of them with a relatively easy mind.

I’m particularly proud of this because in my admittedly basic system everything basically handles itself. Each person class its own life-cycle which runs on its own background thread.

public Person(int PassedTaxes)
     Taxes = PassedTaxes;
     t = new Thread(LifeCycle);

public void LifeCycle()
     PersonBorn(this, new EventArgs());
     PersonTaxed(this, new EventArgs());
     PersonDied(this, new EventArgs());

This means that when it comes time to managing each of these people in my main program they can all be added or removed from the big list of people whenever the ‘PersonDied’ event had been triggered.

This is an admittedly simple example of using events, but since the person life-cycle is now essentially self contained, I can spend a lot more time fiddling with the more fun aspects of the program. For example, now that everything runs on its own clock and I don’t have to implement constant checks I can continually alter the the rate at which people are produced since I’m soundly assured that individual life-cycles are accounted for. I could probably implement variable lifespans too.

One of the best bits is that I can now add new functionality to every ‘person’ in my simulation by just adding new events to that life-cycle. For example, I’ve just implemented a 50/50 chance that my person will divorce somewhere between taxation and death (not the happiest 15 second life I know, maybe I’ll throw in a birthday party event if I start feeling altruistic).SimpleSimulationInterface

My simple simulator’s interface

As I say, hardly the most complex bits of software out there, but using my own life-cycle is probably something I’m going to do a good deal more of in future projects.

Simple note keeper (my recurring project)

A few years ago I received a very nice Android Tablet as a Christmas present. I’ve had a lot of fun using it normally, but eventually I decided that I’d quite like to run my own software on it.

The first program I could think to make was something that could communicate data back to a server. I’m not entirely sure why I’ve decided on this but the idea of communicating from a central device back to a server which does the real work has a certain appeal to it.

The first time I did this I tried to communicate back a list of people and associated information. This worked but the GUI for both the client and server were horrible. Additionally this was my first run-in with Android programming and I developed a deep-seated loathing for Eclipse (something I’ve found I can readily extend to Android Studio).

The second time I tried this I decided that I wouldn’t make an android specific program, but instead it’d be all browser-based. The server would spit out the webpage the webpage would send back the data to the server, and then on the server-side cut down the post message to retrieve the data.

Today’s version of the program is a simple note keeper which once again involves and Android-based client (interface below).


The goal for this program is for the application to create a simple file on the device and for the user to be able to send this file to the server when it’s accessible. Its a very simple design from the user’s end: set the note’s title in the top box, set the note’s contents in the larger box below, and add the note to the list of notes with the topmost note button.

Files will be transferred if possible when the user clicks on a Send button (noticeable absent in the above image). This will send the entire list of notes to the server. In order to make the networking aspect somewhat justified in my mind, the client will contact the server when it opens and give the user to download any notes that are not present on the client. I suppose this networking aspect is just present to prevent data loss in the event of some monumental crash.

Now that I’ve created a record of it I’ll hopefully have some kind of mental motivation to finish the thing.

Thanks for reading.

A first blog

After a few years of being told that it would be a good idea to setup an online space to document the type of work you do I finally decided to do it. Last year.

I may as well start this blog with a recap of exactly what went wrong the last time. I decided that it would be a good idea to have my own online space. It would be interesting to have my own domain and to dictate how it was used. Since I enjoy creating things I then decided to make my own webpage powered by AJAX and PHP. I used this to fetch descriptions of the webpages for when the user hovered over the pages button, and to build a search function based on the user’s input.

My website worked, but, as is often the case when you ignore a perfectly good solution and run off with your own nut-ball idea, it didn’t work particularly well. It didn’t scale well to different screen sizes and I’d used fonts that weren’t available on android devices. It was a mess from a user interface point of view.

This side-project cost a not insignificant amount of cash so this time I’ve decided that someone else can shoulder the cost of what could generously be described as ‘my work’ (thanks WordPress).

Hopefully this blog will serve as a useful tool where someone can find something useful. If not it’ll at least serve as a useful reminder of the work I’ve done and stop me making the same program over again (yep!).

Hope you enjoy.