Archives for :

Giant micro:bit

Inspired by the recent giant Makey Makey (I want one of those too!) I said I’d love a giant micro:bit I could demo from the front of the class. My dad – an engineer – said he could make one, but I didn’t expect this sort of detail! It’s great to point out the connectors, where to find the processor and sensors on the back, where the Bluetooth antenna’s hidden, etc. It’s a prop, a talking point. It’s 10x scale, as you can see from the tiny (real) micro:bit sitting on top of it. How cool is this?!

https://twitter.com/mrmckaycomp/status/1026859950730104833

Giant microbit

Video: Makey Makey slide mover

20180722_130151Ever been frustrated when your slide clicker runs out of batteries? Me too! My Code Club kids, and Pi-Wire pal Chris, have a ‘practical’ solution: use a piano pedal!

There were two versions: the first was ok, but had some flaws. As later figured out, it was a bit unreliable. I was so impressed that the kids developed ideas for version 2, improving it a lot! With a bit of tweaking, the second version was perfect – and all it took was some play doh and a bit of rewiring. Click below to see how we did it…

Continue Reading >>

2018 Update

This hasn’t been updated in ages, but…

As of July 2018, I’m a secondary computing science teacher (“probationer” in Scotland, newly-qualified teacher, or NQT). I’ll mostly be keeping this site on as an archive, but I tweet more often as @mrmckaycomp. I did the Strathclyde PGDE and worked in two great placement schools. I’ll now be taking up an NQT post in another (I’m not telling you which) secondary school.

Pi-Wire stays (it hasn’t been updated in ages either) – and we’re now both teachers!

My Google Scholar page is here too, with a list of publications/citations.

HCI 2013 publication – cognitive models

I have a paper coming up at BCS HCI 2013 (September 11-13th, London), “Predictive Modelling for HCI Problems in Novice Program Editors” (Fraser McKay and Michael Kölling). It’s a predictive human performance modelling approach to learner programmer tools, carried out with CogTool. Second author is my PhD supervisor. From the abstract:

We extend previous cognitive modelling work to four new programming systems, with results contributing to the development of a new novice programming editor. Results of a previous paper, which quantified differences in certain visual languages, and feedback we had regarding interest in the work, suggested that there may be more systems to which the technique could be applied. This short paper reports on a second series of models, discusses their strengths and weaknesses, and draws comparisons to the first. This matters because we believe “bottlenecks” in interaction design to be an issue in some beginner languages – painfully slow interactions may not always be noticeable at first, but start to become intrusive as the programs grow larger. Conversely, text-based languages are generally less viscous, but often use difficult symbols and terminology, and can be highly error-prone. Based on the models presented here, we propose some simple design choices that appear to make a useful and substantive difference to the editing problems discussed.

This is a short paper, that ties up the loose ends of a previous HCI paper.

EDIT 12/09/13: I’ve posted a link to my copy of the PDF, and it’s also in open-access on the KAR (my university’s institutional repository). ACM and BCS links will (presumably) follow once available.

How to draw pi…

3141 digits with stampI’m possibly the least mathematically-minded programmer I know, but a maths-teacher friend recently prompted me to throw together an app we’ve called Pi-Wire. It started with the mathematical artwork of Cristian Ilies Vasile. To quote Visual news,

First Cristian Ilies Vasile had the idea of connecting each digit of π to its successive digit with links to the position of the numerically corresponding segments. Martin Krzywinski added to Vasile’s visualization…

The effect’s pretty impressive (check out the links). It distributes the digits 0-9 around the edge of a circle, and visualises the order in which they appear in π (or another constant). So, for the digits 3.14159, it draws connections from:

3 → 1, 1 → 4, 4 → 1, 1 → 5, 5 → 9

Chris Smith, maths teacher and noted pi geek, wondered whether it was possible to animate the effect, “so people get a handle for how segments are put together and then the dynamics of it.” The (very cool) software used in the original visualisations is most-often used in biology, though it would probably have been possible to do something here… I’ve heard it remarked that computer scientists like to “make” things, as a first resort, rather than last (gross generalisation, but I include myself in it…). Since there would be work involved in automating Circos, I thought I’d have a bit of fun with version 4.5 of the Windows Presentation APIs*.

