(Note: Although this is primary a C#/.NET thing, this is also posted on DelphiFeeds.com as I think this might be interesting for Delphi developers as well. Maybe this or a similar abstraction is even something to consider for the DPL?)

I did the final presentation for my CS Bachelor thesis at the University of Paderborn today. I thought I would share the thesis here, maybe some of you find it an interesting read. In one sentence, it’s about simplifying concurrent programming with several (new) higher-level abstractions. Here’s the summary:

Although being touted as the next big thing for years now, concurrent programming is still very difficult and error-prone even in modern programming languages and environments. Concurrent and in particular multithreaded programming still requires deep knowledge of low-level techniques like threading or locks and experience with deadlocks, race conditions and other subtle and hard to find concurrency problems. High-level concurrency abstractions and patterns can simplify concurrent programming but are only starting to become available in modern mainstream programming languages.

One of these high-level abstractions is the so called Active Object pattern. The Active Object pattern works, as the name implies, on the object level and not on an object hierarchy like most other design patterns. With an active object, method invocation is decoupled from the actual method execution, i.e. invoked methods of these objects are executed asynchronously and do not block the caller. There are several variants of this pattern known, but all have in common that the concurrency functionality is achieved by running methods in a thread or process context different from that of the caller. Possible results of active methods are encapsulated in so called future objects which can be seen as placeholders or contracts for the real results.

I will post the related code (the active objects runtime library as well as the related code generator/compiler) later this week or maybe early next week. So without further ado, Active Objects and Futures: A Concurrency Abstraction Implemented for C# and .NET.