# Thomas Denney

### Student and app developer

Namisu is a company that designs fountain pens in Fife, Scotland. They've been operating since 2013, but I only discovered their work earlier this year. As far as I'm aware there are relatively few British pen manufacturers, with most expertise now found in Germany and Japan, so I was keen to try out their work. Predominantly focused on minimalist design, their pens are devoid of any of their own branding. They compensate for this with distinctive shapes and high-quality materials.

The Nova is one of their earliest designs, and has been available for three years. I have the aluminium model in red, although it is also available in brass, titanium, and other colours. Of these, I think the titanium looks the best and I imagine they don't differ in their ergonomics. Namisu currently also ship the similar Orion and Ixion pens, along with a few rollerballs, although these are more expensive than the Nova.

Each of their pens ships with nibs produced by Peter Bock in Germany. The choice of Bock nibs is a pragmatic one, I think, as they are both a reliable and relatively inexpensive choice. My Nova has a fine steel nib, although titanium and broader nibs are also available. I initially struggled to get ink flowing through the pens, and experimented with a number of inks and notepads, but continued to find that the nib scratched the surface of the paper, often without flow. However, after flexing the nib a little I eventually managed to get ink flowing comfortably from the pen without issue.

Although it looks very nice, I didn't find the Nova terrificly comfortable to write with, especially for longer periods. The section — the part you grip with your fingers — is wider than any other pen I own, and its surface is completely flat, rather than a gentle curve or moulded grip seen on other pens. Those with small hands may find the pen uncomfortable to maneuver, but I can certainly see the pen being more comfortable for those with larger fingers. The flat surface was a bigger issue, especially considering that the pen seemed to initially require significant pressure to get ink flowing, with my fingers left with pen-shaped indentations after an hour or two of use. The only other significant downside of the design is that it tended to roll a lot on my desk.

Overall, I wouldn't recommend the Nova over other pens in its price category — TWSBI certainly make significantly nicer pens for a similar price — but from an aesthetic perspective it is certainly worth it. There are very few pens with all-metal bodies available at that price, and after about six months of ownership I haven't noticed a single scratch anywhere on the body; this pen is durable. I haven't yet experimented with posting the pen, but I wouldn't recommend it as the cap screws on and off. Prior experience suggests that the screw thread is likely to eventually damage the body.

The Nova is available at Namisu's online store for £45.

In general I am not a fan of ball point pens, but the magnetic cap design of the KOSMOS pen intrigued me. Rather than pressing a button or removing a cap, the KOSMOS pen by Stilform, a design studio based in Munich, allows you to pull back on the cap, which is then held in place magnetically. It is a simple but effective idea.

Stilform clearly care about design, and the KOSMOS pen is certainly the best designed ballpoint that I’ve used. That design does come at a price; my aluminium model cost €50, but a titanium bodied model is also available at €100. The aluminium models come in five colours, three of which are intentionally similar to Apple’s MacBook lineup.

Aside from the magnetic cap, one of pen’s best features is barely mentioned in Stilform’s marketing: the pen rolls very little. I suspect they’ve weighted the body on one side, but I couldn’t tell where after playing with it for a few minutes. I was a little disappointed to find that it didn’t always roll to show the logo, which is engraved near the top of the pen. I think the engraving could be a little deeper, but the rest of pen's design seems to call for minimalism.

Before I received the pen I wasn’t sure which part of the pen actually moves when you shift the cap. The cap screws onto the black segment that initially separates the cap from the body, and both of these move when the cap slides — the refill always stays in place. I’d like the cap to screw in a little tighter, although only because I fiddled with it repeatedly this week! When I did unscrew the cap I found that the spring inside it would often come loose and fall out; I think a grove near the end of the cap could solve this problem.

The pen is loud. Not to write with, but with the snap as you shift the cap in and out of place. By way of comparison, it is much louder than closing the lid of my AirPods case and certainly louder than any other retractable pen that I’ve used before.