The result was Pi Wire, which has been thrown together in the last few days. The application exposes parameters that adjust what’s being visualised, and it animates the process, as well as saving final (or intermediate) images. It renders pi, e, or φ to a variable number of decimal places. Each connection, in the example above, is rendered in colour, depending on the value of the (first) digit – 3s are pink/purple, 1s are orange, etc. It doesn’t look like much when working with only five decimal places, but the example shown in the picture uses the first 10,000 digits of pi. Chris blogged a little bit about the maths and patterns here.

Critically, the animation means a picture can be built up bit-by-bit (for demonstrating to kids, for example). As well as tweaking the render settings, we can adjust colours, line properties, and so on. We can switch on or off individual segments/digit values. The golden/orange graphic (right) shows only the progressions (for the first 100 digits) which start with 1. It shows the spread of which digits usually follow a 1.Pi 1000 digits - draw 1 only

It’s a bit of a rush job, though it’s (fairly) easy to use and hopefully interesting. Chris is certainly having a lot of fun making pretty pictures!

* Which I’d been using for work anyway (an old link, but one example).

 

PPIG Publication, November 2012

In press is a conference paper I’m about to present at the Psychology of Programming Interest Group (PPIG) workshop in London, 21st-23rd November 2012. As I noted on my HCI 2012 post, some of these have now been going on longer than the participants (this being PPIG no. 24). This is a full paper written with my PhD supervisor, Prof. Michael Kölling (well known in the field of computing education). The paper reports on a pilot study where we evaluated the effectiveness of new HCI usability heuristics (which we created), specific to the domain of learner programming systems (e.g. Greenfoot, Scratch, the Mindstorms kits, etc.). The abstract follows below.

EDIT: The paper is now published, and a PDF can be downloaded for free from the Kent Academic Repository, or directly from this link. The Q&A session after the talk gave an opportunity for some interesting discussion with the likes of Thomas Green, Alan Blackwell, and the other cognitive dimensions “grandees”!

Evaluation of Subject-Specific Heuristics for Initial Learning Environments: A Pilot Study

Fraser McKay & Michael Kölling

“Heuristic evaluation is a “discount” technique for finding usability problems in well-established domains. This paper presents thirteen suggested heuristics for initial learning environments (ILEs). To investigate the usefulness of these heuristics to other developers, we conducted a pilot study that compared two groups of evaluators: one using an older, generalised set of heuristics from the literature, and one using our domain-specific heuristics. In this study, we compare not just the number of problems found, but the way in which the problem reports were expressed. There was a significant difference in the length of written comments when problems were found (those from the new set being longer). New-set reviews touch on more themes – many make suggestions about what would improve the problem; many comments refer to a suggested cause-and-effect relationship. As designers, we find this detail helpful in understanding problems. Quantitative data from this study is not large enough to support any robust conclusions about the relative thoroughness of the heuristics at this time, but we plan to use lessons learned from this study in a larger version shortly.”

HCI 2012 publication

I’m presenting a work-in-progress paper at the BCS HCI 2012, next month in Birmingham. HCI (the “People and Computers” series) is one of the big international HCI conferences, now older than some of the participants, in year 26 (I’m 23!). This is a work-in-progress paper entitled “A Prototype Structured but Low-viscosity Editor for Novice Programmers”. The abstract, below, is on the conference programme site. The paper will be published in the proceedings, and on the ACM digital library and the BCS ewics archive - which I’ll link to here later.

EDIT: BCS ewics repository (PDF – open access)
EDIT: ACM digital library (PDF – login required)

