Build systems faster and more effectively with Mob Programming. Mob Programming is an approach to developing software that radically reduces defects and key-person dependencies by having a group of people work together at a single machine. See how to avoid the most common pitfalls that teams make when first starting out. Discover what it takes to create and support a successful mob. Now you can take collaborative programming to the next level with Mob Programming. Mob Programming is a natural extension of the popular Pair Programming concept, and is not restricted to a specific programming language or technology. It can be used by anyone who develops software, including dev leads, software developers, and agile coaches. The more people working on a bug or feature results in fewer dependencies on individuals, and overall increased learning for everyone involved. With more eyes on the code, you'll find you develop better solutions with fewer defects. Set up your team for success by introducing Mob Programming in a way that benefits them. Create a good first Mobbing experience for your team with a template that avoids the common traps beginners may fall into. Master a collaborative and empathic mindset to help optimize the Mobbing experience. Learn how to make adjustments when things go wrong. Adapt your mobbing to different types of development tasks. Get management buy-in for your Mobbing experiment by demonstrating the benefits. Discover the equipment and resources you need, and how to adjust your workspace for an effective mob. Get important features to market sooner, squish bugs faster, and collaborate better today with Mob Programming. What You Need: All you need is three or more programmers, a meeting workspace that's large enough to accommodate your mob, and a computer on which to work.

The amount of software used in safety-critical systems is increasing at a rapid rate. At the same time, software technology is changing, projects are pressed to develop software faster and more cheaply, and the software is being used in more critical ways. Developing Safety-Critical Software: A Practical Guide for Aviation Software and DO-178C Compliance equips you with the information you need to effectively and efficiently develop safety-critical, life-critical, and mission-critical software for aviation. The principles also apply to software for automotive, medical, nuclear, and other safety-critical domains.

An international authority on safety-critical software, the author helped write DO-178C and the U.S. Federal Aviation Administration s policy and guidance on safety-critical software. In this book, she draws on more than 20 years of experience as a certification authority, an avionics manufacturer, an aircraft integrator, and a software developer to present best practices, real-world examples, and concrete recommendations.

The book includes:

• An overview of how software fits into the systems and safety processes
• Detailed examination of DO-178C and how to effectively apply the guidance
• Insight into the DO-178C-related documents on tool qualification (DO-330), model-based development (DO-331), object-oriented technology (DO-332), and formal methods (DO-333)
• Practical tips for the successful development of safety-critical software and certification
• Insightful coverage of some of the more challenging topics in safety-critical software development and verification, including real-time operating systems, partitioning, configuration data, software reuse, previously developed software, reverse engineering, and outsourcing and offshoring

An invaluable reference for systems and software managers, developers, and quality assurance personnel, this book provides a wealth of information to help you develop, manage, and approve safety-critical software more confidently.

The focus of this book is on bridging the gap between two extreme methods for developing software. On the one hand, there are texts and approaches that are so formal that they scare off all but the most dedicated theoretical computer scientists. On the other, there are some who believe that any measure of formality is a waste of time, resulting in software that is developed by following gut feelings and intuitions.

Kourie and Watson advocate an approach known as "correctness-by-construction," a technique to derive algorithms that relies on formal theory, but that requires such theory to be deployed in a very systematic and pragmatic way. First they provide the key theoretical background (like first-order predicate logic or refinement laws) that is needed to understand and apply the method. They then detail a series of graded examples ranging from binary search to lattice cover graph construction and finite automata minimization in order to show how it can be applied to increasingly complex algorithmic problems. The principal purpose of this book is to change the way software developers approach their task at programming-in-the-small level, with a view to improving code quality. Thus it coheres with both the IEEE's Guide to the Software Engineering Body of Knowledge (SWEBOK) recommendations, which identifies themes covered in this book as part of the software engineer's arsenal of tools and methods, and with the goals of the Software Engineering Method and Theory (SEMAT) initiative, which aims to "refound software engineering based on a solid theory.""

