The document discusses various object-oriented methodologies including Rumbaugh, Booch, and Jacobson methodologies. It provides details on Rumbaugh's Object Modeling Technique (OMT) which separates modeling into object, dynamic, and functional models. It describes Booch's methodology which uses class, object, state transition, and other diagrams. It also discusses Jacobson's methodologies including Object-Oriented Software Engineering (OOSE) which is use case driven, and Object-Oriented Business Engineering (OOBE) which uses use cases. The document then covers topics on software quality assurance including types of errors, testing strategies like black box and white box testing, and testing approaches like top-down
The document discusses Unit II of a syllabus which covers class diagrams, including elaboration, domain modeling, finding conceptual classes and relationships. It discusses when to use class diagrams and provides examples of a class diagram for a hotel management system. It also discusses inception and elaboration phases in software development processes and provides artifacts used in elaboration. Finally, it discusses domain modeling including how to identify conceptual classes, draw associations, and avoid adding too many associations.
This document discusses techniques for refining domain models, including:
- Adding association classes to model relationships between concepts
- Modeling whole-part relationships using aggregation
- Representing time intervals to capture historical and planned attribute values
- Organizing domain model elements using packages and showing dependencies between packages
The COCOMO model is a widely used software cost estimation model that predicts development effort and schedule based on project attributes. It includes basic, intermediate, and detailed models of increasing complexity. The intermediate model estimates effort as a function of source lines of code and cost drivers. The detailed model further incorporates the impact of cost drivers on development phases. COCOMO 2 expands on this with application composition, early design, reuse, and post-architecture models for different project stages.
UML (Unified Modeling Language) is a standardized modeling language used in software engineering to visualize the design of a system. There are two main types of UML diagrams: structural diagrams that depict the static elements of a system, and behavioral diagrams that show the dynamic interactions between structural elements over time. Behavioral diagrams include sequence diagrams, activity diagrams, and state machine diagrams. Sequence diagrams specifically depict the sequential order of interactions between objects in a system through message passing and lifelines.
This document provides an overview of domain modeling concepts including:
- A domain model illustrates meaningful conceptual classes in a problem domain and is not focused on software components.
- Key elements of a domain model include conceptual classes, associations between classes, and attributes of classes.
- Identifying conceptual classes involves techniques like analyzing common nouns and noun phrases.
- Associations represent meaningful relationships between conceptual classes and should be identified based on information needs.
- Attributes specify logical data values of conceptual classes and should be kept simple.
- The document uses examples to demonstrate domain modeling techniques.
This document discusses classes and objects in object-oriented analysis and design. It defines objects as having state, behavior, and identity, with similar objects defined by common classes. Classes represent groups of objects with similar behavior and structures. The relationships between classes and objects are explored, including generalization, aggregation, and association. Identification of classes and objects in analysis is discussed through various approaches like use case analysis and CRC cards. The importance of proper classification and key abstractions and mechanisms are also covered.
This document discusses different approaches to identifying classes and objects in object-oriented analysis, including:
1. Classical categorization, conceptual clustering, and prototype theory which group entities based on common properties.
2. Behavior analysis which identifies objects based on their behaviors and responsibilities.
3. Use case analysis which identifies participant objects and responsibilities by analyzing system usage scenarios.
4. CRC cards which record each class's responsibilities and collaborations to represent system interactions.
The document discusses Unit II of a syllabus which covers class diagrams, including elaboration, domain modeling, finding conceptual classes and relationships. It discusses when to use class diagrams and provides examples of a class diagram for a hotel management system. It also discusses inception and elaboration phases in software development processes and provides artifacts used in elaboration. Finally, it discusses domain modeling including how to identify conceptual classes, draw associations, and avoid adding too many associations.
This document discusses techniques for refining domain models, including:
- Adding association classes to model relationships between concepts
- Modeling whole-part relationships using aggregation
- Representing time intervals to capture historical and planned attribute values
- Organizing domain model elements using packages and showing dependencies between packages
The COCOMO model is a widely used software cost estimation model that predicts development effort and schedule based on project attributes. It includes basic, intermediate, and detailed models of increasing complexity. The intermediate model estimates effort as a function of source lines of code and cost drivers. The detailed model further incorporates the impact of cost drivers on development phases. COCOMO 2 expands on this with application composition, early design, reuse, and post-architecture models for different project stages.
UML (Unified Modeling Language) is a standardized modeling language used in software engineering to visualize the design of a system. There are two main types of UML diagrams: structural diagrams that depict the static elements of a system, and behavioral diagrams that show the dynamic interactions between structural elements over time. Behavioral diagrams include sequence diagrams, activity diagrams, and state machine diagrams. Sequence diagrams specifically depict the sequential order of interactions between objects in a system through message passing and lifelines.
This document provides an overview of domain modeling concepts including:
- A domain model illustrates meaningful conceptual classes in a problem domain and is not focused on software components.
- Key elements of a domain model include conceptual classes, associations between classes, and attributes of classes.
- Identifying conceptual classes involves techniques like analyzing common nouns and noun phrases.
- Associations represent meaningful relationships between conceptual classes and should be identified based on information needs.
- Attributes specify logical data values of conceptual classes and should be kept simple.
- The document uses examples to demonstrate domain modeling techniques.
This document discusses classes and objects in object-oriented analysis and design. It defines objects as having state, behavior, and identity, with similar objects defined by common classes. Classes represent groups of objects with similar behavior and structures. The relationships between classes and objects are explored, including generalization, aggregation, and association. Identification of classes and objects in analysis is discussed through various approaches like use case analysis and CRC cards. The importance of proper classification and key abstractions and mechanisms are also covered.
This document discusses different approaches to identifying classes and objects in object-oriented analysis, including:
1. Classical categorization, conceptual clustering, and prototype theory which group entities based on common properties.
2. Behavior analysis which identifies objects based on their behaviors and responsibilities.
3. Use case analysis which identifies participant objects and responsibilities by analyzing system usage scenarios.
4. CRC cards which record each class's responsibilities and collaborations to represent system interactions.
Evolutionary process models allow developers to iteratively create increasingly complete versions of software. Examples include the prototyping paradigm, spiral model, and concurrent development model. The prototyping paradigm uses prototypes to elicit requirements from customers. The spiral model couples iterative prototyping with controlled development, dividing the project into framework activities. The concurrent development model concurrently develops components with defined interfaces to enable integration. These evolutionary models allow flexibility and accommodate changes but require strong communication and updated requirements.
The document provides an overview of software cost estimation, outlining various methods used including algorithmic models like COCOMO, expert judgement, top-down and bottom-up approaches, and estimation by analogy. It discusses COCOMO in detail, including the original COCOMO 81 model and updated COCOMO II model, and emphasizes the importance of calibration for accurate estimates.
UML (Unified Modeling Language) is a standard modeling language used to specify, visualize, and document software systems. It uses graphical notations to model structural and behavioral aspects of a system. Common UML diagram types include use case diagrams, class diagrams, sequence diagrams, and state diagrams. Use case diagrams model user interactions, class diagrams show system entities and relationships, sequence diagrams visualize object interactions over time, and state diagrams depict object states and transitions. UML aims to simplify the complex process of software design through standardized modeling.
The data design action translates data objects into data structures at the software component level.
Data Design is the first and most important design activity. Here the main issue is to select the appropriate data structure i.e. the data design focuses on the definition of data structures.
Data design is a process of gradual refinement, from the coarse "What data does your application require?" to the precise data structures and processes that provide it. With a good data design, your application's data access is fast, easily maintained, and can gracefully accept future data enhancements.
The document discusses context models and their use in system modeling. Context models illustrate the operational context of a system by showing what lies outside its boundaries, including other systems in the environment. They help define a system's boundaries and show how IT applications fit into the context of people and organizations. Two examples are provided: (1) a Mental Health Care Patient Management System (MHC-PMS) and its connections to other clinical systems; (2) an Automated Teller Machine (ATM) and its links to banking systems. Context models on their own do not show relationships between external systems, so additional models are needed.
GIve differences in 4 unique and basic terms of UML, classification , definitions ,frameworks. understandable through diagrams. Some similarities / Trade-off are also for more detailed knowledge.
The document discusses collaboration diagrams, which capture the dynamic behavior of objects collaborating to perform tasks. Collaboration diagrams illustrate object interactions through messages in a graph format. They show objects, links between objects, and messages to model control flow and coordination. Notations are used to represent classes, instances, links, messages, return values, self-messages, conditional messages, iteration, and collections of objects. Examples of converting sequence diagrams to collaboration diagrams for making a phone call, changing flight itineraries, and making a hotel reservation are provided.
Database recovery techniques restore the database to its most recent consistent state before a failure. There are three states: pre-failure consistency, failure occurrence, and post-recovery consistency. Recovery approaches include steal/no-steal and force/no-force, while update strategies are deferred or immediate. Shadow paging maintains current and shadow tables to recover pre-transaction states. The ARIES algorithm analyzes dirty pages, redoes committed transactions, and undoes uncommitted ones. Disk crash recovery uses log/database separation or backups.
This document discusses different approaches to requirements modeling including scenario-based modeling using use cases and activity diagrams, data modeling using entity-relationship diagrams, and class-based modeling using class-responsibility-collaborator diagrams. Requirements modeling depicts requirements using text and diagrams to help validate requirements from different perspectives and uncover errors, inconsistencies, and omissions. The models focus on what the system needs to do at a high level rather than implementation details.
This document discusses two common models for distributed computing communication: message passing and remote procedure calls (RPC). It describes the basic primitives and design issues for each model. For message passing, it covers synchronous vs asynchronous and blocking vs non-blocking primitives. For RPC, it explains the client-server model and how stubs are used to convert parameters and return results between machines. It also discusses binding, parameter passing techniques, and ensuring error handling and execution semantics.
This document provides an overview of design patterns, including their definition, origins, properties, types, and examples. It discusses common design patterns like Singleton, Observer, Strategy, Adapter, Facade, and Proxy. For each pattern, it describes the context, problem, forces, solution, and examples. The document also covers challenges of applying patterns and developing new patterns.
The document discusses requirements analysis and analysis modeling principles for software engineering. It covers key topics such as:
1. Requirements analysis specifies a software's operational characteristics and interface with other systems to establish constraints. Analysis modeling focuses on what the software needs to do, not how it will be implemented.
2. Analysis modeling principles include representing the information domain, defining functions, modeling behavior, partitioning complex problems, and moving from essential information to implementation details.
3. Common analysis techniques involve use case diagrams, class diagrams, state diagrams, data flow diagrams, and data modeling to define attributes, relationships, cardinality and modality between data objects.
This document discusses active database management systems. It defines active databases as database systems that can automatically respond to events inside or outside the system through the use of event-condition-action rules. These rules allow the database to monitor and react to specific events. The document outlines the key components of an active database architecture, including a knowledge model and execution model. It also discusses features, applications, strengths and weaknesses of active databases.
UML (Unified Modeling Language) is a standard language for specifying, visualizing, and documenting software systems. It uses various diagrams to model different views of a system, such as structural diagrams (e.g. class diagrams), behavioral diagrams (e.g. sequence diagrams), and deployment diagrams. The key building blocks of UML include things (classes, interfaces, use cases), relationships (associations, generalizations), and diagrams. UML aims to provide a clear blueprint of software systems for both technical and non-technical audiences.
This document provides an introduction to the Unified Modeling Language (UML). It defines UML as a standard modeling language used to visualize, specify, construct and document software systems. The document outlines the basics of UML including common diagram types like use case diagrams, class diagrams and sequence diagrams. It also discusses modeling tools that support working with UML diagrams.
This document discusses domain state modeling. It explains that some domain objects pass through distinct states, each with different properties and constraints. A domain state model identifies classes with states, finds the states and events that cause transitions, builds state diagrams, and evaluates the diagrams. The document provides steps for domain state modeling and examples using an ATM machine to illustrate states like account types and events like incorrect PIN. It emphasizes iteratively refining the analysis model to improve consistency and structure.
Distributed shared memory (DSM) provides processes with a shared address space across distributed memory systems. DSM exists only virtually through primitives like read and write operations. It gives the illusion of physically shared memory while allowing loosely coupled distributed systems to share memory. DSM refers to applying this shared memory paradigm using distributed memory systems connected by a communication network. Each node has CPUs, memory, and blocks of shared memory can be cached locally but migrated on demand between nodes to maintain consistency.
The document discusses different types of video display devices, focusing on cathode ray tubes (CRTs). It describes how CRTs work using an electron gun, deflection plates, and phosphor-coated screen to produce images. Color CRT monitors are also covered, explaining how they produce color using either beam penetration or shadow mask methods. Other display types mentioned include direct view storage tubes, flat panel displays, and their key differences from CRTs.
Unit 3(advanced state modeling & interaction meodelling)Manoj Reddy
The document provides an overview of advanced state modeling and interaction modeling techniques in UML. It discusses nested state diagrams and concurrent state diagrams for controlling complexity in state diagrams. It also covers activity models, use case models, and sequence models for interaction modeling. The relationships between class models, state models, and interaction models are also briefly described.
This document discusses distributed database and distributed query processing. It covers topics like distributed database, query processing, distributed query processing methodology including query decomposition, data localization, and global query optimization. Query decomposition involves normalizing, analyzing, eliminating redundancy, and rewriting queries. Data localization applies data distribution to algebraic operations to determine involved fragments. Global query optimization finds the best global schedule to minimize costs and uses techniques like join ordering and semi joins. Local query optimization applies centralized optimization techniques to the best global execution schedule.
The document discusses object oriented methodologies and software quality assurance. It provides an overview of object oriented analysis and design, including object oriented methodologies like Rumbaugh's Object Modeling Technique (OMT), the Booch methodology, and Jacobson's methodologies. It also discusses software quality assurance activities and processes, object oriented metrics, quality costs, and formal technical reviews. The key aspects covered are modeling techniques in OMT, phases of development in various methodologies, and ensuring quality through activities like reviews, audits, and metrics.
CS8592 Object Oriented Analysis & Design - UNIT V pkaviya
This document discusses object-oriented methodologies for software development. It describes the Rumbaugh, Booch, and Jacobson methodologies which were influential in the development of the Unified Modeling Language. The Rumbaugh Object Modeling Technique focuses on object models, dynamic models, and functional models. The Booch methodology emphasizes class diagrams, state diagrams, and other modeling tools. Jacobson's methodologies like Objectory emphasize use case modeling and traceability between phases.
Evolutionary process models allow developers to iteratively create increasingly complete versions of software. Examples include the prototyping paradigm, spiral model, and concurrent development model. The prototyping paradigm uses prototypes to elicit requirements from customers. The spiral model couples iterative prototyping with controlled development, dividing the project into framework activities. The concurrent development model concurrently develops components with defined interfaces to enable integration. These evolutionary models allow flexibility and accommodate changes but require strong communication and updated requirements.
The document provides an overview of software cost estimation, outlining various methods used including algorithmic models like COCOMO, expert judgement, top-down and bottom-up approaches, and estimation by analogy. It discusses COCOMO in detail, including the original COCOMO 81 model and updated COCOMO II model, and emphasizes the importance of calibration for accurate estimates.
UML (Unified Modeling Language) is a standard modeling language used to specify, visualize, and document software systems. It uses graphical notations to model structural and behavioral aspects of a system. Common UML diagram types include use case diagrams, class diagrams, sequence diagrams, and state diagrams. Use case diagrams model user interactions, class diagrams show system entities and relationships, sequence diagrams visualize object interactions over time, and state diagrams depict object states and transitions. UML aims to simplify the complex process of software design through standardized modeling.
The data design action translates data objects into data structures at the software component level.
Data Design is the first and most important design activity. Here the main issue is to select the appropriate data structure i.e. the data design focuses on the definition of data structures.
Data design is a process of gradual refinement, from the coarse "What data does your application require?" to the precise data structures and processes that provide it. With a good data design, your application's data access is fast, easily maintained, and can gracefully accept future data enhancements.
The document discusses context models and their use in system modeling. Context models illustrate the operational context of a system by showing what lies outside its boundaries, including other systems in the environment. They help define a system's boundaries and show how IT applications fit into the context of people and organizations. Two examples are provided: (1) a Mental Health Care Patient Management System (MHC-PMS) and its connections to other clinical systems; (2) an Automated Teller Machine (ATM) and its links to banking systems. Context models on their own do not show relationships between external systems, so additional models are needed.
GIve differences in 4 unique and basic terms of UML, classification , definitions ,frameworks. understandable through diagrams. Some similarities / Trade-off are also for more detailed knowledge.
The document discusses collaboration diagrams, which capture the dynamic behavior of objects collaborating to perform tasks. Collaboration diagrams illustrate object interactions through messages in a graph format. They show objects, links between objects, and messages to model control flow and coordination. Notations are used to represent classes, instances, links, messages, return values, self-messages, conditional messages, iteration, and collections of objects. Examples of converting sequence diagrams to collaboration diagrams for making a phone call, changing flight itineraries, and making a hotel reservation are provided.
Database recovery techniques restore the database to its most recent consistent state before a failure. There are three states: pre-failure consistency, failure occurrence, and post-recovery consistency. Recovery approaches include steal/no-steal and force/no-force, while update strategies are deferred or immediate. Shadow paging maintains current and shadow tables to recover pre-transaction states. The ARIES algorithm analyzes dirty pages, redoes committed transactions, and undoes uncommitted ones. Disk crash recovery uses log/database separation or backups.
This document discusses different approaches to requirements modeling including scenario-based modeling using use cases and activity diagrams, data modeling using entity-relationship diagrams, and class-based modeling using class-responsibility-collaborator diagrams. Requirements modeling depicts requirements using text and diagrams to help validate requirements from different perspectives and uncover errors, inconsistencies, and omissions. The models focus on what the system needs to do at a high level rather than implementation details.
This document discusses two common models for distributed computing communication: message passing and remote procedure calls (RPC). It describes the basic primitives and design issues for each model. For message passing, it covers synchronous vs asynchronous and blocking vs non-blocking primitives. For RPC, it explains the client-server model and how stubs are used to convert parameters and return results between machines. It also discusses binding, parameter passing techniques, and ensuring error handling and execution semantics.
This document provides an overview of design patterns, including their definition, origins, properties, types, and examples. It discusses common design patterns like Singleton, Observer, Strategy, Adapter, Facade, and Proxy. For each pattern, it describes the context, problem, forces, solution, and examples. The document also covers challenges of applying patterns and developing new patterns.
The document discusses requirements analysis and analysis modeling principles for software engineering. It covers key topics such as:
1. Requirements analysis specifies a software's operational characteristics and interface with other systems to establish constraints. Analysis modeling focuses on what the software needs to do, not how it will be implemented.
2. Analysis modeling principles include representing the information domain, defining functions, modeling behavior, partitioning complex problems, and moving from essential information to implementation details.
3. Common analysis techniques involve use case diagrams, class diagrams, state diagrams, data flow diagrams, and data modeling to define attributes, relationships, cardinality and modality between data objects.
This document discusses active database management systems. It defines active databases as database systems that can automatically respond to events inside or outside the system through the use of event-condition-action rules. These rules allow the database to monitor and react to specific events. The document outlines the key components of an active database architecture, including a knowledge model and execution model. It also discusses features, applications, strengths and weaknesses of active databases.
UML (Unified Modeling Language) is a standard language for specifying, visualizing, and documenting software systems. It uses various diagrams to model different views of a system, such as structural diagrams (e.g. class diagrams), behavioral diagrams (e.g. sequence diagrams), and deployment diagrams. The key building blocks of UML include things (classes, interfaces, use cases), relationships (associations, generalizations), and diagrams. UML aims to provide a clear blueprint of software systems for both technical and non-technical audiences.
This document provides an introduction to the Unified Modeling Language (UML). It defines UML as a standard modeling language used to visualize, specify, construct and document software systems. The document outlines the basics of UML including common diagram types like use case diagrams, class diagrams and sequence diagrams. It also discusses modeling tools that support working with UML diagrams.
This document discusses domain state modeling. It explains that some domain objects pass through distinct states, each with different properties and constraints. A domain state model identifies classes with states, finds the states and events that cause transitions, builds state diagrams, and evaluates the diagrams. The document provides steps for domain state modeling and examples using an ATM machine to illustrate states like account types and events like incorrect PIN. It emphasizes iteratively refining the analysis model to improve consistency and structure.
Distributed shared memory (DSM) provides processes with a shared address space across distributed memory systems. DSM exists only virtually through primitives like read and write operations. It gives the illusion of physically shared memory while allowing loosely coupled distributed systems to share memory. DSM refers to applying this shared memory paradigm using distributed memory systems connected by a communication network. Each node has CPUs, memory, and blocks of shared memory can be cached locally but migrated on demand between nodes to maintain consistency.
The document discusses different types of video display devices, focusing on cathode ray tubes (CRTs). It describes how CRTs work using an electron gun, deflection plates, and phosphor-coated screen to produce images. Color CRT monitors are also covered, explaining how they produce color using either beam penetration or shadow mask methods. Other display types mentioned include direct view storage tubes, flat panel displays, and their key differences from CRTs.
Unit 3(advanced state modeling & interaction meodelling)Manoj Reddy
The document provides an overview of advanced state modeling and interaction modeling techniques in UML. It discusses nested state diagrams and concurrent state diagrams for controlling complexity in state diagrams. It also covers activity models, use case models, and sequence models for interaction modeling. The relationships between class models, state models, and interaction models are also briefly described.
This document discusses distributed database and distributed query processing. It covers topics like distributed database, query processing, distributed query processing methodology including query decomposition, data localization, and global query optimization. Query decomposition involves normalizing, analyzing, eliminating redundancy, and rewriting queries. Data localization applies data distribution to algebraic operations to determine involved fragments. Global query optimization finds the best global schedule to minimize costs and uses techniques like join ordering and semi joins. Local query optimization applies centralized optimization techniques to the best global execution schedule.
The document discusses object oriented methodologies and software quality assurance. It provides an overview of object oriented analysis and design, including object oriented methodologies like Rumbaugh's Object Modeling Technique (OMT), the Booch methodology, and Jacobson's methodologies. It also discusses software quality assurance activities and processes, object oriented metrics, quality costs, and formal technical reviews. The key aspects covered are modeling techniques in OMT, phases of development in various methodologies, and ensuring quality through activities like reviews, audits, and metrics.
CS8592 Object Oriented Analysis & Design - UNIT V pkaviya
This document discusses object-oriented methodologies for software development. It describes the Rumbaugh, Booch, and Jacobson methodologies which were influential in the development of the Unified Modeling Language. The Rumbaugh Object Modeling Technique focuses on object models, dynamic models, and functional models. The Booch methodology emphasizes class diagrams, state diagrams, and other modeling tools. Jacobson's methodologies like Objectory emphasize use case modeling and traceability between phases.
This document discusses various object-oriented methodologies for systems development, including Rumbaugh's Object Modeling Technique (OMT), Booch's methodology, Jacobson's use case approach, design patterns, frameworks, and the Unified Approach (UA). The UA aims to combine the best practices of these methodologies using the Unified Modeling Language (UML) and a layered architecture.
The document discusses several object-oriented methodologies for software design including Rumbaugh's Object Modeling Technique (OMT), Booch methodology, and Jacobson's Object-Oriented Software Engineering (OOSE) methodology. It also covers the generic components of object-oriented design, the system design process, and the object design process. Key aspects covered include class diagrams, use case modeling, partitioning analysis models into subsystems, and inter-subsystem communication.
Architecture of Object Oriented Software EngineeringSandesh Jonchhe
The document describes the architecture of object-oriented system engineering (OOSE). It discusses 5 main models used in OOSE: the requirements model, analysis model, design model, implementation model, and test model. Each model focuses on a different aspect of system development, from capturing user requirements to implementing and testing the system. The analysis model aims to structure the system into a robust object model, while the design model refines this for the implementation environment. Traceability between the models allows changes to propagate through the system architecture.
The document discusses object-oriented system development life cycles and methodologies. It describes Rumbaugh's Object Modeling Technique (OMT), which uses object models, dynamic models, and functional models to analyze, design, and implement systems. It also covers Booch methodology, which focuses on analysis and design using class, object, state, module, process, and interaction diagrams. Additionally, it mentions Jacobson's use case methodology for user-driven analysis.
This document discusses object-oriented testing methodologies. It provides an overview of the Rumbaugh, Booch, and Jacobson object-oriented design methodologies. It also covers patterns, frameworks, the unified approach to modeling using UML, and various testing strategies like unit testing, integration testing, and validation testing. Quality assurance testing includes debugging, stress testing, and performance testing. Object-oriented concepts like inheritance can impact testing by making some errors less likely while introducing new types of errors. Guidelines for developing test cases include describing the feature under test and testing normal and abnormal use cases.
The document discusses various topics related to software architecture and design including software design phases, goals and limitations of software architecture, data modeling types, database design life cycle, data warehouse modeling, analyzing alternative architectural designs both qualitatively and quantitatively, and measuring architectural complexity based on different dependency types.
Object Oriented Methodologies discusses several object-oriented analysis and design methodologies including Rambaugh's Object Modeling Technique (OMT), Booch methodology, and Jacobson's Object-Oriented Software Engineering (OOSE). OMT separates modeling into object, dynamic, and functional models represented by diagrams. Booch methodology uses class, object, state transition, module, process, and interaction diagrams. OOSE includes use case, domain object, analysis object, implementation, and test models.
This document provides an introduction to software engineering and object-oriented concepts. It defines key terms like program, documentation, software characteristics. It describes various software engineering methodologies like Coad and Yourdon, Booch, Rumbaugh, and Jacobson. It also discusses object-oriented modeling, the Unified Modeling Language (UML), and compares traditional vs. object-oriented approaches.
The document provides an overview of the Structured Systems Analysis and Design Method (SSADM). It describes SSADM as a comprehensive, structured approach to systems development that is considered the true successor to traditional system development lifecycles. The key techniques of SSADM are described as logical data modeling, data flow modeling, and entity event modeling. The stages of the SSADM methodology are then outlined, including feasibility study, investigation of the current environment, business system options, requirements specification, technical system options, logical design, and physical design.
The document describes the SIMQUEST authoring system, which allows authors to create simulation-based educational software. It discusses how SIMQUEST takes a knowledge engineering approach to support the authoring process. Authors can select pre-defined building blocks from a library to create their educational simulation. These building blocks include simulation models, interfaces, and instructional tools. The system was enhanced over time based on author feedback to better bridge the gap between the author's knowledge and the tools provided. Intermediate "knowledge models" were introduced to implicitly support authors as they develop their instructional simulation.
OOAD Part A Question with answer and Part B & C questions.
References :
1) Previous University Questions.
2) Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design and Iterative Development by Craig Larman.
3) Google search engine for text and images.
SE_Unit 2.pdf it is a process model of it studentRAVALCHIRAG1
The document discusses various process models for software engineering including waterfall, incremental, RAD, evolutionary (prototyping and spiral), concurrent, component-based, aspect-oriented, and reuse-oriented models. It also covers project metrics, software measurement approaches including size-oriented metrics like lines of code and function-oriented metrics like function points. Key aspects of each model are defined along with their applicability and limitations.
The document discusses several prescriptive software development models:
1. The waterfall model is a linear sequential model and was one of the earliest prescriptive models proposed.
2. Variations of the waterfall model include the V-model and incremental model, which allow for some iteration and incremental delivery of features.
3. Evolutionary models like prototyping and the spiral model combine iterative development with controlled aspects of waterfall, producing prototypes and incremental releases to manage risk.
SADP PPTs of all modules - Shanthi D.L.pdfB.T.L.I.T
The document discusses design patterns and software architecture. It includes an introduction to design patterns, describing what they are and how they solve common design problems. It also provides details on various design patterns organized in a catalog, including creational, structural and behavioral patterns. The document gives an example of using the Model-View-Controller (MVC) pattern in Smalltalk and provides a template for describing design patterns.
The document discusses key concepts in software design, including:
- Design involves modeling the system architecture, interfaces, and components before implementation. This allows assessment and improvement of quality.
- Important design concepts span abstraction, architecture, patterns, separation of concerns, modularity, information hiding, and functional independence. Architecture defines overall structure and interactions. Patterns help solve common problems.
- Separation of concerns and related concepts like modularity and information hiding help decompose problems into independently designed and optimized pieces to improve manageability. Functional independence means each module has a single, well-defined purpose with minimal interaction.
Object oriented analysis emphasizes investigating the problem domain to identify relevant objects and their relationships. The key goals are to define relevant classes and their attributes, operations, relationships, and behaviors through iterative refinement. Various analysis methods take different approaches, but generally involve use case modeling, class modeling, and behavior modeling.
This document discusses object-oriented system design and modeling. It introduces key concepts like object-oriented principles, the software development lifecycle, and UML modeling. It explains that object-oriented concepts are widely used in software solution design across domains. Skilled professionals with a strong foundation in object-oriented design are needed to fulfill increasing requirements. The document then covers stages of software development like analysis, design, and implementation. It also discusses phases of object-oriented development like analysis, design, and self-contained objects and classes.
This document provides an overview of software construction. It begins with definitions of software construction and discusses why the construction phase is important. It describes the key activities in construction as developing the design model and implementation. The document focuses on developing the design model, including ensuring traceability to the analysis model and adapting the design for the implementation environment. It provides examples from a sample recycling machine system to illustrate traceability between models and handling inheritance and associations in the design model.
The document discusses applying object-oriented design principles to the design of a point of sale (POS) system. It covers applying several GRASP patterns, including Creator, Information Expert, and Low Coupling.
For the Creator pattern, it suggests the Sale class should create SalesLineItem objects since a Sale contains line items. For Information Expert, it assigns responsibilities to classes that have the necessary information - Sale computes the total since it contains line items, SalesLineItem computes the subtotal since it knows quantity and price, and ProductDescription provides the price. Low Coupling aims to reduce dependencies between classes.
The document provides information about Unit III of the syllabus, which covers dynamic and implementation UML diagrams. It discusses different types of dynamic diagrams like interaction diagrams (sequence diagram, collaboration diagram), state machine diagrams, and activity diagrams. It also discusses implementation diagrams like package diagrams, component diagrams, and deployment diagrams. Chapters from the third edition textbook related to these diagrams are listed. The document then provides more details on types of UML diagrams including structural diagrams and behavioral diagrams. It focuses on interaction diagrams, describing sequence diagrams and communication diagrams in detail. Examples and notation for drawing interaction diagrams are also explained.
The document discusses object-oriented analysis and design (OOAD) and the Unified Process (UP). It covers key concepts in OOAD like requirements analysis, use cases, domain modeling, interaction diagrams, and design class diagrams. It also discusses iterative development approaches like the Unified Process, which emphasizes iterative development through short iterations with analysis, design, implementation, and testing in each iteration and feedback between iterations.
This document provides an introduction to the analysis of algorithms. It defines an algorithm and lists key properties including being finite, definite, and able to produce the correct output for any valid input. Common computational problems and basic algorithm design strategies are outlined. Asymptotic notations for analyzing time and space efficiency are introduced. Examples of algorithms for calculating the greatest common divisor and determining if a number is prime are provided and analyzed. Fundamental data structures and techniques for analyzing recursive algorithms are also discussed.
This document discusses lower bounds and limitations of algorithms. It begins by defining lower bounds and providing examples of problems where tight lower bounds have been established, such as sorting requiring Ω(nlogn) comparisons. It then discusses methods for establishing lower bounds, including trivial bounds, decision trees, adversary arguments, and problem reduction. The document covers several examples to illustrate these techniques. It also discusses the complexity classes P, NP, and NP-complete problems. Finally, it discusses approaches for tackling difficult combinatorial problems that are NP-hard, including exact and approximation algorithms.
Iterative improvement is an algorithm design technique for solving optimization problems. It starts with a feasible solution and repeatedly makes small changes to the current solution to find a solution with a better objective function value until no further improvements can be found. The simplex method, Ford-Fulkerson algorithm, and local search heuristics are examples that use this technique. The maximum flow problem can be solved using the iterative Ford-Fulkerson algorithm, which finds augmenting paths in a flow network to incrementally increase the flow from the source to the sink until no more augmenting paths exist.
This document discusses dynamic programming and greedy algorithms. It begins by defining dynamic programming as a technique for solving problems with overlapping subproblems. It provides examples of dynamic programming approaches to computing Fibonacci numbers, binomial coefficients, the knapsack problem, and other problems. It also discusses greedy algorithms and provides examples of their application to problems like the change-making problem, minimum spanning trees, and single-source shortest paths.
This document discusses brute force and divide-and-conquer algorithms. It covers various brute force algorithms like computing an, string matching, closest pair problem, convex hull problems, and exhaustive search algorithms like the traveling salesman problem and knapsack problem. It then discusses divide-and-conquer techniques like merge sort, quicksort, and multiplication of large integers. Examples and analysis of algorithms like selection sort, bubble sort, and mergesort are provided.
Embedded machine learning-based road conditions and driving behavior monitoringIJECEIAES
Car accident rates have increased in recent years, resulting in losses in human lives, properties, and other financial costs. An embedded machine learning-based system is developed to address this critical issue. The system can monitor road conditions, detect driving patterns, and identify aggressive driving behaviors. The system is based on neural networks trained on a comprehensive dataset of driving events, driving styles, and road conditions. The system effectively detects potential risks and helps mitigate the frequency and impact of accidents. The primary goal is to ensure the safety of drivers and vehicles. Collecting data involved gathering information on three key road events: normal street and normal drive, speed bumps, circular yellow speed bumps, and three aggressive driving actions: sudden start, sudden stop, and sudden entry. The gathered data is processed and analyzed using a machine learning system designed for limited power and memory devices. The developed system resulted in 91.9% accuracy, 93.6% precision, and 92% recall. The achieved inference time on an Arduino Nano 33 BLE Sense with a 32-bit CPU running at 64 MHz is 34 ms and requires 2.6 kB peak RAM and 139.9 kB program flash memory, making it suitable for resource-constrained embedded systems.
Electric vehicle and photovoltaic advanced roles in enhancing the financial p...IJECEIAES
Climate change's impact on the planet forced the United Nations and governments to promote green energies and electric transportation. The deployments of photovoltaic (PV) and electric vehicle (EV) systems gained stronger momentum due to their numerous advantages over fossil fuel types. The advantages go beyond sustainability to reach financial support and stability. The work in this paper introduces the hybrid system between PV and EV to support industrial and commercial plants. This paper covers the theoretical framework of the proposed hybrid system including the required equation to complete the cost analysis when PV and EV are present. In addition, the proposed design diagram which sets the priorities and requirements of the system is presented. The proposed approach allows setup to advance their power stability, especially during power outages. The presented information supports researchers and plant owners to complete the necessary analysis while promoting the deployment of clean energy. The result of a case study that represents a dairy milk farmer supports the theoretical works and highlights its advanced benefits to existing plants. The short return on investment of the proposed approach supports the paper's novelty approach for the sustainable electrical system. In addition, the proposed system allows for an isolated power setup without the need for a transmission line which enhances the safety of the electrical network
Introduction- e - waste – definition - sources of e-waste– hazardous substances in e-waste - effects of e-waste on environment and human health- need for e-waste management– e-waste handling rules - waste minimization techniques for managing e-waste – recycling of e-waste - disposal treatment methods of e- waste – mechanism of extraction of precious metal from leaching solution-global Scenario of E-waste – E-waste in India- case studies.
Discover the latest insights on Data Driven Maintenance with our comprehensive webinar presentation. Learn about traditional maintenance challenges, the right approach to utilizing data, and the benefits of adopting a Data Driven Maintenance strategy. Explore real-world examples, industry best practices, and innovative solutions like FMECA and the D3M model. This presentation, led by expert Jules Oudmans, is essential for asset owners looking to optimize their maintenance processes and leverage digital technologies for improved efficiency and performance. Download now to stay ahead in the evolving maintenance landscape.
CHINA’S GEO-ECONOMIC OUTREACH IN CENTRAL ASIAN COUNTRIES AND FUTURE PROSPECTjpsjournal1
The rivalry between prominent international actors for dominance over Central Asia's hydrocarbon
reserves and the ancient silk trade route, along with China's diplomatic endeavours in the area, has been
referred to as the "New Great Game." This research centres on the power struggle, considering
geopolitical, geostrategic, and geoeconomic variables. Topics including trade, political hegemony, oil
politics, and conventional and nontraditional security are all explored and explained by the researcher.
Using Mackinder's Heartland, Spykman Rimland, and Hegemonic Stability theories, examines China's role
in Central Asia. This study adheres to the empirical epistemological method and has taken care of
objectivity. This study analyze primary and secondary research documents critically to elaborate role of
china’s geo economic outreach in central Asian countries and its future prospect. China is thriving in trade,
pipeline politics, and winning states, according to this study, thanks to important instruments like the
Shanghai Cooperation Organisation and the Belt and Road Economic Initiative. According to this study,
China is seeing significant success in commerce, pipeline politics, and gaining influence on other
governments. This success may be attributed to the effective utilisation of key tools such as the Shanghai
Cooperation Organisation and the Belt and Road Economic Initiative.
KuberTENes Birthday Bash Guadalajara - K8sGPT first impressionsVictor Morales
K8sGPT is a tool that analyzes and diagnoses Kubernetes clusters. This presentation was used to share the requirements and dependencies to deploy K8sGPT in a local environment.
2. SYLLABUS
• Object Oriented Methodologies – Software
Quality Assurance – Impact of object
orientation on Testing – Develop Test Cases
and Test Plans
Dept of CSE, VEC
3/9/2022 2
3. Object Oriented Methodologies
• Object Oriented Methodologies
– Set of methods, models and rules for developing systems
– Modelling is the process of describing an existing or
proposed system
– Modelling provides a means for communicating ideas in
an easy to understand and unambiguous form
Dept of CSE, VEC
3/9/2022 3
4. Object Oriented Methodologies
• Methodologies and their modeling notations
developed by :
• Rumbaugh Methodology : It is suitable for
describing the object model or the static structure
of the system.
• Booch Methodology : It produces detailed object-
oriented design models.
• Jacobson Methodology : It is suitable for producing
user-driven analysis model.
Dept of CSE, VEC
3/9/2022 4
6. Rumbaugh Methodology - Object
Modeling Technique
• Object modeling Technique (OMT) presented by Jim Rumbaugh.
• It describes a method for the analysis, design and
implementation of a system using an object-oriented technique.
• OMT is a fast, perceptive approach for identification and the
modeling of objects.
• In OMT, class details such as attributes, method, inheritance and
association can be explained in the easiest way,
• OMT dynamic model describes the dynamic behaviour of
objects.
• It explains detailed state transitions and their descriptions within
a system.
• It also express the product description and consumer - producer
relationship using OMT functional models.
Dept of CSE, VEC
3/9/2022 6
7. Object modeling Technique (OMT)
• OMT consists of four phases
• Analysis :The results are objects and dynamic and functional
models.
• System design : It defines the structure of the basic architecture of
the system along with high-level strategy decisions.
• Object design : It produces a design document, consists of detailed
objects static, dynamic and functional model.
• Implementation : It produces reusable, extendible and robust
code.
• OMT separates modeling into 3 parts :
• An object model, A dynamic model, A functional model,
Dept of CSE, VEC
3/9/2022 7
8. Object modeling Technique (OMT)
• OMT separates modeling into 3 parts :
• An object model, A dynamic model, A functional model,
An object model
• It describes the structure of objects in a system.
• Their identify, relationships to other objects, attributes and
operations.
• Object model is represented by object diagram.
Eg: Object model for banking system.
Dept of CSE, VEC
3/9/2022 8
9. Object modeling Technique (OMT)
An object model
Eg: Object model for banking system.
Dept of CSE, VEC
3/9/2022 9
The object diagram
contains classes which is
connected by association
lines.
Each class in the object
diagram represents a set of
individual objects.
The association lines
establish relationships
between the classes.
The association line also
represents a set of links from
objects of one class to
objects of another class.
10. Object modeling Technique (OMT)
OMT Dynamic Model :
• OMT provides a detailed and comprehensive dynamic
model.
• OMT depicts states, transitions, events and actions.
• OMT dynamic model is represented by state transition
diagram.
• OMT state transition diagram is a network of states and
events.
• Each state receives one or more events.
• OMT state transition diagram, makes from transition to the
next state.
• The next state depends on the current state and events.
Dept of CSE, VEC
3/9/2022 10
11. Object modeling Technique (OMT)
OMT Dynamic Model :
State transition diagram for banking system
Dept of CSE, VEC
3/9/2022 11
12. Object modeling Technique (OMT)
OMT Functional Model :
• OMT data flow diagram shows the flow of data between
different processes.
• DFD provides a simple method for describing business
process without focus on the details.
Data flow diagrams use four primary symbols :
1. Process : Any function being performed.
Eg.: Verify password.
2. Data Flow : Direction of data element movement.
3. Data Stroe : Location where data are stored.
4. External entity : Source or destination of a data element.
Eg : ATM card reader.
Dept of CSE, VEC
3/9/2022 12
13. Object modeling Technique (OMT)
OMT Functional Model :
Data Flow Diagram for ATM system
Dept of CSE, VEC
3/9/2022 13
15. The Booch Methodology
• Booch methodology is a widely used object-oriented method.
• Booch methodology which covers the analysis and design phase of an OO
system.
• Booch methodology consists of various diagrams :
Class diagrams
Object diagrams
State transition diagram
Module diagram
Interaction diagram
• Here state transition and object diagram is given as an example design phase
of OO system in Booch Methodology.
• Booch methodology uses a macro development process and a micro
development process.
Dept of CSE, VEC
3/9/2022 15
16. The Booch Methodology
The Macro Development Process :
• Macro Development Process is a controlling framework for micro process.
• The primary focus for macro development process is technical management of the system.
• This technical management is responsible for the requirements set for project rather than the
object oriented design.
The macro development process consists of the following steps:
1. Conceptualization: The core requirements of the system are established. A set of goals
are established and develop a prototype to prove the concept.
2. Analysis and development of the model:
• Class diagram is used to describe the roles and responsibilities of objects to performing
the behavior of the system.
• Object diagram is used to describe the behavior of the system in terms of scenarios.
• Interaction diagram is also used to describe the behavior of the system in terms of
scenarios.
Dept of CSE, VEC
3/9/2022 16
17. The Booch Methodology
The Macro Development Process :
3. Design or create the system architecture
• The class diagram in the design phase is used to decide that classes exist and how they
relate to each other.
• Then the object diagram is used for specifying mechanisms of object collabration.
• Then use module diagram to map out where each class and object should be declared
• Finally use process diagram to determine which processor to allocate process
4. Evolution or implementation
• Refine the system through many iterations.
• Produce a stream of executable files each of which is a refinement of prior one.
5. Maintenance
• Make changes to the system to add new requirements and eliminate bugs.
Dept of CSE, VEC
3/9/2022 17
18. The Booch Methodology
Object Modeling - Booch Technology
State Transition Diagram - Booch methodology
Dept of CSE, VEC
3/9/2022 18
19. The Booch Methodology
The Micro Development Process :
• Each macro development process has its own micro development
processes.
• Micro process is a description of the day-to-day activities by a
single or small group of software developers.
• The micro development process consists of the following steps :
– Identify classes and objects.
– Identify class and object semantics.
– Identify class and object relationships.
– Identify class and object interfaces and implementation.
Dept of CSE, VEC
3/9/2022 19
21. The Jacobson Methodologies
• Jacobson methologies examples are object-oriented.
Business Engineering (OOBE), object-oriented
Software Engineering (OOSE) and objectory
(usecases).
• These examples cover the entire lifecycle and stress
traceability between the different phases.
• This traceability enables reuse of analysis and design
work possibly much bigger factors in the reduction of
development time than reuse of code.
• Use case concepts are evolved with objectory (object
factory for software development)
Dept of CSE, VEC
3/9/2022 21
22. The Jacobson Methodologies
• Use cases :
• Scenarios for understanding
system requirements.
• It is an interaction between
user and a system.
• The use case model captures
the goal of the user and the
responsibility of the system to
its users.
Dept of CSE, VEC
3/9/2022 22
23. The Jacobson Methodologies
• Description of use case
– Non formal text with no clear flow of events
– Text , easy to read, clear flow of events
(Recommended)
– Formal style with pseudo code
24. The Jacobson Methodologies
The usecase description must contain :
• How and when the usecase begins and ends :
• The interaction between the usecase its actor, including
when the interaction occurs and what is exchanged.
• How and when the usecae will store data in the system.
• Exceptions to the flow of events.
• How and when the concepts of the problem domain
are handled.
• Every usecase should describe one flow of events.
Dept of CSE, VEC
3/9/2022 24
25. The Jacobson Methodologies
The usecase description must contain: (Cont..)
• An exceptional or additional flow of events could be added.
• The usecase model employs extends and uses relationships.
• The extends relationship is used when you have one usecase
that is similar to another usecase.
• The uses relationship reuses common behaviour in different
usecases.
• Usecases can be viewed as concrete or abstract.
• An abstract usecase is not complete and has no actors that
initiate it.
• Abstract usecases also the ones that have uses or extends
relationships.
Dept of CSE, VEC
3/9/2022 25
26. The Jacobson Methodologies
Object-Oriented Software Engineering - Objectory :
• OOSE also called as objectory, is a method of object-oriented
development with the aim of developing real-time systems.
• The development process, called usecase driven development
which involved in several phases including analysis, design,
validation and testing.
• The usecase scenario begins with a user of the system initiating a
sequence of interrelated events.
• The system development method based on OOSE, is a disciplined
process for the industrialized development of software based on
a use-case driven design.
Dept of CSE, VEC
3/9/2022 26
27. The Jacobson Methodologies :
Object-Oriented Software Engineering - Objectory : (Cont..)
• It is an approach to OO analysis and design.
• By organizing the analysis and design models around sequences
of user interaction and actual usage scenarios, this method
produces the system that are more usable and more robust.
• Jacobson objectory has been developed and applied to
numerous application areas.
Dept of CSE, VEC
3/9/2022 27
28. The Jacobson Methodologies
Object-Oriented Software Engineering - Objectory : (Cont..)
• Objectory is build around several models :
• Use-case model :The use-case model defines the outside (actors)
and inside (usecase) of the system’s behavior.
• Domain object model : The objects of the real world are mapped
into the domain object model.
• Analysis object model : The analysis object model presents how
the source code should be carried out and written.
• Implementation model :Represents the implementation of the
system.
• Test Model :It constitutes the test plans, specifications and
reports.
Dept of CSE, VEC
3/9/2022 28
29. The Jacobson Methodologies
Object-Oriented Software Engineering - Objectory : (Cont..)
Usecase model is considered in every model and phase
Dept of CSE, VEC
3/9/2022 29
30. The Jacobson Methodologies
Object-oriented Business Engineering :
• Object-Oriented Business Engineering (OOBE) is object modeling
at the enterprise level.
• Usecases are the central for modeling, providing traceability
throughout the software engineering processes.
• Analysis Phase :
• The analysis phase defines the system to be built in terms of
problem - domain object model, the requirements model and
the analysis model.
• The analysis process should not take into account the actual
implementation environment.
Dept of CSE, VEC
3/9/2022 30
31. The Jacobson Methodologies
Object-oriented Business Engineering :
• This reduces complexity and promotes maintainability over the
life of the system, since the description of the system will be
independent of hardware and software requirements.
• This analysis process is iterative but the requirements and
analysis models should be stable before moving to subsequent
models.
Dept of CSE, VEC
3/9/2022 31
32. The Jacobson Methodologies
Design and implementation phases :
• Implementation environment must be identified for the design
model.
• This includes factors such as DBMS, distribution of process,
constraints due to the programming language, available
component libraries, incorporation of graphical user interface
tools.
• The analysis objects are translated into design objects.
• Testing phase :
• Jacobson describes several testing levels and techniques.
• The levels include unit testing, integration testing and system
testing.
Dept of CSE, VEC
3/9/2022 32
34. SOFTWARE QUALITY ASSURANCE
• To develop and deliver robust systems,
– Each component will behave correctly.
– Collective behavior is correct.
– No incorrect collective behavior will be produced.
• The elimination of the syntactical bug is the process of
debugging.
• The detection and elimination of the logical bug is the
process of testing.
Dept of CSE, VEC
3/9/2022 34
35. SOFTWARE QUALITY ASSURANCE
Quality Assurance Tests :
• After the development of the product, quality assurance test is
needed.
• Debugging is the process of finding out where something went
wrong and correcting the code to eliminate the errors or bugs
that cause unexpected results.
• Testing and searching for bugs is a balance of science, art and
luck.
• By selecting appropriate testing strategies and a test plan, the
errors in the system can be located and fix them using readily
available debugging tools.
• A Software debugging system can provide tools for finding
errors in progress.
Dept of CSE, VEC
3/9/2022 35
36. SOFTWARE QUALITY ASSURANCE
Following kinds of errors may encountered:
1. Language (Syntax) Error
– incorrectly constructed code (keyword not typed correctly)
2. Run-time errors
– error found during program running
3. Logic errors
– code does not perform the way you intended
Dept of CSE, VEC
3/9/2022 36
37. SOFTWARE QUALITY ASSURANCE
• Quality assurance testing can be divided into 2 major
categories
– Error based testing
– Scenario based testing
• Error based testing
– Search a given class’s method for particular clue of interest
– To test this Emp.payroll(hours), try different values for hours (40,30
etc)
– Testing boundary condition
– Method should handle any value. if not error must be recorded and
reported
38. • Scenario based testing
– Usage based testing
– Concentrates on what user does, not what the product does
– Capturing usecases and the task users perform, then performing them
and their variants as tests
– Can identify interaction bugs
– More complex than error-based test
39. Testing Strategies :
• The extent of testing a system is controlled by many factors,
such as
• Risks involved
• Limitation on resources
• Deadlines
• To resolve these issues, a best testing strategy must be deploy
to find defects in a product within the given constraints.
Many testing strategies are used :
• Black box testing
• White box testing
• Top-down testing
• Bottom-up testing
40. SOFTWARE QUALITY ASSURANCE
Black box testing :
• The concept of the black box is used to represent a system whose inside
working are not available.
• Black box is an imaginary box that hides its internal workings
• The test item is treated as “black”, since its logic is unknown. So this testing
is defined as black-box testing.
• All that known is input and output.
Dept of CSE, VEC
3/9/2022 40
41. SOFTWARE QUALITY ASSURANCE
White-box Testing :
• White-box testing assumes the specific logic is important and must be
tested to guarantee the system proper functioning.
• The main use of white box testing is in error-based testing.
• In white box testing, bugs have a low probability of execution.
• One form of white-box testing called path testing, makes certain that each
path in a object method is executed atleast once during testing.
Dept of CSE, VEC
3/9/2022 41
42. SOFTWARE QUALITY ASSURANCE
Two types of white-box testing (or) path testing :
• Statement testing coverage
• Branch testing coverage
Statement testing coverage
• Test every statement in the object’s method by executing it atleast once
Branch testing Coverage :
• Main aim is to perform enough tests to ensure that every branch alternative
has been executed atleast once under some test.
• It is unfeasible to fully test program of considerable size.
Dept of CSE, VEC
3/9/2022 42
43. Top-down testing :
• Top-down testing assumes that the main logic or object interactions and
systems messages of the application need more testing than an individual
object’s method or supporting logic.
• A top-down strategy can detect the serious design flaws.
• Top-down testing should find critical design errors early in the testing
process and significantly improve the quality of the delivered software
because of the iterative nature of the test.
44. SOFTWARE QUALITY ASSURANCE
Bottom-up Testing :
• Bottom-up testing starts with the details of the system and proceeds to higher levels
by a progressive aggregation of details until they fit the requirements for the system.
• It is appropriate for testing the individual objects in a system.
• Initially test each object.
• Then combine each object and test their interaction and the messages passed
among objects.
• Bottom-up testing start with the methods and classes.
• Then progress to the next level.
• Then combine bottom two layers.
• Proceed until you are testing the entire program.
• Bottom-up testing leads to integration testing which leads to system testing.
Dept of CSE, VEC
3/9/2022 44
45. IMPACT OF OBJECT ORIENTATION ON TESTING
• The impact of an object orientation on testing is summarized as :
– Some types of errors could become less probability.
– Some types of errors could become more probability.
– Some new types of errors might appear.
• The process of testing variable uses in OOD essentially does not change, but
the user has to decide
– What needs testing?
– Has the possibility of faults changed?
– Some types of fault are less feasible or more feasible.
– There are more opportunities for integration faults.
Dept of CSE, VEC
3/9/2022 45
46. IMPACT OF OBJECT ORIENTATION ON TESTING
• Consider this eg:
• The base class A contains methods square( ) and rectangle( ) and the
derived class B redefines the rectangle( ) method.
• The B::rectangle( ) has to be tested because it is a new code.
• Does B::square( ) have to be retested?
• If it uses rectangle( ) and the rectangle( ) has changed, the B::square may
mishandle the new behaviour.
• So it needs new tests even though the B::square( ) itself has not changed.
• If the A:square has been changed, the B::rectangle( ) may not have to be
completely tested.
• If the OOD guidelines do not follow, the objects are hard to debug and
maintain.
Dept of CSE, VEC
3/9/2022 46
47. IMPACT OF OBJECT ORIENTATION ON TESTING
Reusability of tests :
• If A::rectangle( ) and B::rectangle( ) are two different methods with different
protocols and implementations.
• Each needs a different set of test requirements derived from the usecases,
analysis, design or implementation.
• But the methods are likely to be similar.
• Write new tests only for those B::rectangle requirements which is not
satisfied by the A::rectangle tests.
• If the A::rectangle tests is apply to objects of the class B, the test inputs may
be appropriate for both classes.
– But the expected results might differ in the derived class.
• Marick argues that test is more likely to be reusable in subclasses.
– Simple tests are used to find only the faults.
– Complex tests are better at both finding those faults and shuffling across others.
Dept of CSE, VEC
3/9/2022 47
48. TEST CASES
TEST CASES
• To have a comprehensive testing scheme, the test must cover all methods or
a good majority of them.
• All the services of your system must be checked by atleast one test.
• To test a system, construct some test input cases, then describe the output.
• Next, perform the tests and compare the outcome with the expected
output.
• The usecases developed during analysis can be used to describe the usage
test cases.
• Tests always should be designed from specifications.
The objective of testing as follows:
• Testing is the process of executing a program with the intent of finding
errors.
• A good test case is the one that has a high probability of detecting an
undiscovered error.
• A successful test case is the one that detects an undiscovered error.
Dept of CSE, VEC
3/9/2022 48
49. TEST CASES
Guidelines for Developing Quality Assurance Test Cases :
• Basically a test case is a set of what-if questions.
• Freedman and Thomas developed guidelines
– Describe which feature or service your test attempts to cover.
– If the test case is based on a usecase, it is good idea to refer to the
usecase name. Remember that the usecases are the source of test
cases. The software is supposed to match the usecases. If we have
enough of usecases, write the test plan.
– Specify what we are testing and which particular feature (methods).
Dept of CSE, VEC
3/9/2022 49
50. TEST CASES
Guidelines for Developing Quality Assurance Test Cases : (Cont..)
– Specify what is the input for test feature and what will be the output.
– Test the normal use of the object’s methods.
– Test the abnormal but reasonable use of the object’s methods.
– Test the abnormal and unreasonable use of the object’s methods.
– Test the boundary conditions.
– Test object’s interactions and the messages sent among them. Sequence
diagram is useful for this process.
– Whenever the revisions have been made, document the cases so they become
the starting basis for the follow-uip test.
– Attempting to reach agreement on answers will raise other what-if questions.
Add these to the list and answer them, repeat the process until the list is
stabilized.
Dept of CSE, VEC
3/9/2022 50
51. TEST CASES
Guidelines for Developing Quality Assurance Test Cases : (Cont..)
– The quality of the software, such as its reusability and extendability should be
assessed.
– The reusability and extendability are more difficult to test.
– Reuse is widely desired and often the benefit of utilizing object technology.
– Many object-oriented reuse efforts fail because of little focus on technology
rather than the policies set by an organization.
– Software assets are consistently used and maintained to obtain high levels of
reuse, which optimize the organization’s ability to produce high-quality software
products.
– Specifying result is difficult for the development of test cases.
– During testing, it is important to alert the person running them that failure is
expected.
Dept of CSE, VEC
3/9/2022 51
52. TEST CASES
Guidelines for Developing Quality Assurance Test Cases : (Cont..)
We are testing a File open feature
Specify the result as follows :
• 1. Drop down the file menu and select open.
• 2. Try opening the following types of files :
– A file that is there (should work)
– A file that is not there (should get an Error message).
– A file name with international characters (should work).
– A file type that the program does not open (should get a
message or conversion dialog box)
Dept of CSE, VEC
3/9/2022 52
53. TEST PLAN
• In the real world, it may be a good idea to use a test
plan and find bugs and remove it.
• A test plan is developed to detect and identify
potential problems before delivering the software to
its users.
• A test plan offers a road map for testing activities,
whether usability, user satisfaction or quality
assurance tests.
• The test plan need not be very large.
Dept of CSE, VEC
3/9/2022 53
54. TEST PLAN
The following steps are needed to create a test plan:
1. Objectives of the test :
• Create the objectives and describe how to achieve them.
• For eg: if the objective is usability of the system, that must
be stated and how to realize it.
• Most software companies use beta testing, in-expensive
and effective way to test software on a select group of the
actual users of the system.
• Alpha testing, where testing is done by programmers,
software engineers and internal users.
Dept of CSE, VEC
3/9/2022 54
55. TEST PLAN
2. Development of a test case :
• Develop test data, both input and output based on the domain of the data
and the expected behaviors that must be tested.
3. Test Analysis :
• This step involves the examination of the test output and the
documentation of the test results.
• If bugs are detected, then this is reported.
• After debugging, steps 1 through 3 must be repeated until no bugs can be
detected.
• All passed tests should be repeated with the revised program, called
regression testing.
• It can discover errors introduced during the debugging process.
• When sufficient testing is believed to have been conducted, this fact should
be reported and testing for this specific product is complete.
• A good test plan is one of the strongest tool.
Dept of CSE, VEC
3/9/2022 55
56. TEST PLAN
3. Test Analysis : (Cont..)
It gives the clear view about,
– What will be tested?
– How it will be tested?
– Intended schedule.
• Use test plan as a checklist, to make sure that we do not forget to test any
features.
• For a small application, the designer team will develop the test plan and test
cases.
• Many organizations have a separate team, such as a quality assurance
group, that works closely with the design team and is responsible for these
activities.
Dept of CSE, VEC
3/9/2022 56
57. TEST PLAN
Guidelines for developing test plans :
• As software gains complexity and interaction among
programs.
• A good test plan not only prevents overlooking a
feature.
• The following guidelines have been developed by
Thomas for writing test plans.
– Requirements which are used that dictate a specific
appearance or format for your test plan. These
requirements may be generated by the users. Whatever the
appearance of your test plan, by to include much possible
details about the test.
Dept of CSE, VEC
3/9/2022 57
58. TEST PLAN
Guidelines for developing test plans :
• The test plan should contain a schedule and a list of required
resources. List how many people will be needed. When the testing
has to be done. What are the equipments will be required.
• After the determination of what types of testing are necessary (such
as blackbox, whitebox, top-down or bottom-up testing) document
the specification of what the user has to do.
• The level of detail in your plan may be driven by several factors such
as:
– How much test time to you have?
– Will you use the test plan as a training tool for newer team members?
Dept of CSE, VEC
3/9/2022 58