Unit -1

Problem Solving:
A general process of problem solving involves the following steps.

1. Understanding the problem

2. Describing the problem in a clear, complete and error free from

3. Designing a solution to the problem by algorithm

4. Developing a computer solution to the problem

5. Testing the solution

1. Program Analysis:

Analyze the problem and what desire output you want. Analysis and gathering knowledge about the
requirement from problem. Try to identify what requirement you need as a [Link] define what
the program is to do. Clarify output and processing tasks. Define your program techniques and financial,
legal feasible or not. And document the analysis.

[Link] Designing:

All the functionality converted into graphical form. Designing is a process of problem solving and
planning for a solution developer will design to develop a plan for solution using diagrammatic
representation using flowchart, data flow diagram, decision tree all these tools are used.
3. Coding:

After designing coding steps comes. The goal of coding is to translate the design of the system into code
in a given programming language. It’s a process of developing the program well written code can reduce
the testing and maintenance effort.

4. program debugging:

Bug means “Error” and debugging means correct the error.

In this step developer test the program and try to find out any error and if error occurs then fix it. After
testing program to ensure that all modules working correctly or not.

5. Program documentation:

For programmer it is easy to understand program and code but general user cannot understand
programming code and program working how to operate so it’s a responsibility of developer to create a
program with user manual documents. It is a instruction manual book or guide help user to understand
working or program start to end. This manual guide is called program documentation.

6. Maintenance:

Used to correct and upgrade program.

Problem Definition

Problem definition is simply identifying what you need the program to do. It involves understanding the
task at hand, gathering all necessary information, and then laying out a step-by-step solution before
even thinking about writing code. In Python, as with any language, you need to have a clear
understanding of the problem before jumping into coding. Without this clarity, you might end up
creating a program that doesn't solve the actual problem or only partially addresses it.

Why Is It Important?

Problem definition is like a roadmap for coding. It saves time, prevents errors, and makes coding more
efficient. Here's why it’s essential:

1. Prevents confusion: Without a clear definition, you might not know where to start or what steps
to take.

2. Reduces errors: A good problem definition helps you avoid common mistakes and missed
details.

3. Saves time: Instead of writing code that doesn’t work or has to be rewritten, you can get things
right the first time.

4. Improves focus: A clearly defined problem helps you stay on track, focusing on what matters
without getting distracted by irrelevant issues.
Steps for Defining a Problem in Python

1. Understand the Problem

Before you even think about Python code, you need to fully understand the problem. Ask yourself
questions like:

• What are the inputs and outputs?

• What is the goal of the problem?

• Are there any specific constraints (e.g., time limits, memory usage)?

Let’s take an example: You are tasked with creating a Python program that calculates the average of a list
of numbers.

Here, the problem is clear. The input is a list of numbers, and the output is their average.

2. Break the Problem into Smaller Parts

Once you understand the overall problem, break it down into smaller tasks or components. This makes it
easier to tackle and allows you to focus on one thing at a time.

Using our example:

• First, you need to get the list of numbers.

• Then, sum all the numbers.

• Finally, divide the sum by the number of elements in the list to get the average.

By breaking it down, you've simplified the problem into manageable parts, making it easier to approach
each step logically.

3. Think About the Edge Cases

Edge cases are unusual situations that might cause problems in your code if not considered. Think of
scenarios that might break your program or return incorrect results. In the average calculation example,
possible edge cases include:

• What if the list is empty? Your program might try to divide by zero, which is an error.

• What if the list contains non-numeric values? This could cause issues when summing the
numbers.

Anticipating these problems in advance helps you write more robust and error-free code.

4. Design the Solution

Now that you understand the problem and have considered edge cases, you can design a solution. This
doesn’t mean jumping right into coding yet, but instead sketching out the logic of how your program will
work.

For the average calculation:

 1. You will need a way to input the list of numbers.

2. You will sum the numbers using a loop or built-in function.

3. You will divide the sum by the length of the list.

4. You will handle any errors, such as an empty list or invalid input.

Program design consists of the steps a programmer should do before they start coding the program in a
specific language. These steps when properly documented will make the completed program easier for
other programmers to maintain in the future. There are three broad areas of activity:

• Understanding the Program

• Using Design Tools to Create a Model

• Develop Test Data

Understanding the Program

If you are working on a project as one of many programmers, the system analyst may have created a
variety of documentation items that will help you understand what the program is to do. These could
include screen layouts, narrative descriptions, documentation showing the processing steps, etc. If you
are not on a project and you are creating a simple program you might be given only a simple description
of the purpose of the program. Understanding the purpose of a program usually involves understanding
its:

• Inputs

• Processing

• Outputs

This IPO approach works very well for beginning programmers. Sometimes, it might help to visualize the
program running on the computer. You can imagine what the monitor will look like, what the user must
enter on the keyboard and what processing or manipulations will be done.

Using Design Tools to Create a Model

At first, you will not need a hierarchy chart because your first programs will not be complex. But as they
grow and become more complex, you will divide your program into several modules (or functions).

