rbd

To Factor and Back Again

2026-07-07T00:00:00+00:00

Warning: bad Factor code contained within.

As an escape from AI, I recently started programming in Factor. As well as being a very interesting departure from C-like languages, AI kind of sucks at writing in it - keeping me from reaching for that crutch.

After messing around a little bit, getting used to the syntax (which was much easier than I expected thanks to its simplicity and the resulting consistency), I decided upon a first project: I would resurrect this blog, once powered by Jekyll, with a custom generator.

The first hurdle

No package manager… and no markdown package.

So… I sat down and started writing a parser from scratch. This was a good exercise, and it was during this that the concatenative style really clicked for me. One eureka moment was realising how much more readable and expressive code could be when following the sorts of functional patterns we often use in Swift: map, reduce, etc (I had initially reached for recursion 🤷‍♂️).

:: parse-md-line ( string -- md-line )
  ! ( -- line-type slice )
  all-line-types
  [
    line-type-pattern string
    swap <regexp>
    first-match
  ]
  map-find
  swap
  
  ! ( slice -- string )
  1array missing-slices
  "" join

  md-line boa
;

Rescued by the standard library

While Factor doesn’t have a package manager, what it does have is a great standard library.

After beginning to get frustrated by my lack of progress, I discovered the fantastic EBNF package after watching Factor: an extensible interactive language by Factor’s creator, Slava Pestov. With this vocab (library) at my disposal, I binned all my work up to this point, and started again 🙂. In a fraction of the time I had spent on the previous version I had ~90% of a parser.

EBNF: markdown [=[
  text = [^*_[\n]+
    => [[ >string text swap 2array ]]
  char = [^\n]
    => [[ 1string text swap 2array ]]
  link-text = [^*_[\]\n]+
    => [[ >string text swap 2array ]]
  link-char = [^\]\n]
    => [[ 1string text swap 2array ]]
  bold = "*"~ (!("*") inline)+:xs "*"~
    => [[ xs >array bold swap 2array ]]
  italic = "_"~ (!("_") inline)+:xs "_"~
    => [[ xs >array italic swap 2array ]]
  link-inline = bold | italic | link-text | link-char
  link = "["~ link-inline+:label "]"~ "("~ [^)]+:url ")"~
    => [[ label >array url >string link -rot 3array ]]
  inline = bold | italic | link | text | char
  h1 = "#"~ " "+~ [^\n]+:t "\n"~
    => [[ t >string h1 swap 2array ]]
  h2 = "##"~ " "+~ [^\n]+:t "\n"~
    => [[ t >string h2 swap 2array ]]
  h3 = "###"~ " "+~ [^\n]+:t "\n"~
    => [[ t >string h3 swap 2array ]]
  ulitem = "*"~ " "+~ inline+:xs "\n"~
    => [[ xs >array ul-item swap 2array ]]
  olitem = [0-9]+~ "."~ " "+~ inline+:xs "\n"~
    => [[ xs >array ol-item swap 2array ]]
  list = (ulitem|olitem)+
    => [[ >array list swap 2array ]]
  paragraph = inline+:xs "\n"~
    => [[ xs >array paragraph swap 2array ]]
  blank = " "*~ "\n"~
    => [[ ignore ]]
  header = h1 | h2 | h3
  block = header | list | paragraph
  document = (blank|block)+
    => [[ [ ignore = ] reject >array ]]
]=]

For templating, I simply took advantage of Factor’s ability to dynamically evaluate a string of Factor code. Strings wrapped in %% become quotations (closures) that are expected to push a string onto the stack when called (returning a string). Post metadata uses %%%, whose quotation instead relies on side effects to set metadata and leaves the stack unchanged.

USING: kernel splitting parser strings math sequences ;
IN: template.parser

<PRIVATE

: parse-quotation ( slice -- quotation )
  >string
  split-lines
  parse-lines
;

: quote-text ( slice -- quotation )
  >string [ ] curry
;

: parse-body ( string -- blocks )
  "%%" split-subseq
  [
    2 mod 0 = [
      quote-text
    ] [
      parse-quotation
    ] if
  ] map-index
;

PRIVATE>

TUPLE: template meta body ;

: parse-template ( string -- template )
  "%%%\n" split1
  dup [ swap ] unless
  parse-body
  [
    dup [ parse-quotation ] when
  ] dip
  template boa
;

This post was rendered by Ruby

