Purpose of the Book This book presents an approach to improve the standard object-oriented pro gramming model. The proposal is aimed at supporting a larger range of incre mental behavior variations and thus promises to be more effective in mastering the complexity of today's software. The ability of dealing with the evolutionary nature of software is one of main merits of object-oriented data abstraction and inheritance. Object-orientation allows to organize software in a structured way by separating the description of different kinds of an abstract data type into different classes and loosely connecting them by the inheritance hierarchy. Due to this separation, the soft ware becomes free of conditional logics previously needed for distinguishing between different kinds of abstractions and can thus more easily be incremen tally extended to support new kinds of abstractions. In other words, classes and inheritance are means to properly model variations of behavior related to the existence of different kinds of an abstract data type. The support for extensi bility and reuse with respect to such kind-specific behavior variations is among the main reasons for the increasing popularity of object-oriented programming in the last two decades. However, this popularity does not prevent us from questioning the real effec tiveness of current object-oriented techniques in supporting incremental vari ations. In fact, this popularity makes a critical investigation of the variations that can actually be performed incrementally even more important."

Software maintenance work is often considered a dauntingly rigid activity - this book proves the opposite: it demands high levels of creativity and thinking outside the box. Highlighting the creative aspects of software maintenance and combining analytical and systems thinking in a holistic manner, the book motivates readers not to blithely follow the beaten tracks of "technical rationality". It delivers the content in a pragmatic fashion using case studies which are woven into long running story lines. The book is organized in four parts, which can be read in any order, except for the first chapter, which introduces software maintenance and evolution and presents a number of case studies of software failures. The "Introduction to Key Concepts" briefly introduces the major elements of software maintenance by highlighting various core concepts that are vital in order to see the forest for the trees. Each such concept is illustrated with a worked example. Next, the "Forward Engineering" part debunks the myth that being fast and successful during initial development is all that matters. To this end, two categories of forward engineering are considered: an inept initial project with a multitude of hard evolutionary phases and an effective initial project with multiple straightforward future increments. "Reengineering and Reverse Engineering" shows the difficulties of dealing with a typical legacy system, and tackles tasks such as retrofitting tests, documenting a system, restructuring a system to make it amenable for further improvements, etc. Lastly, the "DevOps" section focuses on the importance and benefits of crossing the development versus operation chasm and demonstrates how the DevOps paradigm can turn a loosely coupled design into a loosely deployable solution. The book is a valuable resource for readers familiar with the Java programming language, and with a basic understanding and/or experience of software construction and testing. Packed with examples for every elaborated concept, it offers complementary material for existing courses and is useful for students and professionals alike.

Manufacturing computers in series was quite a feat in the 1950s. As mathematical as it gets, the machines discussed here were called X1 and X8. The industrial achievement combined with the background in a mathematical research center made the company Electrologica a legend in Dutch computing. The tales in this book are told by those who have a right to tell. Highly engaged professionals take readers back to their pioneering work with the machines and in retrospect unveil some of the values, which went without saying in the 1960s. To disagree, Paul Klint relates the contrasting views on software in Dutch research traditions. ALGOL culture: Frans Kruseman Aretz takes the reader along to the detailed decisions on constructing compilers and shows the values of an ALGOL culture transpiring. Signposts: Dirk Dekker for the first time 'owns' his algorithm for mutual exclusion. In particle physics: Rene van Dantzig's use case was an Electrologica X8 computer controlling two other computers in three-dimensional detection of colliding particles. Early steps in AI: Lambert Meertens' tale of the X8 machine composing a violin quartet comes with his original presentation, as well as the code in ALGOL 60. The reflections of first hand experiences combine well with the second thoughts of historical research into archival sources. Historians Huub de Beer and Gerard Alberts offer a view into the boardrooms of the local enterprise Electrologica, and of the electronics multinational Philips. Where pioneers and historians meet in an inspiring dialogue, the reader gains a view on the often implicit decisions constituting the field. Fortuitously, a copy of the X8 was retrieved from Kiel, Germany, and put on display at Rijksmuseum Boerhaave, Leiden. Sparked by the very material presence of an X8, the present book takes stock of the state of historiography of Electrologica. Gerard Alberts is an associate professor in History of Digital Cultures, retired from the University of Amsterdam. Jan Friso Groote is a full professor of Formal Methods at the Eindhoven University of Technology.

