MSDN Magazine: Concurrency rss

All MSDN Magazine Topics
  • Synchronization Coverage: Code Coverage for Concurrency
    Chris Dern, Roy Tan - September 2009 2009
    As more and more multi-threaded software applications get developed, software development professionals need to adopt new tools, techniques and metrics that can deal with multi-threaded software. Synchronization coverage is a simple, practical way to do this and this article covers a prototype synchronization coverage tool for .NET, called Sync Cover.

  • CLR Inside Out: Memory Usage Auditing For .NET Applications
    Subramanian Ramaswamy and Vance Morrison - June 2009
    Memory usage can have a direct impact on how fast an application executes and thus is important to optimize. In this article we discuss the basics of memory optimization for .NET programs.

  • Concurrent Affairs: Solving The Dining Philosophers Problem With Asynchronous Agents
    Rick Molloy - June 2009
    We use the new Asynchronous Agents Library in Visual C++ 2010 to solve the classic Dining Philosophers concurrency problem.

  • .NET Matters: Parallelizing Operations With Dependencies
    Stephen Toub - April 2009
    In this month’s installment, Stephen Toub examines some techniques for enforcing dependencies in the running order of asynchronous operations and builds a DependencyManagement class to help.

  • .NET Matters: Ordered Execution With ThreadPool
    Stephen Toub - February 2009
    This month we demonstrate how you can use the ThreadPool to support ordered execution without having to build custom thread pools yourself.

  • Net Matters: Round-Robin Access To The ThreadPool
    Stephen Toub - January 2009
    Stephen Toub shows you how to add round-robin scheduling support on top of the ThreadPool for more granular processing control.

  • CLR Inside Out: Thread Management In The CLR
    Erika Fuentes and Eric Eilebrecht - December 2008
    Getting the performance you want in concurrent applications is not as straightforward as you might think. See how common threading issues can affect your application.

  • Paradigm Shift: Design Considerations For Parallel Programming
    David Callahan - October 2008
    This article presents an overview of the motivation behind new techniques that decompose problems into independent pieces for optimal use of parallel programming.

  • Coding Tools: Improved Support For Parallelism In The Next Version Of Visual Studio
    Stephen Toub and Hazim Shafi - October 2008
    We take a look at planned support for parallel programming for both managed and native code in the next version of Visual Studio.

  • Concurrency Hazards: Solving 11 Likely Problems In Your Multithreaded Code
    Joe Duffy - October 2008
    Here we describe some of the more common challenges to concurrent programming and present advice for coping with them in your software.

  • Easy Async: Build Concurrent Apps From Simple F# Expressions
    Chance Coble - October 2008
    In this article, the author explores how the F# language helps you create asynchronous function libraries that can be called seamlessly from any other .NET-compliant language.

  • Editor's Note: new Thread(ReadEditorsNote).Start(); yourAttention.WaitOne();
    Howard Dierking - October 2008
    Introducing the issue, Howard Dierking points out that you can't simply parallelize your code blindly if you expect to truly reap the benefits that parallelism promises.

  • .NET Matters: False Sharing
    Stephen Toub, Igor Ostrovsky, and Huseyin Yildiz - October 2008
    This month: memory access issues in multi-core systems and diagnosing and avoiding false sharing in your parallel computing applications.

  • { End Bracket }: Don’t Be Afraid To Throw Away Your Work
    Josh Phillips - October 2008
    With today's processing power at your disposal, Josh Phillips recommends speculative computation—performing operations ahead of time even if you may never need the results.

  • Concurrent Affairs: More AsyncEnumerator Features
    Jeffrey Richter - August 2008
    Jeffrey Richter shows you some additional cool features of his AsyncEnumerator class.

  • .NET Matters: Asynchronous I/O with WebClient
    Stephen Toub - July 2008
    In this month’s installment of .NET Matters, columnist Stephen Toub answers reader questions concerning asynchronous I/O .

  • Concurrency: Tools And Techniques to Identify Concurrency Issues
    Rahul V. Patil and Boby George - June 2008
    Efficient parallel applications aren’t born by merely running an old app on a parallel processor machine. Tuning needs to be done if you’re to gain maximum benefit.

  • Concurrent Affairs: Simplified APM with the AsyncEnumerator
    Jeffrey Richter - June 2008
    Here Jeffrey Richter introduces his AsyncEnumerator class, which drives an iterator so that different thread pool threads can execute the same code at different times.

  • Performance: Scaling Strategies for ASP.NET Applications
    Richard Campbell and Kent Alstad - April 2008
    Performance problems can creep into your Web app as it scales up, and when they do, you need to find the causes and the best strategies to address them.

  • Interview++: Bjarne Stroustrup on the Evolution of Languages
    Howard Dierking - April 2008
    Howard Dierking talks to the inventor of C++, Bjarne Stroustrup, about language zealots, the evolution of programming, and what’s in the future of programming.

  • .NET Matters: Asynchronous Stream Processing
    Stephen Toub - March 2008
    This month Stephen Toub discusses asynchronous stream processing.

  • .NET Matters: Stream Pipeline
    Stephen Toub - February 2008
    This month Stephen Toub explains how to make the most of dual processors when running encryption and compression tasks.

  • Concurrent Affairs: Simplified APM with C#
    Jeffrey Richter - November 2007
    Jeffrey Richter introduces his AsyncEnumerator class and explains how it harnesses some recent additions to the C# programming language that make working with the asynchronous programming model significantly easier.

  • Pooled Threads: Improve Scalability With New Thread Pool APIs
    Robert Saccone - October 2007
    The new threadpool APIs in Windows Vista and in the upcoming Windows Server 2008 provide advances that even native Windows developers can benefit from.

  • WPF Threads: Build More Responsive Apps With The Dispatcher
    Shawn Wildermuth - October 2007
    Understanding the Windows Presentation Foundation threading model helps when creating user interfaces that are both compelling and responsive.

  • Parallel LINQ: Running Queries On Multi-Core Processors
    Joe Duffy and Ed Essey - October 2007
    Use Parallel Language Integrated Query (PLINQ) to take advantage of multi-processor computers and the newer wave of multi-core processors.

  • Parallel Performance: Optimize Managed Code For Multi-Core Machines
    Daan Leijen and Judd Hall - October 2007
    While multi-core processors have become increasingly common, most applications still fail to take advantage of multiple cores. Here's an overview of creating multithreaded applications that benefit from these new processors.

  • Windows with C++: Task Scheduler 2.0
    Kenny Kerr - October 2007
    The new Task Scheduler in Windows Vista can do so much more than previous versions. We introduce some basic concepts and building blocks you can put to use in your own scheduled task projects.

  • .NET Matters: Deadlock monitor
    Stephen Toub - October 2007
    This month Stephen Toub discusses deadlocks that can occur when synchronizing threads.

  • Cutting Edge: Canceling Server Tasks with ASP.NET AJAX
    Dino Esposito - August 2007
    This month Dino explains how to remotely cancel tasks running on the server using ASP.NET AJAX.

  • NTFS: Enhance Your Apps With File System Transactions
    Jason Olson - July 2007
    Presented here is an overview of Transactional NTFS and how it revolutionizes transactions.

  • Bugslayer: Wait Chain Traversal
    John Robbins - July 2007
    Windows Vista has a new API called Wait Chain Traversal (WCT), which allows you to determine when and why a process is deadlocked. Read on.

  • CONCURRENCY: Synchronization Primitives New To Windows Vista
    Robert Saccone and Alexander Taskov - June 2007
    Windows Vista has lots of goodies for native C++ developers including condition variables, slim reader/writer locks, and one-time initialization.

  • Concurrent Affairs: Asynchronous Device Operations
    Jeffrey Richter - June 2007
    Jeff Richter uses the AsyncResult<TResult> class to implement the CLR’s Asynchronous Programming Model to perform hardware device operations asynchronously.

  • .NET Matters: Handling Messages in Console Apps
    Stephen Toub - June 2007
    Many developers who use the Microsoft .NET Framework think that application type is tied to the libraries that can be used in that application. Stephen Toub clarifies.

  • CLR Inside Out: 9 Reusable Parallel Data Structures and Algorithms
    Joe Duffy - May 2007


  • Wicked Code: Scalable Apps with Asynchronous Programming in ASP.NET
    Jeff Prosise - March 2007


  • Concurrent Affairs: Implementing the CLR Asynchronous Programming Model
    Jeffrey Richter - March 2007


  • Data Points: RSS Feeds on a Smartphone
    John Papa - December 2006
    John Papa builds a Windows Mobile 5.0 application that reads RSS feeds and loads them into an ADO.NET DataSet.

  • Concurrent Affairs: The ReaderWriterGate Lock
    Jeffrey Richter - November 2006


  • Wicked Code: Running ASMX Web Services on STA Threads
    Jeff Prosise - October 2006
    Jeff Prosise describes performance problems in an ASMX Web service that relied on legacy COM and Visual Basic 6.0 to perform key processing tasks and the approach he took to find a fix.

  • CLR Inside Out: Using concurrency for scalability
    Joe Duffy - September 2006
    Because of the popularity of multiprocessor machines, many concurrency articles focus on how to make concurrency safe in your code. However, they don't deal with how to get concurrency into your code in the first place.

  • Concurrent Affairs: Concurrency and Coordination Runtime
    Jeffrey Richter - September 2006
    What can a robot-programming toolkit do for you? Read on and find out.

  • .NET Matters: Scope<T> and More
    Stephen Toub - September 2006
    This month Stephen Toub explains how you can get some of the functionality found in the TransactionScope class in your own classes.

  • Web App Follies: Keep Sites Running Smoothly By Avoiding These 10 Common ASP.NET Pitfalls
    Jeff Prosise - July 2006


  • Extreme ASP.NET: Asynchronous Web Parts
    Fritz Onion - July 2006
    Building a customizable Web site complete with a collection of pluggable Web Parts is fairly easy with the portal infrastructure of ASP. NET 2. 0. This model is very flexible, allowing users to easily place your Web Parts anywhere on the Web page so they are free to customize your site.

  • Concurrent Affairs: Reader/Writer Locks and the ResourceLock Library
    Jeffrey Richter - June 2006
    If multiple threads concurrently execute code that writes to or modifies a resource, then obviously the resource must be protected with a thread synchronization lock to ensure that the resource doesn't get corrupted.

  • .NET Matters: Parameterized ThreadStart, EventWaitHandle, and More
    Stephen Toub - June 2006
    This month Stephen Toub answers readers questions that include: How do I pass data to a new thread? Why can't I convert from "ref string" to "ref object"? And what's the difference between EventWaitHandle, AutoResetEvent and ManualResetEvent?

  • No More Hangs: Advanced Techniques To Avoid And Detect Deadlocks In .NET Apps
    Joe Duffy - April 2006
    You can combat deadlock using a combination of disciplined locking practices which Joe Duffy aptly explains in this article.

  • Concurrent Affairs: Build a Richer Thread Synchronization Lock
    Jeffrey Richter - March 2006
    In my last column, I showed the various thread synchronization mechanisms employed by the Microsoft® . NET Framework (see Concurrent Affairs: Performance-Conscious Thread Synchronization). I then examined the performance characteristics of all these mechanisms and determined that the Interlocked methods performed the best because the calling thread never has to transition to kernel mode.

  • .NET Matters: Abortable Thread Pool
    Stephen Toub - March 2006


  • Memory Models: Understand the Impact of Low-Lock Techniques in Multithreaded Apps
    Vance Morrison - October 2005
    Because the use of low-lock techniques in your application significantly increases the likelihood of introducing hard-to-find bugs, it is best to use them only when absolutely necessary. Here Vance Morrison demonstrates the limitations and subtleties low-lock techniques so that if you are forced to use them you have a better chance of using them correctly.

  • OpenMP and C++: Reap the Benefits of Multithreading without All the Work
    Kang Su Gatlin and Pete Isensee - October 2005
    Having more than one CPU core on a single chip makes a system with a processor with two cores operate just like a dual-processor computer, and a system with a processor with four cores operate like a quad-processor computer, so you get much better performance. But if your application does not take advantage of these multiple cores, you may not reap the benefits. OpenMP helps you create multithreaded C++ applications more quickly so the benefits of multithreading can be realized.

  • Wicked Code: Asynchronous Pages in ASP.NET 2.0
    Jeff Prosise - October 2005
    ASP.NET 2.0 is replete with new features ranging from declarative data binding and Master Pages to membership and role management services. But my vote for the coolest new feature goes to asynchronous pages, and here's why.

  • Concurrent Affairs: Performance-Conscious Thread Synchronization
    Jeffrey Richter - October 2005
    In my career, I have architected and implemented many thread synchronization techniques. This has provided me with a lot of experience that has shaped the way I now think about thread synchronization problems.

  • Concurrency: What Every Dev Must Know About Multithreaded Apps
    Vance Morrison - August 2005
    Multithreading offers lots of benefits, but it's not a technique you can employ willy nilly without first learning about all the potential pitfalls. To get you started, Vance Morrison covers multithreading and the shared memory threading model, race conditions and how concurrent access can break invariants. He also discusses how to use locks so you can understand the costs involved.

  • Winsock: Get Closer to the Wire with High-Performance Sockets in .NET
    Daryn Kiely - August 2005
    The Win32 Windows Sockets library (Winsock) provides mechanisms to improve the performance of programs that use sockets, and the Microsoft .NET Framework provides a layer over Winsock so that managed applications can communicate over sockets. To use all these layers to write a truly high-performance socket-based application requires a little background information, as Daryn Kiely explains here.

  • Debugging: Root Out Elusive Production Bugs with These Effective Techniques
    Matt Adamson - July 2005
    Errors happen. But in production, error logs often provide little or no help in pinpointing the exact line of code in which the problem originates. You can't usually isolate the root cause by modifying code in a production environment because recreating the exact same environment is very difficult due to the large number of potential software and hardware configurations. This article provides some concrete steps you can take to get at the heart of the problems in your production code.

  • .NET Matters: StringStream, Methods with Timeouts
    Stephen Toub - July 2005


  • Make It Snappy: Juice Up Your App with the Power of Hyper-Threading
    Yaniv Pessach - June 2005
    In this article, the author explores the hyper-threading technology found on newer Intel Pentium 4 processors and demonstrates how adding parallelism to your code can improve performance on hyper-threaded machines. He covers advanced optimizations for hyper-threading and shows a number of useful patterns. Code samples are in C#, but you can apply the same principles in other languages as they apply to both managed and unmanaged applications.

  • Wicked Code: Power Programming Tips for ASP.NET 2.0
    Jeff Prosise - June 2005
    In the February 2005 issue, I introduced five lesser-known features of ASP. NET 2. 0 that have the potential to make a significant impact on the security, performance, and robustness of your code (see Wicked Code: Five Undiscovered Features on ASP.

  • .NET Matters: ICustomTypeDescriptor, Part 2
    Stephen Toub - May 2005
    In last month's . NET Matters column, I answered a question concerning the PropertyGrid control, specifically about using it with classes that expose fields instead of properties. I demonstrated how the ICustomTypeDescriptor interface in the Microsoft® .

  • Advanced Basics: Doing Async the Easy Way
    Ken Getz - March 2005
    If you've been following Ted Pattison's excellent series of Basic Instincts columns on multithreading and asynchronous behavior, you should by now be an expert on handling the issues involved in working with multiple threads in Windows®-based apps.

  • Basic Instincts: Using the ReaderWriterLock Class
    Ted Pattison - February 2005
    In several installments over the past year I have written about multithreading programming techniques in Visual Basic® . NET. In the September 2004 issue of MSDN®Magazine, I discussed the need for thread synchronization and how to write thread-safe code using monitors.

  • .NET Matters: File Copy Progress, Custom Thread Pools
    Stephen Toub - February 2005


  • .NET Matters: Asynchronous HttpWebRequests, Interface Implementation, and More
    Stephen Toub - December 2004


  • .NET Matters: ThreadPoolPriority, and MethodImplAttribute
    Stephen Toub - November 2004


  • .NET Matters: ThreadPoolWait and HandleLeakTracker
    Stephen Toub - October 2004


  • Basic Instincts: Thread Synchronization
    Ted Pattison - September 2004
    My last three Basic Instincts columns have examined techniques for using asynchronous delegates and creating secondary threads. Those columns demonstrated how to introduce multithreaded behavior into your applications.

  • Basic Instincts: Creating and Managing Secondary Threads
    Ted Pattison - June 2004


  • Basic Instincts: Updating the UI from a Secondary Thread
    Ted Pattison - May 2004


  • Advanced Basics: Synchronizing Multiple Windows Forms
    Ken Spencer - April 2004


  • Timers: Comparing the Timer Classes in the .NET Framework Class Library
    Alex Calvo - February 2004
    Timers often play an important role in both client applications and server-based components (including Windows services). Writing effective timer-driven managed code requires a clear understanding of program flow and the subtleties of the .NET threading model. The .NET Framework Class Library provides three different timer classes: System.Windows.Forms.Timer, System.Timers.Timer, and System.Threading.Timer. Each of these classes has been designed and optimized for use in different situations. This article examines the three timer classes and helps you gain an understanding of how and when each class should be used.

  • Basic Instincts: Asynchronous Method Execution Using Delegates
    Ted Pattison - January 2004


  • .NET Column: Practical Multithreading for Client Apps
    Jason Clark - January 2004


  • Threading: Break Free of Code Deadlocks in Critical Sections Under Windows
    Matt Pietrek and Russ Osterlund - December 2003
    Critical sections, a mechanism that prohibits more than one thread at a time from executing a particular section of code, is a topic that has not received much attention and thus tends not to be well understood. A solid understanding of critical sections in Windows can really come in handy when you need to track down multithreading performance issues in your code. This articles delves under the hood of critical sections to reveal information useful in finding deadlocks and in pinpointing performance problems. It also includes a handy utility program that shows all of your critical sections and their current states.

  • Coroutines: Implementing Coroutines for .NET by Wrapping the Unmanaged Fiber API
    Ajai Shankar - September 2003
    Coroutines are a powerful feature of many programming languages including CLU, Scheme, Python, Ruby, and ICON. Coroutines can save processor overhead and reduce redundancy because they allow you to stop execution of a procedure midstream, return a value, and resume exactly where the procedure left off.This article shows how coroutines can be implemented for the .NET Framework by using the Fiber API and Managed Extensions for C++, and how they can be easily used with other .NET-compliant languages. This article also shows a sophisticated use of the runtime host for running multiple managed threads on a single OS thread.

  • ASP.NET Pipeline: Use Threads and Build Asynchronous Handlers in Your Server-Side Web Code
    Fritz Onion - June 2003
    Fortunately for developers, threading in ASP.NET is a lot easier than it was in ASP. In this article, the author takes a look at threading in the ASP.NET HTTP pipeline, and explains how threads are managed efficiently without the involvement of the developer. The article considers how the common language runtime threadpool is used by ASP.NET to service requests, looks at the pooling mechanisms used for handlers, modules, and applications, and covers both IIS 5.0 and IIS 6.0 and how they differ in their approach to request processing and thread allocation. Finally, how and when to use asynchronous handlers is discussed for developers who still need to use threads in their own applications.

  • .NET Column: The CLR's Thread Pool
    Jeffrey Richter - June 2003
    How does the thread pool work in the CLR?

  • Windows Forms: Give Your .NET-based Application a Fast and Responsive UI with Multiple Threads
    Ian Griffiths - February 2003
    If your application performs any non-UI processing on the thread that controls the user interface, it may make the app seem slow and sluggish, frustrating users. But writing multithreaded apps for Windows has long been restricted to C++ developers. Now with the .NET Framework, you can take advantage of multiple threads in C# to control the flow of instructions in your programs and isolate the UI thread for a fast and snappy user interface. This article shows you how. Also, it discusses the pitfalls of multiple threads and presents a framework for safe concurrent thread execution.

  • .NET Column: Safe Thread Synchronization
    Jeffrey Richter - January 2003
    By far, the most common use of thread synchronization is to ensure mutually exclusive access to a shared resource by multiple threads. In the Win32® API, the CRITICAL_SECTION structure and associated functions offers the fastest and most efficient way to synchronize threads for mutually exclusive access when the threads are all running in a single process.

  • Spider in .NET: Crawl Web Sites and Catalog Info to Any Data Store with ADO.NET and Visual Basic .NET
    Mark Gerlach - October 2002
    Visual Basic .NET comes loaded with features not available in previous versions, including a new threading model, custom class creation, and data streaming. Learn how to take advantage of these features with an application that is designed to extract information from Web pages for indexing purposes. This article also discusses basic database access, file I/O, extending classes for objects, and the use of opacity and transparency in forms.

  • SOAP: Using ATL Server to Build an Asynchronous SOAP Client in Unmanaged C++
    Pranish Kumar and Bogdan Crivat - April 2002
    SOAP opens up a new world of Web Services, letting you make function calls across a network or the Internet. But this flexibility creates new problems when your app needs to wait for calls to return from halfway around the world. What you need is an asynchronous SOAP client that takes advantage of threading to continue execution while waiting for calls over the wire. This article covers the basics of building such a client with ATL.

  • Web Q&A: Threading in MSXML, Sorting XML, Order-by, Changing Mouse Pointer, and More
    Edited by Nancy Michell - February 2002


  • Multiprocessor Optimizations: Fine-Tuning Concurrent Access to Large Data Collections
    Ian Emmons - August 2001
    Application performance involves more than just speed. In a Web server environment, top performance also means ensuring that the maximum numbers of users can be served concurrently. This can be accomplished through efficient use of multiprocessor machines and thread management. This article presents techniques that can solve a number of concurrency problems. One approach, using thread management, controls access to a database on a per-thread basis, which protects the integrity of the data. In the article, reusable thread classes are built and presented. The classes are then tested and their performance in a live environment is examined.

  • .NET Delegates: Making Asynchronous Method Calls in the .NET Environment
    Richard Grimes - August 2001
    One of the many great features of the .NET Framework is that it has asynchronous infrastructure built in. In .NET you can call any method asynchronously by defining a delegate for the method and calling the delegate's asynchronous methods. This is beneficial to your application because when a synchronous call is made, the calling thread is blocked until the method completes whereas an asynchronous call is made on a different thread, and this allows the original thread to continue its work while the asynchronous call is in progress.This article explains delegates in .NET and how to use them to perform asynchronous calls, eliminating age-old threading problems.

  • Visual Basic .NET: Tracing, Logging, and Threading Made Easy with .NET
    Yasser Shohoud - July 2001
    Visual Basic has always been a language of innovation, but at the same time it's left its proponents wanting certain high-level features. With the upcoming version, Visual Basic .NET, the language takes advantage of the Microsoft .NET Framework to provide several new features that will be vital to developers. This article begins by discussing tracing and error logging in Visual Basic .NET. Next, you'll see how to write a Windows service without third-party help. Monitoring the file system, a previously daunting task, is also covered. Finally, the author ties these concepts together with a sample application that waits for XML files to be deposited in a directory and then imports them into SQL Server database.

  • Serving the Web: HTML Scraping with Visual Basic and AsyncRead
    Ken Spencer - March 2001


  • Windows CE 3.0: Enhanced Real-Time Features Provide Sophisticated Thread Handling
    Paul Yao - November 2000
    Windows CE is a small, configurable, feature-rich, real-time operating system. In Windows CE 3.0, the real-time support has been improved. This article looks at specific support for the creation of real-time systems and how it compares to the support in Windows for the desktop. The way interrupt handlers, processes, memory management, and synchronization work in Windows CE 3.0 is discussed. An extensive look at threads and thread priority, misconceptions surrounding them, and their impact on performance is included. Refinements to the Windows CE scheduler and support for nestable interrupts are also covered.

  • Windows Sockets 2.0: Write Scalable Winsock Apps Using Completion Ports
    Anthony Jones and Amol Deshpande - October 2000
    Writing a network-aware application isn't difficult, but writing one that is scalable can be challenging. Overlapped I/O using completion ports provides true scalability on Windows NT and Windows 2000. Completion ports and Windows Sockets 2.0 can be used to design applications that will scale to thousands of connections. The article begins with a discussion of the implementation of a scalable server, discusses handling low-resource, high-demand conditions, and addresses the most common problems with scalability.

  • Win32 Q&A: Handy Features in Windows, and Interlocked Functions
    Jeffrey Richter - July 2000


  • Under the Hood: Happy 10th Anniversary, Windows
    Matt Pietrek - July 2000


  • Windows 2000: Asynchronous Method Calls Eliminate the Wait for COM Clients and Servers
    Jeff Prosise - April 2000
    Windows 2000 is the first version of COM to support asynchronous method calls, which permit clients to make nonblocking calls to COM objects and objects to process incoming calls without blocking the calling threads. COM clients benefit from asynchronous method calls because they can continue working while waiting for outbound calls to return. Objects benefit because they can queue incoming calls and service them from a thread pool. Our SieveClient and SieveServer sample apps demonstrate how to create and use asynchronous clients and servers in COM-based distributed applications.

  • House of COM: Performance Trade-offs of the Windows 2000 Component Execution Environment
    Don Box - March 2000