Unit 3

Q Difference between cohesion and coupling

Q Explain user interface design model and user interface design principle

• User interface is the front-end application view to which user interacts in order to use the
software. The software becomes more popular if its user interface is:

• Attractive

• Simple to use

• Responsive in short time

 • Clear to understand

• Consistent on all interface screens

• There are two types of User Interface:

1. Command Line Interface: Command Line Interface provides a command prompt, where the
user types the command and feeds to the system. The user needs to remember the syntax of
the command and its use.

2. Graphical User Interface: Graphical User Interface provides the simple interactive interface
to interact with the system. GUI can be a combination of both hardware and software. Using
GUI, user interprets the software.

User Interface Design Process:

The analysis and design process of a user interface is iterative and can be represented by a spiral
model. The analysis and design process of user interface consists of four framework activities.

1. User, task, environmental analysis, and modeling: Initially, the focus is based on the profile
of users who will interact with the system, i.e. understanding, skill and knowledge, type of
user, etc, based on the user’s profile users are made into categories. From each category
requirements are gathered. Based on the requirements developer understand how to
develop the interface. Once all the requirements are gathered a detailed analysis is
conducted. In the analysis part, the tasks that the user performs to establish the goals of the
system are identified, described and elaborated. The analysis of the user environment
focuses on the physical work environment.
2. Interface Design: The goal of this phase is to define the set of interface objects and actions
i.e. Control mechanisms that enable the user to perform desired tasks. Indicate how these
control mechanisms affect the system. Specify the action sequence of tasks and subtasks,
also called a user scenario. Indicate the state of the system when the user performs a
particular task. Always follow the three golden rules stated by Theo Mandel. Design issues
such as response time, command and action structure, error handling, and help facilities are
considered as the design model is refined. This phase serves as the foundation for the
implementation phase.
3. Interface construction and implementation: The implementation activity begins with the
creation of prototype (model) that enables usage scenarios to be evaluated. As iterative
design process continues a User Interface toolkit that allows the creation of windows,
menus, device interaction, error messages, commands, and many other elements of an
interactive environment can be used for completing the construction of an interface.
4. Interface Validation: This phase focuses on testing the interface. The interface should be in
such a way that it should be able to perform tasks correctly and it should be able to handle a
variety of tasks. It should achieve all the user’s requirements. It should be easy to use and
easy to learn. Users should accept the interface as a useful one in their work.
The Golden Rules
1. Place the user in control
2. Reduce the User’s Memory Load
3. Make the Interface Consistent
• The following are the golden rules stated by Theo Mandel that must be followed during the
design of the interface.
1. Place the user in control:
• Define the interaction modes in such a way that does not force the user into unnecessary or
undesired actions: The user should be able to easily enter and exit the mode with little or no
effort.
• Provide for flexible interaction: Different people will use different interaction mechanisms,
some might use keyboard commands, some might use mouse, some might use touch screen,
etc, Hence all interaction mechanisms should be provided.
• Allow user interaction to be interruptible and undoable: When a user is doing a sequence of
actions the user must be able to interrupt the sequence to do some other work without
losing the work that had been done. The user should also be able to do undo operation.
• Streamline interaction as skill level advances and allow the interaction to be customized:
Advanced or highly skilled user should be provided a chance to customize the interface as
user wants which allows different interaction mechanisms so that user doesn’t feel bored
while using the same interaction mechanism.
• Hide technical internals from casual users: The user should not be aware of the internal
technical details of the system. He should interact with the interface just to do his work.
• Design for direct interaction with objects that appear on screen: The user should be able to
use the objects and manipulate the objects that are present on the screen to perform a
necessary task. By this, the user feels easy to control over the screen.
2. Reduce the user’s memory load:
• Reduce demand on short-term memory: When users are involved in some complex tasks the
demand on short-term memory is significant. So the interface should be designed in such a
way to reduce the remembering of previously done actions, given inputs and results.
• Establish meaningful defaults: Always initial set of defaults should be provided to the average
user, if a user needs to add some new features then he should be able to add the required
features.
• Define shortcuts that are intuitive: Mnemonics should be used by the user. Mnemonics
means the keyboard shortcuts to do some action on the screen.
• The visual layout of the interface should be based on a real-world metaphor: Anything you
represent on a screen if it is a metaphor for real-world entity then users would easily
understand.
• Disclose information in a progressive fashion: The interface should be organized
hierarchically i.e. on the main screen the information about the task, an object or some
 behavior should be presented first at a high level of abstraction. More detail should be