In an article for Wired Magazine in 2006, Jeff Howe defined crowdsourcing as an idea for outsourcing a task that is traditionally performed by a single employee to a large group of people in the form of an open call. Since then, by modifying crowdsourcing into different forms, some of the most successful new companies on the market have used this idea to make people's lives easier and better. On the other hand, software testing has long been recognized as a time-consuming and expensive activity. Mobile application testing is especially difficult, largely due to compatibility issues: a mobile application must work on devices with different operating systems (e.g. iOS, Android), manufacturers (e.g. Huawei, Samsung) and keypad types (e.g. virtual keypad, hard keypad). One cannot be 100% sure that, just because a tested application works well on one device, it will run smoothly on all others.Crowdsourced testing is an emerging paradigm that can improve the cost-effectiveness of software testing and accelerate the process, especially for mobile applications. It entrusts testing tasks to online crowdworkers whose diverse testing devices/contexts, experience, and skill sets can significantly contribute to more reliable, cost-effective and efficient testing results. It has already been adopted by many software organizations, including Google, Facebook, Amazon and Microsoft. This book provides an intelligent overview of crowdsourced testing research and practice. It employs machine learning, data mining, and deep learning techniques to process the data generated during the crowdsourced testing process, to facilitate the management of crowdsourced testing, and to improve the quality of crowdsourced testing.

The first edition of Exercises in Programming Style was honored as an ACM Notable Book and praised as "The best programming book of the decade." This new edition retains the same presentation but has been upgraded to Python 3, and there is a new section on neural network styles. Using a simple computational task (term frequency) to illustrate different programming styles, Exercises in Programming Style helps readers understand the various ways of writing programs and designing systems. It is designed to be used in conjunction with code provided on an online repository. The book complements and explains the raw code in a way that is accessible to anyone who regularly practices the art of programming. The book can also be used in advanced programming courses in computer science and software engineering programs. The book contains 40 different styles for writing the term frequency task. The styles are grouped into ten categories: historical, basic, function composition, objects and object interactions, reflection and metaprogramming, adversity, data-centric, concurrency, interactivity, and neural networks. The author states the constraints in each style and explains the example programs. Each chapter first presents the constraints of the style, next shows an example program, and then gives a detailed explanation of the code. Most chapters also have sections focusing on the use of the style in systems design as well as sections describing the historical context in which the programming style emerged.

This book constitutes the refereed proceedings of five International Workshops held as parallel events of the 18th IFIP WG 12.5 International Conference on Artificial Intelligence Applications and Innovations, AIAI 2022, virtually and in Hersonissos, Crete, Greece, in June 2022: the 11th Mining Humanistic Data Workshop (MHDW 2022); the 7th 5G-Putting Intelligence to the Network Edge Workshop (5G-PINE 2022); the 1st workshop on AI in Energy, Building and Micro-Grids (AIBMG 2022); the 1st Workshop/Special Session on Machine Learning and Big Data in Health Care (ML@HC 2022); and the 2nd Workshop on Artificial Intelligence in Biomedical Engineering and Informatics (AIBEI 2022). The 35 full papers presented at these workshops were carefully reviewed and selected from 74 submissions.

This textbook provides a progressive approach to the teaching of software engineering. First, readers are introduced to the core concepts of the object-oriented methodology, which is used throughout the book to act as the foundation for software engineering and programming practices, and partly for the software engineering process itself. Then, the processes involved in software engineering are explained in more detail, especially methods and their applications in design, implementation, testing, and measurement, as they relate to software engineering projects. At last, readers are given the chance to practice these concepts by applying commonly used skills and tasks to a hands-on project. The impact of such a format is the potential for quicker and deeper understanding. Readers will master concepts and skills at the most basic levels before continuing to expand on and apply these lessons in later chapters.

User-Developer Cooperation in Software Development brings together the strengths of task analysis and user participation within an overall software development process, and presents a detailed observation and theoretical analysis of what it is for users and developers to cooperate, and the nature of user-developer interaction. Eamonn O'Neill deals with these issues through the development and application of an approach to task-based participatory development in two real world development projects, and discusses the strengths of task analysis and participatory design methods, and how they complement each other's weaker aspects.

