Software development has been a troubling since it first started. There are seven chronic problems that have plagued it from the beginning: Incomplete and ambiguous user requirements that grow by >2% per month. Major cost and schedule overruns for large applications > 35% higher than planned. Low defect removal efficiency (DRE) < 85% on large systems. Cancelled projects that are not completed: > 30% above 10,000 function points. Poor quality and low reliability after the software is delivered: > 5 bugs per FP. Breach of contract litigation against software outsource vendors. Expensive maintenance and enhancement costs after delivery. These are endemic problems for software executives, software engineers and software customers but they are not insurmountable. In Software Development Patterns and Antipatterns, software engineering and metrics pioneer Capers Jones presents technical solutions for all seven. The solutions involve moving from harmful patterns of software development to effective patterns of software development. The first section of the book examines common software development problems that have been observed in many companies and government agencies. The data on the problems comes from consulting studies, breach of contract lawsuits, and the literature on major software failures. This section considers the factors involved with cost overruns, schedule delays, canceled projects, poor quality, and expensive maintenance after deployment. The second section shows patterns that lead to software success. The data comes from actual companies. The section's first chapter on Corporate Software Risk Reduction in a Fortune 500 company was based on a major telecom company whose CEO was troubled by repeated software failures. The other chapters in this section deal with methods of achieving excellence, as well as measures that can prove excellence to C-level executives, and with continuing excellence through the maintenance cycle as well as for software development.

Write More Elegant C++ Programs The official C++ Core Guidelines provide consistent best practices for writing outstanding modern C++ code and improving legacy code, but they're organized as a reference for looking up one specific point at a time, not as a tutorial for working developers. In C++ Core Guidelines Explained, expert C++ instructor Rainer Grimm has distilled them to their essence, removing esoterica, sharing new insights and context, and presenting well-tested examples from his own training courses. Grimm helps experienced C++ programmers use the Core Guidelines with any recent version of the language, from C++11 onward. Most of his code examples are written for C++17, with added coverage of newer versions and C++20 wherever appropriate, and references to the official C++ Core Guidelines online. Whether you're creating new software or improving legacy code, Grimm will help you get more value from the Core Guidelines' most useful rules, as you write code that's safer, clearer, more efficient, and easier to maintain. Apply the guidelines and underlying programming philosophy Correctly use interfaces, functions, classes, enum, resources, expressions, and statements Optimize performance, implement concurrency and parallelism, and handle errors Work effectively with constants, immutability, templates, generics, and metaprogramming Improve your C++ style, manage source files, and use the Standard Library "We are very pleased to see Rainer Grimm applying his teaching skills and industrial background to tackling the hard and necessary task of making the C++ Core Guidelines accessible to more people." --Bjarne Stroustrup and Herb Sutter, co-editors, C++ Core Guidelines Register your book for convenient access to downloads, updates, and/or corrections as they become available. See inside book for details.

Fundamentals of Engineering Programming with C and Fortran, first published in 1998, is a beginner's guide to problem solving with computers which shows how to quickly prototype a program for a particular engineering application. The book's side by side coverage of C and Fortran, the predominant computer languages in engineering, is unique. It emphasizes the importance of developing programming skills in C while carefully presenting the importance of maintaining a good reading knowledge of Fortran. Beginning with a brief description of computer architecture, the book then covers the fundamentals of computer programming for problem solving. It devotes separate chapters to data types and operators, control flow, type conversion, arrays, and file operations. The final chapter contains case studies that illustrate particular elements of modeling and visualization. Also included are a number of appendices covering C and Fortran language summaries and other useful topics. This concise and accessible book can be used as a text for introductory-level undergraduate courses on engineering programming or as a self-study guide for practising engineers.

Based on the practical experiences of its authors, who collectively have spent several decades teaching software skills to scientists. Readers only need a basic understanding of Python includes over a hundred exercises to allow readers to practice their skills

Classical FORTRAN: Programming for Engineering and Scientific Applications, Second Edition teaches how to write programs in the Classical dialect of FORTRAN, the original and still most widely recognized language for numerical computing. This edition retains the conversational style of the original, along with its simple, carefully chosen subset language and its focus on floating-point calculations. New to the Second Edition Additional case study on file I/O More about CPU timing on Pentium processors More about the g77 compiler and Linux With numerous updates and revisions throughout, this second edition continues to use case studies and examples to introduce the language elements and design skills needed to write graceful, correct, and efficient programs for real engineering and scientific applications. After reading this book, students will know what statements to use and where as well as why to avoid the others, helping them become expert FORTRAN programmers.

