%{search_type} search results

Das Buch vermittelt die Grundlagen, Methoden und Techniken des Software Engineerings. Es ist als Material zu Vorlesungen über Software Engineering konzipiert. Darum wurde besonderes Gewicht auf die Darstellung und Vermittlung der Einsichten, Erkenntnisse und Erfahrungen gelegt, die von Forschern und Praktikern gewonnen, formuliert und angewendet wurden und der Kritik standgehalten haben. Auch für Praktiker, die mit der Software-Entwicklung und -Bearbeitung und den dabei auftretenden Problemen vertraut sind, ist das Buch sehr gut geeignet, um die Kenntnisse im Selbststudium zu ergñzen und zu vertiefen.Der Inhalt des Buches ist in fünf Hauptteile gegliedert:I Grundlagen: Modelle und Modellierung, Grundbegriffe, Software-Nutzen und -Kosten, Software-Qualitt̃II Menschen und Prozesse: Software-Projekt, Projektleitung und Projektleiter, Vorgehensmodelle, Prozessmodelle, Bewertung und Verbesserung des Software-ProzessesIII Daueraufgaben im Software-Projekt: Dokumentation, Software-Qualitt̃ssicherung und -Prüfung, Metriken und BewertungenIV Techniken der Software-Bearbeitung: Analyse und Spezifikation, Entwurf, Codierung, Programmtest, IntegrationV Verwaltung und Erhaltung der Software: Konfigurationsverwaltung, Software-Wartung, Reengineering, WiederverwendungEin Nachwort zum Studium der Softwaretechnik, ein aktuelles Literaturverzeichnis und ein prz̃iser Index schliessen das Buch ab.Die 4. Auflage enthl̃t neben vielen kleinen Verbesserungen und Aktualisierungen neue Themen wie Scht̃zung in agilen Projekten, agile Skalierung, Behavior-Driven Development, Microservices, Domain-Driven Design und automatische Software-Auslieferung.

• Part I: Continuous Delivery.- Introduction to the Continuous Delivery Theme.-
• 1. Climbing the Stairway to Heaven.-
• 2. Modeling Continuous Integration Practice Differences in Industry Software Development.-
• 3. Efficient and Effective Exploratory Testing of Large-Scale Software Systems.- Part II: Continuous Architecture.- Introduction to the Continuous Architecture Theme.-
• 4. Technical Debt Tracking: Current State of Practice: A Survey and Multiple Case Study in 15 Large Organizations.-
• 5. Expectations and Challenges from Scaling Agile in Mechatronics-Driven Companies - A Comparative Case Study.-
• 6. Lightweight Consistency Checking for Agile Model-Based Development in Practice.- Part III: Metrics.- Introduction to the Metrics Theme.-
• 7. MESRAM - A Method for Assessing Robustness of Measurement Programs in Large Software Development Organizations and Its Industrial Evaluation.-
• 8. Recognizing Lines of Code Violating Company-Specific Coding Guidelines Using Machine Learning.-
• 9. SimSAX: A Measure of Project Similarity Based on Symbolic Approximation Method and Software Defect Inflow.- Part IV: Customer Data and Ecosystem Driven Development.- Introduction to the Customer Data and Ecosystem-Driven Development Theme.-
• 10. Requirements Engineering Challenges and Practices in Large-Scale Agile System Development.-
• 11. Experimentation for Business-to-Business Mission-Critical Systems: A Case Study.-
• 12. The Evolution of Continuous Experimentation in Software Product Development: From Data to a Data-Driven Organization at Scale.- Part V: AI Engineering.- Introduction to the AI Engineering Theme.-
• 13. Engineering AI Systems.
• (source: Nielsen Book Data)

