What You Need to Know About Software Engineering Concepts by Richard Fairley (1997)
Software Engineering Concepts by Richard Fairley: A Review
Software engineering is the discipline of applying systematic methods and principles to develop high-quality software systems that meet the needs and expectations of users and stakeholders. Software engineering is important because it enables us to create reliable, efficient, secure, scalable, maintainable, reusable, adaptable, usable, and cost-effective software solutions that solve real-world problems.
Software Engineering Concepts Richard Fairley 1997 Tmhpdf
Richard Fairley is a professor of computer science at Portland State University. He has over 40 years of experience in teaching, researching, consulting, and practicing software engineering. He has authored or co-authored several books and papers on various topics related to software engineering. He has also served as a reviewer, editor, chairperson, or keynote speaker for many conferences and journals in the field.
Software Engineering Concepts is one of his most popular books on software engineering. It was first published in 1985 by McGraw-Hill as part of their series in software engineering and technology. It has been revised and updated several times since then, with the latest edition being published in 1997 by Tata McGraw-Hill. The book covers the fundamental concepts, principles, methods, techniques, tools, and practices of software engineering. It also discusses the current and emerging trends and challenges in the field.
The book is intended for undergraduate and graduate students, as well as practitioners and researchers, who want to learn or improve their knowledge and skills in software engineering. The book is organized into nine chapters, each focusing on a major topic of software engineering. The book also includes numerous examples, exercises, case studies, diagrams, tables, figures, references, and appendices to illustrate and reinforce the concepts presented. The book is written in a clear, concise, and comprehensive manner that makes it easy to read and understand.
The objectives of reading this book are to:
Gain a solid foundation and overview of software engineering concepts.
Understand the software engineering process models and their applications.
Learn the techniques and tools for software requirements analysis.
Apply the principles and methods for software design.
Develop the skills and practices for software implementation.
Ensure and evaluate the quality of software systems.
Manage software projects effectively and efficiently.
Select and use appropriate software engineering tools.
Identify and analyze the trends and challenges in software engineering.
The benefits of reading this book are to:
Enhance your theoretical and practical knowledge of software engineering.
Improve your ability to create high-quality software systems.
Increase your confidence and competence as a software engineer.
Expand your career opportunities and prospects as a software engineer.
Software Engineering Process Models
A process model is a representation of the activities, tasks, roles, artifacts, and relationships involved in developing a software system. A process model provides a framework and a guideline for planning, organizing, executing, monitoring, controlling, and improving the software engineering process. A process model also helps to ensure that the software system meets the requirements, standards, quality criteria, and constraints of the project.
There are different types of process models that can be used for software engineering. Each type has its own characteristics, advantages, disadvantages, suitability, applicability, and variations. Some of the most common types of process models are:
The waterfall model: This is a linear and sequential process model that divides the software engineering process into distinct phases, such as feasibility study, requirements analysis, design, implementation, testing, deployment, and maintenance. Each phase has its own inputs, outputs, activities, deliverables, verification methods, and documentation. The output of one phase serves as the input for the next phase. The waterfall model is simple, easy to understand, easy to manage, and well-defined. However, it is also rigid, inflexible, inadequate for complex or changing requirements, prone to errors or defects in later phases, and slow to deliver results.
The incremental model: This is an iterative and incremental process model that divides the software system into smaller modules or increments that can be developed separately and integrated gradually. Each increment has its own requirements analysis, design, implementation, testing, and deployment phases that follow the waterfall model. The increments are prioritized based on their importance or functionality. The incremental model is flexible, adaptive, responsive, efficient, and fast to deliver results. However, it is also complex, difficult to manage, dependent on proper integration, and requires more resources and coordination.
The spiral model: This is a risk-driven and evolutionary process model that combines the features of the waterfall and incremental models with an emphasis on risk analysis and mitigation. The spiral model consists of four quadrants: planning, risk analysis, engineering, and evaluation. Each quadrant represents a cycle or iteration that produces a prototype or increment of the software system. The cycles are repeated until the final product is achieved or the project is terminated. The spiral model is flexible, adaptive, responsive, efficient, and effective in managing risks. However, it is also complex, difficult to implement, expensive, and requires more expertise and commitment.
The prototyping model: This is an experimental and exploratory process model that focuses on creating and refining prototypes or mock-ups of the software system based on user feedback and evaluation. A prototype is a partial or incomplete version of the software system that demonstrates some of its features or functionality. The prototyping model consists of four phases: communication, quick design, construction of prototype, and deployment or delivery of prototype. The phases are repeated until the final product is achieved or the project is terminated. The prototyping model is useful for validating Software Requirements Analysis
Software requirements are the statements that describe what the software system should do, how it should behave, and what qualities it should have. Software requirements are essential for software engineering because they define the scope, objectives, specifications, constraints, and criteria of the software system. Software requirements also provide the basis for software design, implementation, testing, quality assurance, and project management.
Software requirements analysis is the process of eliciting, analyzing, specifying, validating, and managing software requirements. Software requirements analysis involves the following techniques and tools:
Eliciting requirements: This is the technique of gathering and collecting requirements from various sources, such as users, customers, stakeholders, domain experts, existing systems, documents, standards, regulations, etc. Eliciting requirements can be done using various methods, such as interviews, questionnaires, surveys, observations, workshops, brainstorming sessions, use cases, scenarios, user stories, etc.
Analyzing requirements: This is the technique of clarifying, refining, organizing, prioritizing, and modeling requirements to ensure that they are complete, consistent, correct, feasible, testable, and verifiable. Analyzing requirements can be done using various methods, such as functional decomposition, data flow diagrams, entity-relationship diagrams, state transition diagrams, class diagrams, sequence diagrams, etc.
Specifying requirements: This is the technique of documenting and communicating requirements in a clear, concise, and unambiguous manner that can be understood and agreed upon by all parties involved. Specifying requirements can be done using various formats, such as natural language, structured language, formal language, graphical notation, tabular notation, etc.
Validating requirements: This is the technique of checking and confirming that the requirements meet the needs and expectations of the users and stakeholders and conform to the standards and regulations of the domain. Validating requirements can be done using various methods, such as reviews, inspections, walkthroughs, prototypes, simulations, tests, etc.
Managing requirements: This is the technique of controlling and tracking the changes and evolution of the requirements throughout the software engineering process. Managing requirements can be done using various tools, such as configuration management tools, change management tools, traceability tools, requirements management tools, etc.
Fairley explains and illustrates these techniques and tools in his book with examples and exercises from different domains and applications. He also discusses the challenges and issues related to software requirements analysis and provides guidelines and best practices for conducting it effectively and efficiently.
Software Design
Software design is the process of creating and defining the architecture and structure of the software system that satisfies the software requirements. Software design is important for software engineering because it determines how the software system will be implemented and tested and how it will perform and behave. Software design also affects the quality attributes of the software system such as reliability, efficiency, security, scalability, maintainability, reusability, adaptability, usability, etc.
Software design involves the following principles and methods:
Principles of software design: These are the general rules or guidelines that help to create effective and efficient software designs. Some of the common principles of software design are:
Abstraction: This is the principle of hiding or ignoring irrelevant or unnecessary details and focusing on essential or relevant features.
Modularity: This is the principle of dividing or decomposing a complex system into smaller or simpler modules or components that can be developed separately and integrated easily.
Cohesion: This is the principle of ensuring that each module or component has a single or specific purpose or function and performs it well.
Coupling: This is the principle of minimizing or reducing the dependencies or interactions between modules or components to make them independent and loosely connected.
Hierarchy: This is the principle of organizing or arranging modules or components into different levels or layers based on their abstraction or complexity.
Encapsulation: This is the principle of hiding or protecting the internal details or implementation of a module or component from external access or modification.
Inheritance: This is the principle of reusing or extending the features or functionality of an existing module or component by creating a new module or component that inherits from it.
Polymorphism: This is the principle of allowing or enabling a module or component to have different forms or behaviors based on the context or situation.
Methods of software design: These are the specific techniques or approaches that help to apply the principles of software design and create concrete or detailed software designs. Some of the common methods of software design are:
Structured design: This is a method of software design that uses top-down and bottom-up strategies to decompose and compose the software system into modules or components that are connected by data flow diagrams or structure charts.
Object-oriented design: This is a method of software design that uses objects as the basic units of the software system. An object is a combination of data and behavior that represents a real-world entity or concept. Object-oriented design uses classes as the templates or blueprints for creating objects and relationships such as inheritance and association for connecting objects.
Component-based design: This is a method of software design that uses components as the building blocks of the software system. A component is a self-contained and reusable unit of software that provides a specific service or function. Component-based design uses interfaces as the contracts or specifications for defining and accessing components and frameworks as the platforms or environments for integrating and deploying components.
Service-oriented design: This is a method of software design that uses services as the elements or resources of the software system. A service is a discrete and independent unit of software that performs a specific task or operation and communicates with other services using standard protocols and formats. Service-oriented design uses service-oriented architecture (SOA) as the paradigm or model for designing and developing distributed and interoperable software systems.
Fairley describes and demonstrates these principles and methods in his book with examples and exercises from different domains and applications. He also discusses the challenges and issues related to software design and provides guidelines and best practices for conducting it effectively and efficiently.
Software Implementation
Software implementation is the process of coding, testing, debugging, documenting, and maintaining the software system based on the software design. Software implementation is crucial for software engineering because it transforms the software design into an executable and operational software product that delivers the desired functionality and quality. Software implementation also involves resolving any errors or defects that may occur during or after the development of the software system.
Software implementation involves the following skills and practices:
Coding: This is the skill of writing, editing, compiling, and running source code using programming languages, tools, and environments. Coding requires knowledge of syntax, semantics, logic, algorithms, data structures, libraries, etc. Coding also requires adherence to coding standards, conventions, styles, etc.
Testing: This is the practice of verifying and validating that the software system meets the requirements, specifications, quality criteria, and expectations. Testing involves designing, executing, and evaluating test cases using various testing techniques, tools, levels, types, etc. Testing also involves identifying, reporting, and fixing errors or defects.
Debugging: This is the practice of locating and correcting errors or defects in the source code or executable code using various debugging techniques, tools, strategies, etc. Debugging also involves tracing, monitoring, analyzing, and modifying the behavior or state of the software system.
Documenting: This is the practice of creating and maintaining documents that describe or explain various aspects of the software system such as requirements, design, implementation, testing, deployment, maintenance, etc. Documenting involves using various formats, styles, languages, tools, etc. Documenting also involves updating and revising documents as needed.
Maintaining: This is the practice of modifying and improving the software system after its deployment to cope with changes in requirements, specifications, environment, technology, etc. Maintaining involves performing various activities such as corrective maintenance, adaptive maintenance, perfective maintenance, preventive maintenance, etc. Maintaining also involves managing and controlling changes using various tools such as configuration management tools, change management tools, version control tools, etc.
Fairley discusses and exemplifies these skills and practices in his book with examples and exercises from different domains and applications. He also discusses the challenges and issues related to software implementation and provides guidelines and best practices for conducting it effectively and efficiently.
Software Quality Assurance
Software quality assurance is the process of ensuring and evaluating that the software system meets the quality standards and measures defined for it. Software quality assurance is vital for software engineering because it determines how well the software system performs its intended functions and satisfies its intended users and stakeholders. Software quality assurance also affects the reputation and credibility of the software engineers and organizations involved in developing the software system.
Software Quality Assurance
Software quality assurance is the process of ensuring and evaluating that the software system meets the quality standards and measures defined for it. Software quality assurance is vital for software engineering because it determines how well the software system performs its intended functions and satisfies its intended users and stakeholders. Software quality assurance also affects the reputation and credibility of the software engineers and organizations involved in developing the software system.
Software quality assurance involves the following standards and measures:
Standards of software quality: These are the rules or guidelines that define the expected or desired level or degree of quality for a software system. Standards of software quality can be derived from various sources, such as requirements, specifications, regulations, contracts, agreements, etc. Standards of software quality can also be classified into various categories, such as functional quality, non-functional quality, structural quality, process quality, product quality, etc.
Measures of software quality: These are the methods or techniques that quantify or evaluate the actual or achieved level or degree of quality for a software system. Measures of software quality can be obtained from various sources, such as testing, inspection, review, audit, survey, feedback, etc. Measures of software quality can also be classified into various types, such as direct measures, indirect measures, internal measures, external measures, static measures, dynamic measures, etc.
Fairley introduces and applies these standards and measures in his book with examples and exercises from different domains and applications. He also discusses the challenges and issues related to software quality assurance and provides guidelines and best practices for conducting it effectively and efficiently.
Software Project Management
Software project management is the process of planning, organizing, controlling, monitoring, and reporting the activities and resources involved in developing a software system. Software project management is necessary for software engineering because it enables us to achieve the objectives and deliverables of the software project within the constraints of time, cost, scope, quality, risk, etc. Software project management also helps to coordinate and communicate with the team members and stakeholders involved in the software project.
Software project management involves the following activities and techniques:
Planning: This is the activity of defining and documenting the scope, objectives, deliverables, schedule, budget, resources, risks, and assumptions of the softwa