presented after the user indicates interest with a mouse pick.
3. Make the interface consistent:
• Allow the user to put the current task into a meaningful context: Many interfaces have
dozens of screens. So it is important to provide indicators consistently so that the user know
about the doing work. The user should also know from which page has navigated to the
current page and from the current page where can navigate.
• Maintain consistency across a family of applications: The development of some set of
applications all should follow and implement the same design, rules so that consistency is
maintained among applications.
• If past interactive models have created user expectations do not make changes unless there
is a compelling reason.
*User interface design*
• User interface (UI) design is the process designers use to build interfaces in software or
computerized devices, focusing on looks or style. Designers aim to create interfaces which
users find easy to use and pleasurable. UI design refers to graphical user interfaces and other
forms—e.g., voice-controlled interfaces.
• The various types of user interfaces include: graphical user interface (GUI) command line
interface (CLI) menu-driven user interface.
• 4 pillars of Design: Navigation, Presentation, Content, and Interaction help to design a
beautifully crafted user-centric product. The visual design focuses on the aesthetics of a
product and its related materials by artistically implementing images, colors, fonts, and other
elements
• User Interface (UI) Design is the link between users and your website. It includes the basic
design elements that need to be present in order to for someone to navigate your site and
make decisions. It is the ever-evolving relationship between a person and the system that
they are using.

Q Difference between COCOMO1 and COCOMO2 Model

COCOMO I COCOMO II

COCOMO I is useful in the COCOMO II is useful in non-

waterfall models of the software sequential, rapid development
development cycle. and reuse models of software.

It provides estimates that

It provides estimates of effort
represent one standard deviation
and schedule.
around the most likely estimate.

This model is based upon the This model is based upon the non
linear reuse formula. linear reuse formula
 This model is also based upon
This model is also based upon the
reuse model which looks at effort
assumption of reasonably stable
needed to understand and
requirements.
estimate.

Effort equation’s exponent is

Effort equation’s exponent is
determined by 3 development
determined by 5 scale factors.
modes.

Development begins with the

It follows a spiral type of
requirements assigned to the
development.
software.

Number of submodels in In COCOMO II, Number of

COCOMO I is 3 and 15 cost submodel are 4 and 17 cost
drivers are assigned drivers are assigned

Size of software stated in terms

Size of software stated in terms
of Object points, function points
of Lines of code
and lines of code

Q Art of Debugging

• Debugging is the process of identifying and resolving errors, or bugs, in a software system.

• It is an important aspect of software engineering because bugs can cause a software system
to malfunction, and can lead to poor performance or incorrect results.

• Debugging can be a time-consuming and complex task, but it is essential for ensuring that a
software system is functioning correctly.
Techniques used in debugging

1. Code Inspection: This involves manually reviewing the source code of a software system to
identify potential bugs or errors.

2. Debugging Tools: There are various tools available for debugging such as debuggers, trace
tools, and profilers that can be used to identify and resolve bugs.

3. Unit Testing: This involves testing individual units or components of a software system to
identify bugs or errors.

4. Integration Testing: This involves testing the interactions between different components of a
software system to identify bugs or errors.

5. System Testing: This involves testing the entire software system to identify bugs or errors.

6. Monitoring: This involves monitoring a software system for unusual behavior or performance
issues that can indicate the presence of bugs or errors.

7. Logging: This involves recording events and messages related to the software system, which
can be used to identify bugs or errors.

Debugging Process: Steps involved in debugging are:

• Problem identification and report preparation.

• Assigning the report to the software engineer defect to verify that it is genuine.

• Defect Analysis using modeling, documentation, finding and testing candidate flaws, etc.

• Defect Resolution by making required changes to the system.

• Validation of corrections.

• The debugging process will always have one of two outcomes :

1. The cause will be found and corrected.

2. The cause will not be found.

Debugging Approaches/Strategies:

1. Brute Force: Study the system for a larger duration in order to understand the system. It
helps the debugger to construct different representations of systems to be debugged
depending on the need. A study of the system is also done actively to find recent changes
made to the software.

2. Backtracking: Backward analysis of the problem which involves tracing the program
backward from the location of the failure message in order to identify the region of faulty
code. A detailed study of the region is conducted to find the cause of defects.

