Tuesday, July 11, 2006 

[Late] Weekend Readings, Meaningful Coincidences and Some Real Work

I'm always reading a lot, although I'm constantly behind :-), with journals and books piling up. I've spent a little time reading during the weekend (and yesterday and this morning as well), picking up random unfinished magazines from one of the stacks lying around. I'll skip on two articles on UML usage in real projects - they didn't add much that wasn't already largely known. A somewhat interesting paper was "Emphasizing Human Capabilities in Software Development" (IEEE Software, March/April 2006). The authors used a personality test (Cattell's 16PF) to match people to job (analyst, programmer, etc). I'm relatively familiar with other tests (like Myers-Briggs) but didn't know about the 16PF, so I even spent some time to get an online test and guess what, after I bring the results back into the author's model, it turns out I'm pretty good in most software development roles ;-). My ideal position would be, according to the model, "team leader". It seems I lack discipline (which in this context doesn't mean self-discipline, but something more like dutifulness), which I guess is true :-)). I don't really agree on some parts of their model though. For instance, Abstract Thinking is discouraged for people involved in Analysis (that includes, in their model, the Analyst, the Designer, etc), which seems extremely weird, and strongly tied with a notion of analysis being a faithful, non-creative gathering of requirements, which is far from true (more on this another time).
Another somewhat interesting paper was "Prepare Your Mind for Learning", Communications of ACM, September 2005. I loved the concept of metacognitive miscalibration, somewhat less the examples. The suggestions were all good but not very original. I'd like to link this with the concept of filtering (see the bottom of one of my old posts). For some reason or another :-)), that reminds me of some virulent comments :-) on my previous post on test first :-).
Another somewhat interesting paper was "Achieving Scalability in Real-Time Systems", IEEE Computer, May 2006. The authors mentioned a wait-free mechanism for concurrent read/write (Cyclical Asynchronous Buffers), and got me interested enough to dig further. There is even a working implementation of CABs on the E.R.I.K.A. website at Scuola Superiore Sant'Anna (the author is also from there). Well, it's hard not to miss OOP when you read that C code, but anyway, that concept reminds me an interesting pattern (sharing 90% of the underlying idea; that's what makes it a pattern :-), "Resource Exchanger: A Behavioral Pattern for Low-Overhead Concurrent Resource Management", in "Pattern Languages of Program Design Vol. 2".
Interesting coincidence. I teach that pattern, among others, in a course on OOP/OOD for embedded systems. In these days, I'm also working on some teaching materials for embedded systems. I'm extending my "Win32 System Programming" course with a lot of stuff on Windows CE, which has been a constant theme for me in the latest months. It's funny how many things we routinely teach as "good programming style" in C++ makes much more sense for embedded systems (which, after all, should not surprise anybody :-). For instance, under CE the compiler is actually moving static const data to a read-only memory segment (as many "embedded" compilers do). That makes the idea of casting away const on a const reference to a const object dangerous enough :-) to justify the unspecified behaviour label in the ANSI/ISO standard :-), and is indeed my standard explanation (although, I've to admit, it tends to get blank stares from programmers that have never worked on embedded systems :-).