Effective Concurrency: Know When to Use an Active Object Instead of a Mutex

This month’s Effective Concurrency column, “Know When to Use an Active Object Instead of a Mutex,” is now live on DDJ’s website. From the article: Let’s say that your program has a shared log file object. The log file is likely to be a popular object; lots of different threads must be able to write … Continue reading Effective Concurrency: Know When to Use an Active Object Instead of a Mutex

Effective Concurrency: Prefer Using Futures or Callbacks to Communicate Asynchronous Results

This month’s Effective Concurrency column, “Prefer Using Futures or Callbacks to Communicate Asynchronous Results,” is now live on DDJ’s website. From the article: This time, we’ll answer the following questions: How should we express return values and out parameters from an asynchronous function, including an active object method? How should we give back multiple partial … Continue reading Effective Concurrency: Prefer Using Futures or Callbacks to Communicate Asynchronous Results

Effective Concurrency: Prefer Using Active Objects Instead of Naked Threads

This month’s Effective Concurrency column, “Prefer Using Active Objects Instead of Naked Threads,” is now live on DDJ’s website. From the article: … Active objects dramatically improve our ability to reason about our thread’s code and operation by giving us higher-level abstractions and idioms that raise the semantic level of our program and let us … Continue reading Effective Concurrency: Prefer Using Active Objects Instead of Naked Threads

Effective Concurrency Course: June and (Not) October

I forgot to blog about this until now because of focusing on the Effective Concurrency course in Stockholm a few weeks ago, but to answer those who wonder if I’ll be giving it again in North America too: Yes, I’m also giving the public Effective Concurrency course again at the end of this month at … Continue reading Effective Concurrency Course: June and (Not) October

Effective Concurrency: Associate Mutexes with Data to Prevent Races

This month’s Effective Concurrency column, Associate Mutexes with Data to Prevent Races”, is now live on DDJ’s website. From the article: Come together: Associate mutexes with the data they protect, and you can make your code race-free by construction Race conditions are one of the worst plagues of concurrent code: They can cause disastrous effects … Continue reading Effective Concurrency: Associate Mutexes with Data to Prevent Races

Effective Concurrency Europe 2010

Last May, I gave a public Effective Concurrency course in Stockholm. It was well-attended, and a number of people have asked if it will be offered again. The answer is yes. I’m happy to report that Effective Concurrency Europe 2010 will be held on May 5-7, 2010, in Stockholm, Sweden. There’s an early-bird rate available … Continue reading Effective Concurrency Europe 2010

Effective Concurrency: Prefer Futures to Baked-In “Async APIs”

This month’s Effective Concurrency column, Prefer Futures to Baked-In “Async APIs”, is now live on DDJ’s website. From the article: When designing concurrent APIs, separate "what" from "how" Let’s say you have an existing synchronous API function [called DoSomething]… Because DoSomething could take a long time to execute (whether it keeps a CPU core busy … Continue reading Effective Concurrency: Prefer Futures to Baked-In “Async APIs”

Effective Concurrency: Prefer structured lifetimes – local, nested, bounded, deterministic.

This month’s Effective Concurrency column, Prefer structured lifetimes – local, nested, bounded, deterministic, is now live on DDJ’s website. From the article: Where possible, prefer structured lifetimes: ones that are local, nested, bounded, and deterministic. This is true no matter what kind of lifetime we’re considering, including object lifetimes, thread or task lifetimes, lock lifetimes, … Continue reading Effective Concurrency: Prefer structured lifetimes – local, nested, bounded, deterministic.

Effective Concurrency: Avoid Exposing Concurrency – Hide It Inside Synchronous Methods

This month’s Effective Concurrency column, Avoid Exposing Concurrency – Hide It Inside Synchronous Methods, is now live on DDJ’s website. From the article: You have a mass of existing code and want to add concurrency. Where do you start? Let’s say you need to migrate existing code to take advantage of concurrent execution or scale … Continue reading Effective Concurrency: Avoid Exposing Concurrency – Hide It Inside Synchronous Methods

Effective Concurrency: Design for Manycore Systems

This month’s Effective Concurrency column, Design for Manycore Systems, is now live on DDJ’s website. From the article: Why worry about “manycore” today? Dual- and quad-core computers are obviously here to stay for mainstream desktops and notebooks. But do we really need to think about "many-core" systems if we’re building a typical mainstream application right … Continue reading Effective Concurrency: Design for Manycore Systems