The heart of any system that simulates the physical interaction between objects is collision detection-the ability to detect when two objects have come into contact. This system is also one of the most difficult aspects of a physical simulation to implement correctly, and invariably it is the main consumer of CPU cycles. Practitioners, new to the field or otherwise, quickly discover that the attempt to build a fast, accurate, and robust collision detection system takes them down a long path fraught with perils and pitfalls unlike most they have ever encountered. Without in-depth knowledge and understanding of the issues associated with engineering a collision detection system, the end of that path is an abyss that has swallowed many a good programmer!
Gino van den Bergen's new book is the story of his successful journey down that path. The outcome is his well-known collision detection system, the SOftware Library for Interference Detection (SOLID). Along the way, he covers the topics of vector algebra and geometry, the various geometric primitives of interest in a collision system, the powerful method of separating axes for the purposes of intersection testing, and the equally powerful Gilbert-Johnson-Keerthi (GJK) algorithm for computing the distance between convex objects. But this book provides much more than a good compendium of the ideas that go into building a collision system. The curse of practical computational geometry is floating-point arithmetic. Algorithms with straightforward implementations when using exact arithmetic can have catastrophic failures in a floating-point system. Specifically, intersection and distance algorithms implemented in a floating-point systemtend to fail exactly in the most important case in a collision system-when two objects are just touching. Great care must be taken to properly handle floating-point round off errors. Gino's ultimate accomplishment in this book is his presentation on how to correctly implement the GJK distance algorithm in the presence of single-precision floating-point arithmetic. And what better way to illustrate this than with a case study, the final chapter on the design and implementation of SOLID.
About the CD-ROM
The companion CD-ROM includes the full C++ source code of SOLID 3.5 as well as API documentation in HTML and PDF formats. Both single (32bit) and double (64bit) precision versions of the SOLID SDK plus example programs can be compiled for Linux platforms using GNU g++ version 2.95 to 3.3 and for Win32 platforms using Microsoft Visual C++ version 6.0 to 7.1. Use of the SOLID source code is governed by the terms of either the GNU GPL or the Trolltech QPL (see CD-ROM documentation for details).
About the Author
Gino van den Bergen is a game developer living and working in The Netherlands. He is the creator of SOLID and holds a Ph.D. in computing science from Eindhoven University of Technology. Gino implemented collision detection and physics in NaN Technologies' Blender, a creation suite for interactive 3D content.
*Explains the fundamental geometric and numerical concepts that underlie the key algorithms of collision detection.
*CD-ROM includes the full C++ source code of SOLID, a well-known library for collision detection, plus binaries and example programs for Win32.
*Discusses algorithms for commonly used primitive types, such as spheres, boxes, cylinders, cones, triangles, rays, and convex polyhedra.
*Presents techniques for accelerating collision detection for complex models and scenes.

As the first book about software culture, this book discusses software culture from three perspectives including historical perspective, the classification of software and software applications. This book takes credit from the view of science and technology development. It analyzed scientific innovations and the social areas promoted following the growth of technology. And according to the fact that information helps to build human cultural form, we proposed the concept and researching method of software culture. The aim of writing this book is to strengthen the connection between software and culture, to replenish knowledge system in the subject of software engineering, and to establish a new area of study that is the culture of software.

The product of many years of practical experience and research in the software measurement business, this technical reference helps you select what metrics to collect, how to convert measurement data to management information, and provides the statistics necessary to perform these conversions. The author explains how to manage software development measurement systems, how to build software measurement tools and standards, and how to construct controlled experiments using standardized measurement tools.

There are three fundamental questions that this book seeks to answer. First, exactly how do you get the measurement data? Second, how do you convert the data from the measurement process to information that you can use to manage the software development process? Third, how do you manage all of the data?

Millions of dollars are being spent trying to secure software systems. When suitable instrumentation is placed into the systems that we develop, their activity can be monitored in real time. Measurement based automatic detection mechanisms can be designed into systems. This will permit the detection of system misuse and detect incipient reliability problems.