3. Forward analysis of the program involves tracing the program forwards using breakpoints or
print statements at different points in the program and studying the results. The region
where the wrong outputs are obtained is the region that needs to be focused on to find the
defect.
4. Using past experience with the software debug the software with similar problems in
nature. The success of this approach depends on the expertise of the debugger.

5. Cause elimination: it introduces the concept of binary partitioning. Data related to the error
occurrence are organized to isolate potential causes.

6. Static analysis: Analyzing the code without executing it to identify potential bugs or errors.
This approach involves analyzing code syntax, data flow, and control flow.

7. Dynamic analysis: Executing the code and analyzing its behavior at runtime to identify errors
or bugs. This approach involves techniques like runtime debugging and profiling.

8. Collaborative debugging: Involves multiple developers working together to debug a system.

This approach is helpful in situations where multiple modules or components are involved,
and the root cause of the error is not clear.

9. Logging and Tracing: Using logging and tracing tools to identify the sequence of events
leading up to the error. This approach involves collecting and analyzing logs and traces
generated by the system during its execution.

10. Debugging: The use of automated tools and techniques to assist in the debugging process.
These tools can include static and dynamic analysis tools, as well as tools that use machine
learning and artificial intelligence to identify errors and suggest fixes.

Debugging Tools:

Radare2

WinDbg

Valgrind

Difference Between Debugging and Testing: Debugging is different from testing. Testing
focuses on finding bugs, errors, etc whereas debugging starts after a bug has been identified
in the software. Testing is used to ensure that the program is correct and it was supposed to
do with a certain minimum success rate.

Advantages of Debugging:

• Improved system quality

• Reduced system downtime

• Increased user satisfaction

• Reduced development costs

• Increased security

• Facilitates change

• Better understanding of the system

• Facilitates testing
Disadvantages of Debugging:

• Time-consuming

• Requires specialized skills

• Can be difficult to reproduce

• Can be difficult to diagnose

• Can be difficult to fix

• Limited insight

• Can be expensive

Q Differences between Black Box Testing vs White Box Testing:

Q RFP and their 7 steps and how to create RFP

RFP (Request for Proposal)

• A Request for Proposal is a formal document that outlines the requirements, scope, and
objectives of a project, inviting qualified vendors or contractors to submit their proposals for
consideration.

• RFPs are commonly used when an organization seeks to procure goods, services, or solutions
for a project.

• They provide a clear framework for potential vendors to understand the project's needs and
deliver tailored solutions.

The 7 Steps in an RFP Process

• Creating an effective RFP involves a systematic process that ensures all necessary details are
communicated to potential vendors.

• The following are the seven key steps in an RFP process:

1. Project Initiation

• Clearly define the project's objectives, scope, timeline, and budget. Identify the need for
external vendors and outline the specific requirements.

2. Drafting the RFP

• Craft a comprehensive RFP document that includes the project's background, scope of work,
specifications, evaluation criteria, and submission guidelines.
3. Vendor Selection

• Identify potential vendors based on their expertise, track record, and alignment with the
project's goals. Create a shortlist of candidates to receive the RFP.

4. Distribution of RFP

• Send the RFP to the shortlisted vendors and provide them with ample time to review the
document, ask questions, and seek clarifications.

5. Vendor Clarifications

• Address vendor inquiries promptly and transparently, ensuring a clear understanding of the
project's requirements and expectations.

6. Proposal Submission

• Receive and evaluate vendor proposals according to the specified guidelines and evaluation
criteria.

7. Evaluation and Award

• Assess vendor proposals based on predetermined criteria, negotiate terms, and select the
vendor that best aligns with the project's needs and goals.

How to Create an RFP in Project Management?

• Creating a well-crafted RFP requires attention to detail and clear communication. Below is a
step-by-step guide to creating an effective RFP:

• Define Project Objectives: Clearly outline the project's objectives, scope, deliverables, and
expected outcomes.

• Scope of Work: Describe the tasks and responsibilities of the vendor, including specific
requirements and any relevant technical details.

• Project Timeline: Provide a timeline with key milestones, deadlines, and expected project
duration.

• Budget: Specify the budget for the project, including any cost constraints, payment terms,
and pricing structure.

• Evaluation Criteria: Define the criteria that will be used to evaluate vendor proposals, such as
technical capabilities, experience, cost, and approach.

• Submission Guidelines: Clearly outline the vendor proposals' format, content, and
submission instructions.

• Legal and Contractual Details: Include any legal requirements, terms and conditions, and
intellectual property considerations.

• Contact Information: Provide a point of contact for vendor inquiries and clarifications.