Docsity
Docsity

Prepare for your exams
Prepare for your exams

Study with the several resources on Docsity


Earn points to download
Earn points to download

Earn points by helping other students or get them with a premium plan


Guidelines and tips
Guidelines and tips

CS2043 cheat sheet allowed for final exam, Study notes of Computer Science

CS2043 cheat sheet allowed for exam.

Typology: Study notes

2021/2022

Uploaded on 06/01/2023

abdel-ghanem
abdel-ghanem 🇨🇦

1 document

1 / 2

Toggle sidebar

This page cannot be seen from the preview

Don't miss anything!

bg1
Slide 1
definition of software engineering and why we need it.
Software engineering is the application of a systematic, disciplined, quantifiable approach to
the development, deployment, operation, and maintenance of high-quality software with
limited resources.
Software engineering practices aim to shift developers from writing programs to building
systems. As the size and complexity of a system grows, and/or as more people become
involved in development, adhering to software engineering practices help us to manage the
effort.
Chaos report’s most costly contributors to project failures are lack of user input, incomplete
or changing requirements, lack of resources.
Code of ethics:
1. Public – Software engineers shall act consistently with the public interest.
2. Client and Employer - Software engineers shall act in a manner that is in the best interests
of their client and employer consistent with the public interest.
3. Product - Software engineers shall ensure that their products and related modifications
meet the highest professional standards possible.
4. JUDGMENT – Software engineers shall maintain integrity and independence in their
professional judgment.
5. MANAGEMENT – Software engineering managers and leaders shall subscribe to and
promote an ethical approach to the management of software development and maintenance.
6. PROFESSION – Software engineers shall advance the integrity and reputation of the
profession consistent with the public interest.
7. COLLEAGUES – Software engineers shall be fair to and supportive of their colleagues.
8. SELF – Software engineers shall participate in lifelong learning regarding the practice of
their profession and shall promote an ethical approach to the practice of the profession.
Slide 2
What Software Engineers should pay attention to today.
Choose and properly use a variety of programming languages & application
frameworks
Choose and adhere to a variety of development methodologies
Work towards engineering high quality software
oProduct quality attends mostly to Verification and Validation, but
also Product-in-use
oProcess quality attends to Productivity, Effort Estimation,
Development Pace Sustainability etc.
Software engineers are able to communicate with management, developers, and
clients
Software engineers focus on requirements as delineated by clients
Software engineers carefully choose technologies to support their management,
development, deployment and maintenance efforts
Software engineers are involved in the deployment, operational training,
evolution and maintenance of the software they develop
Informed Design Effort – with tools like Gantt, Burndown, and PICK
Informed Effort to Ensure Quality – with quality control, Product quality attends mostly to
Verification and Validation, but also Product-in-use. Process quality attends to Productivity,
Effort Estimation, Development Pace Sustainability etc.
Informed Effort to Uphold Ethics and Equity Standards – with diversity, equity and inclusion.
Respect Pyramid: |TOP|Delightful (Human Experience), |MIDDLE| Functional convenient &
reliable (Human Effort), |BOTTOM| Decentralised, private, open, interoperable, accessible,
secure & sustainable (Human Rights).
Slide 3
Follow Coding Conventions, Conventions are standard practices that all developers on a team
agree to follow. Some are common practices, while others can be specific to a team.
Slide 4
Software development life cycle = Requirements > Architecture > Design > Implementation >
Testing > Deployment > Support or Decommission > loop.
Fundamental software engineering activities
Software Specification – The functionality of the software and constraints on its operation
must be defined.
Software Development – The software to meet the specification must be produced.
Software Validation – The software must be validated before to ensure that it does what the
customer wants.
Software Evolution – The software must evolve to meet changing customer needs.
Process Model is a description of what tasks need to be performed, in what sequence, in what
conditions by whom to achieve the “desired results.” This is useful to provide a guidance for
systematic coordination and controlling of the task and the personnel who performs the task.
Waterfall Development Cycle = Requirements > System Analysis & Design > Implementation >
Testing & Verification > Integration & Packaging. > loop (Incremental and Traditional)
Incremental Development Cycle starts with a fully formed vision of the final product and then
its built piece by piece.
Iterative Development Cycle starts with a conceptual vision of the final product, then it gets
more detail the more its built.
Rational Unified Process/Development (RUP) is both iterative and incremental.
Key guiding practices for RUP: Manage requirements > Develop Iteratively > Model Quality >
Use Component Architecture > Control Changes.
Pros of Modern Development Process – RUP
The Iterative approach to the elaboration, construction, and transition phases enables you to
incrementally define the requirements and assemble the application.
The elaboration iterations focus on risks and risk mitigation to improve the project’s chance of
success.
It can accommodate different development models flexibly. For example, can use series of
waterfall and agile in construction phase.
The inception and elaboration phases generate a lot of documentation that can help new
developers join the team later.
It can enable incremental releases if wanted.
Cons of Modern Development Process – RUP
It’s complicated, which requires more resources than simpler approach. Risk Analysis can be
difficult. The complication isn’t always worth the effort, particularly for low-risk projects. It
doesn’t work well with small projects.
Slide 5
Problems with “Traditional” Processes
Focused and oriented towards “large projects” and lengthy development time. (years). –
Started SWE
Inability to cope with changes in requirements and technology fast enough.
Assumes requirements are completely understood at beginning of project.
Starting to rely on non-sustainable heroic and lengthy development effort by the developers –
Hard to maintain constantly high productivity.
Complex set of activities.
Waste or duplication of effort, especially in documentation.
Agile Manifesto
Individuals and interactions over processes and tools
Working software over comprehensive documentation
Customer collaboration over contact negotiation
Responding to change over following a plan.
Agile Principles
Working software is the primary measure of progress.
Agile processes promote sustainable development.
Continuous attention to technical excellence and good design enhance agility.
Simplicity – the art of maximizing the amount of work not done – is essential.
The best architectures, requirements, and designs emerge from self-organizing teams.
At regular intervals, the team reflects on how to become more effective. Then tunes and
adjusts its behaviour accordingly.
Key Practices guiding Agile.
Short releases and iterations > Develop incrementally > involve users > document minimally >
communicate continuously but informally > embrace change.
XP release cycle
Evaluate system > select user stories for this release > break down stories to tasks > plan
release > develop/integrate/test software > release software > loop.
XP Role – Customer, Tracker, programmer, coach, tester, administrator.
XP Core Values - Communication, Simplicity, Feedback, Courage
XP Fundamental Principles – Rapid feedback, Simplicity, Incremental change, Embrace
change, Quality work.
Crystal Family Methodology
Crystal Clear – for “non-critical” projects (6-8 people)
Crystal Orange – for “critical” projects (up to 40 people)
Crystal Orange Web – for web development.
Crystal Clear has one team, working in same room. There are at least four people being
sponsors, senior designer, programmer, and user. Work products are nine items, including
schedule, use cases, design sketches, test cases and user manuals. The maximum release
length is 2 months.
Crystal Orange has different teams for system planning, project monitoring, architecture,
technology, functions, infrastructure, and external testing. Fourteen roles played by different
people, + crystal clear roles + project manager, sponsor, business expert, architect, design
mentor, tester, and UI designer. Thirteen work products + crystal clear + requirements
documents, status reports, UI design documents, and interteam specs. Work Products are
developed until they are understandable, precise, and stable enough for peer review.
Maximum release length is 2-4 months, two user viewings per release.
Scrum - Incremental and iterative development approach. Develops small sprints in short
cycle of 2-3 weeks.
Scrum Process Approach
Vision > Product Backlog > Sprint Backlog > 2-4 week sprint > Daily scrum meeting >
Potentially shippable product increment.
Kanban Core Practices - Make the project status and the workflow visible. Minimize the
overall WIP in the process. Manage the overall workflow via measuring the tasks and items in
development. Make the process explicit and clear. Ensure there is a feedback loop for
properly monitoring and controlling the flow of the project. Ensure and improve collaboration.
Agile Summary – Small teams, requirements gathering, requirements validation, repeated
customer, constant integration and testing, informal review and communication, short
iterations and deferring complicated features.
Main Points of Each Methodology
XP – Requires high discipline and adherence to principles and practices. Based on four core
values (communication, simplicity, feedback, courage). Five fundamental principles (rapid
feedback, Simplicity, Incremental change, Embrace change, quality work, and 12 practices.
(high agility, discipline)
Crystal Clear – Does not require adherence to all principles. Based on 7 principles: frequent
delivery, reflective improvement, close communication, personal safety, focus, easy access to
expert users, and a good technical environment. Will only work for small team projects. (high
agility, low discipline)
Crystal Orange – Suitable for larger projects. It has different teams for different functions. Not
suitable for large or life-critical projects. (Medium agility, discipline)
Scrum – most popular agile process. A disciplined methodology that can be adapted and
combined with other techniques. It provides clear visibility to the project status and, in the
long run, reduces the effort spent on project management. (High agility, discipline)
RUP – Framework, instantiated as a very heavy process. Can be pared down to a relatively
agile process. (Low to Medium agility, high discipline)
Kanban – Minimize work in progress. Use visual cards for each task. Pull activities forward
when needed by focusing resources on them. (high agility, low discipline)
Slide 6
Requirements – the statements that describe what the software system should be but not
how it is to be constructed.
Requirements engineering – A set of activities related to the development and agreement of
the final set of requirement specifications.
Requirement activities – Elicitation, Documentation and Definitions, Prototyping, Analysis &
Organization, Specification, Review and Validation, Negotiation and Acceptance.
Analysis requirements – Checking for consistency (there are no contradictions), Checking for
Completeness (there are no ambiguities)
Slide 7
pf2

Partial preview of the text

Download CS2043 cheat sheet allowed for final exam and more Study notes Computer Science in PDF only on Docsity!

Slide 1 definition of software engineering and why we need it. Software engineering is the application of a systematic, disciplined, quantifiable approach to the development, deployment, operation, and maintenance of high-quality software with limited resources. Software engineering practices aim to shift developers from writing programs to building systems. As the size and complexity of a system grows, and/or as more people become involved in development, adhering to software engineering practices help us to manage the effort. Chaos report’s most costly contributors to project failures are lack of user input, incomplete or changing requirements, lack of resources. Code of ethics:

  1. Public – Software engineers shall act consistently with the public interest.
  2. Client and Employer - Software engineers shall act in a manner that is in the best interests of their client and employer consistent with the public interest.
  3. Product - Software engineers shall ensure that their products and related modifications meet the highest professional standards possible.
  4. JUDGMENT – Software engineers shall maintain integrity and independence in their professional judgment.
  5. MANAGEMENT – Software engineering managers and leaders shall subscribe to and promote an ethical approach to the management of software development and maintenance.
  6. PROFESSION – Software engineers shall advance the integrity and reputation of the profession consistent with the public interest.
  7. COLLEAGUES – Software engineers shall be fair to and supportive of their colleagues.
  8. SELF – Software engineers shall participate in lifelong learning regarding the practice of their profession and shall promote an ethical approach to the practice of the profession. Slide 2 What Software Engineers should pay attention to today.  Choose and properly use a variety of programming languages & application frameworks  Choose and adhere to a variety of development methodologies  Work towards engineering high quality software o Product quality attends mostly to Verification and Validation, but also Product-in-use o Process quality attends to Productivity, Effort Estimation, Development Pace Sustainability etc.  Software engineers are able to communicate with management, developers, and clients  Software engineers focus on requirements as delineated by clients  Software engineers carefully choose technologies to support their management, development, deployment and maintenance efforts  Software engineers are involved in the deployment, operational training, evolution and maintenance of the software they develop Informed Design Effort – with tools like Gantt, Burndown, and PICK Informed Effort to Ensure Quality – with quality control, Product quality attends mostly to Verification and Validation, but also Product-in-use. Process quality attends to Productivity, Effort Estimation, Development Pace Sustainability etc. Informed Effort to Uphold Ethics and Equity Standards – with diversity, equity and inclusion. Respect Pyramid: |TOP|Delightful (Human Experience), |MIDDLE| Functional convenient & reliable (Human Effort), |BOTTOM| Decentralised, private, open, interoperable, accessible, secure & sustainable (Human Rights). Slide 3 Follow Coding Conventions , Conventions are standard practices that all developers on a team agree to follow. Some are common practices, while others can be specific to a team. Slide 4 Software development life cycle = Requirements > Architecture > Design > Implementation > Testing > Deployment > Support or Decommission > loop. Fundamental software engineering activities Software Specification – The functionality of the software and constraints on its operation must be defined. Software Development – The software to meet the specification must be produced. Software Validation – The software must be validated before to ensure that it does what the customer wants. Software Evolution – The software must evolve to meet changing customer needs. Process Model is a description of what tasks need to be performed, in what sequence, in what conditions by whom to achieve the “desired results.” This is useful to provide a guidance for systematic coordination and controlling of the task and the personnel who performs the task. Waterfall Development Cycle = Requirements > System Analysis & Design > Implementation > Testing & Verification > Integration & Packaging. > loop (Incremental and Traditional) Incremental Development Cycle starts with a fully formed vision of the final product and then its built piece by piece. Iterative Development Cycle starts with a conceptual vision of the final product, then it gets more detail the more its built. Rational Unified Process/Development (RUP) is both iterative and incremental. Key guiding practices for RUP : Manage requirements > Develop Iteratively > Model Quality > Use Component Architecture > Control Changes. Pros of Modern Development Process – RUP The Iterative approach to the elaboration, construction, and transition phases enables you to incrementally define the requirements and assemble the application. The elaboration iterations focus on risks and risk mitigation to improve the project’s chance of success. It can accommodate different development models flexibly. For example, can use series of waterfall and agile in construction phase. The inception and elaboration phases generate a lot of documentation that can help new developers join the team later. It can enable incremental releases if wanted. Cons of Modern Development Process – RUP It’s complicated, which requires more resources than simpler approach. Risk Analysis can be difficult. The complication isn’t always worth the effort, particularly for low-risk projects. It doesn’t work well with small projects. Slide 5 Problems with “Traditional” Processes Focused and oriented towards “large projects” and lengthy development time. (years). – Started SWE Inability to cope with changes in requirements and technology fast enough. Assumes requirements are completely understood at beginning of project. Starting to rely on non-sustainable heroic and lengthy development effort by the developers – Hard to maintain constantly high productivity. Complex set of activities. Waste or duplication of effort, especially in documentation. Agile Manifesto Individuals and interactions over processes and tools Working software over comprehensive documentation Customer collaboration over contact negotiation Responding to change over following a plan. Agile Principles Working software is the primary measure of progress. Agile processes promote sustainable development. Continuous attention to technical excellence and good design enhance agility. Simplicity – the art of maximizing the amount of work not done – is essential. The best architectures, requirements, and designs emerge from self-organizing teams. At regular intervals, the team reflects on how to become more effective. Then tunes and adjusts its behaviour accordingly. Key Practices guiding Agile. Short releases and iterations > Develop incrementally > involve users > document minimally > communicate continuously but informally > embrace change. XP release cycle Evaluate system > select user stories for this release > break down stories to tasks > plan release > develop/integrate/test software > release software > loop. XP Role – Customer, Tracker, programmer, coach, tester, administrator. XP Core Values - Communication, Simplicity, Feedback, Courage XP Fundamental Principles – Rapid feedback, Simplicity, Incremental change, Embrace change, Quality work. Crystal Family Methodology Crystal Clear – for “non-critical” projects (6-8 people) Crystal Orange – for “critical” projects (up to 40 people) Crystal Orange Web – for web development. Crystal Clear has one team , working in same room. There are at least four people being sponsors, senior designer, programmer, and user. Work products are nine items, including schedule, use cases, design sketches, test cases and user manuals. The maximum release length is 2 months. Crystal Orange has different teams for system planning, project monitoring, architecture, technology, functions, infrastructure, and external testing. Fourteen roles played by different people, + crystal clear roles + project manager, sponsor, business expert, architect, design mentor, tester, and UI designer. Thirteen work products + crystal clear + requirements documents, status reports, UI design documents, and interteam specs. Work Products are developed until they are understandable, precise, and stable enough for peer review. Maximum release length is 2-4 months, two user viewings per release. Scrum - Incremental and iterative development approach. Develops small sprints in short cycle of 2-3 weeks. Scrum Process Approach Vision > Product Backlog > Sprint Backlog > 2-4 week sprint > Daily scrum meeting > Potentially shippable product increment. Kanban Core Practices - Make the project status and the workflow visible. Minimize the overall WIP in the process. Manage the overall workflow via measuring the tasks and items in development. Make the process explicit and clear. Ensure there is a feedback loop for properly monitoring and controlling the flow of the project. Ensure and improve collaboration. Agile Summary – Small teams, requirements gathering, requirements validation, repeated customer, constant integration and testing, informal review and communication, short iterations and deferring complicated features. Main Points of Each Methodology XP – Requires high discipline and adherence to principles and practices. Based on four core values (communication, simplicity, feedback, courage). Five fundamental principles (rapid feedback, Simplicity, Incremental change, Embrace change, quality work, and 12 practices. (high agility, discipline) Crystal Clear – Does not require adherence to all principles. Based on 7 principles: frequent delivery, reflective improvement, close communication, personal safety, focus, easy access to expert users, and a good technical environment. Will only work for small team projects. (high agility, low discipline) Crystal Orange – Suitable for larger projects. It has different teams for different functions. Not suitable for large or life-critical projects. (Medium agility, discipline) Scrum – most popular agile process. A disciplined methodology that can be adapted and combined with other techniques. It provides clear visibility to the project status and, in the long run, reduces the effort spent on project management. (High agility, discipline) RUP – Framework, instantiated as a very heavy process. Can be pared down to a relatively agile process. (Low to Medium agility, high discipline) Kanban – Minimize work in progress. Use visual cards for each task. Pull activities forward when needed by focusing resources on them. (high agility, low discipline) Slide 6 Requirements – the statements that describe what the software system should be but not how it is to be constructed. Requirements engineering – A set of activities related to the development and agreement of the final set of requirement specifications. Requirement activities – Elicitation, Documentation and Definitions, Prototyping, Analysis & Organization, Specification, Review and Validation, Negotiation and Acceptance. Analysis requirements – Checking for consistency (there are no contradictions), Checking for Completeness (there are no ambiguities) Slide 7

Software Design starts mostly from/with requirements, the two main levels of design are: Architectural and Detailed design. Detailed design comes from requirements and architecture. Software Architecture Structure of the solution compromise of:

  1. Major software elements,
  2. Their externally visible properties,
  3. Relationships among elements. Depending on the perspective there might be multiple structures, and every software system has an architecture. External properties of components (and modules) are component (module) interface and interactions. System architecture has architectural views and viewpoints. They are: Logical (Object- oriented decomposition), Process (Runtime), Subsystem decomposition, Physical architecture (and use cases). **Architecutral Styles/Patters
  4. Pipe-Filter Architectural style** is decomposed into two generic parts Filter – service that transforms a stream of input data into a stream of output data Pipe – mechanism or conduit through which the data flows from one filter to another 2. Event-Driven (Real-Time) – based on an event dispatcher , which manages events and the functionalities which depends on those events. Events may be: simple notification or include associate data, prioritized or be based on constraints such as time, require (a)synchrounous processing, “(un)registered” by components. 3. Client-Server Style – client may connect to more than 1 server. 4. Model-View-Controller (MVC) – Separates model (data) from view (often controller). (web) 5. Layered Style – The “outer” layer can only ask for service from the “inner” layer or “upper” layer can only ask for service from “lower” layer.  Strict layering – only directly inside or below layers  Relaxed layering - any inside or below layers 6. Shared Data (DB) Centric Style – the clients communicate directly with the database. Popular within the business application community 7. Three-tier Style (Mixture) – Clients do not access DB directly, better flexibility, integrity 8. Service-Oriented Architecture (SOA) style – Independent services, accessed through network. May have Enterprise service bus. Enterprise service bus - tool that implements a multidirectional communication system between software components in a SOA. With the components talking to the ESB instead of directly to each other, the components can be more loosely coupled. 9. Microservices – Smaller services (5 to 10 person team), service mesh instead of ESB. SOA vs Microservices Key difference comes from functionality. Services is the main component of both. There are 4 basic types of services: Functional, Enterprise, Application, Infrastructure. Evolution of software architecture: monolithic->service-oriented->microservices Architecture Tactics Tactics are for solving smaller “smaller, specific” problems HeartBeat and Ping/Echo are different architectural tactics which can be used to detect faults in multi-component systems Good structural design is easy to: communicate and develop, maintain and extend, reuse, understand, change, test, integrate, code Slide 8 Coupling is the measure of the degree of interdependence between modules. In other words, how much one class knows about another class. Best to worst types of coupling: data > control > external > common > content. Cohesion is the degree to which all elements directed towards performing a single task. More Focused/High cohesiveness is easier to maintain, well-focused purpose, more reusable. High to low ways of cohesion: Function > Sequential > Communicational > Procedural > Temporal > Logical > Coincidential. Coupling vs Cohesion: loose coupling, high cohesion | tight coupling, low cohesion  Concept of inter module vs concept of intra module  Relationships between modules vs relationships within module  Increasing in coupling is avoided vs increasing in cohesion is good for software  Independence among modules vs functional strength of modules  Low coupling is good for software vs high cohesion is good for software  Modules are connected to each other vs Module focuses on the single thing User Interface Design – Two main issues: flow of interactions, look and feel. Types of interface : cmd, text, GUI. Low-fidelity prototype is a simple mock-up sketch of the target product, High-fidelity prototype is a detailed mock-up resembling and behaving close to the final product. The GOMS ModelGoals of the user, Operations provided by the system, Methods or the sequence of operations, Selection rules. Other UI issues – kinds of users, Heuristics, UI guidelines, multicultural issues, metaphors, multiplatform software, accessibility, multimedia interfaces. Slide 9 Implementation is transforming a detailed design into valid program. Good implementations: readability, maintainability, performance, traceability, correctness, completeness. Coding Guidelines are organization specific, important for consistency, programmers get used to them easily and are usually mandated (indenting, formatting, naming conventions, languages to use/avoid). Ground Rules:LOLS : Law of Least Surprises  DRY : Don’t Repeat Yourself o Lowers Line of Code count o Less lines = clean, simple, maintainable code o 200 lines per class o Code Smell: terminology that indicates that the code source has a deeper underlying problem o Code Refactoring: changing code without changing behaviour o Refactoring: putting duplicated code in a function  KISS : Keep it Super Simple o Untangles complex code, making it easier to read o Common Kiss Code Smell: “what’s going on”, “I can’t follow this code” o Refactoring: try other alternative code SOLID Principles:  Single Responsibility Principle : A class should have only 1 reason to change  Open-closed Principle : Classes should be open to extension but closed to change  Liskov Substitution Principle : Derived must be completely substitutable for their Base Classes  Interface Segregation Principle : Clients should not be forced to depend on interfaces they don’t use  Dependence Inversion Principle : o High Level Classes should not depend on low-level classes – Both should depend on abstractions o Abstractions should not depend on details. Details should depend on abstractions Comments Types : repeat of the code, explanation of the code, marker in the code, summary of the code, description of code’s intent, external references. Debugging is locating and fixing errors in code, noticed by testing, inspection, and use. There are four phases: Stabilization (reproduction), Localization, Correction, Verification. Virtualization and Containers  Server load varies overtime  May need bigger server to support max load  If you can run different isolated applications on the same server, you can balance load.  Virtualization allows you to isolate applications on the same physical server.  Containers provide lightweight virtualization Clouds are pay per use (not per capacity), other people’s servers that can quickly scale up or down to zero. It can provide : infrastucturea as a service, platform as a service, cloud application services, cloud services for devs. It’s advantages are: flexibility, scalability and less sysadmin labor. It’s disadvantages are: Less control, legal issues, and cost. Slide 10 DevOps: Plan > Branch > Code > Merge > Build > Release > Deploy > Operate > Monitor > Plan.  Quality Assurance (QA): activities designed to measure and improve quality in a product and process.  Quality Control (QC): activies designed to validate and verify the quality of the product through detecting faults and “fixing” the defects. Verification : Checking the software conforms to its requirements. Validation : Checking software meets user requirements ( fit to use ) Error detecting techniques : testing, inspection and review, formal methods, static analysis  Error : a mistake made by a programmer or software engineer that caused the fault, which in turn may cause a failure.  Fault (defect, bug) : condition that may cause a failure in the system.  Failure (problem) : inability of system to perform a function according to its spec due to some fault  Fault or failure/problem severity is based on consequences  Fault or failure/problem priority is based on importance of developing a fix, based on severity Testing is activity performed for evaluating product quality and improving products by identifying defects and having them fixed prior to software release.  Who tests: programmers, tester/req analyst, users  What is tested: unit code, functional code, UI.  Why test: acceptance, conformance, config, performance/stress/security  How designed: Intuition, specification based (black box, boundaries test), code based (white box, path test), existing cases (regression). Stop testing when all planned tests are executed or when all found problems are fixed. Other techniques are stopping when you can’t find any errors or defect seeding. Not when out of time. Defect Seeding : Generate and scatter with “x” number of bugs and don’t tell testers. Set a % (eg 95%) of seed bugs found as stopping criteria. Suppose “y” number of “x” seed bugs are found. If (y/x) > stopping %, stop testing. If (y/x) <= stopping %, keep testing. Review : any process involving human testers reading and understanding a document and then analyzing it with the purpose of detecting errors. Walkthrough : author explaining document to team of people Software Inspection : detailed reviews of work in progress, following Fagan’s method. Inspections vs testing Inspection is partially cost-effective, can be applied to intermediate artifacts , catches defects early , helps disseminate knowledge about project and best practices. Testing finds errors cheaper, but correcting them is expensive, can only be applied to code , catches defects late (after implementation) , necessary gauge quality. UML
  • public, - private, ~ void, # protected