By demonstrating how to develop simple experiments for the empirical validation of theoretical research and showing how to convert measurement data into meaningful and valuable information, this text fosters more precise use of software measurement in the computer science and software engineering literature. Software Engineering Measurement shows you how to convert your measurement data to valuable information that can be used immediately for software process improvement.

This book constitutes the refereed proceedings of the 7th International IFIP WG 2.13 Conference on Open Source Systems, OSS 2010, held in Salvador, Brazil, in October 2011. The 20 revised full papers presented together with 4 industrial full papers and 8 lightning talks were carefully reviewed and selected from 56 submissions. The papers are organized in the following topical sections: OSS quality and reliability, OSS products, review of technologies of and for OSS, knowledge and research building in OSS, OSS reuse, integration, and compliance, OSS value and economics, OSS adoption in industry, and mining OSS repositories.

This book addresses the development of safety-critical software and to this end proposes the SafeScrum (R) methodology. SafeScrum (R) was inspired by the agile method Scrum, which is extensively used in many areas of the software industry. Scrum is, however, not intended or designed for use with safety-critical systems; hence the authors propose guidelines and additions to make it both practically useful and compliant with the additional requirements found in safety standards. The book provides an overview of agile software development and how it can be linked to safety and relevant safety standards. SafeScrum (R) is described in detail as a useful approach for reaping the benefits of agile methods, and is intended as a set of ideas and a basis for adaptation in industry projects. The book covers roles, processes and practices, and documentation. It also includes tips on how standard software process tools can be employed. Lastly, some insights into relevant research in this new and emerging field are provided, and selected real-world examples are presented. The ideas and descriptions in this book are based on collaboration with the industry, in the form of discussions with assessment organizations, general discussions within the research fields of safety and software, and last but not least, the authors' own experiences and ideas. It was mainly written for practitioners in industry who know a great deal about how to produce safety-critical software but less about agile development in general and Scrum in particular.

• UML (the Unified Modeling Language), design patterns, and software component technologies are three new advances that help software engineers create more efficient and effective software designs
• A helpful project threaded throughout the book enables readers to apply what they are learning
• Presents a modern and applied approach to software design
• Numerous design patterns with detailed explanations provide essential tools for technical and professional growth
• Includes extensive discussion of UML with many UML examples

Ruby, Io, Prolog, Scala, Erlang, Clojure, Haskell. With Seven Languages in Seven Weeks, by Bruce A. Tate, you'll go beyond the syntax-and beyond the 20-minute tutorial you'll find someplace online. This book has an audacious goal: to present a meaningful exploration of seven languages within a single book. Rather than serve as a complete reference or installation guide, Seven Languages hits what's essential and unique about each language. Moreover, this approach will help teach you how to grok new languages. For each language, you'll solve a nontrivial problem, using techniques that show off the language's most important features. As the book proceeds, you'll discover the strengths and weaknesses of the languages, while dissecting the process of learning languages quickly--for example, finding the typing and programming models, decision structures, and how you interact with them. Among this group of seven, you'll explore the most critical programming models of our time. Learn the dynamic typing that makes Ruby, Python, and Perl so flexible and compelling. Understand the underlying prototype system that's at the heart of JavaScript. See how pattern matching in Prolog shaped the development of Scala and Erlang. Discover how pure functional programming in Haskell is different from the Lisp family of languages, including Clojure. Explore the concurrency techniques that are quickly becoming the backbone of a new generation of Internet applications. Find out how to use Erlang's let-it-crash philosophy for building fault-tolerant systems. Understand the actor model that drives concurrency design in Io and Scala. Learn how Clojure uses versioning to solve some of the most difficult concurrency problems. It's all here, all in one place. Use the concepts from one language to find creative solutions in another-or discover a language that may become one of your favorites.