This book celebrates the 10-year anniversary of Software Center (a collaboration between 18 European companies and five Swedish universities) by presenting some of the most impactful and relevant journal or conference papers that researchers in the center have published over the last decade. The book is organized around the five themes around which research in Software Center is organized, i.e. Continuous Delivery, Continuous Architecture, Metrics, Customer Data and Ecosystems Driven Development, and AI Engineering. The focus of the Continuous Delivery theme is to help companies to continuously build high quality products with the right degree of automation. The Continuous Architecture theme addresses challenges that arise when balancing the need for architectural quality and more agile ways of working with shorter development cycles. The Metrics theme studies and provides insight to understand, monitor and improve software processes, products and organizations. The fourth theme, Customer Data and Ecosystem Driven Development, helps companies make sense of the vast amounts of data that are continuously collected from products in the field. Eventually, the theme of AI Engineering addresses the challenge that many companies struggle with in terms of deploying machine- and deep-learning models in industrial contexts with production quality. Each theme has its own part in the book and each part has an introduction chapter and then a carefully selected reprint of the most important papers from that theme. This book mainly aims at researchers and advanced professionals in the areas of software engineering who would like to get an overview about the achievement made in various topics relevant for industrial large-scale software development and management - and to see how research benefits from a close cooperation between industry and academia.
(source: Nielsen Book Data)