The first modeling tool you will usually learn is pseudocode. You will document the logic or algorithm of
each function in your program. At first, you will have only one function, and thus your pseudocode will
follow closely the IPO approach above.

There are several methods or tools for planning the logic of a program. They include: flowcharting,
hierarchy or structure charts, pseudocode, HIPO, Nassi-Schneiderman charts, Warnier-Orr diagrams, etc.
Programmers are expected to be able to understand and do flowcharting and pseudocode. These
methods of developing the model of a program are usually taught in most computer courses. Several
standards exist for flowcharting and pseudocode and most are very similar to each other. However, most
companies have their own documentation standards and styles. Programmers are expected to be able to
quickly adapt to any flowcharting or pseudocode standards for the company at which they work. The
other methods that are less universal require some training which is generally provided by the employer
that chooses to use them.

Later in your programming career, you will learn about using application software that helps create an
information system and/or programs. This type of software is called Computer-Aided Software
Engineering (CASE).

Understanding the logic and planning the algorithm on paper before you start to code is a very
important concept. Many students develop poor habits and skipping this step is one of them.

Develop Test Data

Test data consists of the programmer providing some input values and predicting the outputs. This can
be quite easy for a simple program and the test data can be used to check the model to see if it produces
the correct results.

Debugging is the process of finding, isolating and resolving coding errors known as bugs in software
programs. Debugging helps uncover the cause of coding errors, prevent software function issues and
improve the overall performance of software.

Coding errors such as logical errors, runtime errors, syntax errors and semantic errors can lead to
crashes, incorrect or inaccurate outputs, security vulnerabilities and data loss. Unlike software testing,
which enables developers to investigate the effects of these errors in a program’s source code,
debugging seeks the root cause and remediation of these errors.

Through the debugging process, software developers conduct root cause analysis to make sure bugs that
are found in computer programs are fixed and do not happen again. Bugs can negatively impact software
stability, reliability and user experience. Debugging tools and strategies help optimize the debugging
process.

Semantic errors

A piece of code that violates the rules of a coding language cause a semantic error. Unlike a logical error,
which produces an incorrect output, a semantic error will not produce a meaningful output.

Syntax errors

This error occurs when a developer misses an element of code such as a parenthesis, comma or other
typographical error. Unlike in written human languages where a sentence with a typographical error
might still be understood, missing pieces of code immediately cause errors.

Logical errors

This type of bug includes syntax that is technically correct but has incorrect directions that cause an
undesired output. Because the syntax is correct, these errors can be difficult to detect. When a system
does not immediately crash and the exact location of the incorrect code can be time-consuming to find.

Runtime errors
These errors happen when an application is running or starting up. Runtime errors can occasionally be
fixed by refreshing, restarting or reinstalling an application. Other times they can be a signal of a
program that requires more memory or of another type of error such as a logical error.

DEBUGGING
Debugging is the process of fixing a bug in the program/software. They use different debugging tools to
carefully go through the code, step by step, find the issue, and make the necessary corrections.

Process of Debugging:

Debugging is a crucial skill in programming.

Step 1: Reproduce the Bug

To start, you need to recreate the conditions that caused the bug. This means making the error happen
again so you can see it firsthand.

Step 2: Locate the Bug

Find where the bug is in your code. This involves looking closely at your code and checking any error
messages or logs. Developers often use debugging tools to help with this step.

Step 3: Identify the Root Cause

Examine the logic and flow of your code and see how different parts interact under the conditions that
caused the bug.

Step 4: Fix the Bug

This involves making changes and then testing the program to ensure the bug is gone.

Step 5: Test the Fix

After fixing the bug, run tests to ensure everything works correctly. These tests include:

Unit Tests: Check the specific part of the code that was changed.

Integration Tests: Verify the entire module where the bug was found.

System Tests: Test the whole system to ensure overall functionality.

Regression Tests: Make sure the fix didn’t cause any new problems elsewhere in the application.
Step 6: Document the Process

Write down what caused the bug, how you fixed it, and any other important details.

Advantages of Debugging

Improved system quality: By identifying and resolving bugs, a software system can be made more reliable
and efficient, resulting in improved overall quality.

Reduced system downtime: By identifying and resolving bugs, a software system can be made more stable
and less likely to experience downtime, which can result in improved availability for users.

Increased user satisfaction: By identifying and resolving bugs, a software system can be made more user-
friendly and better able to meet the needs of users, which can result in increased satisfaction.

Reduced development costs: Identifying and resolving bugs early in the development process, can save
time and resources that would otherwise be spent on fixing bugs later in the development process or after
the system has been deployed.

Increased security: By identifying and resolving bugs that could be exploited by attackers, a software
system can be made more secure, reducing the risk of security breaches.

Facilitates change: With debugging, it becomes easy to make changes to the software as it becomes easy
to identify and fix bugs that would have been caused by the changes.

Better understanding of the system: Debugging can help developers gain a better understanding of how a
software system works, and how different components of the system interact with one another.

Facilitates testing: By identifying and resolving bugs, it makes it easier to test the software and ensure that
it meets the requirements and specifications.

***