Factor is incredibly powerful. A quotation is just a collection of words (functions), providing similar flexibility to that of Lisp’s homoiconicity. Coupled with its seamless support for macros - it’s a language which will be whatever you want it to be.

Factor is beautiful. I realised during the project that its concatenative style is a purer, cleaner way of expressing some of my favourite patterns in Swift and PowerShell: method chaining and piping. Being point-free, it’s physically quicker to make changes to your ‘chains’ than either of those two languages.

The tooling is amazing. You’re provided with one of the best REPLs I’ve ever used, and are encouraged to conduct all your development through it: scaffold modules and tests, play with and edit code, search documentation. I haven’t done much ‘REPL-driven programming’ before, but the listener has converted me.

It’s also fast.

However…

You could make most of these points about Ruby too… maybe not about speed 🙂, but certainly power, its metaprogramming capabilities placing it firmly in the same league as Factor - Ruby’s power is just derived from its Smalltalk lineage rather than from Forth (Factor has great OO facilities too - but they don’t feel as seamless as Ruby’s to me).

I was also becoming concerned about Forth/Factor’s reputation as being ‘write-only’ languages. Readability would likely improve with experience, but even coming back to code I had written the previous evening could prove difficult. Thinking Forth presents Forth’s stack and point-free style as an aid to modularity:

Forth eliminates from our programs the details of how words are invoked and how data are passed. What’s left? Only the words that describe our problem.

But the same coupling to arguments in C-like languages’ functions exists here too, it’s just hidden. Forth words are coupled to the stack order - the order of their positional arguments. I believe the more explicit coupling allowed in Ruby, of non-positional argument names, is more accommodating to change and re-use.

In the end

I tired of fixing edge cases in my parser, and the allure of Ruby got the better of me (or perhaps I’m just fickle). I grabbed Kramdown and ERB. Much less work… after spending an afternoon configuring Pry and Neovim to provide a fraction of the listener experience 😅.

I found myself omitting a lot of brackets.

(much to Rubocop’s disgust)

SwiftUI OMDb search experiment

2019-06-05T00:00:00+00:00

SwiftUI, announced yesterday at WWDC, is very cool 🤓. Allowing you to create your UI with a declarative style it seems to reduce a lot of boiler plate code. And as mentioned in a post I wrote about Flutter (which also adopts a declarative style), I think it will naturally encourage reusability and cleaner code.

For the chance to mess around with it a bit, I reproduced some of the UIKit OMDb client I talked about in my previous post. Although it took a little getting used to, the number of lines for features I reproduced in SwiftUI were generally reduced. And, although I’m sure what I wrote won’t match future best practices, I think I preferred the style of the code I wrote with SwiftUI to that with UIKit.

XCode

Although I’ve not yet had a go with some of the new XCode features related to SwiftUI (they need Mac OS Catalina), the support for SwiftUI looks even better than the support for Flutter on Android studio. The hot reload and new ‘interface builder’ that provides shortcuts but doesn’t make you give up the power of programmatically defining your UI looks incredible.

Custom ‘tab bar controller’ for two child VCs

2019-05-24T00:00:00+00:00

The 1.1.1.1 App uses an interesting way of navigating to and from its settings menu. It performs the role of a tab bar, but possibly looks a lot cleaner than a tab bar would with only two items.

To accomplish a similar navigation I wrote a simple subclass of UIViewController that has two child VCs and swaps between displaying each of their views using a persistent UIButton.

Find the project here.

Flutter Experiment

2019-01-30T00:00:00+00:00

With all the buzz around flutter at the moment, especially among the android developers at work I find, I thought I’d have a go at making a simple app. So I made a to do list app of course.

Initial impressions

I am probably biased. Maybe the development cost savings are worth it, but overall, I definitely don’t think it approaches the native Xcode development for iOS at least. And, although the apps look good, to me they just don’t feel as nice on iOS, and there are things that make them pretty destingishable.

However! The hot reload was really cool, and definitely saves a lot of time. I also quite like the step away from ‘Storyboard-like’ development, I’ve been trying to use storyboards less in my Xcode/swift development anyway, I think it promotes reusability can produce simpler code.

Editors

Another nice thing is not being as chained to Xcode. Although I think Xcode is pretty great, I prefer using Vim keybindings which is impossible or a pain to get working with Xcode. Android studio and the fist party plugin for VSCode both work great and allow for Vim keybindings 🥳.

