Users increasingly demand more from their software than ever before more features, fewer errors, faster runtimes. To deliver the best quality products possible, software engineers are constantly in the process of employing novel tools in developing the latest software applications. Progressions and Innovations in Model-Driven Software Engineering investigates the most recent and relevant research on model-driven engineering. Within its pages, researchers and professionals in the field of software development, as well as academics and students of computer science, will find an up-to-date discussion of scientific literature on the topic, identifying opportunities and advantages, and complexities and challenges, inherent in the future of software engineering.

At the dawn of the 21st century and the information age, communication and c- puting power are becoming ever increasingly available, virtually pervading almost every aspect of modern socio-economical interactions. Consequently, the potential for realizing a signi?cantly greater number of technology-mediated activities has emerged. Indeed, many of our modern activity ?elds are heavily dependant upon various underlying systems and software-intensive platforms. Such technologies are commonly used in everyday activities such as commuting, traf?c control and m- agement, mobile computing, navigation, mobile communication. Thus, the correct function of the forenamed computing systems becomes a major concern. This is all the more important since, in spite of the numerous updates, patches and ?rmware revisions being constantly issued, newly discovered logical bugs in a wide range of modern software platforms (e. g. , operating systems) and software-intensive systems (e. g. , embedded systems) are just as frequently being reported. In addition, many of today's products and services are presently being deployed in a highly competitive environment wherein a product or service is succeeding in most of the cases thanks to its quality to price ratio for a given set of features. Accordingly, a number of critical aspects have to be considered, such as the ab- ity to pack as many features as needed in a given product or service while c- currently maintaining high quality, reasonable price, and short time -to- market.

"Meta-Programming and Model-Driven Meta-Program Development: Principles, Processes and Techniques" presents an overall analysis of meta-programming, focusing on insights of meta-programming techniques, heterogeneous meta-program development processes in the context of model-driven, feature-based and transformative approaches.

The fundamental concepts of meta-programming are still not thoroughly understood, in this well organized book divided into three parts the authors help to address this. Chapters include: Taxonomy of fundamental concepts of meta-programming; Concept of structural heterogeneous meta-programming based on the original meta-language; Model-driven concept and feature-based modeling to the development process of meta-programs; Equivalent meta-program transformations and metrics to evaluate complexity of feature-based models and meta-programs; Variety of academic research case studies within different application domains to experimentally verify the soundness of the investigated approaches.

Both authors are professors at Kaunas University of Technology with 15 years research and teaching experience in the field. "Meta-Programming and Model-Driven Meta-Program Development: Principles, Processes and Techniques" is aimed at post-graduates in computer science and software engineering and researchers and program system developers wishing to extend their knowledge in this rapidly evolving sector of science and technology.

For real-time systems, the worst-case execution time (WCET) is the key objective to be considered. Traditionally, code for real-time systems is generated without taking this objective into account and the WCET is computed only after code generation. Worst-Case Execution Time Aware Compilation Techniques for Real-Time Systems presents the first comprehensive approach integrating WCET considerations into the code generation process. Based on the proposed reconciliation between a compiler and a timing analyzer, a wide range of novel optimization techniques is provided. Among others, the techniques cover source code and assembly level optimizations, exploit machine learning techniques and address the design of modern systems that have to meet multiple objectives.

Using these optimizations, the WCET of real-time applications can be reduced by about 30% to 45% on the average. This opens opportunities for decreasing clock speeds, costs and energy consumption of embedded processors. The proposed techniques can be used for all types real-time systems, including automotive and avionics IT systems.

The subject of this book is the control of software engineering. The rapidly increasing demand for software is accompanied by a growth in the number of products on the market, as well as their size and complexity. Our ability to control software engineering is hardly keeping pace with this growth. As a result, software projects are often late, software products sometimes lack the required quality and the productivity improvements achieved by software engineering are insufficient to keep up with the demand This book describes ways to improve software engineering control. It argues that this should be expanded to include control of the development, maintenance and reuse of software, thus making it possible to apply many of the ideas and concepts that originate in production control and quality control. The book is based on research and experience accumulated over a number of years. During this period I had two employers: Eindhoven University of Technology and Philips Electronics. Research is not a one-man activity and I would like to thank the following persons for their contributions to the successful completion of this project. First and foremost my Ph. D. advisers Theo Bemelmans, Hans van Vliet and Fred Heemstra whose insights and experience proved invaluable at every stage. Many thanks are also due to Rob Kusters and Fred Heemstra for their patience in listening to my sometimes wild ideas and for being such excellent colleagues.