A unique approach to "Intro CS." In a nutshell, the authors of this book's objective is to provide an introduction to computer science as an intellectually rich and vibrant field rather than focusing exclusively on computer programming. While programming is certainly an important and pervasive element of their approach, they emphasize concepts and problem-solving over syntax and programming language features. This book is a companion to the course "CS for All" developed at Harvey Mudd College and subsequently adopted at a variety of colleges and universities. At Mudd, this course is taken by almost every first-year student - irrespective of the student's ultimate major - as part of the college's core curriculum. The offering is also taken by many students at the Claremont Colleges, including students majoring in the humanities, social sciences, and the arts. Thus, it serves as a first computing course for students regardless of their major. This book is intended to be used with the substantial resources that we have developed for the course. These resources include complete lecture slides, a rich collection of weekly assignments, some accompanying software, documentation, and papers that have been published about the course. The authors have deliberately kept this book relatively short and have endeavored to make it fun and readable. The content of this book is an accurate reflection of the content of the course rather than an intimidating encyclopedic tome that can't possibly be covered in a single semester. The book has been written in the belief that a student can read all of it comfortably as the course proceeds.

A valuable learning tool for students and an indispensable resource for professional scientists and engineers

Several outstanding features make this book a superior introduction to modern statistical mechanics: It is the only intermediate-level text offering comprehensive coverage of both basic statistical mechanics and modern topics such as molecular dynamic methods, renormalization theory, chaos, polymer chain folding, oscillating chemical reactions, and cellular automata. It is also the only text written at this level to address both equilibrium and nonequilibrium statistical mechanics. Finally, students and professionals alike will appreciate such aids to comprehension as detailed derivations for most equations, more than 100 chapter-end exercises, and 15 computer programs written in FORTRAN that illustrate many of the concepts covered in the text.

Statistical Mechanics begins with a refresher course in the essentials of modern statistical mechanics which, on its own, can serve as a handy pocket guide to basic definitions and formulas. Part II is devoted to equilibrium statistical mechanics. Readers will find in-depth coverage of phase transitions, critical phenomena, liquids, molecular dynamics, Monte Carlo techniques, polymers, and more. Part III focuses on nonequilibrium statistical mechanics and progresses in a logical manner from near-equilibrium systems, for which linear responses can be used, to far-from-equilibrium systems requiring nonlinear differential equations.

Software Engineering: A Methodical Approach (Second Edition) provides a comprehensive, but concise introduction to software engineering. It adopts a methodical approach to solving software engineering problems, proven over several years of teaching, with outstanding results. The book covers concepts, principles, design, construction, implementation, and management issues of software engineering. Each chapter is organized systematically into brief, reader-friendly sections, with itemization of the important points to be remembered. Diagrams and illustrations also sum up the salient points to enhance learning. Additionally, the book includes the author's original methodologies that add clarity and creativity to the software engineering experience. New in the Second Edition are chapters on software engineering projects, management support systems, software engineering frameworks and patterns as a significant building block for the design and construction of contemporary software systems, and emerging software engineering frontiers. The text starts with an introduction of software engineering and the role of the software engineer. The following chapters examine in-depth software analysis, design, development, implementation, and management. Covering object-oriented methodologies and the principles of object-oriented information engineering, the book reinforces an object-oriented approach to the early phases of the software development life cycle. It covers various diagramming techniques and emphasizes object classification and object behavior. The text features comprehensive treatments of: Project management aids that are commonly used in software engineering An overview of the software design phase, including a discussion of the software design process, design strategies, architectural design, interface design, database design, and design and development standards User interface design Operations design Design considerations including system catalog, product documentation, user message management, design for real-time software, design for reuse, system security, and the agile effect Human resource management from a software engineering perspective Software economics Software implementation issues that range from operating environments to the marketing of software Software maintenance, legacy systems, and re-engineering This textbook can be used as a one-semester or two-semester course in software engineering, augmented with an appropriate CASE or RAD tool. It emphasizes a practical, methodical approach to software engineering, avoiding an overkill of theoretical calculations where possible. The primary objective is to help students gain a solid grasp of the activities in the software development life cycle to be confident about taking on new software engineering projects.

Based on the practical experiences of its authors, who collectively have spent several decades teaching software skills to scientists. Readers only need a basic understanding of Python includes over a hundred exercises to allow readers to practice their skills

