Control modes are critical for promoting information systems development (ISD) performance, however the relationship is elusive. Further, control is typically discussed in terms of the use of portfolios of control comprised of both formal (outcome and behavior) and informal (clan and self) mechanisms. Yet, the extent to which formal and informal controls individually relate to both performance and each other is still not fully established. This research utilizes meta-analysis to examine these relationships. The results indicate that control does enhance performance, although the strength of the relationship varies across types of control and different measures of performance. The results also show a significant relationship between formal and informal control modes, providing support for views of complementarities between modes within portfolios of control. It appears, however, that only clan control is positively associated with formal control. Building on these findings we suggest future directions for the study of control in ISD.

We present the programming model, design and implementation of NePalTM; a transactional memory system where atomic blocks can be used for concurrency control at an arbitrary level of nested parallelism.

This paper presents a software transactional memory system that introduces first-class C++ language constructs for transactional programming. We describe new C++ language extensions, a production-quality optimizing C++ compiler that translates and optimizes these extensions, and a high-performance STM runtime library. The transactional language constructs support C++ language features including classes, inheritance, virtual functions, exception handling, and templates. The compiler automatically instruments the program for transactional execution and optimizes TM overheads. The runtime library implements multiple execution modes and implements a novel STM algorithm that supports both optimistic and pessimistic concurrency control. The runtime switches a transaction's execution mode dynamically to improve performance and to handle calls to precompiled functions and I/O libraries. We present experimental results on 8 cores (two quad-core CPUs) running a set of 20 non-trivial parallel programs. Our measurements show that our system scales well as the numbers of cores increases and that our compiler and runtime optimizations improve scalability.