This book analyses quantitative open source software (OSS) reliability assessment and its applications, focusing on three major topic areas: the Fundamentals of OSS Quality/Reliability Measurement and Assessment; the Practical Applications of OSS Reliability Modelling; and Recent Developments in OSS Reliability Modelling. Offering an ideal reference guide for graduate students and researchers in reliability for open source software (OSS) and modelling, the book introduces several methods of reliability assessment for OSS including component-oriented reliability analysis based on analytic hierarchy process (AHP), analytic network process (ANP), and non-homogeneous Poisson process (NHPP) models, the stochastic differential equation models and hazard rate models. These measurement and management technologies are essential to producing and maintaining quality/reliable systems using OSS.

An Introduction to R and Python for Data Analysis helps teach students to code in both R and Python simultaneously. As both R and Python can be used in similar manners, it is useful and efficient to learn both at the same time, helping lecturers and students to teach and learn more, save time, whilst reinforcing the shared concepts and differences of the systems. This tandem learning is highly useful for students, helping them to become literate in both languages, and develop skills which will be handy after their studies. This book presumes no prior experience with computing, and is intended to be used by students from a variety of backgrounds. The side-by-side formatting of this book helps introductory graduate students quickly grasp the basics of R and Python, with the exercises providing helping them to teach themselves the skills they will need upon the completion of their course, as employers now ask for competency in both R and Python. Teachers and lecturers will also find this book useful in their teaching, providing a singular work to help ensure their students are well trained in both computer languages. All data for exercises can be found here: https://github.com/tbrown122387/r_and_python_book/tree/master/data. Key features: - Teaches R and Python in a "side-by-side" way. - Examples are tailored to aspiring data scientists and statisticians, not software engineers. - Designed for introductory graduate students. - Does not assume any mathematical background.

This book draws new attention to domain-specific conceptual modeling by presenting the work of thought leaders who have designed and deployed specific modeling methods. It provides hands-on guidance on how to build models in a particular domain, such as requirements engineering, business process modeling or enterprise architecture. In addition to these results, it also puts forward ideas for future developments. All this is enriched with exercises, case studies, detailed references and further related information. All domain-specific methods described in this volume also have a tool implementation within the OMiLAB Collaborative Environment - a dedicated research and experimentation space for modeling method engineering at the University of Vienna, Austria - making these advances accessible to a wider community of further developers and users. The collection of works presented here will benefit experts and practitioners from academia and industry alike, including members of the conceptual modeling community as well as lecturers and students.

Scientific applications involve very large computations that strain the resources of whatever computers are available. Such computations implement sophisticated mathematics, require deep scientific knowledge, depend on subtle interplay of different approximations, and may be subject to instabilities and sensitivity to external input. Software able to succeed in this domain invariably embeds significant domain knowledge that should be tapped for future use. Unfortunately, most existing scientific software is designed in an ad hoc way, resulting in monolithic codes understood by only a few developers. Software architecture refers to the way software is structured to promote objectives such as reusability, maintainability, extensibility, and feasibility of independent implementation. Such issues have become increasingly important in the scientific domain, as software gets larger and more complex, constructed by teams of people, and evolved over decades. In the context of scientific computation, the challenge facing mathematical software practitioners is to design, develop, and supply computational components which deliver these objectives when embedded in end-user application codes. The Architecture of Scientific Software addresses emerging methodologies and tools for the rational design of scientific software, including component integration frameworks, network-based computing, formal methods of abstraction, application programmer interface design, and the role of object-oriented languages. This book comprises the proceedings of the International Federation for Information Processing (IFIP) Conference on the Architecture of Scientific Software, which was held in Ottawa, Canada, in October 2000. It will prove invaluable reading for developers of scientific software, as well as for researchers in computational sciences and engineering.