The included Stilform cartridge let the rest of the pen down. I initially found that I had to apply a lot of pressure — a lot more than I would apply with other ballpoints — to get a consistent stroke. Thankfully the cartridge is a standard (it is the same ISO G2 cartridge that Parker include in their ballpoints), so it can be easily replaced. Otherwise, the pen is a very comfortable weight and I didn’t have any issues writing with it for a few hours.

As much as I like the elegant design of the KOSMOS pen, I’ll continue using fountain pens for regular writing. At the moment I’m carrying it in my backpack for situations where I have to write on paper that ink would bleed on.

Later in 2018 Stilform will release the KOSMOS Ink, a fountain pen with a removable magnetic cap. I’ve pre-ordered the pen, and I look forward to seeing their ideas applied to other stationery.

Over the course of the last term I presented five introductory Python sessions as part of the Oxford University Computer Society's Learn to Code series. This year we saw the highest demand ever for the course, with over 1,100 people “interested” on Facebook and more than 200 attending the sessions — we packed out both lecture theatres in the Department of Computer Science!

All of the session materials from the course are available here. Note that this is my personal fork of the course materials with the version that I presented (it is quite likely that a future commmittee will present a different version next year). A playlist of all the screen recordings is available on YouTube. This was the first time I'd ever done any video editing, but in the end it turned out to be more of an exercise in audio editing.

The first video was edited entirely in iMovie, but from the second session onwards all the video was edited in Final Cut Pro. I imagine that iMovie would have been sufficient for all the videos, but I fancied trying out Final Cut Pro.

We used a Focusrite Scarlett Solo interface along with the cheapest wireless mic I could find on Amazon to record the audio. I later had to redub a few of the sessions due to recording issues in the lecture theatre, but most of the audio was recorded live. The sessions recorded in the lecture theatre sound a lot better and, as a friend commented, avoid the “teenager making Minecraft videos” vibe. I struggled to get audio levels right until the very end of the course, so many of the early videos are far too quiet. By the end of the course I was also a lot more leniant in what I allowed through the editing process; some of the early sessions don't have a single utterance of “erm”, “OK”, or “so” but by the end I gave up and tried to keep the editing process straightforward.

It would have been nice to record video for the session in addition to the screen captures, but a lack of preparation on my part killed this plan. Besides, each session required around a total of ten hours a week to prepare the resources, reheasrse, execute the session, and then edit the video and I don't think I could have spared much more time out of an already packed term.

I am indebted to the dozen-or-so Oxford CS students that dedicated their Thursday evenings with me to run the course this year, in particular to Sauyon Lee, who presented sessions in a second lecture theatre. The student helpers managed everything from registration to helping out students with exercises, which allowed me to focus on just the presentation during the sessions.

Although Learn to Code was undoubtedly my greatest success as president of Oxford's Computer Society, there are many ways in which the course could be improved, and I leave this advice to my successor next year:

• Don't be afraid to go slowly. In the first session I discovered that around half the audience had done some programming before, and sped up the session to cater for them. This was a mistake — I should have continued with my plan to aim the content at complete beginners
• Encourage students to do exercises as much as possible, as early as possible. A small number of students went away and did nearly every exercise in the notes, and they definitely made the most progress over the course
• Provide other materials that students can look at after the course or between sessions
• Video editing is really hard! If the next committee plans to film the 2019 sessions then I hope they can find somebody that can edit the video content, because it certainly consumed far too much of my time
• Focus on getting syntax right before introducing algorithms. My experience this year and last year was that once students mastered the basics of Python syntax they were far more able to solve problems than introducing algorithms and syntax concurrently. We definitely introduced the binary search algorithm too early this year, for example

Overall, teaching Learn to Code this year was an absolute pleasure. Even after relatively high demand for the course last year I was shocked to see so much demand this year, and I loved seeing so many students returning each week.