The control-flow issues presented in this textbook are extremely relevant in modern computer languages and programming styles. In addition to the basic control-flow mechanisms, virtually all new computer languages provide some form of exceptional control flow to support robust programming introduced in this textbook. Also, concurrency capabilities are appearing with increasing frequency in both new and old programming languages, and are covered in this book. Understanding Control Flow: With Concurrent Programming Using C++ starts with looping, and works through each of the basic control-flow concepts, examining why each is fundamental and where it is useful. Time is spent on each concept according to its level of difficulty. Examples and exercises are also provided in this textbook. New programming methodologies are requiring new forms of control flow, and new programming languages are supporting these methodologies with new control structures, such as the concurrency constructs discussed in this textbook. Most computers now contain multi-threading and multi-cores, while multiple processors and distributed systems are ubiquitous - all of which require advanced programming methodologies to take full advantage of the available parallelism summarized in this textbook. Advance forms of control flow are becoming basic programming skills needed by all programmers, not just graduate students working in the operating systems or database disciplines. This textbook is designed for advanced-level students studying computer science and engineering. Professionals and researchers working in this field, specifically programming and software engineering, will find this book useful as a reference.

Prototyping and user testing is the best way to create successful products, but many designers skip this important step and use gut instinct instead. By explaining the goals and methodologies behind prototyping-and demonstrating how to prototype for both physical and digital products-this practical guide helps beginning and intermediate designers become more comfortable with creating and testing prototypes early and often in the process. Author Kathryn McElroy explains various prototyping methods, from fast and dirty to high fidelity and refined, and reveals ways to test your prototypes with users. You'll gain valuable insights for improving your product, whether it's a smartphone app or a new electronic gadget. Learn similarities and differences between prototyping for physical and digital products Know what fidelity level is needed for different prototypes Get best practices for prototyping in a variety of mediums, and choose which prototyping software or components to use Learn electronics prototyping basics and resources for getting started Write basic pseudocode and translate it into usable code for Arduino Conduct user tests to gain insights from prototypes

Here is an ideal textbook on software visualization, written especially for students and teachers in computer science. It provides a broad and systematic overview of the area including many pointers to tools available today. Topics covered include static program visualization, algorithm animation, visual debugging, as well as the visualization of the evolution of software. The author's presentation emphasizes common principles and provides different examples mostly taken from seminal work. In addition, each chapter is followed by a list of exercises including both pen-and-paper exercises as well as programming tasks.

The modern application server is a complex platform that is the linchpin of an enterprise environment that includes a very wide range of technologies-web document formatting, web protocols, server-side scripts, servlets, applets, programming languages, distributed object technologies, security capabilities, directory and naming services, load balancing, system management, and others. As such, it can be a daunting task to try to comprehend these systems. Application Servers for E-Business helps you understand the use of application servers in e-business. The book presents a comprehensive overview of the technologies related to application servers in their facilitation of E-business. These technologies include CORBA, Java, Enterprise Java Beans, Java 2, web servers, and legacy systems. It explores the role these servers play in the modern enterprise IT infrastructure and the environment in which they operate. The material also includes implementation considerations for application servers, including security, scalability, load balancing, and fault tolerance.

Chapter one provides an overview of application servers, the evolution of computing that took us from hierarchical, mainframe-centric environments to the web model of computing, and the rationale for E-commerce and E-business. Chapters two through five cover specific technologies, from web browsers and servers to applets and servlets. Chapter three provides an overview of Java technologies, and chapter four covers CORBA. Chapter five discusses application servers in detail. Since application servers are increasingly supporting the key mission-critical processes of an enterprise, it is critical that organizations deploying them build in "enterprise-class" facilities for security, scalability, load balancing, fault tolerance, and management. Chapter six discusses these deployment design issues. The book concludes with chapter seven, a chapter that presents several examples of the advantages of application servers in large enterprises. It also presents two case studies that illustrate the decision process, and an overview of seventeen application servers. The chapters are organized in a straightforward manner, with section and subsections clearly indicated so that they can be easily skimmed. The comprehensive coverage offered in this book makes it an ideal reference for IT management and staff responsible for specifying, designing, evaluating, and implementing electronic commerce solutions.