I like Vim a lot though, so I spent way longer than was worth it setting up neovim for flutter development and it did a pretty good job thanks to LanguageClient-neovim & dart_language_server, deoplete.nvim and dart-vim-plugin.

PowerCLI: Reset VM to Current Snapshot

2018-06-21T00:00:00+00:00

One thing I often found myself doing with the VMWare vSphere client is resetting VMs to their previous snapshot, therefore ‘cleaning’ them. I’ve since started using PowerCLI for almost everything, however, I couldn’t find a simple way to use if for resetting VMs, the built-in cmdlets requiring you to name a specific snapshot (please let me know if there’s something I’ve missed!).

To get around this I wrote a simple function that will just reset any VM to its most recent snapshot, which I keep, along with some other PowerCLI related functions, in a PowerShell module that gets imported whenever I connect to the server:

function Reset-VMToCurrentSnapshot {
    [CmdletBinding()]
    param (
        [parameter(Mandatory = $true,
        ValueFromPipeline)]
        [string] $VM,

        [parameter(Mandatory = $false)]
        [switch] $confirm = $true
    )

    PROCESS {
        $doit = $true
        $snap = Get-Snapshot -VM $VM | where {$_.IsCurrent -eq $true}
        if (((Get-VM $VM).PowerState -eq "PoweredOn") -and $confirm) {
            $title = "Revert $VM to $snap"
            $message = "$VM is powered on, are you sure you want to revert it?"
            $yes = New-Object `
                System.Management.Automation.Host.ChoiceDescription "&Yes", `
                "Revert $VM to $snap."
            $no = New-Object `
                System.Management.Automation.Host.ChoiceDescription "&No", `
                "Don't revert $VM."
            $options = [System.Management.Automation.Host.ChoiceDescription[]]($yes, $no)
            $result = $host.ui.PromptForChoice($title, $message, $options, 0)
            switch ($result)
                {
                    0 {
                        Write-Verbose "Reverting $VM."
                    }
                    1 {
                        Write-Host "Leaving $VM as is."
                        $doit = $false
                    }
                }
        }

        if ($doit) {
            Write-Verbose "Setting $VM to $snap..."
            Set-VM -VM $VM -SnapShot $snap -Confirm:$false
            Write-Verbose "Done!"
        }
    }
}

GoLang GUI Libraries

2018-06-20T00:00:00+00:00

At work, I’ve recently had the need to create simple desktop programs for Windows to provide more effective user interfaces to configure and launch a number of scripts. And, mainly because I’ve been really enjoying using the language lately, I decided to use Go to write it… Problem is, there aren’t very many libraries available to do this that are stable and complete! In this blog post, I hope to highlight some of the more promising ones.

Qt bindings

There are a couple of projects on Github claiming almost complete Go bindings for Qt. Although I’ve found Qt to be very useful for similar things in the past, the ~35GBs for Qt itself, and relatively complex setup were enough to put me off even trying these libraries out. But they do exist! There is a nice list of libraries for building GUI programs here, you’ll be able to find the more popular Qt bindings there, as well as many other options.

Walk

Windows Application Library Kit. This one looked very promising at first, it’s Windows-specific and can be set up using go get. I’ve also read a few articles praising it. My personal experience was okay, I think I could have used it if I’d needed to. It isn’t the most complete but it’s not bad, and its declarative subpackage can make code actually arranging the interface widgets more readable than other options. In the end, it still had some of the same problems as other options and I’d prefer something with a bit better documentation.

ui

ui is a very simple cross-platform GUI library based on libui (a C GUI library by the same author). Ultimately, it’s the option I chose to use. I found it very easy to set up (it also supports go get) and to use. It got the job done! The main drawback, as with most of the options, is completeness. As of writing this post, there is no text area widget (however, another fork of the project has one!). I ran into other issues due to lacking features but there was always a solution/workaround easy enough to be found.

PowerShell User Interaction

2018-04-20T00:00:00+00:00

With a lot of scripts, automating repetitive tasks is the goal, and therefore user interaction should be minimal. That being said, PowerShell is rich in ways to handle it.

Pauses

For PowerShell 3 and up you can just do Pause to pause until the user presses enter.

Press Enter to continue...: _

For earlier versions, you could define a ‘Pause’ function with Read-Host:

function Pause {
    Read-Host "Press Enter to continue..." | Out-Null
}

Fall back to using cmd.exe:

function Pause {
    cmd /c "pause"
}

