Are you still there?

It’s been a busy time at work lately, what with working on the next version of Reflector, and the requirement of getting our summer intern up to speed. Also it’s holiday season, and there’s also the question of the latest IBM Ponder which I spent a lot of time thinking about – the answer for the latter is contained in this MathOverflow post. This post is a summary of the useful articles and posts that I have recently found to be useful.

I’ve read previous editions of Windows Internals, and the recently released sixth edition keeps the standard very high. It covers the material of older editions, but has now been split into two books, only the first of which is currently available. I’d wondered recently about the implementation of virtualisation using a Hypervisor and how 32 bit applications run successfully on a 64 bit machine – this is covered in some detail in the book and makes a very interesting read (and also set the scene for understanding the recent post about a bug in this area). I read the book from cover to cover, which is a good way to get an idea of the topics that you’ll want to come back to at a later state.

During a holiday, I think it is good to read a couple of technical books (as well as a couple of non-technical books), so this year I took a couple of books and papers on my iPad.

Programming Windows Sixth Edition which is a version of the classic text aimed at the XAML stack that runs on WinRT – as usual it’s a clear explanation of the windows side of applications for this platform. Petzold takes his time explaining the mapping between the XAML and underlying object instantiations in the underlying platform. It includes some good examples and some good explanations.

A Tutorial on Co-induction and Function Programming by Andrew Gordon is a great explanation of the foundation of co-induction and explains how co-induction can make it easy to prove properties of lazy functional programs. Gordon explains a formulation of bisimulation as a means of proving properties of functional programs starting from an operational semantics. It’s a fairly concise paper with some maths that takes a while to get to grips with.

Isolated Actors for Race Free Concurrent Programming is a Phd thesis which covers the design of the Scala actors library. It’s interesting that Scala offers enough language hooks to make it possible to implement Actors as a library; the library offers both the threading and reactive version of the Actors. In the former, the Actor potentially consumes a thread pool thread while it is blocking whereas in the latter, the continuation is stored into a task which can be started by the library when the continuation can continue. The only real weakness of a library approach is that an exception is needed to exit the local computation and return to the main processing loop – this exception could be seen (and potentially caught) by user code, breaking the invariants of the library implementation.

The thesis covers the threading and eventing models of distributed computation and explores their trade offs. In also covers the implementation of a Join calculus library on top of the Actor model. This highlights the hooks that Scala has for implementing such libraries – in particular the way that function application is translated into a method call of an apply method on a function object which is extended to partial functions (which support the isDefinedAt which can be called before the apply is launched), and the extension of pattern matching to use an unapply method to convert what looks like a simple pattern match into active code execution.

The last chapter of the thesis covers a new type based approach for ensuring Actor isolation.

I’ve also spent some time watching the following videos.

Bart De Smet covers Rx 2.0 in a Channel9 Deep Dive. Rx is a fascinating technology and seems to be getting more and more hardened for industrial use as the releases go by. 2.0 has a number of performance improvements and bug fixes. This is the first video that I’ve seen which goes into detail about the abstraction over time which underlies the library.

.NET 4.5 in Practice: Bing is a Channel9 interview with a couple of members of the .NET team and a developer on the Bing platform. It covers some of the improvements that have been made to the .NET 4.5 platform, and explains how some of the optimisations were used to improve the performance of the Bing web site.

Deep dive into the kernel of the .NET framework, a video from last year’s build, covers the profiler guided optimisation and background thread jitting that was included in the latest version of the .NET framework. There’s also a recent Channel9 Live on the subject of Roslyn.

Building HTML and Javascript apps with KnockoutJS and MVVM was also good viewing, giving a good overview of KnockoutJS and showing how it enables one to write a view model and bind it to the GUI with simple declarative syntax.

There’s the best explanation of WinRT and how it fits in with .NET on a recent HanselMinutes. The interview covers projections and the adapters that implement them, and makes it clear that the WinRT API surface is designed to surface abstractions that can be implemented by many languages and their associated runtimes.

Finally, Joe Duffy advertises a dream job here.

This entry was posted in Computers and Internet. Bookmark the permalink.

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )


Connecting to %s