Now in its fifth edition, bridges the gap between the technical specifications and the real world of designing and programming devices that connect over the Universal Serial Bus (USB). Readers will learn how to select the appropriate USB speed, device class, and hardware for a device; communicate with devices using Visual C# and Visual Basic; use standard host drivers to access devices, including devices that perform vendor-defined tasks; save power with USB's built-in power-conserving protocols; and create robust designs using testing and debugging tools. This fully revised edition also includes instruction on how to increase bus speed with SuperSpeed and SuperSpeedPlus, implement wireless communications, and develop for USB On-The-Go and embedded hosts.

Developing Graphics Frameworks with Python and OpenGL shows you how to create software for rendering complete three-dimensional scenes. The authors explain the foundational theoretical concepts as well as the practical programming techniques that will enable you to create your own animated and interactive computer-generated worlds. You will learn how to combine the power of OpenGL, the most widely adopted cross-platform API for GPU programming, with the accessibility and versatility of the Python programming language. Topics you will explore include generating geometric shapes, transforming objects with matrices, applying image-based textures to surfaces, and lighting your scene. Advanced sections explain how to implement procedurally generated textures, postprocessing effects, and shadow mapping. In addition to the sophisticated graphics framework you will develop throughout this book, with the foundational knowledge you will gain, you will be able to adapt and extend the framework to achieve even more spectacular graphical results.

Microservices architecture (MSA) is increasingly popular with software architects and engineers as it accelerates software solution design, development, and deployment in a risk-free manner. Placing a software system into a production environment is elegantly simplified and sped up with the use of MSA development platforms, runtime environments, acceleration engines, design patterns, integrated frameworks, and related tools. The MSA ecosystem is expanding with third-party products that automate as many tasks as possible. MSA is being positioned as the enterprise-grade and agile-application design method. This book covers in-depth the features and facilities that make up the MSA ecosystem. Beginning with an overview of Service-Oriented Architecture (SOA) that covers the Common Object Request Broker Architecture (CORBA), Distributed Component Object Model (DCOM), and Remote Method Invocation (RMI), the book explains the basic essentials of MSA and the continuous delivery of applications to customers. The book gives software developers insight into: Current and emerging communication models Key architectural elements of MSA-based applications Designing efficient APIs for microservices MSA middleware platforms such as REST, SOAP, Apache Thrift, and gRPC Microservice discovery and the API gateway Service orchestration and choreography for composing individual services to achieve a useful business process Database transactions in MSA-centric applications Design, composition, security, and deployment patterns MSA security Modernizing legacy applications The book concludes with a chapter on composing and building powerful microservices. With the exponential growth of IoT devices, microservices are being developed and deployed on resource-constrained but resource-intensive devices in order to provide people-centric applications. The book discusses the challenges of these applications. Finally, the book looks at the role of microservices in smart environments and upcoming trends including ubiquitous yet disappearing microservices.

This book meant for those who seek to apply evolutionary algorithms to problems in engineering and science. To this end, it provides the theoretical background necessary to the understanding of the presented evolutionary algorithms and their shortcomings, while also discussing themes that are pivotal to the successful application of evolutionary algorithms to real-world problems. The theoretical descriptions are illustrated with didactical Python implementations of the algorithms, which not only allow readers to consolidate their understanding, but also provide a sound starting point for those intending to apply evolutionary algorithms to optimization problems in their working fields. Python has been chosen due to its widespread adoption in the Artificial Intelligence community. Those familiar with high level languages such as MATLAB (TM) will not have any difficulty in reading the Python implementations of the evolutionary algorithms provided in the book. Instead of attempting to encompass most of the existing evolutionary algorithms, past and present, the book focuses on those algorithms that researchers have recently applied to difficult optimization problems, such as control problems with continuous action spaces and the training of high-dimensional convolutional neural-networks. The basic characteristics of real-world optimization problems are presented, together with recommendations on its proper application to evolutionary algorithms. The applied nature of the book is reinforced by the presentation of successful cases of the application of evolutionary algorithms to optimization problems. This is complemented by Python source codes, giving users an insight into the idiosyncrasies of the practical application of evolutionary algorithms.

Recent progress in artificial intelligence (AI) has revolutionized our everyday life. Many AI algorithms have reached human-level performance and AI agents are replacing humans in most professions. It is predicted that this trend will continue and 30% of work activities in 60% of current occupations will be automated. This success, however, is conditioned on availability of huge annotated datasets to training AI models. Data annotation is a time-consuming and expensive task which still is being performed by human workers. Learning efficiently from less data is a next step for making AI more similar to natural intelligence. Transfer learning has been suggested a remedy to relax the need for data annotation. The core idea in transfer learning is to transfer knowledge across similar tasks and use similarities and previously learned knowledge to learn more efficiently. In this book, we provide a brief background on transfer learning and then focus on the idea of transferring knowledge through intermediate embedding spaces. The idea is to couple and relate different learning through embedding spaces that encode task-level relations and similarities. We cover various machine learning scenarios and demonstrate that this idea can be used to overcome challenges of zero-shot learning, few-shot learning, domain adaptation, continual learning, lifelong learning, and collaborative learning.