I’ve also seen people write pause functions to continue on any key press (not just enter) like this:

function Pause {
    Write-Host "Press any key to continue..."
    do {
        $x = $host.UI.RawUI.ReadKey("NoEcho,IncludeKeyUp")
    } while (9, 16, 17, 18, 91, 92, 144 -contains $x.VirtualKeyCode)
    # ignore some keys (Tab, Shift, Ctrl, Alt, WinL, WinR, NumLock) sent by certain events when running via RDP
}

Prompt for Choice

Another common way of getting user interaction is presenting a list of options using $host.UI.PromptForChoice.

$title = "Version number"
$message = "Is $version the correct version number?"

$yes = New-Object System.Management.Automation.Host.ChoiceDescription "&Yes", "Use version number $version."
$no = New-Object System.Management.Automation.Host.ChoiceDescription "&No", "Enter a version number manually."

$options = [System.Management.Automation.Host.ChoiceDescription[]]($yes, $no)

$result = $host.ui.PromptForChoice($title, $message, $options, 0)

switch ($result)
    {
        0 {
            Write-Host "Yes!"
        }
        1 {
            Write-Host "No!"
        }
    }

This will give your user an interface that looks like:

Version number
Is <someVersionNumber> the correct version number?
[Y] Yes  [N] No  [?] Help (default is "Y"):

They can then enter y for yes, n for no etc.

GUIs

If you’re using Windows PowerShell you also have the option for user interaction through GUIs. The cmdlet Out-GridView lets you visually filter or select objects, I’ve previously written a post specifically on Out-GridView. Having access to full .NET also allows you to easily create bespoke GUIs using Windows Forms or WPF, I’ve also previously written a post on this.

PowerShell with Vim

2018-04-05T00:00:00+00:00

Using Vim with and to write PowerShell!

Not as good as VSCode

When it comes to writing large PowerShell scripts, VSCode is plain better, thanks to Microsoft’s extension for PowerShell (there are extensions to emulate Vi key bindings too). To be honest, the PowerShell ISE is also a better bet. But! There are some cases where it can make sense to use Vim, mostly when you want to quickly write a short script or make a small change to a pre-existing script. Vim launches faster than VSCode (not that VSCode is at all slow) and, provided you know the correct key bindings, can often be quicker to perform the edit with. Or maybe you just like using Vim!

Neovim

If you’re wanting to use Vim to write PowerShell, even with the introduction of cross-platform PowerShell core, chances are you’re on Windows. If that’s the case I recommend using Neovim with the Neovim-Qt GUI. Using a GUI just feels more natural on Windows and Neovim-Qt is cleaner out-of-the-box than gVim. I’ve also run into fewer problems running Neovim than I have with Vim when on Windows.

Windows clipboard

To get Ctrlc/v copy/paste working for Neovim-Qt when in insert mode just add source $VIMRUNTIME/mswin.vim to your vimrc file.

On Windows, Neovim’s vimrc file is located at %USERPROFILE%\AppData\Local\nvim\init.vim.

Setting Posh as Vim’s shell

By default, shell commands use cmd.exe, to use PowerShell instead just add the following snippet to your vimrc file.

set shell=powershell.exe
set shellcmdflag=-NoProfile\ -NoLogo\ -NonInteractive\ -Command
set shellpipe=|
set shellredir=>

Adding -NoProfile\ when setting shellcmdflag stops PowerShell from loading your profile every time you run a shell command from Vim, e.g. :!ls, but still loads it when creating a Neovim terminal buffer, :terminal.

ps1.vim

To add syntax highlighting, I use this plugin. It does what it says on the tin! I recommend using vim-plug for managing plugins if you’re not using something already.

Abbreviations

It’s good practice to use a cmdlet’s full name when writing PowerShell scripts so I like to set up abbreviations for my most frequently used aliases e.g.

:ab ls Get-ChildItem

Since abbreviations activate just the same when writing comments or strings (you might not want them to), I avoid setting them for cmdlet aliases that I rarely use.

Reuse

As I don’t want these abbreviations when using vim for anything but PowerShell I put them in ftplugin\ps1_ab.vim instead of my vimrc file. They are then only loaded when the filetype is ‘ps1’. Because I have ps1.vim installed (see above) the abbreviations will be picked up for other PowerShell file extensions too, e.g. .psm1.

For the sake of using vim-plug to manage ps1_ab.vim, I keep it in a Git repository and just add Plug 'robin1996/posh-ab' to my vimrc file.