Is Internet software so different from "ordinary" software? This book practically answers this question through the presentation of a software design method based on the State Chart XML W3C standard along with Java. Web enterprise, Internet-of-Things, and Android applications, in particular, are seamlessly specified and implemented from "executable models." Internet software puts forward the idea of event-driven or reactive programming, as pointed out in Boner et al.'s "Reactive Manifesto" (http://www.reactivemanifesto.org). It tells us that reactiveness is a must. However, beyond concepts, software engineers require effective means with which to put reactive programming into practice. This book's purpose is to outline and explain such means. The lack of professional examples in the literature that illustrate how reactive software should be shaped can be quite frustrating. Therefore, this book helps to fill in that gap by providing in-depth professional case studies that contain comprehensive details and meaningful alternatives. Furthermore, these case studies can be downloaded for further investigation. Internet software requires higher adaptation, at run time in particular. After reading Reactive Internet Programming, the reader therefore will be ready to enter the forthcoming Internet era.

The text focuses on mathematical modeling and applications of advanced techniques of machine learning, and artificial intelligence, including artificial neural networks, evolutionary computing, data mining, and fuzzy systems to solve performance and design issues more precisely. Intelligent computing encompasses technologies, algorithms, and models in providing effective and efficient solutions to a wide range of problems including the airport's intelligent safety system. It will serve as an ideal reference text for senior undergraduate, graduate students, and academic researchers in fields including industrial engineering, manufacturing engineering, computer engineering, and mathematics. The book- Discusses mathematical modeling for traffic, sustainable supply chain, vehicular Ad-Hoc networks, internet of things networks with intelligent gateways. Covers advanced machine learning, artificial intelligence, fuzzy systems, evolutionary computing, data mining techniques for real-world problems. Presents applications of mathematical models in chronic diseases such as kidney and coronary artery diseases. Highlights advances in mathematical modeling, strength, and benefits of machine learning and artificial intelligence, including driving goals, applicability, algorithms, and processes involved. Showcases emerging real-life topics on mathematical models, machine learning, and intelligent computing using an interdisciplinary approach. The text presents emerging real-life topics on mathematical models, machine learning, and intelligent computing in a single volume. It will serve as an ideal text for senior undergraduate, graduate students, and researchers in diverse fields domains including industrial and manufacturing engineering, computer engineering, and mathematics.

Advances in Computers, Volume 118, the latest volume in this innovative series published since 1960, presents detailed coverage of new advancements in computer hardware, software, theory, design and applications. Chapters in this updated release include Introduction to non-volatile memory technologies, The emerging phase-change memory, Phase-change memory architectures, Inter-line level schemes for handling hard errors in PCMs, Handling hard errors in PCMs by using intra-line level schemes, and Addressing issues with MLC Phase-change Memory.

Demonstrates how category theory can be used for formal software development.

The mathematical toolbox for the Software Engineering in the new age of complex interactive systems.

Open-source development has been around for decades, with software developers co-creating tools and information systems for widespread use. With the development of open-source software such as learning objects, interactive articles, and educational games, the open-source values and practices have slowly been adopted by those in education sectors. Open-Source Technologies for Maximizing the Creation, Deployment, and Use of Digital Resources and Information highlights the global importance of open-source technologies in higher and general education. Written for those working in education and professional training, this collection of research explores a variety of issues related to open-source in education, such as its practical underpinnings, requisite cultural competence in global open-source, strategies for employing open-source in online learning and research, the design of an open-source networking laboratory, and other endeavors.