• Cover
• Title Page
• Copyright Page
• About the Author
• Acknowledgments
• Contents
• Introduction
• What Is Software Engineering?
• Why Is Software Engineering Important?
• Who Should Read This Book?
• Approach
• What This Book Covers (and What It Doesn't)
• What Tools Do You Need?
• Conventions
• Errata
• Important URLs
• Contacting the Author
• Disclaimer
• Part I Software Engineering Step-by-Step
• Chapter 1 Software Engineering from 20,000 Feet
• Requirements Gathering
• High-Level Design
• Low-Level Design
• Development
• Testing
• Deployment
• Maintenance

• Wrap-up
• Everything All at Once
• Summary
• What You Learned in This Chapter
• Chapter 2 Before the Beginning
• Document Management
• Historical Documents
• Email
• Code
• Code Documentation
• Application Documentation
• Summary
• What You Learned in This Chapter
• Chapter 3 The Team
• Team Features
• Clear Roles
• Effective Leadership
• Clear Goals
• Consensus
• Open Communication
• Support for Risk-Taking
• Shared Accountability
• Informal Atmosphere
• Trust
• Team Roles
• Common Roles
• More-Specialized Roles
• Informal Roles
• Roles Wrap-Up
• Team Culture

• Interviews
• Interview Puzzles
• The Bottom Line
• Physical Environment
• Creativity
• Office Space
• Ergonomics
• Work-Life Balance
• Collaboration Software
• Searching
• Overload
• Outsourcing
• Summary
• What You Learned in This Chapter
• Chapter 4 Project Management
• Executive Support
• Project Management
• PERT Charts
• Critical Path Methods
• Gantt Charts
• Scheduling Software
• Predicting Times
• Get Experience
• Break Unknown Tasks into Simpler Pieces
• Look for Similarities
• Expect the Unexpected
• Track Progress
• Risk Management
• Summary

• What You Learned in This Chapter
• Chapter 5 Requirements Gathering
• Requirements Defined
• Clear
• Unambiguous
• Consistent
• Prioritized
• Verifiable
• Words to Avoid
• Requirement Categories
• Audience-Oriented Requirements
• Business Requirements
• User Requirements
• Functional Requirements
• Nonfunctional Requirements
• Implementation Requirements
• FURPS
• FURPS+
• Common Requirements
• Gathering Requirements
• Listen to Customers (and Users)
• Use the Five Ws (and One H)
• Who
• What
• When
• Where
• Why
• How
• Study Users
• Refining Requirements

• Copy Existing Systems
• Clairvoyance
• Brainstorm
• Recording Requirements
• UML
• User Stories
• Use Cases
• Prototypes
• Requirements Specification
• Validation and Verification
• Changing Requirements
• Digital Transformation
• What to Digitize
• How to Digitize
• Summary
• Exercises
• What You Learned in This Chapter
• Chapter 6 High-Level Design
• The Big Picture
• What to Specify
• Security
• Hardware
• User Interface
• Internal Interfaces
• External Interfaces
• Architecture
• Monolithic
• Client/Server
• Component-Based
• Service-Oriented
• Data-Centric

Discover the foundations of software engineering with this easy and intuitive guide In the newly updated second edition of Beginning Software Engineering, expert programmer and tech educator Rod Stephens delivers an instructive and intuitive introduction to the fundamentals of software engineering. In the book, you'll learn to create well-constructed software applications that meet the needs of users while developing the practical, hands-on skills needed to build robust, efficient, and reliable software. The author skips the unnecessary jargon and sticks to simple and straightforward English to help you understand the concepts and ideas discussed within. He also offers you real-world tested methods you can apply to any programming language. You'll also get: Practical tips for preparing for programming job interviews, which often include questions about software engineering practices A no-nonsense guide to requirements gathering, system modeling, design, implementation, testing, and debugging Brand-new coverage of user interface design, algorithms, and programming language choices Beginning Software Engineering doesn't assume any experience with programming, development, or management. It's plentiful figures and graphics help to explain the foundational concepts and every chapter offers several case examples, Try It Out, and How It Works explanatory sections. For anyone interested in a new career in software development, or simply curious about the software engineering process, Beginning Software Engineering, Second Edition is the handbook you've been waiting for

• 1. Fundamentals of Software Engineering.-
• 2. Ethics and Professional Responsibility.-
• 3. Ethical Software Engineering.-
• 4. Software Project Management.-
• 5. Requirements Engineering.-
• 6. Software Design and Development.-
• 7. Software Inspections.-
• 8. Software Testing.-
• 9. Data Science and Privacy.-
• 10. Software Metrics and Problem Solving.-
• 11. Supplier Selection and Management.-
• 12. Configuration Management.-
• 13. Software Quality Assurance.-
• 14. Agile Methodology.-
• 15. Software Reliability and Dependability.-
• 16. Formal Methods.-
• 17. Z Specification Language.
• (source: Nielsen Book Data)

This textbook presents a concise introduction to the fundamental principles of software engineering, together with practical guidance on how to apply the theory in a real-world, industrial environment. The wide-ranging coverage encompasses all areas of software design, management, and quality. Topics and features: presents a broad overview of software engineering, including software lifecycles and phases in software development, and project management for software engineering; examines the areas of requirements engineering, software configuration management, software inspections, software testing, software quality assurance, and process quality; covers topics on software metrics and problem solving, software reliability and dependability, and software design and development, including Agile approaches; explains formal methods, a set of mathematical techniques to specify and derive a program from its specification, introducing the Z specification language; discusses software process improvement, describing the CMMI model, and introduces UML, a visual modelling language for software systems; reviews a range of tools to support various activities in software engineering, and offers advice on the selection and management of a software supplier; describes such innovations in the field of software as distributed systems, service-oriented architecture, software as a service, cloud computing, and embedded systems; includes key learning topics, summaries and review questions in each chapter, together with a useful glossary. This practical and easy-to-follow textbook/reference is ideal for computer science students seeking to learn how to build high quality and reliable software on time and on budget. The text also serves as a self-study primer for software engineers, quality professionals, and software managers.
(source: Nielsen Book Data)

• 1. Requirements: basic concepts and definitions.-
• 2. Requirements: general principles.-
• 3. Standard Plan for requirements.-
• 4. Requirements quality and verification.-
• 5. How to write requirements.-
• 6. How to gather requirements.-
• 7. Scenarios: use cases, user stories.-
• 8. Object-oriented requirements.-
• 9. Benefiting from formal methods.-
• 10. Abstract data types.-
• 11. Are my requirements complete?.-
• 12. Requirements in the software lifecycle.
• (source: Nielsen Book Data)

Meyer's Handbook of Requirements and Business Analysis is a comprehensive treatise providing the reader with all the principles and techniques necessary to produce effective requirements. Even the best design, implementation and verification are worthless if they are the solution to the wrong problem. Defining the problem properly is the task of requirements, also known as business analysis. To be successful, a project must apply to requirements the same engineering standards as to other parts of system construction. The Handbook presents a holistic view of requirements including four elements or PEGS: Project, Environment, Goals and System. One of its principal contributions is the definition of a Standard Plan for requirements documents, consisting of the four corresponding books and replacing the structure of the obsolete IEEE 1998 standard. The text covers both classical requirements techniques and advanced topics. The successive chapters address: fundamental concepts and definitions; requirements principles; the Standard Plan for requirements; how to write good requirements; how to gather requirements; scenario techniques (use cases, user stories); object-oriented requirements; how to take advantage of formal methods; abstract data types; and the place of requirements in the software lifecycle. The Handbook is suitable both as a practical guide for industry and as a textbook, with over 50 exercises and supplementary material available from the book's site, including slides and links to video lectures (MOOCs). .
(source: Nielsen Book Data)

• 1 Introduction
• 2 Action Research as Research Methodology in Software Engineering
• 3 Diagnosing
• 4 Action Planning
• 5 Action taking
• 6 Evaluation
• 7 Specifying learning
• 8 Action research vs. design research
• 9 Ensuring sustainability of knowledge
• 10 Validity evaluation
• 11 Reporting Action Research Studies
• 12 Conclusions.

This book addresses action research (AR), one of the main research methodologies used for academia-industry research collaborations. It elaborates on how to find the right research activities and how to distinguish them from non-significant ones. Further, it details how to glean lessons from the research results, no matter whether they are positive or negative. Lastly, it shows how companies can evolve and build talents while expanding their product portfolio. The books structure is based on that of AR projects; it sequentially covers and discusses each phase of the project. Each chapter shares new insights into AR and provides the reader with a better understanding of how to apply it. In addition, each chapter includes a number of practical use cases or examples. Taken together, the chapters cover the entire software lifecycle: from problem diagnosis to project (or action) planning and execution, to documenting and disseminating results, including validity assessments for AR studies. The goal of this book is to help everyone interested in industry-academia collaborations to conduct joint research. It is for students of software engineering who need to learn about how to set up an evaluation, how to run a project, and how to document the results. It is for all academics who arent afraid to step out of their comfort zone and enter industry. It is for industrial researchers who know that they want to do more than just develop software blindly. And finally, it is for stakeholders who want to learn how to manage industrial research projects and how to set up guidelines for their own role and expectations.

• Part 1 - Cloud Requirements Engineering and Domain Modelling: 1. Requirement Engineering Framework for Service and Cloud Computing (REF-SCC).- 2. Towards an Effective Requirement Engineering Approach for Cloud Applications.- 3. Requirements Engineering for Large-Scale Big Data Applications.- 4. Migrating from Monoliths to Cloud-Based Microservices: A Banking Industry Example.- 5. Cloud Enabled Domain Based Software Development.- 6. Security Challenges in Software Engineering for the Cloud: A Systematic Review.
• Part 2 - Cloud Design and Software Engineering Analytics with Machine Learning Approaches : 7. Software Engineering Framework for Software Defect Management Using Machine Learning Techniques with Azure.- 8. Sentiment Analysis of Twitter Data Through Machine Learning Techniques.- 9. Connection Handler: A Design Pattern for Recovery from Connection Crashes.
• Part 3 : Cloud Testing and Software Process Improvement as a Service : 10. A Modern Perspective on Cloud Testing Ecosystems.- 11. Towards Green Software Testing in Agile and DevOps using Cloud Virtualization for Environmental Protection.- 12. Machine Learning as a Service for Software Process Improvement.- 13. Comparison of Data Mining Techniques in the Cloud for Software Engineering.
• (source: Nielsen Book Data)

This book focuses on the development and implementation of cloud-based, complex software that allows parallelism, fast processing, and real-time connectivity. Software engineering (SE) is the design, development, testing, and implementation of software applications, and this discipline is as well developed as the practice is well established whereas the Cloud Software Engineering (CSE) is the design, development, testing, and continuous delivery of service-oriented software systems and applications (Software as a Service Paradigm). However, with the emergence of the highly attractive cloud computing (CC) paradigm, the tools and techniques for SE are changing. CC provides the latest software development environments and the necessary platforms relatively easily and inexpensively. It also allows the provision of software applications equally easily and on a pay-as-you-go basis. Business requirements for the use of software are also changing and there is a need for applications in big data analytics, parallel computing, AI, natural language processing, and biometrics, etc. These require huge amounts of computing power and sophisticated data management mechanisms, as well as device connectivity for Internet of Things (IoT) environments. In terms of hardware, software, communication, and storage, CC is highly attractive for developing complex software that is rapidly becoming essential for all sectors of life, including commerce, health, education, and transportation. The book fills a gap in the SE literature by providing scientific contributions from researchers and practitioners, focusing on frameworks, methodologies, applications, benefits and inherent challenges/barriers to engineering software using the CC paradigm.
(source: Nielsen Book Data)

• Foreword xi
• Preface xvii
• Acknowledgments xxv
• Online Resources xxvii
• Part I Introduction and Foundations 1
• 1 Introduction 3
• 2 The Nature of Code 39
• 3 Fundamental Principles 67
• 4 Functional and Nonfunctional Requirements 91
• 5 UML Overview 115
• 6 Partitioning Systems into Domains 125
• Part II Semantic Modeling: Model-Based Functional Requirements 151
• 7 Use Case Diagrams: Scope and Context 153
• 8 Class Models: Policies to Enforce 183
• 9 Interaction Diagrams: Process at a Mid-Level 237
• 10 State Models: Process at a Fine-Grained Level 261
• 11 Partitioning Domains into Subdomains 305
• 12 Wrapping Up Semantic Modeling 323
• Part III Model-Based Design and Code 369
• 13 Introduction to Design and Code 371
• 14 Designing Interfaces: Specifying Real-World Interaction 379
• 15 High-Level Design: Classes and Operations 407
• 16 High-Level Design: Contracts and Signatures 447
• 17 Detailed Design and Code 503
• 18 Formal Disciplines of Design and Code 539
• 19 Optimization 583
• 20 Model Compilation 633
• 21 Advanced Open Model Compilation 675
• 22 Wrapping Up Model-Based Design and Code 705
• Part IV Related Topics 723
• 23 Estimation 725
• 24 Development and Maintenance Processes 759
• 25 Economics of Error Handling 787
• 26 Arguments Against Model-Based Software Engineering 815
• Part V Summary 827
• 27 Closing Remarks 829
• Part VI Appendices 843
• Appendix A: Documentation Principles 845
• Appendix B: WebBooks 2.0 Background 849
• Appendix C: WebBooks 2.0 Domains 853
• Appendix D: Semantic Model for Order fulfillment 857
• Appendix E: (Pro Forma) Order fulfillment Design 885
• Appendix F: Semantic Model for Payment 905
• Appendix G: (Pro Forma) Payment Design 927
• Appendix H: Semantic Model for Scalability 943
• Appendix I: (Pro Forma) Scalability Design 969
• Appendix J: Semantic Model for High availability 985
• Appendix K: (Pro Forma) High availability Design 1001
• Appendix L: Semantics of Semantic Modeling 1011
• Appendix M: Sample Production Rules 1049
• Appendix N: Software Structural Complexity Metrics 1061
• References 1081
• Index 1091.
• (source: Nielsen Book Data)

A guide to the application of the theory and practice of computing to develop and maintain software that economically solves real-world problem How to Engineer Software is a practical, how-to guide that explores the concepts and techniques of model-based software engineering using the Unified Modeling Language. The author--a noted expert on the topic--demonstrates how software can be developed and maintained under a true engineering discipline. He describes the relevant software engineering practices that are grounded in Computer Science and Discrete Mathematics. Model-based software engineering uses semantic modeling to reveal as many precise requirements as possible. This approach separates business complexities from technology complexities, and gives developers the most freedom in finding optimal designs and code. The book promotes development scalability through domain partitioning and subdomain partitioning. It also explores software documentation that specifically and intentionally adds value for development and maintenance. This important book: Contains many illustrative examples of model-based software engineering, from semantic model all the way to executable code Explains how to derive verification (acceptance) test cases from a semantic model Describes project estimation, along with alternative software development and maintenance processes Shows how to develop and maintain cost-effective software that solves real-world problems Written for graduate and undergraduate students in software engineering and professionals in the field, How to Engineer Software offers an introduction to applying the theory of computing with practice and judgment in order to economically develop and maintain software.
(source: Nielsen Book Data)

• Creating evolving project data sets in software engineering.- Mining Bug Repositories for Bug Triage Automation.- Scalable and Accurate Detection of Function Clones in Software using Multithreading.- Inferring hints for defect fixing order from requirements-to-test-case mappings.- Safety and Security Integrated SIL Evaluation Using the NFR Approach.- A Software Analysis Based Vulnerability Detection System For Smart Contracts.- Securing connection and data transfer between devices and IoT cloud service.- A data-driven conceptual modeling.- On Cognitive Biases in Requirements Elicitation.- Nuts and Bolts of Extracting Variability Models from Natural Language Requirements Documents.- On Importance of Non-functional Requirements in Agile Software Projects - A Survey.- Emerging Results: Evaluation of Selected UX Techniques by Product Managers - a Preliminary Survey.- Towards a Lightweight Approach for the Evaluation of Requirements Engineering Impact on Other IT Project Areas.- From COBOL to Business Rules - Extracting Business Rules from Legacy COBOL Code.- ISO 25010 support in Test Point Analysis for testing effort estimation.-Software for integration of manufacturing resources in the hybrid cloud model for Industry 4.0.- Integration of Senior Software Project Courses in an Undergraduate Software Engineering Program.
• (source: Nielsen Book Data)

In this book, the authors highlight recent findings that hold the potential to improve software products or development processes; in addition, they help readers understand new concepts and technologies, and to see what it takes to migrate from old to new platforms. Some of the authors have spent most of their careers in industry, working at the frontiers of practice-based innovation, and are at the same time prominent researchers who have made significant academic contributions. Others work together with industry to test, in industrial settings, the methods they've developed in the lab. The choice of subject and authors represent the key elements of this book. Its respective chapters cover a wide range of topics, from cloud computing to agile development, applications of data science methods, re-engineering of aging applications into modern ones, and business and requirements engineering. Taken together, they offer a valuable asset for practitioners and researchers alike. .
(source: Nielsen Book Data)

• 1. Preface
• 2. Requirements Engineering: State of Art
• 3. Software Intensive Systems and the Challenges to Requirements Engineering
• 4. Principles, Conceptual Framework and Process
• 5. Environment Modelling and System Requirements Identification
• 6. Software Functionality Identification and Specification
• 7. Environment Related Non-functional Properties Analysis
• 8. Concern about Self-adaptation
• 9. Conclusion
• 10. Index.
• (source: Nielsen Book Data)

Environment Modeling-Based Requirements Engineering for Software Intensive Systems provides a new and promising approach for engineering the requirements of software-intensive systems, presenting a systematic, promising approach to identifying, clarifying, modeling, deriving, and validating the requirements of software-intensive systems from well-modeled environment simulations. In addition, the book presents a new view of software capability, i.e. the effect-based software capability in terms of environment modeling.
(source: Nielsen Book Data)

• Software engineering paradigms & concepts software process
• Software requirement: an understanding
• Software design paradigms
• Testing: an exploration and understanding
• Software quality: an analysis and understanding.

This book provides a comprehensive and exhaustive coverage of the software engineering paradigm and concepts. Various software development life cycle activities like analysis, design and testing are described in detail. An overview of the software product and process is provided with special focus on latest developments like agile methods. Umbrella activities like software configuration management, risk management and change management are elucidated. The book also provides new insights into Process frameworks like CMMI and ISO. Course material for software testing certification is yet another highlight.

• Chapter 1. Introduction
• Chapter 2. Systematic literature reviews
• Chapter 3. Software metrics
• Chapter 4. Experimental design
• Chapter 5. Mining data from software repositories
• Chapter 6. Data analysis and statistical testing
• Chapter 7. Model development and interpretation
• Chapter 8. Validity threats
• Chapter 9. Reporting results
• Chapter 10. Mining unstructures data
• Chapter 11. Demonstrating empirical procedures
• Chapter 12. Tools for analyzing data

• Introduction. Systematic Literature Reviews. Software Metrics. Experimental Design. Mining Data from Software Repositories. Data Analysis and Statistical Testing. Model Development and Interpretation. Validity Threats. Reporting Results. Mining Unstructured Data. Demonstrating Empirical Procedures. Tools for Analyzing Data. Appendix. References. Index.
• (source: Nielsen Book Data)

• Introduction What Is Empirical Software Engineering? Overview of Empirical Studies Types of Empirical Studies Empirical Study Process Ethics of Empirical Research Importance of Empirical Research Basic Elements of Empirical Research Some Terminologies Concluding Remarks
• Systematic Literature Reviews Basic Concepts Case Study Planning the Review Methods for Presenting Results Conducting the Review Reporting the Review SRs in Software Engineering
• Software Metrics Introduction Measurement Basics Measuring Size Measuring Software Quality OO Metrics Dynamic Software Metrics System Evolution and Evolutionary Metrics Validation of Metrics Practical Relevance
• Experimental Design Overview of Experimental Design Case Study: Fault Prediction Systems Research Questions Reviewing the Literature Research Variables Terminology Used in Study Types Hypothesis Formulation Data Collection Selection of Data Analysis Methods
• Mining Data from Software Repositories Configuration Management Systems Importance of Mining Software Repositories Common Types of Software Repositories Understanding Systems Version Control Systems Bug Tracking Systems Extracting Data from Software Repositories Static Source Code Analysis Software Historical Analysis Software Engineering Repositories and Open Research Data Sets Case Study: Defect Collection and Reporting System for Git Repository
• Data Analysis and Statistical Testing Analyzing the Metric Data Attribute Reduction Methods Hypothesis Testing Statistical Testing Example-Univariate Analysis Results for Fault Prediction System
• Model Development and Interpretation Model Development Statistical Multiple Regression Techniques ML Techniques Concerns in Model Prediction Performance Measures for Categorical Dependent Variable Performance Measures for Continuous Dependent Variable Cross-Validation Model Comparison Tests Interpreting the Results Example-Comparing ML Techniques for Fault Prediction
• Validity Threats Categories of Threats to Validity Example-Threats to Validity in Fault Prediction System Threats and Their Countermeasures
• Reporting Results Reporting and Presenting Results Guidelines for Masters and Doctoral Students Research Ethics and Misconduct
• Mining Unstructured Data Introduction Steps in Text Mining Applications of Text Mining in Software Engineering Example-Automated Severity Assessment of Software Defect Reports
• Demonstrating Empirical Procedures Abstract Introduction Related Work Experimental Design Research Methodology Analysis Results Discussion and Interpretation of Results Validity Evaluation Conclusions and Future Work Appendix
• Tools for Analyzing Data WEKA KEEL SPSS MATLAB R Comparison of Tools
• Appendix
• References
• Index
• Exercises and Further Reading appear at the end of most chapters.
• (source: Nielsen Book Data)

Empirical research has now become an essential component of software engineering yet software practitioners and researchers often lack an understanding of how the empirical procedures and practices are applied in the field. Empirical Research in Software Engineering: Concepts, Analysis, and Applications shows how to implement empirical research pro.
(source: Nielsen Book Data)
Empirical research has now become an essential component of software engineering yet software practitioners and researchers often lack an understanding of how the empirical procedures and practices are applied in the field. Empirical Research in Software Engineering: Concepts, Analysis, and Applications shows how to implement empirical research processes, procedures, and practices in software engineering. Written by a leading researcher in empirical software engineering, the book describes the necessary steps to perform replicated and empirical research. It explains how to plan and design experiments, conduct systematic reviews and case studies, and analyze the results produced by the empirical studies. The book balances empirical research concepts with exercises, examples, and real-life case studies, making it suitable for a course on empirical software engineering. The author discusses the process of developing predictive models, such as defect prediction and change prediction, on data collected from source code repositories. She also covers the application of machine learning techniques in empirical software engineering, includes guidelines for publishing and reporting results, and presents popular software tools for carrying out empirical studies.
(source: Nielsen Book Data)

• Introduction to Software Engineering Introduction Components of a Computer Building the Software Products What Is Software Engineering? Why Software Engineering? Challenges in Software Engineering Project Management and Software Engineering Costs Involved in Software Development Methodologies Used for Software Development Some Careers in Software Engineering Software Industry Size Code of Ethics Book Organization Chapter Summary Recommended Reading Software Engineering Methodologies Introduction Why a Methodology? Agile Methodologies Waterfall Model Rational Unified Process Spiral Model Incremental Iteration Model eXtreme Programming Scrum Methodology for Implementing SaaS Products Methodology for Implementing COTS Products A Discussion on the Usage of Software Development Models Popular Process Standards Process Standards and Software Engineering Methodologies Software Process Activities Chapter Summary Recommended Reading Feasibility Study Introduction Feasibility Study for Software Projects Finding the Economic Feasibility of Requirements Finding the Technical Feasibility of Requirements Prototyping Pilot Projects Chapter Summary Recommended Reading Software Requirement Specifications Introduction Software Engineering Methodologies and Requirement Management Implementation of the Requirements 6 Requirement Types Sources of Requirements Categories of Users Software Requirement Life Cycle Requirement Gathering (Elicitation) Requirement Analysis Requirement Specification Requirement Management Case Study Chapter Summary Recommended Reading Software High-Level Design and Modeling Introduction Methodology Used How to Reduce Complexity in Software Design Logical Design for Software Architecture Architecture Design Patterns Client-Server Architecture Web-Based Architecture Service-Oriented Architecture Software Component Design Fundamentals Component Diagrams Data Flow Diagram Software Design Patterns Programming Language Considerations Types of Programming Languages: A Brief Review Security Performance Case Study Chapter Summary Recommended Reading Software User Interface Design and Construction Introduction Graphical User Interface Graphic Control Elements Hyper Text Markup Language Cascading Style Sheets Client-Side Scripting Asynchronous JavaScript and XML Simple (Model-View) User Interface Model-View-Controller Case Study Chapter Summary Recommended Reading Software Middle Layer Design and Construction Introduction Software Design and Implementation and Software Engineering Methodology Procedural Programming: A Brief Introduction Object-Oriented Programming Basics of Programming Languages Variables and Variable Types Operators Decision Trees and Loops Methods Classes Objects and Object-Oriented Programming Packages Database Programming Model-View-Controller Revisited Refactoring Client-Side and Server-Side Scripts Debugging Case Study Chapter Summary Recommended Reading Database Design and Construction Introduction Databases and Software Engineering Methodologies Database Types Database Languages Database Entities Database Design Database Management Systems Object Relational Databases Case Study Chapter Summary Recommended Reading Software Testing (Verification and Validation) Introduction Software Testing and Software Engineering Methodologies Introduction to Different Types of Software Testing Introduction to Verification and Validation Introduction to Levels of Software Testing (Validation) Verification Unit Testing Integration Testing System Testing User Acceptance Testing Other Important Tests Test Case Design Test Preparation Test Life Cycle Case Study Chapter Summary Recommended Reading Software Release Introduction Software Release and Software Engineering Methodology Integration Documentation Release Cycles User Training Deployment Software Migration Strategies Software Product Release Checklist Chapter Summary Recommended Reading Software Maintenance Introduction Software Maintenance and Software Engineering Methodology Production Environment Maintenance Production Environment Monitoring Maintenance Process Types of Software Maintenance Software Maintenance Strategies Reverse Engineering Chapter Summary Recommended Reading Configuration and Version Management Introduction Configuration Management and Version Control Concepts CVS Systems Chapter Summary Recommended Reading Software Project Management Introduction Project Management and Software Engineering Methodologies Project Planning Project Monitoring and Controlling Project Team Management Project Customer Management Supplier Management Chapter Summary Recommended Reading Appendix: Answers to Questions Index.
• (source: Nielsen Book Data)

The best way to learn software engineering is by understanding its core and peripheral areas. Foundations of Software Engineering provides in-depth coverage of the areas of software engineering that are essential for becoming proficient in the field. The book devotes a complete chapter to each of the core areas. Several peripheral areas are also explained by assigning a separate chapter to each of them. Rather than using UML or other formal notations, the content in this book is explained in easy-to-understand language. Basic programming knowledge using an object-oriented language is helpful to understand the material in this book. The knowledge gained from this book can be readily used in other relevant courses or in real-world software development environments. This textbook educates students in software engineering principles. It covers almost all facets of software engineering, including requirement engineering, system specifications, system modeling, system architecture, system implementation, and system testing. Emphasizing practical issues, such as feasibility studies, this book explains how to add and develop software requirements to evolve software systems. This book was written after receiving feedback from several professors and software engineers. What resulted is a textbook on software engineering that not only covers the theory of software engineering but also presents real-world insights to aid students in proper implementation. Students learn key concepts through carefully explained and illustrated theories, as well as concrete examples and a complete case study using Java. Source code is also available on the book's website. The examples and case studies increase in complexity as the book progresses to help students build a practical understanding of the required theories and applications.
(source: Nielsen Book Data)

• 1. Modeling
• 2. Analysis
• 3. Proof
• 4. Refinement
• 5. Applications