This is the first book to explain Ripple-Down Rules, an approach to building knowledge-based systems which is more similar to machine learning methods than other rule-based systems but which depends on using an expert rather than applying statistics to data The book provides detailed worked examples and uses publicly available software to demonstrate Ripple-Down Rules The examples enable users to build their own RDR tools

This is the first book to explain Ripple-Down Rules, an approach to building knowledge-based systems which is more similar to machine learning methods than other rule-based systems but which depends on using an expert rather than applying statistics to data The book provides detailed worked examples and uses publicly available software to demonstrate Ripple-Down Rules The examples enable users to build their own RDR tools

Research and Evidence in Software Engineering: From Empirical Studies to Open Source Artifacts introduces advanced software engineering to software engineers, scientists, postdoctoral researchers, academicians, software consultants, management executives, doctoral students, and advanced level postgraduate computer science students. This book contains research articles addressing numerous software engineering research challenges associated with various software development-related activities, including programming, testing, measurements, human factors (social software engineering), specification, quality, program analysis, software project management, and more. It provides relevant theoretical frameworks, empirical research findings, and evaluated solutions addressing the research challenges associated with the above-mentioned software engineering activities. To foster collaboration among the software engineering research community, this book also reports datasets acquired systematically through scientific methods and related to various software engineering aspects that are valuable to the research community. These datasets will allow other researchers to use them in their research, thus improving the quality of overall research. The knowledge disseminated by the research studies contained in the book will hopefully motivate other researchers to further innovation in the way software development happens in real practice.

This book is the follow-up of the Boost Volume I book and it has been written for software developers who use Boost C++ libraries to create flexible applications. We discuss approximately 20 advanced libraries that can be classified into the following major categories: Mathematics: special functions, statistical distributions, interval arithmetic and matrix algebra. Special data structures: date and time, circular buffer, UUID, dynamic bitsets, pool memory. TCP and UDP portable network programming using the software interface. Interprocess communication and shared memory programming models. Three chapters on graphs, graph algorithms and their implementation in Boost. The focus is hands-on and each library is discussed in detail and numerous working examples are given to get the reader up to speed as soon as possible. Each library is described in a step-by-step fashion and you can use the corresponding code as a basis for more advanced applications. These libraries are the ideal basis for new applications. We shall use them in Volume III of the current series when we discuss applications to engineering, science and computational finance. About the Authors Robert Demming is software designer, developer and trainer and he has been involved with software projects in the areas of optical technology, process control, CAD and order processing systems since 1993. He has a BSc degree in technical computerscience from Amsterdam Hogeschool. Daniel J. Duffy is founder of Datasim Education BV and has been working with C++ and its applications since 1989 and with software development since 1979. He is designer, algorithm builder and trainer. He has a PhD in numerical analysis from Trinity College, Dublin. One of the projects that he is involved in is applying the Boost libraries to computational finance."

Temporal logic has developed over the last 30 years into a powerful formal setting for the specification and verification of state-based systems. Based on university lectures given by the authors, this book is a comprehensive, concise, uniform, up-to-date presentation of the theory and applications of linear and branching time temporal logic; TLA (Temporal Logic of Actions); automata theoretical connections; model checking; and related theories.

All theoretical details and numerous application examples are elaborated carefully and with full formal rigor, and the book will serve as a basic source and reference for lecturers, graduate students and researchers.

Originally published in 1966. Professor Rescher's aim is to develop a "logic of commands" in exactly the same general way which standard logic has already developed a "logic of truth-functional statement compounds" or a "logic of quantifiers". The object is to present a tolerably accurate and precise account of the logically relevant facets of a command, to study the nature of "inference" in reasonings involving commands, and above all to establish a viable concept of validity in command inference, so that the logical relationships among commands can be studied with something of the rigour to which one is accustomed in other branches of logic.

