Modern network centric information systems implement highly distributedarchitectures that usually include multiple application servers. Application design ismainly based on the fundamental object—oriented principles and the adoptedarchitecture matches the logical decomposition of applications into several tierssuch as presentation, logic and data to their software and hardware structuring.Transactions offer a convenient mechanism for structuring distributed workloadsdue to the ACID properties (Atomicity, Consistency, Isolation, Durability). For someapplications however, the ACID properties are too restrictive. In mobile computing or in web applications for example, long intervals of non—responsiveness or frequentdisconnections lead to long—running transactions that may block concurrentlyrunning transactions and render acquired resources unavailable to other processes.New transaction models often relax one of the ACID properties in order to cope withthe challenges of the aforementioned execution environments. In transactionalmemory for example, consistency and durability guaranties are not provided. Thenew transaction models, often termed as advanced transactions, may not fulfillsome intended properties. Formal specification and reasoning for transactionproperties is essential for proving the validity of transaction models, but it has beenlimited to proof—theoretic approaches despite the recent progress in modelchecking. Moreover, we have not seen so far automated techniques that can derivea correct implementation from a valid transaction model. Performance andavailability of transaction processing depends on the adopted architectural designfor a given transaction model. Design decisions have measurable effects onavailability and performance of transaction processing systems. Existing trade—offsamong the design factors of an architecture affect the quality of the transactionprocessing service in a complex manner.In order to address the discussed problems, we introduce a model—drivenarchitecture based approach with a two—fold contribution.First, we provide a systematic process for model checking a transaction model andautomatically generate a correct implementation. Models are specified by statemachines that represent interacting transactional entities synchronized on a set ofevents. Verification is performed by examining all possible execution paths of thesynchronized state machines for property violations.Second, we elaborate on an approach for discovering architecture trade—offs andfor evaluating the impact of design decisions on performance and availability. Theproposed method is applicable on experimental data obtained by simulation or froma prototype implementation. If an architecture design fails to fulfill the performanceand availability goals for the considered workloads, the method is iteratively appliedtowards modifying the initial architecture until the goals are achieved.The aforementioned contributions are part of a process for the development oftransaction systems that we believe is capable to cope with the inherent complexityof distributed transaction processing.