Making Sense of Design Effective design is at the heart of everything from software development to engineering to architecture. But what do we really know about the design process? What leads to effective, elegant designs? The Design of Design addresses these questions. These new essays by Fred Brooks contain extraordinary insights for designers in every discipline. Brooks pinpoints constants inherent in all design projects and uncovers processes and patterns likely to lead to excellence. Drawing on conversations with dozens of exceptional designers, as well as his own experiences in several design domains, Brooks observes that bold design decisions lead to better outcomes. The author tracks the evolution of the design process, treats collaborative and distributed design, and illuminates what makes a truly great designer. He examines the nuts and bolts of design processes, including budget constraints of many kinds, aesthetics, design empiricism, and tools, and grounds this discussion in his own real-world examples-case studies ranging from home construction to IBM's Operating System/360. Throughout, Brooks reveals keys to success that every designer, design project manager, and design researcher should know.

Spring Framework 6 remains - by far - the leading de-facto "out of the box" practical Java meta application development framework for building complex enterprise, cloud-native applications as well as web applications and microservices. Introducing Spring Framework 6 is your hands-on tutorial guide for learning the Spring Framework 6 from top to bottom, and allows you to build an example application along the way from the ground-up. As you learn the Spring Framework over the course of this book, you'll incrementally build your first Spring application piece-by-piece as you learn each module, project or component of the Spring Framework and its extensions and ecosystem. As you learn the various fundamentals, you'll then apply them immediately to your Spring application. This Spring application, My Documents, enables you to learn by doing. After reading this book, you will have the essentials you should need to start using the Spring Framework and building your own Java-based applications or microservices with it. What you'll learn: Get started with Spring Framework 6 by VMWare Tanzu and the Spring community Build your first My Documents application using Spring Framework and its extensions Test your Spring application Add persistence to your application using Spring Data JPA and more Show your Spring application on the Web with Spring MVC and related Use REST APIs to enhance your application and add messaging with Kafka and AMQP Integrate your Spring application with external systems using Spring Integration toolkit Who is this book for: This book is for those aspiring software developers and programmers who are new to Spring. Some prior programming experience recommended, preferably in Java.

This book summarizes the results of Design Thinking Research carried out at Stanford University in Palo Alto, California, USA, and Hasso Plattner Institute in Potsdam, Germany.

The authors offer readers a closer look at Design Thinking with its processes of innovations and methods. The contents of the articles range from how to design ideas, methods, and technologies via creativity experiments and wicked problem solutions, to creative collaboration in the real world and the connectivity of designers and engineers. But the topics go beyond this in their detailed exploration of design thinking and its use in IT systems engineering fields and even from a management perspective.

The authors show how these methods and strategies work in companies, introduce new technologies and their functions and demonstrate how Design Thinking can influence as diverse a topic area as marriage. Furthermore, we see how special design thinking use functions in solving wicked problems in complex fields.

Thinking and creating innovations are basically and inherently human - so is Design Thinking. Due to this, Design Thinking is not only a factual matter or a result of special courses nor of being gifted or trained: it's a way of dealing with our environment and improving techniques, technologies and life.

In modern computing a program is usually distributed among several processes. The fundamental challenge when developing reliable and secure distributed programs is to support the cooperation of processes required to execute a common task, even when some of these processes fail. Failures may range from crashes to adversarial attacks by malicious processes. Cachin, Guerraoui, and Rodrigues present an introductory description of fundamental distributed programming abstractions together with algorithms to implement them in distributed systems, where processes are subject to crashes and malicious attacks. The authors follow an incremental approach by first introducing basic abstractions in simple distributed environments, before moving to more sophisticated abstractions and more challenging environments. Each core chapter is devoted to one topic, covering reliable broadcast, shared memory, consensus, and extensions of consensus. For every topic, many exercises and their solutions enhance the understanding This book represents the second edition of "Introduction to Reliable Distributed Programming". Its scope has been extended to include security against malicious actions by non-cooperating processes. This important domain has become widely known under the name "Byzantine fault-tolerance".