This book presents, in an integrated form, both the analysis and synthesis of three different types of hidden Markov models. Unlike other books on the subject, it is generic and does not focus on a specific theme, e.g. speech processing. Moreover, it presents the translation of hidden Markov models' concepts from the domain of formal mathematics into computer codes using MATLAB (R). The unique feature of this book is that the theoretical concepts are first presented using an intuition-based approach followed by the description of the fundamental algorithms behind hidden Markov models using MATLAB (R). This approach, by means of analysis followed by synthesis, is suitable for those who want to study the subject using a more empirical approach. Key Selling Points: Presents a broad range of concepts related to Hidden Markov Models (HMM), from simple problems to advanced theory Covers the analysis of both continuous and discrete Markov chains Discusses the translation of HMM concepts from the realm of formal mathematics into computer code Offers many examples to supplement mathematical notation when explaining new concepts

Do modern programming languages, IDEs, and libraries make coding easy? Maybe, but coding is not design. Large-scale or expensive apps clearly require evaluation of design choices. Still, software design directly impacts code reuse and longevity even for small-scale apps with limited overhead. This text evaluates and contrasts common object-oriented designs. A given problem may have many solutions. A developer may employ different design techniques - composition, inheritance, dependency injection, delegation, etc. - to solve a particular problem. A skilled developer can determine the costs and benefits of different design responses, even amid competing concerns. A responsible developer documents design choices as a contract with the client, delineating external and internal responsibilities. To promote effective software design, this book examines contractual, object-oriented designs for immediate and sustained use as well as code reuse. The intent of identifying design variants is to recognize and manage conflicting goals such as short versus long-term utility, stability versus flexibility, and storage versus computation. Many examples are given to evaluate and contrast different solutions and to compare C# and C++ effects. No one has a crystal ball; however, deliberate design promotes software longevity. With the prominence of legacy OO code, a clear understanding of different object-oriented designs is essential. Design questions abound. Is code reuse better with inheritance or composition? Should composition rely on complete encapsulation? Design choices impact flexibility, efficiency, stability, longevity, and reuse, yet compilers do not enforce design and syntax does not necessarily illustrate design. Through deliberate design, or redesign when refactoring, developers construct sustainable, efficient code.

Do modern programming languages, IDEs, and libraries make coding easy? Maybe, but coding is not design. Large-scale or expensive apps clearly require evaluation of design choices. Still, software design directly impacts code reuse and longevity even for small-scale apps with limited overhead. This text evaluates and contrasts common object-oriented designs. A given problem may have many solutions. A developer may employ different design techniques - composition, inheritance, dependency injection, delegation, etc. - to solve a particular problem. A skilled developer can determine the costs and benefits of different design responses, even amid competing concerns. A responsible developer documents design choices as a contract with the client, delineating external and internal responsibilities. To promote effective software design, this book examines contractual, object-oriented designs for immediate and sustained use as well as code reuse. The intent of identifying design variants is to recognize and manage conflicting goals such as short versus long-term utility, stability versus flexibility, and storage versus computation. Many examples are given to evaluate and contrast different solutions and to compare C# and C++ effects. No one has a crystal ball; however, deliberate design promotes software longevity. With the prominence of legacy OO code, a clear understanding of different object-oriented designs is essential. Design questions abound. Is code reuse better with inheritance or composition? Should composition rely on complete encapsulation? Design choices impact flexibility, efficiency, stability, longevity, and reuse, yet compilers do not enforce design and syntax does not necessarily illustrate design. Through deliberate design, or redesign when refactoring, developers construct sustainable, efficient code.

Using the implementation of a deep learning framework as an example, C++ Template Metaprogramming in Practice: A Deep Learning Framework explains the application of metaprogramming in a relatively large project and emphasizes ways to optimize systems performance. The book is suitable for developers with a basic knowledge of C++. Developers familiar with mainstream deep learning frameworks can also refer to this book to compare the differences between the deep learning framework implemented with metaprogramming and compile-time computing with deep learning frameworks using object-oriented methods. Consisting of eight chapters, the book starts with two chapters discussing basic techniques of metaprogramming and compile-time computing. The rest of the book's chapters focus on the practical application of metaprogramming in a deep learning framework. It examines rich types and systems, expression templates, and writing complex meta-functions, as well as such topics as: Heterogeneous dictionaries and policy templates An introduction to deep learning Type system and basic data types Operations and expression templates Basic layers Composite and recurrent layers Evaluation and its optimization Metaprogramming can construct flexible and efficient code. For C++ developers who are familiar with object-oriented programming, the main difficulty in learning and mastering C++ metaprogramming is establishing the thinking mode of functional programming. The meta-programming approach involved at compile time is functional, which means that the intermediate results of the construction cannot be changed, and the impact may be greater than expected. This book enables C++ programmers to develop a functional mindset and metaprogramming skills. The book also discusses the development cost and use cost of metaprogramming and provides workarounds for minimizing these costs.