Archive for January, 2007

Episode 44: Interview Brian Goetz and David Holmes

Filed in Episodes by on January 27, 2007 1 Comment
Episode 44: Interview Brian Goetz and David Holmes

This is another episode on concurrency. We talk to two experts in the field, Brian Goetz and David Holmes about aspects of concurrency we hadn’t really covered before.

We start out by discussing liveness and safety and then continue to talk about synchronizers (latches, barriers, semaphores) as well as the importance of agreeing on protocols when developing concurrent applications. We then talked about thread confinement as a way of building thread-safe programs, as well as using functional programming and immutable data. The next set of topics covers various ways of how compilers can optimize the performance wrt. to concurrency, talking about techniques such as escape analysis as well as lock elision and coarsening. We then covered how to test concurrent programs and the consequences of the Java memory model on concurrency. We then went on to look at some more advanced topics, namely, lock-free programming and atomic variables. We also briefly discussed the idea of transactional memory.

Finally, we looked at how better language support – specifically, a more declarative style of concurrent programming as e.g. in the Fortress language – can aid in improving the quality of concurrent programs.

Continue Reading »

Episode 43: eXtreme Programming Pt.2

Filed in Episodes by on January 17, 2007 0 Comments
Episode 43: eXtreme Programming Pt.2

This is the second part of our two part discussion of the eXtreme Programming development methodology. While the first part introduced the values, principles and basic practices, this time Arno and Alex speak about the practices that set the context for an XP project and how to get started, and they discuss some FAQs they often get when introducing XP.

Continue Reading »

Episode 42: Interview Gregor Hohpe

Filed in Episodes by on January 7, 2007 1 Comment
Episode 42: Interview Gregor Hohpe

In this episode, Gregor Hohpe gives us a great introduction to enterprise messaging based on his EAI Patterns book. Before we started discusssing the patterns in his book, we characterized messaging and talked about the various interaction styles. We also contrasted the messaging architectural style with an RPC based approach. We then took a look at the relationship to SOA, the role of contracts and the orchestration-vs-choreography discussion. We briefly discussed the nature of pattern languages before we then went through the different section in the book. There are six main sections: channel, message, routing, transfomation, endpoint as well as management and monitoring. We discussed the core patterns for each of these sections. This should give listeners a good high-level view of message-based systems. We concluded the discussion by looking at the critical importance of systems management and monitoring.

Continue Reading »