A multi-user game, web site, cloud application, or networked database can have thousands of users all interacting at the same time. You need a powerful, industrial-strength tool to handle the really hard problems inherent in parallel, concurrent environments. You need Erlang. In this second edition of the bestselling "Programming Erlang," you'll learn how to write parallel programs that scale effortlessly on multicore systems. Using Erlang, you'll be surprised at how easy it becomes to deal with parallel problems, and how much faster and more efficiently your programs run. That's because Erlang uses "sets of parallel processes"-not a single sequential process, as found in most programming languages. Joe Armstrong, creator of Erlang, introduces this powerful language in small steps, giving you a complete overview of Erlang and how to use it in common scenarios. You'll start with sequential programming, move to parallel programming and handling errors in parallel programs, and learn to work confidently with distributed programming and the standard Erlang/Open Telecom Platform (OTP) frameworks. You need no previous knowledge of functional or parallel programming. The chapters are packed with hands-on, real-world tutorial examples and insider tips and advice, and finish with exercises for both beginning and advanced users. The second edition has been extensively rewritten. New to this edition are seven chapters covering the latest Erlang features: maps, the type system and the Dialyzer, WebSockets, programming idioms, and a new stand-alone execution environment. You'll write programs that dynamically detect and correct errors, and that can be upgraded without stopping the system. There's also coverage of rebar (the de facto Erlang build system), and information on how to share and use Erlang projects on github, illustrated with examples from cowboy and bitcask. Erlang will change your view of the world, and of how you program. What You Need The Erlang/OTP system. Download it from erlang.org.

This book is proof that debugging has graduated from a black art to a systematic discipline. It demystifies one of the toughest aspects of software programming, showing clearly how to discover what caused software failures, and fix them with minimal muss and fuss.
The fully updated second edition includes 100+ pages of new material, including new chapters on Verifying Code, Predicting Erors, and Preventing Errors. Cutting-edge tools such as FindBUGS and AGITAR are explained, techniques from integrated environments like Jazz.net are highlighted, and all-new demos with ESC/Java and Spec#, Eclipse and Mozilla are included.
This complete and pragmatic overview of debugging is authored by Andreas Zeller, the talented researcher who developed the GNU Data Display Debugger(DDD), a tool that over 250,000 professionals use to visualize the data structures of programs while they are running. Unlike other books on debugging, Zeller's text is product agnostic, appropriate for all programming languages and skill levels.
The book explains best practices ranging from systematically tracking error reports, to observing symptoms, reproducing errors, and correcting defects. It covers a wide range of tools and techniques from hands-on observation to fully automated diagnoses, and also explores the author's innovative techniques for isolating minimal input to reproduce an error and for tracking cause and effect through a program. It even includes instructions on how to create automated debugging tools.
The text includes exercises and extensive references for further study, and a companion website with source code for all examples and additional debugging resources is available.
*The new edition of this award-winning productivity-booster is for any developer who has ever been frustrated by elusive bugs
*Brand new chapters demonstrate cutting-edge debugging techniques and tools, enabling readers to put the latest time-saving developments to work for them
*Learn by doing. New exercises and detailed examples focus on emerging tools, languages and environments, including AGITAR, FindBUGS, Python and Eclipse.

The latest edition of the definitive guide to the Ada language covers the full details of the core language Ada 2012 as updated by the 2016 ISO Corrigendum and introduces the key new features in Ada 2022. The book is in four parts. It begins by introducing the fundamental concepts for newcomers, before moving onto algorithmic aspects and then structural features such as OOP and multitasking. The fourth part gives details of the standard library and interaction with the external environment. Six complete executable programs illustrate the core features of the language in action. The book concludes with an appendix focussing on the new features in Ada 2022. These new features aid program proof and the efficient use of multicore architectures.

A comprehensive guide to understanding the standard and most recent advances in the design of reliable computer systems. It is organized into three sections, beginning with an in-depth review of existing reliability techniques and evaluation criteria for both hardware and software. also examined are the models for detecting faults and predicting failures, and the financial considerations which are inherent in the design, purchase, operation, and maintenance of a reliable system.