This book presents a new paradigm of software testing by emphasizing the role of critical thinking, system thinking and rationality as the most important skills for the tester. It thus approaches software testing from a different perspective than in past literature, as the vast majority of books describe testing in the context of specific tools, automation, documentation, particular test design techniques or test management. In addition, the book proposes a novel meta-approach for designing effective test strategies, which is based on recent advances in psychology, economics, system sciences and logic. Chapter 1 starts by introducing the fundamental ideas underlying software testing. Chapter 2 then describes meta-strategies in software testing, i.e. general approaches that can be adapted to many different situations that a software tester encounters. Next, Chapter 3 presents the concept of Thinking-Driven Testing (TDT). This approach utilizes the concepts discussed in the two previous chapters and introduces the main ideas that underlie a reasonable and optimal approach to software testing. Chapter 4 builds on this basis and proposes a specific approach to testing, called TQED, that makes it possible to increase creativity in the context of delivering effective, optimal test ideas. Chapter 5 provides an overview of different types of testing techniques in order to understand the fundamental concepts of test design, while Chapter 6 details various pitfalls a tester may encounter and that can originate from a wide range of testing process areas. Lastly, Chapter 7 puts all this into practice, as it contains several exercises that will help testers develop a number of crucial skills: logical thinking and reasoning, thinking out of the box, creativity, counting and estimating, and analytical thinking. By promoting critical, rational and creative thinking, this book invites readers to re-examine common assumptions regarding software testing and shows them how to become professional testers who bring added value to their company.

This book provides the reader with a comprehensive knowledge of all the tools provided in the software SOLIDWORKS for a variety of engineering areas. It presents a broad choice of examples to be imitated in one's own work. In developing these examples, the authors' intent has been to exercise many program features and refinements. By displaying these, the authors hope to give readers the confidence to employ these program enhancements in their own modeling applications.

DESCRIPTION Types are often seen as a tool for checking errors, with the programmer writing a complete program first and using the type checker to detect errors. And while tests are used to show presence of errors, they can only find errors that you explicitly test for. In typedriven development, types become your tools for constructing programs and, used appropriately, can show the absence of errors. And you can express precise relationships between data, your assumptions are explicit and checkable, and you can precisely state and verify properties. Type-driven development lets users write extensible code, create simple specifications very early in development, and easily create mock implementation for testing. Type-Driven Development with Idris, written by the creator of Idris, teaches programmers how to improve the performance and accuracy of programs by taking advantage of a state-of-the-art type system. This book teaches readers using Idris, a language designed from the very beginning to support type-driven development. Readers learn how to manipulate types just like any other construct (numbers, strings, lists, etc.). This book teaches how to use type-driven development to build real-world software, as well as how to handle side-effects, state and concurrency, and interoperating with existing systems. By the end of this book, readers will be able to develop robust and verified software in Idris and apply type-driven development methods to programming in other languages. KEY FEATURES * Written by the creator of Idris * Improve performance and accuracy of programs * Teaches Idris, a new type-driven development language * Hands-on code examples * Build real-world software AUDIENCE Written for programmers with knowledge of basic functional programming concepts. ABOUT THE TECHNOLOGY Type-driven development lets you write extensible code, create simple specifications very early in development, and easily create mock implementation for testing. In type-driven development, types become your tools for constructing programs and, used appropriately, can show the absence of errors.

Python for Scientific Computation and Artificial Intelligence is split into 3 parts: in Section 1, the reader is introduced to the Python programming language and shown how Python can aid in the understanding of advanced High School Mathematics. In Section 2, the reader is shown how Python can be used to solve real-world problems from a broad range of scientific disciplines. Finally, in Section 3, the reader is introduced to neural networks and shown how TensorFlow (written in Python) can be used to solve a large array of problems in Artificial Intelligence (AI). This book was developed from a series of national and international workshops that the author has been delivering for over twenty years. The book is beginner friendly and has a strong practical emphasis on programming and computational modelling. Features: No prior experience of programming is required. Online GitHub repository available with codes for readers to practice. Covers applications and examples from biology, chemistry, computer science, data science, electrical and mechanical engineering, economics, mathematics, physics, statistics and binary oscillator computing. Full solutions to exercises are available as Jupyter notebooks on the Web.

This textbook sets out to provide professionals with an in-depth understanding of the software-testing people and process issues that are critical for delivering high-quality software on time and within budget. The authors aim to give those involved in building and maintaining complex, mission-critical software systems a flexible, risk-based process to improve their software-testing capabilities. Whether an organization currently has a well-defined testing process or almost no process, this resource provides insights into better ways to test software. This guide is written for: software-test managers; testers; developers; quality-assurance managers; and software configuration managers.

