Bits ‘n’ pieces

Last weekend was taken up travelling to run a half marathon on the South Downs, so I’ve dropped behind in my reading, though I’ve also been working through a book on computational complexity and re-reading Windows Internals and both are fairly time consuming. Chess seems to be making its way back as a lunchtime game at Red Gate towers, so I’ve also started working through some chess problems which has also been taking up my free time.

Xamarin recently held their Evolve conference, and the keynote is available here. They did promise to make the session videos available, but I don’t think they are available yet (EDIT: there’s now a link to the first batch). Some of the sessions are really interesting. The keynote emphasises the rapid uptake in Smartphones, and a vast market for applications that is on the verge of happening. Xamarin have bet their venture funding on making the Mono (.NET) runtime available on iOS and Android, allowing the developer to write the main logic of their application in portable C# and offering GUI interface libraries for the target platforms which allow the developer to access the native widgets. This seems to hit the sweet spot of rapid development with C’# whilst still writing applications that use the widgets and therefore look good on the base platform. The keynote points out some of the successes that they have had.

The Channel 9 Defrag Tools show has some interesting episodes on debugging the CLR GC using Windbg. The episodes cover the use of the SOS extension, and the commands that it offers which give you information of the state of the garbage collector and its various heaps. Along the way, the CLR GC developer, Maoni Stephens, gives various interesting titbits around the design of the collector and what users should expect from it.

The fourth episode of this mini-series covers PerfView which can process the ETW messages that the CLR runtime logs in order to let you see if your applications is causing the GC undue grief. I thought this was really interesting. Lots of profiling around garbage collection seems to focus on memory leaks, with the main technique being the use of snapshots. You take a snapshot by doing a full garbage collection followed by dumping all of the heap objects and their relationships. You then compare the snapshots to see if objects are still being held in the live object graph when you’d expect them to have been collected. Most profilers seem to be missing the other part of the available information. How frequent are collections and how much time is the garbage collector taking? What object allocations are provoking garbage collections? Are temporary objects getting promoted into higher generations?

Innovation and whether it is happening inside Windows is covered a little by this blog post. It’s an interesting question whether product development should be driven by feature addition rather than feature improvement. The post by the developer on the Windows Kernel team is obviously a little over the top, but some of the underlying issues are worth some thought.

I also enjoyed this introductory article on WebGL, and for the wannabe mathematician in me, this article on factoring using number sieves brought back some memories. While we are down memory lane, our Lisp runtime went in to space on board the Deep Space 1 probe in the 1990s, and this talk discusses why Lisp was dismissed as a programming language by NASA despite some obvious advantages.

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 )

Twitter picture

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

Facebook photo

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

Google+ photo

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

Connecting to %s