I'm thinking of applying Reflective Practice to improving my programming skills. To that end, I want to be able to watch myself writing code.

In general, what is a good method for applying Reflective Practice to the craft of programming?

In particular, if it's a good idea, is there an editor that records keystrokes then plays them back at a later time - possibly running the keys together without delays, or replaying at a 2x/4x/8x accelerated rate?

Screencasting with RecordMyDesktop is an option, but has downsides of waiting for encoding and ending up with a big video file instead of a list of keystrokes.

Update: From "watching myself code" I expect to learn what kind of mistakes I make most frequently or where I waste time while coding. Then I can work on improving those aspects. It could be certain formatting, syntax or runtime errors, or maybe long pauses that indicate I hadn't considered some issue before I started coding, or maybe I re-write entire functions because my initial design was wrong. I understand that there's a lot more to programming than the act of writing code and this won't capture all of it. As recommended I should make more design notes and reflect on those too.

Recording keystrokes may be more helpful to improving my technique in time-limited programming contests, and less helpful for improving day-to-day programming at the office.

You do realize that the actual work happens in your head, and that the typing is the least relevant part of the coding process, right?
–
tdammersJun 21 '12 at 19:59

Could you expand on where you expect to benefit from this that differs from, say, reviewing your code? Unless you're specifically interested in improving as a typist, I'm not sure I see what you'd gain from what you're after.
–
asfallowsJun 21 '12 at 20:00

For programming contests where time is critical I think it matters to minimise the amount of editing and correcting in the process of typing out a segment of code. But you're also right, that the act of typing out the code is only a small part of the whole process of going from requirements to solution.
–
GrahamJun 24 '12 at 7:38

2 Answers
2

I think you have some misunderstandings about Reflective Practice and how it might apply to programming.

At it's simplest form, Reflective Practice is about reflecting upon a task after it has been completed. Programming is not about typing, it's about thinking through a design and solving a problem in a programmatic fashion. Typing is an after-effect of getting the design into the computer.

I don't think you'll learn all that much from watching what and where you were typing for a particular exercise. Beyond a gross-level "oh yeah, I hadn't thought about that yet", I don't think there is that much information to be gleaned. I think you would be better off taking many more notes during a particular problem / design session and then reviewing those notes against the end solution. There are a number of exercise out there that will start you with a simple enough problem to solve, and then you start layering on additions. Seeing how those designs hold up, reflecting upon your original thought process, and identifying areas to tweak will bring you more benefit.

Perhaps looking into a keylogger would help. I've used PyKeyLogger before for simple logging, and it records a few other things besides keystrokes, such as mouse clicks, and screenshots. It has very verbose logging, so be prepared to parse/cleanup the resulting output.

Also, another suggestion. AutoHotKey. Amazing piece of software for all sorts of weird, strange automation and logging tasks. Might need a bit of work, though. But I would suggest going through their forums, and seeing if maybe someone can help you write something close to what you need, or teach you how to do it yourself.