A complete textbook and reference for engineers to learn the fundamentals of computer programming with modern C++ Introduction to Programming with C++ for Engineers is an original presentation teaching the fundamentals of computer programming and modern C++ to engineers and engineering students. Professor Cyganek, a highly regarded expert in his field, walks users through basics of data structures and algorithms with the help of a core subset of C++ and the Standard Library, progressing to the object-oriented domain and advanced C++ features, computer arithmetic, memory management and essentials of parallel programming, showing with real world examples how to complete tasks. He also guides users through the software development process, good programming practices, not shunning from explaining low-level features and the programming tools. Being a textbook, with the summarizing tables and diagrams the book becomes a highly useful reference for C++ programmers at all levels. Introduction to Programming with C++ for Engineers teaches how to program by: Guiding users from simple techniques with modern C++ and the Standard Library, to more advanced object-oriented design methods and language features Providing meaningful examples that facilitate understanding of the programming techniques and the C++ language constructions Fostering good programming practices which create better professional programmers Minimizing text descriptions, opting instead for comprehensive figures, tables, diagrams, and other explanatory material Granting access to a complementary website that contains example code and useful links to resources that further improve the reader's coding ability Including test and exam question for the reader's review at the end of each chapter Engineering students, students of other sciences who rely on computer programming, and professionals in various fields will find this book invaluable when learning to program with C++.

The aim of the book is to create a bridge between two 'lands' that are usually kept separate: technical tools and legal rules should be bound together for moulding a special 'toolbox' to solve present and future issues. The volume is intended to contribute to this 'toolbox' in the area of software services, while addressing how to make legal studies work closely with engineers' and computer scientists' fields of expertise, who are increasingly involved in tangled choices on daily programming and software development. In this respect, law has not lost its importance and its own categories in the digital world, but as well as any social science needs to experience a new realistic approach amid technological development and individuals' fundamental rights and freedoms.

This book presents in their basic form the most important models of computation, their basic programming paradigms, and their mathematical descriptions, both concrete and abstract. Each model is accompanied by relevant formal techniques for reasoning on it and for proving some properties. After preliminary chapters that introduce the notions of structure and meaning, semantic methods, inference rules, and logic programming, the authors arrange their chapters into parts on IMP, a simple imperative language; HOFL, a higher-order functional language; concurrent, nondeterministic and interactive models; and probabilistic/stochastic models. The authors have class-tested the book content over many years, and it will be valuable for graduate and advanced undergraduate students of theoretical computer science and distributed systems, and for researchers in this domain. Each chapter of the book concludes with a list of exercises addressing the key techniques introduced, solutions to selected exercises are offered at the end of the book.

Extensive research conducted by the Hasso Plattner Design Thinking Research Program at Stanford University in Palo Alto, California, USA, and the Hasso Plattner Institute in Potsdam, Germany, has yielded valuable insights on why and how design thinking works. Researchers have identified metrics, developed models, and conducted studies, which are featured in this book, and in the previous volumes of this series. Offering readers a closer look at design thinking, and its innovation processes and methods, this volume covers topics ranging from understanding success factors of design thinking to exploring the potential that lies in the use of digital technologies. Furthermore, readers learn how special-purpose design thinking can be used to solve thorny problems in complex fields, such as the health sector or software development. Thinking and devising innovations are inherently human activities - so is design thinking. Accordingly, design thinking is not merely the result of special courses or of being gifted or trained: it is a way of dealing with our environment and improving techniques, technologies and life. As such, the research outcomes compiled in this book should increase knowledge and provide inspiration to all seeking to drive innovation - be they experienced design thinkers or newcomers.

Effective Data Science Infrastructure is a hands-on guide to assembling infrastructure for data science and machine learning applications. It reveals the processes used at Netflix and other data driven companies to manage their cutting edge data infrastructure. As you work through this easy-to-follow guide, you'll set up end-to end infrastructure from the ground up, with a fully customizable process you can easily adapt to your company. You'll learn how you can make data scientists more productive with your existing cloud infrastructure, a stack of open source software, and idiomatic Python. Throughout, you'll follow a human-centric approach focused on user experience and meeting the unique needs of data scientists. About the Technology Turning data science projects from small prototypes to sustainable business processes requires scalable and reliable infrastructure. This book lays out the workflows, components, and methods of the full infrastructure stack for data science, from data warehousing and scalable compute to modeling frameworks.