“This paper presents work in progress on a prototype programming editor that combines the flexibility of keyboard-driven text entry with a structured visual representation, and drag-and-drop blocks. Many beginners learn with Java, a traditional text-based language. While text entry is ideal for experts desiring speed and efficiency, there is evidence in the literature that a significant portion of novice errors are related to syntax. Some beginners learn with Scratch, Alice and Star Logo, all of which have drag-and-drop, “block”-based interfaces. Validation makes them less prone to syntax errors, but they are very “viscous” – there is resistance to changing or rearranging statements once they have been entered. The new system combines keyboard input with statements that can still be manipulated with the mouse as whole blocks. Standard text idioms can be used – highlighting code by dragging the mouse, copying & pasting (as text), etc. With CogTool cognitive/keystroke models, we show that the new system effectively overcomes the viscosity found in block-based languages, but it retains much of the error-proofing. Work is ongoing, but there are implications for the design of a new novice programming system.”

Interfaces: HCI for Beginner Programmers

This morning, I got my spring copy of the BCS HCI magazine Interfaces. I’m pleased to be published in this quarter’s issue, as part of the “My PhD” series. In the article, I give a brief overview of my general project, and then run through some of the usability heuristics that we’ve been developing for novice programming tools.

McKay, F. HCI for Beginner Programmers. Interfaces, British Computer Society, 90 (2012), 22-23.

Update 19/04/12: an open-access PDF is available from the BCS.
http://www.bcs.org/upload/pdf/interfaces90.pdf

I’ve pasted the introduction here:

My PhD is based in the Programming Education Tools group at the University of Kent, and my project concerns the development of a new way for novices to enter and maintain code. Coding in schools has recently been a more topical issue than usual [1]. Most of my work so far has been about analysing existing systems, but I’ve also begun to work with some early designs. My review of existing systems has been structured with thirteen new heuristics. These are based on previous heuristics [7], the cognitive dimensions [2], and a wider review of the literature on novice programming errors. For specific features, Cog Tool models [4] have exposed subtle differences in the effort a novice might need to exert to make changes in two comparable code editors. Now, at the start of my second year, I am working on prototypes that might make it into a new programming tool.

PPIG, and mini-thesis upgrade

Back in September, I was at my first PPIG conference. I gave a quick talk on my project summary at the doctoral consortium, the work-in-progress paper for which is here:

…The intended outcome of this project is the design and implementation of a new programming language with focus on improved interactions for creating and maintaining novice programs. Evaluating the HCI in current novice programming systems (Scratch, Alice, Greenfoot) has led us to propose new heuristics for these kinds of tools. Cognitive models of viscous interactions in block-based and text-based languages have also been compared. Early prototypes have been created, with some preliminary evaluations being used to refine the ideas…

McKay, F. Work-in-Progress: Design of a Beginners’ Programming Language with a Focus on Novel Interaction Techniques. Doctoral consortium, Psychology of Programming Interest Group. (York, September 6-8th). 2011. [Google Docs].

This month, I also passed the viva based on my minithesis, which includes detailed reviews of the evidence we use in support of the new heuristics, mentioned only briefly in the PPIG paper.

Public static void main: because you’re worth it

I’ve been thinking a bit about the “magic” phrases we find in some programming languages. But then last night, I watched an episode of the BBC’s Outnumbered, where Karen conducts (her take on) a funeral service for a mouse:

…dust to dust,
for richer or for poorer,
in sickness or in health,
may the force be with you,
because you’re worth it.
Amen and out.

The bane of many a Java beginner’s life might be the (slightly less poetic),

public static void main(String args[])

It’s unfair of me to pick on Java specifically, but that’s just an easy example to use. If we repeat that kind of phrase, verbatim, in every one of our first few programs, at which point does it become recitation? It’s like a sort of solemn vow reminding us we’re starting a Java program – a programming ritual. Like various ceremonies, it’s evolved over time, from “int main (void)”, in this case.
Of course, these sorts of things used to be done in Latin, for all that extra weight. Google Translate has alpha support, and suggests “Primor incorporalis sine publico (catena args)”. The thing is, is this actually that less meaningful to, say, a 12 year old?
So, repeat after me:

…for richer, for poorer,
in debugging and at runtime,
primor incorporalis sine publico.
Live long and prosper.*