Software product lines are emerging as a critical new paradigm for software development. Product lines are enabling organizations to achieve impressive time-to-market gains and cost reductions. With the increasing number of product lines and product-line researchers and practitioners, the time is right for a comprehensive examination of the issues surrounding the software product line approach. The Software Engineering Institute at Carnegie Mellon University is proud to sponsor the first conference on this important subject. This book comprises the proceedings of the First Software Product Line Conference (SPLC1), held August 28-31, 2000, in Denver, Colorado, USA. The twenty-seven papers of the conference technical program present research results and experience reports that cover all aspects of software product lines. Topics include business issues, enabling technologies, organizational issues, and life-cycle issues. Emphasis is placed on experiences in the development and fielding of product lines of complex systems, especially those that expose problems in the design, development, or evolution of software product lines. The book will be essential reading for researchers and practitioners alike.

This book presents a coherent description of the theoretical and practical aspects of Coloured Petri Nets (CP-nets or CPN). It shows how CP-nets have been de veloped - from being a promising theoretical model to being a full-fledged lan guage for the design, specification, simulation, validation and implementation of large software systems (and other systems in which human beings and/or com puters communicate by means of some more or less formal rules). The book contains the formal definition of CP-nets and the mathematical theory behind their analysis methods. However, it has been the intention to write the book in such a way that it also becomes attractive to readers who are more interested in applications than the underlying mathematics. This means that a large part of the book is written in a style which is closer to an engineering textbook (or a users' manual) than it is to a typical textbook in theoretical computer science. The book consists of three separate volumes. The first volume defines the net model (i. e. , hierarchical CP-nets) and the basic concepts (e. g. , the different behavioural properties such as deadlocks, fair ness and home markings). It gives a detailed presentation of many small exam ples and a brief overview of some industrial applications. It introduces the for mal analysis methods. Finally, it contains a description of a set of CPN tools which support the practical use of CP-nets.

With the increasing proliferation of information-technology and, especially, Web-based approaches to the implementation of systems and services, researchers, educators, and practitioners worldwide are experiencing a rising need for authoritative references to enhance their understanding of the most current and effective engineering practices leading to robust and successful solutions.""Integrated Approaches in Information Technology and Web Engineering: Advancing Organizational Knowledge Sharing"" presents comprehensive, research-driven insights into the field of Web engineering. This book collects over 30 authoritative articles from distinguished international researchers in information technology and Web engineering, creating an invaluable resource for library reference collections that will equip researchers and practitioners in academia and industry alike with the knowledge base to drive the next generation of innovations.

Take the pain out of managing serverless applications. Knative, a collection of Kubernetes extensions curated by Google, simplifies building and running serverless systems. Knative in Action guides you through the Knative toolkit, showing you how to launch, modify, and monitor event-based apps built using cloud-hosted functions like AWS Lambda. You'll learn how to use Knative Serving to develop software that is easily deployed and autoscaled, how to use Knative Eventing to wire together disparate systems into a consistent whole, and how to integrate Knative into your shipping pipeline. about the technologyWith Knative, managing a serverless application's full lifecycle is a snap. Knative builds on Kubernetes orchestration features, making it easy to deploy and run serverless apps. It handles low-level chores-such as starting and stopping instances-so you can concentrate on features and behavior. about the book Knative in Action teaches you to build complex and efficient serverless applications. You'll dive into Knative's unique design principles and grasp cloud native concepts like handling latency-sensitive workloads. You'll deliver updates with Knative Serving and interlink apps, services, and systems with Knative Eventing. To keep you moving forward, every example includes deployment advice and tips for debugging. what's inside Deploy a service with Knative Serving Connect systems with Knative Eventing Autoscale responses for different traffic surges Develop, ship, and operate software about the readerFor software developers comfortable with CLI tools and an OO language like Java or Go. about the author Jacques Chester has worked in Pivotal and VMWare R&D since 2014, contributing to Knative and other projects.

This book presents real-world decision support systems, i.e., systems that have been running for some time and as such have been tested in real environments and complex situations; the cases are from various application domains and highlight the best practices in each stage of the system's life cycle, from the initial requirements analysis and design phases to the final stages of the project. Each chapter provides decision-makers with recommendations and insights into lessons learned so that failures can be avoided and successes repeated. For this reason unsuccessful cases, which at some point of their life cycle were deemed as failures for one reason or another, are also included. All decision support systems are presented in a constructive, coherent and deductive manner to enhance the learning effect. It complements the many works that focus on theoretical aspects or individual module design and development by offering 'good' and 'bad' practices when developing and using decision support systems. Combining high-quality research with real-world implementations, it is of interest to researchers and professionals in industry alike.

Engineering tasks are supposed to achieve defined goals under certain project constraints. Example goals of software engineering tasks include achieving a certain functionality together with some level of reliability or performance. Example constraints of software engineering tasks include budget and time limitations or experience limitations of the developers at hand. Planning of an engineering project requires the selection of techniques, methods and tools suited to achieve stated goals under given project constraints. This assumes sufficient knowledge regarding the process-product relationships (or effects) of candidate techniques, methods and tools. Planning of software projects suffers greatly from lack of knowledge regarding the process-product relationships of candidate techniques, methods and tools. Especially in the area of testing a project planner is confronted with an abundance of testing techniques, but very little knowledge regarding their effects under varying project conditions. This book offers a novel approach to addressing this problem: First, based on a comprehensive initial characterization scheme (see chapter 7) an overview of existing testing techniques and their effects under varying conditions is provided to guide the selection of testing approaches. Second, the optimisation of this knowledge base is suggested based on experience from experts, real projects and scientific experiments (chapters 8, 9, and 10). This book is of equal interest to practitioners, researchers and students. Practitioners interested in identifying ways to organize their company-specific knowledge about testing could start with the schema provided in this book, and optimise it further by applying similar strategies as offered in chapters 8 and 9.

Software testing is traditionally seen as a difficult and time consuming activity that is hard to embed in the software development process. This book provides a different view. It explains to stakeholders how testing can add value to software development and doing business, and provides the tester with practical information.

TestGoal is not just another methodology. Several good testing methodologies exist. But, like any other profession, also testing encompasses more than the simple application of a methodology. After all, strict adherence to a specific methodology is no guarantee for success. Success stems from the mindset, enthusiasm, knowledge and skill of the tester. These factors determine whether a methodology is applied successfully and whether testing takes on a result-driven character. And that's what TestGoal is about: a result-driven attitude, testing principles and expertise as fundament, and a hands-on six step plan to enable result driven testing.

Derk-Jan de Grood and his colleagues from Collis, an international software testing company, know about the main pitfalls in test projects from their extensive professional experience. TestGoal has emerged from the office floor and captures over a decade of best practice. TestGoal is made by professionals for professionals, and it combines the mindset, knowledge, and skills required to add value with testing and make software development more successful.

This book explains in a clear language how you can make testing result-driven. It explains why testing is important and describes all of the activities involved in testing. It is enriched with recognizable examples, practical tips and useful checklists. This makes it a "GO kit" that enables testers to immediately get started and add value to their organization.

A best-seller in its French edition, the construction of this book is original and its success in the French market demonstrates its appeal. It is based on three principles: 1. An organization of the chapters by families of algorithms : exhaustive search, divide and conquer, etc. At the contrary, there is no chapter only devoted to a systematic exposure of, say, algorithms on strings. Some of these will be found in different chapters. 2. For each family of algorithms, an introduction is given to the mathematical principles and the issues of a rigorous design, with one or two pedagogical examples. 3. For its most part, the book details 150 problems, spanning on seven families of algorithms. For each problem, a precise and progressive statement is given. More important, a complete solution is detailed, with respect to the design principles that have been presented ; often, some classical errors are pointed at. Roughly speaking, two thirds of the book are devoted to the detailed rational construction of the solutions.

A wide range of modern computer applications require the performance and flexibility of parallel and distributed systems. Better software support is required if the technical advances in these systems are to be fully exploited by commerce and industry. This involves the provision of specialised techniques and tools as well as the integration of standard software engineering methods. This book will reflect current advances in this area, and will address issues of theory and practice with contributions from academia and industry. It is the aim of the book to provide a focus for information on this developing which will be of use to both researchers and practitioners.

This book presents a comprehensive survey of the Vesta system for software configuration management (SCM). Vesta, unlike other SCM systems, is specifically designed to handle very large software projects comprising tens of millions of lines of code and beyond. Researchers in the field of software engineering and specialists in the construction of software development tools will especially benefit from this work, but it will also appeal to those responsible for designing and deploying configuration management solutions for large software systems.

Three important but hard-to-achieve properties lie at the heart of Vesta's unique approach to software configuration management:

Every build is repeatable

Every build is incremental

Every build is consistent

To realize these properties in a practical SCM system, Vesta provides a novel repository to store the versions of the files that make up an evolving software system and a flexible language for writing modular configuration descriptions that define how the system is put together. This book explains in depth these facilities and the suite of tools that supports them, together with a methodology for applying them in practice.

Readers who seek more information about Vesta may download the entire system as well as other publications, reference documents, and user documentation from the Vesta home page at http: //www.vestasys.org.

Updated to cover UML 2.0, this student textbook provides a practical understanding of software design and development using UML. Case studies are used to illustrate good practice.

Software engineering research can trace its roots to a few highly influential individuals. Among that select group is Leon J. Osterweil, who has been a major force in driving software engineering from its infancy to its modern reality. For more than three decades, Prof. Osterweil's work has fundamentally defined or significantly impacted major directions in software analysis, development tools and environments, and software process--all critical parts of software engineering as it is practiced today. His exceptional contributions to the field have been recognized with numerous awards and honors through his career, including the ACM SIGSOFT Outstanding Research Award, in recognition of his extensive and sustained research impact, and the ACM SIGSOFT Influential Educator Award, in recognition of his career-long achievements as an educator and mentor. In honor of Prof. Osterweil's profound accomplishments, this book was prepared for a special honorary event held during the 2011 International Conference on Software Engineering (ICSE). It contains some of his most important published works to date, together with several new articles written by leading authorities in the field, exploring the broad impact of his work in the past and how it will further impact software engineering research in the future. These papers, part of the core software engineering legacy and now available in one commented volume for the first time, are grouped into three sections: flow analysis for software dependability, the software lifecycle, and software process.

To achieve consistent software project success under the pressures of today's software development environment, software organizations require achievable plans including viable estimates of schedule, resources, and risks. To estimate realistically, you must understand how to apply sound estimation processes, tools, and data. Software Sizing, Estimation, and Risk Management: When Performance is Measured Performance Improves is a practical, hands-on discussion of the software estimation, planning, and control process. This includes critical factors that impact estimates, methods for selecting and applying appropriate measures to projects, proper software sizing, and processes to identify and manage risk. The authors use their expertise in sizing, estimation, process engineering, and risk management to clearly demonstrate problems that make many estimates crumble and solutions that provide successful project plans. The book offers insight not available anywhere else, enabling you to recognize and avoid downstream impacts resulting from poor estimates.

Software testing is rapidly evolving as a critical sub-discipline of software engineering. The industry needs professionals educated in the modern methods and tools of software testing and quality assurance. Based on the needs of software professionals, "Practical Software Testing" takes a unique approach to teaching readers how to effectively plan for testing, design test cases, test at multiple levels, organize a testing team, and optimize use of testing tools. It introduces testing concepts that are managerial-, technical-, and process-oriented, using the Testing Maturity Model (TMM) as a framework. Features: *includes a sample test plan, comprehensive exercises, and definitions for software testing and quality *introduces both technical and managerial aspects of testing in a clear and precise style, for integrated learning *balanced perspective and comprehensive view of all testing aspects *uses the TMM framework to introduce testing in a systematic, evolutionary way, and describes industrial TMM applications *covers testing topics with either procedurally based or object-oriented programming code With its accessible, practical, and well-focused framework, this new resource provides an integrated presentation of software-testing processes and practices. Professionals and practitioners in software testing, software quality assurance, or software validation and verification will benefit greatly from using this essential resource.