My full vimrc file

{% gist 0238fc1cb42a9b586cd0fc6e6a4fadc6 %}

Mike Attewell on Britain's Decline

2018-03-09T00:00:00+00:00

Local Durham artist, Mike Attewell, recounts the erosion of the welfare state during his lifetime for this week’s Guardian ‘Good To Meet You’.

For more of his work see mike-attewell.co.uk.

PowerShell Notes Gist

2018-02-12T00:00:00+00:00

Just for the sake of writing a Github Gist I decided to post some of the notes I made when first learning PowerShell.

PowerShell XAML GUI

2017-12-13T00:00:00+00:00

Hello! Today I wanted to write a bit about creating GUIs/forms as part of PowerShell scripts. Sometimes having a GUI rather than just a command line interface for scripts can be beneficial, they can often be more intuitive to use and can give the user more of a ‘bird’s eye view’ of the script’s controls than just a succession of questions or script parameters. Plus, who doesn’t want to spend hours adding shiny GUIs to their scripts anyway?

I recently set up a GUI for controlling our scripted build process at work (we will be moving to a CI server soon… hopefully). And, since most of the scripts are written in PowerShell and I don’t know C# I thought it made sense to put the GUI in PowerShell too.

Tools

As Windows PowerShell uses the full .Net framework, it has access to both Windows Forms and WPF. I chose to go down the WPF route as it allows you to write the GUI itself using XAML rather than fiddling with form objects.

There are tools available like Visual Studio that will let you create your XAML GUI using a GUI, which is probably a lot faster and just all around better than writing the XAML by hand… but I decided to use the program Kaxaml (at the time of writing this post their website is down, but you can find the project’s GitHub here). Kaxaml allows you to write XAML and then preview it… it’s free!

Adding the XAML

Once you have written your GUI in XAML you can add the code to your PowerShell script as an XML object using a here-string.

[void][System.Reflection.Assembly]::LoadWithPartialName('presentationframework')
[xml]$xamlCode = @'
<Window
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
Title="Test GUI" WindowStartupLocation="CenterScreen">
    <Grid Margin="0,5,0,0">
        <Grid.RowDefinitions>
            <RowDefinition Height="auto"/>
            <RowDefinition Height="auto"/>
            <RowDefinition Height="auto"/>
        </Grid.RowDefinitions>
            <Label Grid.Row="0" Content="Hello World!!!!!"/>
            <ComboBox Grid.Row="1" Name="testCB"/>
            <Button Grid.Row="2" Name="testBtn" Content="Test"/>
    </Grid>
</Window>
'@

You then need to have PowerShell read the XML object and create the GUI object from it.

$reader = (New-Object System.Xml.XmlNodeReader $xamlCode)
$GUI = [Windows.Markup.XamlReader]::Load($reader)

Connecting functionality

To actually do anything useful with your GUI you’ll want to make its component’s objects easily accessible in PowerShell. A couple of ways to do this are by storing the components you want to use as variables individually, or by parsing your XAML code and storing each of your GUI’s components automatically.

$xamlCode.SelectNodes("//*[@Name]") | ForEach-Object { Set-Variable -Name ($_.Name) -Value $GUI.FindName($_.Name) }

This creates a variable for each component using their names in the XAML. You can then use these variables to set/get each component’s properties.

$testCB.ItemsSource = "Option 1", "Option 2", "Option 3!!"

Or add events.

$testBtn.Add_Click({
    Write-Host $testCB.Text
})

Showing the GUI

Finally, to show your GUI, just call ShowDialog on its object.

$GUI.ShowDialog() | out-null

Tada!

PowerShell git branch GridView

2017-12-11T00:00:00+00:00

Hello! Today, I needed a way to easily input a branch name into a PowerShell script. To do this, I decided to use what is easily the most fun cmdlet: Out-GridView. This solution would let me select the branch I want to use from a searchable GUI list.

I first needed the list of branches.

PS> $dotgit = "C:\Development\Project\.git\"
PS> git --git-dir=$dotgit branch -r | Out-GridView

--git-dir=$dotgit lets me point the command at a git repo without being in it. -r specifies that I want the list of branches on the remote.

Already we have our list of branches! There are still some improvements that can be made. I have no need for the first line in the list, ‘origin/HEAD -> origin/master’, nor the ‘origin/’ word prefixing every line.

