Faculty of Computer Applications &
Information Technology
BCA PROGRAMME
240301406
Object Oriented Analysis & Design
UNIT 5
Moving into Implementation
Managing the
Programming Process
Faculty of Computer Applications & IT
Managing the Programming Process
• A Process is a program in execution. For example, when we write a program in C or C++
and compile it, the compiler creates binary code.
• A process is an ‘active’ entity instead of a program, which is considered a ‘passive’ entity.
• A single program can create many processes when run multiple times; for example, when
we open a .exe or binary file multiple times, multiple instances begin (multiple processes
are created).
Faculty of Computer Applications & IT
Managing the Programming Process
• Program Life Cycle Management is a systematic approach for managing the
development, implementation, and maintenance of large-scale programs and projects.
• It encompasses all the stages of a program’s life cycle.
• Program life cycle management is the process of planning, executing, and closing the
work of a program to achieve specific goals and meet the success criteria.
• It involves coordinating and managing various projects and activities to deliver a
solution that meets business needs and objectives.
• Effective program life cycle management requires clear communication, risk
management, and continuous improvement to ensure successful outcomes.
Faculty of Computer Applications & IT
Managing the Programming Process
• Steps Involved in Programming:
• Analyzing the Problem
• Algorithm design / Pseudo Code
• Flowchart
• Coding
• Debugging
• Testing
• Final output
• Documentation
Faculty of Computer Applications & IT
The Programming Process
Faculty of Computer Applications & IT
The Programming Process
• Understanding the Problem: Programming begins with a clear understanding of the
problem you’re trying to solve. This initial step involves defining the problem
statement, identifying the objectives, and understanding the end-users’ needs.
• Planning and Design: Creating a project roadmap is essential for a successful
programming endeavor. This stage involves setting goals, establishing timelines, and
creating a detailed plan for your project.
• Selecting the Programming Language: Choosing the right programming language is
crucial. Factors such as project requirements, your familiarity with the language, and
its suitability for the task at hand should all be considered.
• Writing Code: Here, we delve into the nitty-gritty of coding. Learn about syntax, code
structure, and best practices for writing clean and maintainable code.
• Debugging and Testing: No program is perfect from the get-go. Discover how to
identify and rectify errors and bugs in your code through effective debugging and
testing techniques.
Faculty of Computer Applications & IT
The Programming Process
• Documentation: Documenting your code is often overlooked but incredibly
important. Learn why good documentation practices can save you time and effort in
the long run.
• Optimization: Optimizing your code ensures that it runs efficiently. Explore
techniques to improve performance and reduce resource consumption.
• Version Control: Managing code changes is simplified with version control systems.
Learn how to use tools like Git to track and collaborate on code.
• Deployment: Making your project live is the ultimate goal. Understand the steps to
deploy your application or website for the world to see.
• User Interface Design: A user-friendly interface is essential for user satisfaction.
Explore the principles of effective UI design.
• User Experience: Enhancing the overall user experience goes beyond just design.
Learn how to create a positive journey for your users.
Faculty of Computer Applications & IT
The Programming Process
• Security: Protecting your software from vulnerabilities and threats is paramount.
Discover best practices for coding securely.
• Scalability: Preparing your project for growth is crucial. Learn how to make your
code scalable and adaptable.
• Maintenance: Coding doesn’t end with deployment. Continuously update and
improve your project to meet evolving needs.
• Collaboration: Programming often involves teamwork. Explore effective
collaboration techniques for a harmonious development process.
• Project Management: Efficiently coordinate your programming project by
adopting project management practices.
• Ethical Considerations: Responsible coding practices involve considering ethical
implications. Learn how to code ethically and responsibly.
• Future-Proofing: Stay ahead in the ever-changing tech world by preparing your
code for future advancements.
Faculty of Computer Applications & IT
The Programming Process
• Troubleshooting: Every coder faces issues. Explore common problems and
solutions in the coding world.
• Resources and Tools: Discover a wealth of resources and tools to aid your
programming journey.
• Stay Updated: Continuous learning is key in programming. Find out how to stay
updated with the latest industry trends.
• Common Pitfalls: Avoiding common coding mistakes is essential. Learn from
others’ experiences to improve your skills.
• Success Stories: Draw inspiration from accomplished programmers who have
made their mark in the coding world.
• Programming Communities: Joining coding communities can be invaluable.
Explore different communities and their benefits.
• Conclusion: Summing up the programming journey and emphasizing the
importance of continuous learning and improvement.
Faculty of Computer Applications & IT
Testing
• A test plan is a document that consists of all future testing-related activities.
• It is prepared at the project level and in general, it defines work products to be
tested, how they will be tested, and test type distribution among the testers.
• Before starting testing there will be a test manager who will be preparing a test
plan.
• The test plan serves as the blueprint that changes according to the progressions in
the project and stays current at all times.
• It serves as a base for conducting testing activities and coordinating activities
among a QA team.
• It is shared with Business Analysts, Project Managers, and anyone associated with
the project.
• A test plan is a comprehensive document outlining all testing-related activities for
a project. It details what will be tested, how, and by whom, serving as a blueprint
for testing and coordinating among the QA team.
Faculty of Computer Applications & IT
Testing
Faculty of Computer Applications & IT
Components of Test Plans (Only Example)
Ref: [Link]
Faculty of Computer Applications & IT
management/what-is-test-plan
Testing
Faculty of Computer Applications & IT
Types of Testing
Faculty of Computer Applications & IT
Unit Tests
• Unit tests are very low level and close to the source of an application.
• They consist in testing individual methods and functions of the classes,
components, or modules used by your software.
• Unit tests are generally quite cheap to automate and can run very quickly by a
continuous integration server.
Faculty of Computer Applications & IT
Integration Tests
• Integration tests verify that different modules or services used by your application
work well together.
• For example, it can be testing the interaction with the database or making sure that
microservices work together as expected.
• These types of tests are more expensive to run as they require multiple parts of the
application to be up and running.
Faculty of Computer Applications & IT
Integration Tests
• Incremental Integration Testing:
• Whenever there is a clear relationship between modules, we go for incremental
integration testing.
• Suppose, we take two modules and analysis the data flow between them if they
are working fine or not.
• If these modules are working fine, then we can add one more module and test
again.
Faculty of Computer Applications & IT
Integration Tests
Non-Incremental Integration Testing
• Whenever the data flow is complex and very difficult to classify a parent and a
child, we will go for the non-incremental integration approach.
• The non-incremental method is also known as the Big Bang method.
Faculty of Computer Applications & IT
System Tests
• In system testing, the test environment is parallel to the production environment.
It is also known as end-to-end testing.
• In this type of testing, each attribute of the software is checked and tested if the
end feature works according to the business requirement.
• And analysis the software product as a complete system.
Faculty of Computer Applications & IT
Acceptance Tests
• Acceptance tests are formal tests that verify if a system satisfies business
requirements.
• They require the entire application to be running while testing and focus on
replicating user behaviors.
• The User acceptance testing (UAT) is done by the individual team known as
domain expert/customer or the client.
• And knowing the application before accepting the final product is called as user
acceptance testing.
• In user acceptance testing, we analyze the business scenarios, and real-time
scenarios on the distinct environment called the UAT environment.
• In this testing, we will test the application before UAI for customer approval.
Faculty of Computer Applications & IT
Developing Documentation
Faculty of Computer Applications & IT
Developing Documentation
• IEEE defines software design documentation as “a description of
software created to facilitate analysis, planning, implementation,
and decision-making”.
• Testing documentation is the documentation of artifacts that are
created during or before the testing of a software application.
• Documentation reflects the importance of processes for the
customer, individual and organization.
• Projects which contain all documents have a high level of
maturity. Careful documentation can save the time, efforts and
wealth of the organization.
• The requirements document describes the “what” of your project,
the design document focuses on the “how”.
Faculty of Computer Applications & IT
Types of Documentation
Faculty of Computer Applications & IT
Types of Documentation
Test Scenarios
• It is a document that defines the multiple ways or combinations
of testing the application.
• Generally, it is prepared to understand the flow of an
application. It does not consist of any inputs and navigation
steps.
Faculty of Computer Applications & IT
Types of Documentation
Test Case
• It is an in-details document that describes step by step
procedure to test an application.
• It consists of the complete navigation steps and inputs and all
the scenarios that need to be tested for the application.
• We will write the test case to maintain the consistency, or
every tester will follow the same approach for organizing the
test document.
Faculty of Computer Applications & IT
Types of Documentation
Test Plan
• It is a document that is prepared by the managers or test lead.
• It consists of all information about the testing activities.
• The test plan consists of multiple components such as
Objectives, Scope, Approach, Test Environments, Test
methodology, Template, Role & Responsibility, Effort
estimation, Entry and Exit criteria, Schedule, Tools, Defect
tracking, Test Deliverable, Assumption, Risk, and Mitigation
Plan or Contingency Plan.
Faculty of Computer Applications & IT
Types of Documentation
Requirement Traceability Matrix (RTM)
• The Requirement traceability matrix [RTM] is a document which
ensures that all the test case has been covered.
• This document is created before the test execution process to
verify that we did not miss writing any test case for the
particular requirement.
Faculty of Computer Applications & IT
Types of Documentation
Test Strategy
• The test strategy is a high-level document, which is used to
verify the test types (levels) to be executed for the product
and also describe that what kind of technique has to be used
and which module is going to be tested.
• The Project Manager can approve it.
• It includes the multiple components such as documentation
formats, objective, test processes, scope, and customer
communication strategy, etc. we cannot modify the test
strategy.
Faculty of Computer Applications & IT
Types of Documentation
Test Data
• It is data that occurs before the test is executed.
• It is mainly used when we are implementing the test case.
• The test data can be used to check the expected result, which
means that when the test data is entered, the expected
outcome will meet the actual result and also check the
application performance by entering the in-correct input data.
Faculty of Computer Applications & IT
Types of Documentation
Bug Report
• The bug report is a document where we maintain a summary of
all the bugs which occurred during the testing process.
• This is a crucial document for both the developers and test
engineers because, with the help of bug reports, they can
easily track the defects, report the bug, change the status of
bugs which are fixed successfully, and also avoid their
repetition in further process.
Faculty of Computer Applications & IT
Types of Documentation
Test Execution Report
• It is the document prepared by test leads after the entire
testing execution process is completed.
• The test summary report defines the constancy of the product,
and it contains information like the modules, the number of
written test cases, executed, pass, fail, and their percentage.
Faculty of Computer Applications & IT
Importance of Design Documentation
• Requirements are well understood: With proper documentation, we can remove
inconsistencies and conflicts about the requirements. Requirements are well
understood by every team member.
• Architecture/Design of product: Architecture/Design documents give us a
complete overview of how the product look like and better insight to the
customer/user about their product.
• New Person can also work on the project: New person to the project can very
easily understand the project through documentations and start working on it.
So, developers need to maintain the documentation and keep upgrading it
according to the changes made in the product/software.
• Everything is well Stated: This documentation is helpful to understand each
and every working of the product. It explains each and every feature of the
product/software.
• Proper Communication: Through documentation, we have good
communication with every member who is part of the project/software. Helpful
in understanding role and contribution of each and every member.
Faculty of Computer Applications & IT
Designing Documentation Structure
Introduction
• Purpose: Outline the purpose of the documentation and its intended audience
(developers, testers, project managers, etc.).
• Scope: Define what the documentation covers, including specific components or
modules of the software.
• Overview: Provide a brief overview of the software, including its goals and key
features.
System Architecture
• Architectural Overview: High-level description of the system architecture,
including key components and their interactions.
• Diagrams: Include architectural diagrams such as component diagrams,
deployment diagrams, and class diagrams.
• Technology Stack: Describe the technologies, frameworks, and tools used in the
system. Faculty of Computer Applications & IT
Designing Documentation Structure
Design Documentation
• Detailed Design: In-depth design of the software, including:
• Class Diagrams: Representation of classes, attributes, methods, and
relationships.
• Sequence Diagrams: Interaction between objects in a particular sequence.
• Activity Diagrams: Workflow of the system or processes..
• API Design: Specifications for any APIs, including endpoints, request/response
formats, and authentication methods.
• Data Design: Database schema, data models, and data flow diagrams.
Faculty of Computer Applications & IT
Designing Documentation Structure
Coding Standards
• Code Style Guidelines: Coding conventions and standards to ensure consistency
across the codebase.
• Naming Conventions: Guidelines for naming classes, methods, variables, and
other code elements.
• Commenting and Documentation: Standards for code comments and inline
documentation.
Development Process
• Development Workflow: Description of the development process, including
branching strategies, pull requests, and code reviews.
• Version Control: Guidelines for using version control systems (e.g., Git),
including branching strategies and commit message conventions.
• Build and Deployment: Instructions for building and deploying the software,
including build scripts and deployment pipelines.
Faculty of Computer Applications & IT
Designing Documentation Structure
Testing
• Test Plan: Overview of the testing strategy, including objectives, scope, and types of
testing (unit, integration, system, acceptance).
• Test Cases: Detailed test cases, including input conditions, expected results, and
execution steps.
• Testing Tools: Tools and frameworks used for testing (e.g., JUnit, Selenium).
• Bug Tracking: Procedures for reporting and tracking bugs, including tools and
workflows.
User Documentation
• User Guides: Documentation for end-users, including how-to guides, FAQs, and
troubleshooting tips.
• API Documentation: Detailed documentation for APIs, including usage examples and
code snippets.
• Installation and Configuration: Instructions for installing and configuring the software.
Faculty of Computer Applications & IT
Designing Documentation Structure
Maintenance and Support
• Maintenance Plan: Guidelines for maintaining and updating the software, including
handling deprecated features and technical debt.
• Support Procedures: Processes for providing user support, including issue resolution
and escalation paths.
Appendices
• Glossary: Definitions of terms and acronyms used in the documentation.
• References: List of external resources, libraries, and tools referenced in the
documentation.
• Change Log: Record of changes made to the documentation and the software.
Faculty of Computer Applications & IT
Identifying Navigation Terms
In software development documentation, identifying navigation terms is
crucial for ensuring clarity and usability in user interfaces, system
documentation, and design specifications.
Some of the common navigation-related terms with reference to
software development processes are:
• Dashboard: A central interface that provides an overview of the
system’s key metrics, features, or functions. It often includes widgets
or panels for quick access to important data.
• Navigation Bar (Nav Bar): A horizontal or vertical bar that contains
links or buttons to different sections of the software. It is typically
located at the top or side of the interface.
• Tabs: Interface elements that allow users to switch between different
views or sections within the same page or window, often organized
into labeled categories.
• Context Menu: A menu that appears upon right-clicking or interacting
with a specific element, providing relevant actions or options for that
element. Faculty of Computer Applications & IT
Identifying Navigation Terms
• Sidebar: A vertical panel that typically provides additional navigation
options, tools, or shortcuts. It is often used to group related features
or sections.
• Breadcrumb Navigation: A hierarchical navigation aid that shows the
user’s current location relative to the structure of the application or
document. It allows users to backtrack through previous sections.
• Accordion Menu: A type of collapsible menu that expands or collapses
to reveal or hide content or sub-menus, often used to save space and
organize information hierarchically.
• Pagination: Controls that allow users to navigate through pages of
content, such as in search results or lists. It typically includes
"Previous," "Next," and page number links.
• Search Functionality: A feature that allows users to enter search
queries to find specific content or functionality within the software. It
may include advanced filters or options.
• Link: A clickable element that directs users to another page, section,
or resource within the application orApplications
Faculty of Computer external & ITwebsites.
Identifying Navigation Terms
• Modal Window: A temporary, overlay window that provides additional
content or options without navigating away from the current page. It
often requires user interaction before returning to the main interface.
• Tooltips: Small informational boxes that appear when a user hovers
over or clicks on an element, providing additional details or guidance.
• User Interface (UI) Controls: Interactive elements such as buttons,
sliders, and checkboxes that facilitate navigation and interaction
within the application.
• Route: In web and app development, a route defines a specific path or
URL that maps to a particular view or component within the
application. It helps in managing navigation between different parts of
the software.
• Navigation Tree: A hierarchical representation of the application’s
structure, often used to visualize and access various sections or
features.
Faculty of Computer Applications & IT
Applying the Concepts
at TuneSource
Faculty of Computer Applications & IT
Tune Source
• In the context of Object-Oriented Analysis and Design (OOAD),
applying the concepts of "Tune Source" to managing programming,
testing, and developing user documentation can be seen as part of
the software development process.
Faculty of Computer Applications & IT
Tune Source: Managing Programming
• Optimizing Code Structure and Performance:
After the initial design phase, tuning source code is crucial to ensure
the system runs efficiently.
This might involve refactoring the object-oriented design to reduce
redundancy, improve inheritance hierarchies, or minimize the
complexity of class interactions.
Managing the programming phase could involve using design patterns
to streamline code structure and make future enhancements easier.
Example: If there are objects that are too tightly coupled, consider
using dependency injection to decouple them and improve
maintainability.
Faculty of Computer Applications & IT
Tune Source: Managing Programming
• Enforcing OOAD Principles:
Ensure that programmers adhere to core OOAD principles like
encapsulation, inheritance, and polymorphism.
Apply the SOLID principles during the programming process to ensure
the codebase remains flexible and adaptable over time.
Example: The Single Responsibility Principle (SRP) suggests that a class
should have only one reason to change, which simplifies management
and future tuning of the source code.
Faculty of Computer Applications & IT
Tune Source: Testing
• Test-Driven Development (TDD):
In OOAD, test-driven development can help tune the source by
ensuring that objects and their interactions behave as expected.
Writing unit tests for each class, method, and object ensures that the
software is designed and functioning correctly.
Example: A class representing a bank account might have methods like
deposit(), withdraw(), and checkBalance().
TDD ensures that each method is correctly implemented by writing
tests before actual development, keeping the design clean and
preventing bugs.
Faculty of Computer Applications & IT
Tune Source: Testing
• Object-Oriented Testing:
Object-oriented systems require testing of both state and behavior.
Methods should be tested for their outcomes as well as how objects
interact (e.g., using mocking for complex object interactions).
Tuning the source here could mean revisiting the object model if
testing reveals weaknesses in the class designs.
For example, if testing shows that certain classes are doing too much,
you might refactor them into smaller, more cohesive objects.
Faculty of Computer Applications & IT
Tune Source: Testing
• Automated Testing:
Automated testing frameworks ensure that tuning the source code does
not break any functionality.
By running tests continuously, developers get instant feedback on the
quality of their object-oriented design.
Example: Continuous Integration (CI) systems automatically run tests
after every commit, ensuring that new code fits well with the existing
object-oriented structure and that any tuning or refactoring does not
introduce bugs.
Faculty of Computer Applications & IT
Tune Source: Developing User Documentation
• Object-Oriented Documentation:
User documentation in an object-oriented system should be modular
and reflect the structure of the system itself.
Each class or object should be documented in terms of its
responsibility, methods, and interactions with other objects.
Example: For a class like Car, the documentation should describe how
to use the methods (e.g., start(), stop(), accelerate()) and what
attributes (e.g., fuel_level, speed) it has.
Faculty of Computer Applications & IT
Tune Source: Developing User Documentation
• Maintaining Documentation Along with Code Tuning:
As you tune and optimize the source code (e.g., refactoring classes or
methods), the user documentation should be updated to reflect these
changes.
This ensures that the documentation stays accurate and useful.
Example: If a method signature is changed as part of tuning (e.g.,
adding new parameters or modifying behavior), the corresponding
documentation must explain these new parameters and how they affect
the object’s usage.
Faculty of Computer Applications & IT
Tune Source: Developing User Documentation
• Generating Documentation from Code:
Tools like can automatically generate user documentation from the
source code itself.
This ensures that any tuned or optimized parts of the system are
reflected accurately in the documentation.
Example: After optimizing a class’s methods and properties, these tools
can regenerate the documentation to include new or changed
information, reducing manual work.
Faculty of Computer Applications & IT
Tune Source: Developing User Documentation
• UML Diagrams and System Documentation:
In object-oriented systems, visual diagrams such as UML class
diagrams, sequence diagrams, and use case diagrams are often part of
the documentation.
These diagrams help users and developers understand the system’s
structure, object interactions, and behavior.
Example: If objects or relationships are tuned (e.g., class inheritance is
restructured), corresponding UML diagrams should be updated to
maintain consistency between the documentation and the actual code
Faculty of Computer Applications & IT
Tune Source: Conclusion
• In the OOAD process, "Tune Source" can be applied by:
Managing and optimizing the object-oriented source code during
programming.
Ensuring rigorous testing to verify that object-oriented principles are
maintained and optimized in practice.
Keeping user documentation updated and aligned with the tuned object
structures, methods, and interactions.
This approach leads to a more maintainable, performant, and
understandable system that is easier to extend or modify in the future.
Faculty of Computer Applications & IT