At the beginning of term I met with David Malan, the originator of Harvard's CS50 course, and after hearing of such high demand at Harvard for a programming course I was delighted we could replicate similar demand on this side of the pond. I wish the very best to my successors teaching our course, and I've no doubt its popularity will continue to grow.

Play Time, my music statistics app, now supports the iPhone X and has lots of fixes for iOS 11. Here's what's new in this release:

• Support for new iPhone sizes and iOS 11
• Use the predominant colour of an album's artwork when artwork is disabled
• Sorting by Album Artist
• Sorting options when breaking down by album, artist, or genre
• Removed option to display play count - it is now displayed based on context
• Explicit songs play time

Fixed:

• Crashing bug when collecting library data
• Resolved bugs related to row selection
• Ensured the typeface is consistent across the app
• Removed old style app rating

You can download the Play Time for $0.99 on the App Store. As well as the usual public, protected, and private access control modifiers, which have with same rules as their Java siblings, Scala also supports the private[this] modifier, which prevents access to a property from other instances. For example, the following code would not compile: class A { private[this] var x = 0 def inc(a: A) = a.x = a.x + 1 } Whereas this would be fine: class B { private var x = 0 def inc(a: A) = a.x = a.x + 1 } Whilst the access control rules are applied at compile time, they lead to slightly different code generation. In the case of a property marked private a private field, a getter method, and a setter method are added to the class. All code that accesses the field (aside from its initialisation) will go through either the getter or setter. On the other hand, a private[this] field will only add the field to the class, and all access to the field is direct, rather than through accessor methods (as, after all, all access is only done by the instance). The behaviour of the Scala compiler can be verified using the javap tool, part of the JDK that prints Java bytecode in a human readable form. I compiled the following two Scala classes: class A { private var x: Int = 37; def add() = x = x + 1 } class B { private[this] var x: Int = 37; def add() = x = x + 1 } The output of javap -p -c A, the class that doesn't use private[this], is: Compiled from "Classes.scala" public class A { private int x; private int x(); Code: 0: aload_0 1: getfield #13 // Field x:I 4: ireturn private void x_$eq(int);
Code:
2: putfield      #13                 // Field x:I
5: return

Code:
2: invokespecial #22                 // Method x:()I
5: iconst_1

At Oxford we submit almost all of our practical assignments on paper, which usually means printing out the diff of the work that we've done. Generally most people just generate the diff with git and send it to the printer with lpr, but I'm yet to succeed at getting output that I like with this approach.

Therefore I am now generating the diff, saving it to a file, and then using the LaTeX listings package to produce line-wrapped, coloured output.

Firstly, I generate the diff file itself:

git diff ORIGINAL_COMMIT_HASH -- > all.diff

Then I generate a PDF via xelatex diff.tex from the following LaTeX file:

\documentclass[11pt,]{article}
\usepackage[margin=1in]{geometry}
\usepackage{listings}
\usepackage{parskip}
\usepackage[rgb,dvipsnames]{xcolor}

\definecolor{mygreen}{rgb}{0.1,0.25,0.01}
\definecolor{myred}{rgb}{0.25,0.1,0.01}
\definecolor{mymagenta}{rgb}{0.5,0.05,0.25}

\lstdefinelanguage{diff}{
morecomment=[f][\color{blue}]{@@},       % group identifier
morecomment=[f][\color{myred}]-,         % deleted lines
morecomment=[f][\color{mymagenta}]{---}, % Diff header lines (must appear after +,-)
morecomment=[f][\color{mymagenta}]{+++},
}

\lstset{
basicstyle=\ttfamily,
numberstyle=\footnotesize,
stepnumber=1,
numbersep=5pt,
backgroundcolor=\color[RGB]{255,255,255},
showspaces=false,
showstringspaces=false,
showtabs=false,
tabsize=2,
captionpos=b,
breaklines=true,
breakatwhitespace=true,
breakautoindent=true,
escapeinside={\%*}{*)},
linewidth=\textwidth,
basewidth=0.5em,
}

\begin{document}

\lstinputlisting{all.diff}

\end{document}