If the skies are grey, read something else

It’s been a fairly busy week at work, and all the spare time I have I’ve been looking at Actorfx, a framework of worker processes that manages state in the cloud. I’ll be writing up my notes on that in a future blog post. It’s been interesting playing around with the local Azure emulator, and getting to grips with various concepts like the fabric controller.

I did have a little time this week for reading a few posts that I’ve been queuing up for some time.

First some Haskell related stuff. This book extract is a really good introduction to what laziness means in Haskell. It shows how you can use the interactive facilities in GHC to understand that values are often only evaluated to weak head normal form (WHNF). In this state the outermost part of the value has been calculated, but internal parts (think fields) of the datatype can remain unevaluated. In other work related to laziness and the advantages and disadvantages it brings, this paper (which is part of the work covered on this page) talks about the space leaks that Haskell’s laziness can cause, and discusses a generator framework that can be used to get some of decoupling that generate and test offers, without some of the inherent problems mixing effects and laziness. The paper shows one of amazing properties of laziness, tying the knot, which is demonstrated effectively by the repmin function in the paper.

I’ve been writing some C++ at work, and enjoyed this list of pitfalls. C++ is back as a strong contender in the WinRT world, and Microsoft have published an interesting paper giving guidance on writing a WinRT application in C++. A post entitled “Welcome back to C++” gives some guidance on how the language has moved on, and now includes automatic type inference (with auto) and easier memory management. It also includes lambda expressions allowing the WinRT code to offer an easy to use promises library.

In C# news, there’s a presentation here from the recent MVP summit that covers some of pitfalls of async that people are experiencing in the real world. If you’ve ever wondered how you might have implemented XNA, there’s a codeplex project to produce a source compatible open framework called ANX, which lets you see into the implementation.

On other news, the mechanical sympathy blog has a great post on memory caches in modern cpus, and there’s another zero day Java exploit.

Advertisements
This entry was posted in Books. Bookmark the permalink.

Leave a Reply

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

WordPress.com Logo

You are commenting using your WordPress.com 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