For anyone who follows me here but doesn’t follow the Omni blog, I’m posting there on OmniFocus in education. My first post, OmniFocus for Academics, gives some ideas for using OmniFocus as a faculty member.
I’m also writing a series of posts on using OmniFocus as a student. The series includes lots of examples drawn from student life, but I hope the lessons are applicable to anyone looking to better manage their tasks and projects. The first post in the series, OmniFocus at School: Quick Entry, focuses on reducing stress by capturing all your tasks in OmniFocus.
Please check out the posts. I hope they’re useful.
For the last few months we’ve been having a weekly book club at Omni. (Big thanks to Liz Marley for starting that!) This week we’re starting on Personal Kanban by Jim Benson and Tonianne DeMaria Barry. This slide set gives a nice high-level introduction to the idea.
For this book, each of us in the reading group is going to set up our own Kanban system, so we can live the ideas instead of just debating them. As a long time practitioner of David Allen’s GTD system using OmniFocus, I’m loath to abandon my fine-tuned system.
Perhaps I won’t need to.
It seems like Personal Kanban and GTD have a lot in common. Both focus on getting ideas out of your head and into a trusted system. Benson and Barry call this your backlog. Allen calls it your project and someday-maybe list. Both focus on knowing what is on your plate so you develop an intuition about what to do and what to set aside. Allen focuses on acquiring that intuition through regular reviews of your lists. Benson and Barry advocate a more visual approach. They use post-it notes on a whiteboard for each task. They divide the board into areas representing your backlog, work in progress, and completed tasks. Besides showing the size of each pile, this is supposed to help you visualize your throughput as tasks move from backlog to in-progress to done.
Rather than abandon my OmniFocus system, I’m thinking of using OmniFocus’s Applescript interface to create a Kanban visualization. Working backwards,
- the Done area will show tasks that I checked off in the past couple of days;
- the Work-In-Progress area will show available tasks that are flagged or are due soon; and
- the Backlog area will show available tasks that aren’t in the Work-In-Progress area.
I’m already using flags in OmniFocus to highlight task that I’d like to complete today, so this isn’t much of a change in that respect. I’ll be curious to see whether the visualization affects my decision making on what projects to tackle and what to set aside. Kanban emphasizes placing limits on the amount of work-in-progress in order to maintain velocity. I really like Benson and Barry’s analogy to a freeway that allows more throughput at 65% capacity than at 100%, when it becomes a parking lot. I’ve always struggled with overcommitting, so I hope this is helpful.
Now to add a another project to my backlog to create the visualization. Hmm, might be a good excuse to dust off my Ruby programming skills…
Microsoft hosted (and generously paid for) the Lang.NEXT conference at their campus in Redmond last week. The conference was previously called Lang.NET and was focused on the .NET platform. This year they opened the conference to other languages and invited a variety of speakers. Videos of most of the talks are available on Channel 9, along with interviews with many of the participants.
What Languages were Discussed?
I counted 24 languages that were covered in some fashion:
- Scala (Martin Odersky)
- Haskell (Andy Adams-Moran)
- Java 8 (John Rose)
- Grace, a teaching language (Andrew Black and Kim Bruce)
- Powershell on Windows 8 (Bruce Payette)
- Delite, a framework for building parallel programming DSLs in Scala (Kunie Olukotun)
- Bloom, distributed datalog programming (Peter Alvaro)
- Julia, technical computing (Jeff Bezanson and Stefan Karpinski)
- F#, Microsoft’s functional language (Donna Malayeri)
- C# (Mads Torgersen)
- Zephyr, a core parallel programming language embeddable in Java targeting JVM (lightning talk, didn’t catch the name)
- Scoop, an ownership-type annotation for parallel programming in Eiffel (lightning talk, didn’t catch the name)
- Virgil III, a core object-oriented language with generics and functions (Ben Titzer)
- Koka, a functional language with effect types (Daan Leijen)
- Dart (Gilad Bracha)
- ECMAScript 6 (Luke Hoban)
- Infer.NET Fun, a DSL for probabilistic programming in F# (Andy Gordon)
- R (John Cook)
- Objective-C, a proposal for adding namespaces (Kyle Sluder)
- Eagle, TCL-like language for .NET (lightning talk, didn’t catch the name)
- Formula, composable logic programming (lightning talk, didn’t catch the name)
- D (Walter Bright, Andrei Alexandrescu)
- C++ (Herb Sutter)
- Go (Robert Griesemeyer)
Other talks covered compile-time and run-time technologies:
- IKVM.NET, a Java VM running on Microsoft’s Common Language Runtime (Jeroen Fritjers)
- Windows Runtime (Martyn Lovell)
- Roslyn, a framework for IDE extension (Dustin Campbell)
- Extensible type systems for Java (Werner Dietl)
There were also panels on:
- Cloud, web, and distributed computing
- Native vs. managed languages
The number of languages covered was a bit dizzying, but several themes emerged.
Functional programming is becoming mainstream, but not in the way the Haskell and ML folks might have wished. Instead, all the mainstream object-oriented languages are embracing closures.
Asynchrony in support of multi-core and UI responsiveness is pervasive. For Windows 8, any system call with a possible latency over 50 ms is only exposed via non-blocking calls. C# 5.0 adds a very cool
await keyword that effectively does a CPS transform on your code. Much like
yield in Python turns a procedure into a generator, adding
await to a C# method makes it asynchronous, returning a Task object instead of a result. The portion of the method after the
await is effectively a continuation that is executed once the awaited result is available. The returned Task object is a future on which callers of the now-asynchronous method can themselves await. Under the hood, this is all implemented using state machines that transition as results of awaited operations become available, avoiding the pesky problem of intersecting tail call optimization and late-binding, virtual dispatch. Asynchronous methods take an optional CancellationToken object that can be used to interrupt the asynchronous code in a way that generates an exception with a stack trace that matches the source code (rather than the transformed version).
IDE support is driving language and OS design. Type providers, a major feature in F# 3.0, are explicitly designed to support autocompletion in the IDE using database schemas vended from on-line databases. IDE plug-ins analyze the live schemas and vend autocompletion suggestions. The new Windows Runtime lets languages provide a shim layer that use WinRT metadata to generate autocompletion information.
Native languages, are back on everyone’s radars after a decade and a half of managed code getting all the buzz. There was some disagreement, but essentially “native” here means languages that target the metal instead of a (non-hardware-emulating) virtual machine. There seem to be a couple things driving this. The first is power consumption. This plays out in the context of data centers. Alexandrescu from Facebook talked about measuring their systems in terms of watts per active user. The power consumption concern also plays out in mobile, where the battery life of iOS devices is substantially better than devices running virtual machines. The second reason given for the resurgence of native languages is their performance. Our phones are remarkable computers, but to maintain the illusion of direct interaction, every bit of latency has to be wrung from the system. That’s tough to do with a virtual machine. It was interesting to hear people outside the Apple developer community echoing things that we talk about inside the community. These arguments always made sense to me, but it’s sometimes hard to separate general opinion from the various echo chambers that we live in.
How do these themes relate to Mac and iOS development? Apple introduced blocks to C in Snow Leopard and iOS 4.0, checking the functional programming box, though using a particularly
ugly C-like syntax while doing it. Apple has a variety of mechanism for asynchrony, including the iCloud APIs that use nested blocks and approach a continuation passing style, though not nearly as elegantly as C#’s
await. Apple never strayed from the native languages camp. After an ill-fated fling with garbage collection, they seem to be on track with ARC to solve the engineering challenges of memory management. (Note that WinRT uses reference counting via AddRef-Release rather than garbage collection.) IDE support is the area where Apple falls far, far behind. Xcode 4 is probably a necessary step in the evolution to a decent IDE experience. Sadly, it still lacks the refactoring power and quick documentation lookup that IntelliJ had a decade ago. It’s probably time to give AppCode a try.
Some powerful thoughts on academic writing from William Tozier:
You are not allowed to keep delight to yourself. Moron. This, above all the other things, is the thing the Academy has lied you into misunderstanding, with its delayed gratifications and postponements of your life: Delight, kept secret, always fades to nothing.
(Thanks to Eugene Wallingford for the link.)