PS> git --git-dir=$dotgit branch -r | Select-Object -Skip 1 | ForEach-Object {$_.replace("  origin/", "")} | Out-GridView

Select-Object is used to skip the first line. ForEach-Object is used to replace the word ‘origin/’, and the unnecessary white space that comes before it, with an empty string.

The list itself is now perfect, but I still need to make some changes to Out-GridView so that I can use it to select the branches I want.

PS> git --git-dir=$dotgit branch -r | Select-Object -Skip 1 | ForEach-Object {$_.replace("  origin/", "")} | Out-GridView -Title "remote branches" -PassThru

-PassTrue does just this, and any branches I select will now be passed down the pipeline when OK is clicked. -Title just sets the window’s title.

function pickBranch($dotgit) {
    git --git-dir=$dotgit branch -r |
        Select-Object -Skip 1 |
        ForEach-Object {$_.replace("  origin/", "")} |
        Out-GridView -Title "remote branches" -PassThru
}

PowerShell File Versions

2017-12-05T00:00:00+00:00

Today, as part of a larger script, I needed to write a PowerShell function to check that an assembly’s version number had been properly bumped between two builds of a program. Writing this function should be simple (right?).

First things first, get the version numbers. I looked at a File Version in Explorer, ‘16.0.255.0’, cool. Went to do the same in PowerShell.

PS> get-item .\someFile.exe | select VersionInfo | Format-List *

...
FileVersion:        16.00.0255
...

‘16.00.0255’, a bit odd? This particular file was an InstallShield setup.exe which was versioned ‘xx.xx.xxxx’ within the MSI so it didn’t seem too strange of a difference. I then took a look at a few more files, although for the majority of them, their FileVersion in PowerShell matched Explorer, for a few others there were more weird differences. There was sometimes an extra part, sometimes the last part was a seemingly random number and sometimes the last part was just left off altogether. At this point, I started worrying about time, and as such, I Googled it.

This blog post by Matthew Reynolds was my salvation. Essentially, the ‘correct’ FileVersion is contained within the VersionInfo property but is slightly out of the way.

Using Matthew’s example, I wrote this short block to put a corrected version number into the property ‘RealFileVersion’.

try {
    Update-TypeData -TypeName System.Io.FileInfo -MemberType ScriptProperty -MemberName RealFileVersion -ErrorAction stop -Value {
        New-Object System.Version -ArgumentList @(
            $this.VersionInfo.FileMajorPart
            $this.VersionInfo.FileMinorPart
            $this.VersionInfo.FileBuildPart
            $this.VersionInfo.FilePrivatePart
        )
    }
} catch [System.Management.Automation.RuntimeException] {
    if ($_.Exception.Message -match "^Error in TypeData \`"System.IO.FileInfo\`": The member RealFileVersion is already present.$") {
        Write-Warning "Could not add 'RealFileVersion' member to 'FileInfo' as it already exists."
    } else {
        Write-Error "An unknown RuntimeException occurred adding the member 'RealFileVersion' to the type 'FileInfo'!" -ErrorAction Stop
    }
} catch {
    Write-Error "Something went very wrong adding the member 'RealFileVersion' to the type 'FileInfo'... and it wasn't a RuntimeException!" -ErrorAction Stop
}

And now to compare some version numbers! Fun!

function checkBumped ([System.IO.FileInfo]$oldFile, [System.IO.FileInfo]$newFile) {
    foreach ($part in "Major","Minor","Build","Revision") {
        If ($newFile.RealFileVersion.$part       -gt $oldFile.RealFileVersion.$part) {
            return $true
        } elseif ($newFile.RealFileVersion.$part -lt $oldFile.RealFileVersion.$part) {
            Write-Error "$oldFile has been rolled back." -ErrorAction Stop
        }
    }
    return $false
}

Research Project (GraphBox iOS App)

2017-05-01T00:00:00+00:00

As my final project at the University of Leeds I built an educational app for iOS using the multi-paradigm programming language swift and Xcode. The app’s purpose is to aid in teaching and learning A-Level Graph Theory and includes functionality for efficiently producing detailed graph drawings and for visualising certain graph algorithms. Throughout the project, I utilised tools such as CocoaPods and Git as well as many of Apple’s frameworks and some third-party ones, most notably the widely used CoreData alternative Realm. The first iteration of the app, ‘GraphBox’, has been published to the iOS App Store and has a promotional web-page available at: ~~http://graphbox.io/~~.