Programmed Title : Diploma in Computing

Learner’s name : Min Thukha Kyaw

Learner’s ID No : RF37178

Unit No :1

Unit Title : Programming

Assignment No : 3 of 3

Assignment Title : Implementing algorithms and Explanation of debugging process and coding
standard

Date of submission : 14. 10.2023

1
Table of Contents
1. Program Development Process using IDE..................................................................................................3
2. Evaluation of using IDE and without using IDE........................................................................................6
2.1 Using IDE............................................................................................................................................6
2.2 Without using IDE...............................................................................................................................6
3. Explanation of debugging process and facilities........................................................................................7
3.1 What is Debugging?..............................................................................................................................7
3.2 Debugging Process...................................................................................................................................8
3.3 explain the debugging facilities available in the IDE...............................................................................9
4. Evaluate how the debugging process can be used to help develop more secure, robust applications. .11
5. Evaluate the role and purpose of a coding standard and why it is necessary in a team as well as for the
individual..........................................................................................................................................................12
6. Explain the coding standard you have used in your code.........................................................................14
References........................................................................................................................................................15

2
1. Program Development Process using IDE

Open Eclipse IDE software. Click the ‘file’. After, click ‘new’. Create a new project.

3
 Create a
Java
project.
Give
the Calcul
at or a name
in the space
provided.
To create a
project,
click
"Finish"
after
giving it a name.

4
 Create
a new Java package. Write the name of the Java package. Click the finish button.

Click the class. Create a new class and write the name of the calculator. Click the finish button.

5
Write a source code in the calculator class. Eclipse software IDE provides auto compilation.

Click the “Run” button.

Run Calculator App will

appear to input data. Click input data.

6
2. Evaluation of using IDE and without using IDE

Developers generally use an IDE, or integrated development environment, to design and test
software. These represent a change from using basic text editors to more cutting-edge technologies
that might help you modify code quickly and effectively. The IDEs often require time to learn and
become proficient in.
2.1 Using IDE
Since Eclipse IDE offers auto compilation, it doesn't need to compile anytime the source code
is corrected. It is made simpler to use library functions (APIs) by providing code help. The code
completion function aids programmers in identifying compile-time errors.

Advantages:

Code Assistance: IDEs offer features like code completion, syntax highlighting, and code
suggestions. This helps developers write code more efficiently and with fewer syntax errors.

Built-in Debugging: IDEs come with built-in debugging tools that make it easier to find and fix
issues in the code.

Project Management: IDEs often provide project management features that help organize code
files, dependencies, and resources.

Version Control Integration: Many IDEs integrate with version control systems like Git, making it
easier to manage code repositories and collaborate with others.

Refactoring Tools: IDEs offer automated refactoring tools that help improve code maintainability
and readability.

Code Templates: IDEs provide code templates for common tasks, reducing the need to write
boilerplate code from scratch.

Disadvantages:

Resource Intensive: Some IDEs can be resource-intensive and slow on older or less powerful
computers.

Learning Curve: Mastering the full potential of an IDE can take time, which might not be suitable
for beginners or those with simple projects.

Vendor Lock-in: Developers may become dependent on specific IDE features, potentially limiting
their ability to switch tools.

2.2 Without using IDE

When making changes to source code, it must be saved and compiled. Due to a lack of
coding support, memorizing library functions is challenging. It is difficult to check for errors without
code completion.

Advantages:

7
Lightweight: Text editors and command-line tools are typically lightweight and can run on low-end
hardware.

Minimal Learning Curve: They are straightforward and have a minimal learning curve compared to
complex IDEs.

Flexibility: Developers have more flexibility to choose tools and workflows that suit their
preferences.

No Vendor Lock-in: There's no dependency on a specific IDE vendor, allowing for tool flexibility.

Disadvantages:

Limited Features: Text editors and command-line tools lack advanced features like integrated
debugging, refactoring, and code suggestions.

Manual Tasks: Developers may need to perform more manual tasks, such as compiling and
debugging code.

Error-Prone: Without the assistance of code analysis and debugging tools, developers are more
prone to errors.

Slower Development: Writing and maintaining code may take longer without the productivity boost
provided by IDE features.

In conclusion, the choice between using an IDE and not using one depends on various
factors, including project complexity, personal preferences, and available resources. For large or
complex projects, an IDE can significantly improve productivity and code quality. However, for
simpler tasks or when resource constraints are a concern, a lightweight text editor or command-line
tools may be more appropriate. Ultimately, the best approach is often a matter of individual or team
preference and the specific requirements of the project.

3. Explanation of debugging process and facilities

Debugging is the process of identifying and fixing errors, bugs, or unexpected behavior in a software
program. It's a crucial part of software development, and modern integrated development
environments (IDEs) provide a range of facilities and tools to aid developers in this process.
3.1 What is Debugging?
In computer programming and engineering, debugging is a multi-step process that involves
identifying an issue, determining what caused it, fixing it, or coming up with a solution. When a
developer is able to find and recreate a code fault in a computer program, the debugging process in
software development gets started. Debugging is a step in both the software testing process and the
entire software development lifecycle.
The debugging process in hardware development seeks out incorrectly installed or configured
hardware components. A JTAG connection test, for instance, might be used by an engineer to debug
connections on an integrated circuit. (Heusser, 2023)

8
3.2 Debugging Process

The debugging process is a critical step in software development that involves identifying, analyzing,
and fixing errors, bugs, or unexpected behavior in a software program. Here are the key steps
involved in the debugging process:

Reproduction of the Issue:

Begin by reproducing the problem consistently. Ensure that you can recreate the issue under
specific conditions or inputs. Reproduction is essential for diagnosing the problem.

Isolation of the Problem:

Once the issue is reproducible, try to isolate it. Determine which part of the code or which module
is causing the problem. You can use various techniques, including code inspection and reviewing
error messages.

Error Identification:

Examine error messages, logs, and any available diagnostic information to identify the nature and
location of the error. Error messages often provide clues about what went wrong.

Debugging Tools and Techniques:

Use debugging tools and techniques to inspect the program's behavior during execution. These
tools include:

Breakpoints: Set breakpoints at specific lines of code to pause program execution and inspect
variables and data.

Step-Through Debugging: Execute the program step by step to understand its flow and identify
the exact point of failure.

Variable Inspection: Examine the values of variables and data structures at runtime.

Call Stack: Review the call stack to understand the sequence of function or method calls leading to
the error.

Watch Expressions: Define watch expressions to monitor specific variables or conditions and
receive notifications when they change.

Conditional Breakpoints: Set breakpoints that trigger only when certain conditions are met.

Interactive Console: Some debugging environments provide interactive consoles for real-time
code execution and variable inspection.

Hypothesis and Testing:

Develop hypotheses about the root cause of the problem based on your analysis. Modify the code to
test these hypotheses. You may need to make small, controlled changes to the code to see their
effects.
9
Regression Testing:

After making changes to the code, perform regression testing to ensure that the problem is resolved
without introducing new issues. Regression tests should cover both the original problem and any
potential side effects of the changes.

Documentation:

Document the debugging process, including the steps taken, the changes made to the code, and any
insights gained. Good documentation helps in the future if similar issues arise or when
collaborating with other team members.

Validation:

Verify that the issue has been resolved. Re-test the software under the same conditions that initially
caused the problem to confirm that it no longer exists.

Code Review:

If your organization follows code review practices, consider having a peer review your changes to
ensure code quality and correctness.

Continuous Improvement:

Reflect on the debugging process and identify ways to prevent similar issues in the future. This
may involve code reviews, automated testing, and improved coding practices.

Debugging can be a challenging and time-consuming process, but it is an essential skill for
software developers. Effective debugging techniques and tools help ensure that software is robust
and reliable.

3.3 explain the debugging facilities available in the IDE.

Integrated Development Environments (IDEs) provide a wide range of debugging facilities

and tools to assist developers in identifying and fixing issues in their code. These facilities are
designed to streamline the debugging process and make it more efficient. Here are some common
debugging facilities available in most modern IDEs: (Anon., 2022)

Breakpoints:

Breakpoints allow developers to pause the execution of their code at specific lines or locations. This
feature is invaluable for inspecting the state of the program at runtime. Developers can set
breakpoints by clicking in the gutter next to the line number.

Step Into, Step Over, and Step Out:

These debugging actions help navigate through the code one step at a time:

Step Into: If the current line contains a function or method call, "Step Into" will take you inside that
function for debugging.

10
Step Over: This action allows you to skip over a function or method call and proceed to the next line
in the current context.

Step Out: If you're inside a function or method, "Step Out" will execute the remaining code in that
function and return to the calling function.

Variable Inspection:

IDEs provide the ability to inspect the values of variables and data structures at runtime. Developers
can hover over variables to see their current values or add them to a watch list for continuous
monitoring.

Call Stack and Frames:

The call stack displays a list of function or method calls, showing the order in which they were
invoked. Developers can navigate through the call stack to understand the flow of program
execution. IDEs also allow users to switch between different frames or contexts in the call stack.

Expression Evaluation:

Developers can evaluate expressions at runtime using the debugging console. This feature is
particularly useful for testing code snippets or verifying the behavior of specific expressions.

Conditional Breakpoints:

Conditional breakpoints allow developers to specify conditions under which a breakpoint should be
triggered. This is helpful when you want to break execution only when certain criteria are met, such
as when a variable reaches a specific value.

Exception Handling:

IDEs provide tools for handling exceptions, including options to pause execution when an exception
is thrown (catchpoint). This helps identify the source of exceptions and inspect their details.

Watch and Evaluate:

Developers can add variables, expressions, or even function calls to a watch list. The IDE will
continuously update the values of these items as the program executes.

Memory and Resource Profiling:

Some IDEs offer memory and resource profiling tools to help identify memory leaks, excessive
resource consumption, and performance bottlenecks.

Code Stepping Options:

IDEs often allow developers to customize the behavior of stepping actions, such as stepping into or
over specific types of code, filtering out library code, or stepping by specific lines or instructions.

Remote Debugging:

11
In some cases, developers need to debug applications running on remote servers or devices. IDEs
support remote debugging by connecting to the remote target, allowing developers to debug code as
if it were running locally.

Version Control Integration:

Many IDEs integrate with version control systems (e.g., Git). This integration allows developers to
view code changes, branches, and commits directly within the IDE, making it easier to track and
debug issues related to code changes.

These debugging facilities in IDEs significantly enhance a developer's ability to identify and
resolve issues in their code efficiently. Using these tools, developers can gain insights into the
runtime behavior of their applications and track down bugs more effectively, ultimately improving
software quality and reliability. (Anon., 2022)

4. Evaluate how the debugging process can be used to help develop more secure, robust
applications

The debugging process plays a crucial role in developing more secure and robust applications.
Let's evaluate how the debugging process can contribute to enhancing the security and robustness of
the provided "Calculator" Java GUI application.

Identifying Security Vulnerabilities:

During the debugging process, developers can scrutinize the code to identify security
vulnerabilities such as input validation issues, insecure data handling, or potential injection attacks.
For example, in the given code, there is a potential division by zero error when handling the "/"
operator. Debugging can help catch such issues and implement proper input validation to prevent
security vulnerabilities.

Testing Boundary Conditions:

Debugging allows developers to test boundary conditions and edge cases. In the calculator
application, debugging can help verify how the application handles extreme values or unexpected
inputs, ensuring that it doesn't crash or produce incorrect results.

Verifying Data Sanitization:

Security often relies on data sanitization and validation. Debugging allows developers to
check if user inputs are properly sanitized to prevent SQL injection, cross-site scripting (XSS), or
other malicious attacks.

Runtime Analysis:

Debugging tools provide runtime analysis capabilities, enabling developers to observe the
application's behavior during execution. This can help detect unexpected behaviors or exceptions that
may lead to security vulnerabilities.

12
Code Review and Inspection:

Debugging encourages developers to review and inspect the code more thoroughly. This can
lead to the discovery of coding errors or insecure practices that might otherwise go unnoticed.

Testing Error Handling:

Robustness is closely related to error handling. Debugging allows developers to simulate

error conditions and check if the application gracefully handles them. In the calculator application,
this includes testing how it handles division by zero errors.

Enhancing Code Quality:

Debugging often leads to code improvements. As developers investigate issues and apply
fixes, they can refactor and optimize code, resulting in a more maintainable and secure application.

Testing for Unauthorized Access:

Security debugging can involve testing for unauthorized access attempts. In the calculator
app, you can verify that only authorized users can perform specific operations and that access control
mechanisms are in place.

Performance Analysis:

While not directly related to security, debugging can help identify performance bottlenecks
and inefficiencies. Optimizing code for performance indirectly contributes to robustness by ensuring
the application can handle a higher load without failures.

Regression Testing:

Debugging is an integral part of regression testing. Whenever a bug is identified and fixed, it
should be accompanied by a new test case to ensure the issue doesn't reoccur in the future. This
process contributes to the long-term robustness of the application.

In summary, the debugging process is a critical step in the development of secure and robust
applications. It helps identify and rectify vulnerabilities, ensures proper error handling, and enhances
overall code quality. By thoroughly debugging applications, developers can reduce the likelihood of
security breaches and build software that is more resilient to unexpected scenarios, ultimately leading
to a more secure and robust final product.

5. Evaluate the role and purpose of a coding standard and why it is necessary in a team as well as
for the individual.

Coding standards play a crucial role in software development, both for individuals and teams, by
providing a set of guidelines and rules for writing code. Their role and purpose are multifaceted and
can greatly benefit the development process. Here's an evaluation of the role and necessity of coding
standards:

Consistency and Readability:

13
 For Individuals: Coding standards ensure that an individual's code is consistent and easy to
read. When revisiting or maintaining code, developers can quickly understand the logic and
structure, reducing errors and speeding up development. For Teams: In a team setting, coding
standards establish a common style and format for code. This consistency allows team members to
review, collaborate on, and understand each other's code more easily.

Maintainability:

For Individuals: Coding standards make an individual's code more maintainable. By

following consistent practices, the codebase remains manageable and adaptable, even when the
original developer is no longer available. For Teams: In a team, the collective adherence to coding
standards ensures that the codebase remains maintainable over time. Any team member can pick up
and work on code written by others without a steep learning curve.

Bug Reduction:

For Individuals: Coding standards help individuals catch errors early, as adherence to these
standards often prevents common coding mistakes. This reduces the time and effort spent on
debugging. For Teams: As teams follow coding standards, the likelihood of introducing bugs due to
coding errors or misunderstandings decreases. This leads to higher software quality.

Collaboration:

For Individuals: When an individual follows coding standards, it becomes easier to

collaborate with others on code. Code reviews are more efficient, and it's simpler to integrate code
written by different team members. For Teams: Coding standards foster a collaborative environment
where team members can seamlessly work together on a shared codebase. The team can focus on
solving complex problems rather than dealing with inconsistent coding styles.

Code Quality:

For Individuals: Adhering to coding standards promotes writing cleaner, more organized, and
higher-quality code. For Teams: A collective commitment to coding standards elevates the overall
code quality of the project. It reduces technical debt and leads to a more robust and reliable product.

Scalability:

For Individuals: Coding standards prepare an individual to work on larger projects or

collaborate with larger teams. The practices learned can be applied to any coding scenario. For
Teams: Teams adhering to coding standards can scale more effectively. As the project grows, the
structure and consistency of the codebase remain intact, making it easier to add new features or
onboard new team members.

Documentation:

For Individuals: Adherence to coding standards can serve as a form of self-documentation.

Code becomes more self-explanatory, reducing the need for extensive comments. For Teams: Coding
standards contribute to the overall documentation of the project. When code is written following
standards, it becomes more understandable and requires fewer external documentation efforts.

Compliance and Regulations:

14
 For Individuals: In certain industries (e.g., healthcare, finance), coding standards are
necessary to ensure compliance with regulations and standards. For Teams: Teams in regulated
industries must adhere to coding standards to meet legal and industry requirements.

In conclusion, coding standards are essential for both individuals and teams in software
development. They enhance code consistency, readability, maintainability, and quality. By reducing
errors and fostering collaboration, coding standards contribute to the success of projects, whether
undertaken by an individual or a team. They are a foundational element of professional software
development practices and help ensure that software is not only functional but also robust and
maintainable over time. (Catarina Gralha,2022)

6. Explain the coding standard you have used in your code.

The code you provided follows several coding standards and best practices:

Naming Conventions: Variable and method names are clear and follow Java naming conventions.
For example, input Field, button Labels, and action Performed.

Indentation: The code is properly indented, making it easy to read and understand.

Comments: Although the code is mostly self-explanatory, comments are provided in a few places to
clarify the purpose of certain code blocks. For example, explaining the functionality of different
sections.

Consistency: The code maintains a consistent coding style throughout, ensuring that variables,
methods, and classes are named in a uniform manner.

Class Structure: The code follows the standard class structure for a Swing-based Java application. It
includes the main class (Calculator) that extends JFrame and implements an ActionListener.

Use of Layout Managers: Proper layout managers (Border Layout and Grid Layout) are used to
organize the user interface components in a structured way.

Font and Styling: The code sets the font and styling for user interface elements, making the
application visually appealing.

Error Handling: The code handles potential errors, such as division by zero, and provides a user-
friendly error message.

ActionListeners: Action listeners are implemented correctly to respond to button clicks and perform
the required operations.

Overall, the code exemplifies good coding standards and practices. It is well-structured, easy
to read, and self-documenting. Additionally, it provides a functional and user-friendly calculator
application.

15
References
Anon., 2018. Auxiliary View Its Types, Methods. [Online]
Available at: https://civilseek.com
[Accessed 01 March 2022].

Anon., 2022. https://ccea.org.uk/downloads/docs/Support/AS%201%20Support/2019/Section%20D%3A%20Fact

%20Files%20-%20Design%20and%20Communication.pdf. [Online]
Available at: https://ccea.org.uk/downloads/docs/Support/AS%201%20Support/2019/Section%20D%3A%20Fact
%20Files%20-%20Design%20and%20Communication.pdf

Anon., 2022. https://doncorgi.com/blog/orthographic-drawing-examples/. [Online]

Available at: https://doncorgi.com/blog/orthographic-drawing-examples/

Anon., 2022. https://everythingwhat.com/what-are-pictorial-techniques. [Online]

Available at: https://everythingwhat.com/what-are-pictorial-techniques

Anon., 2022. https://studylib.net/doc/25296663/benefits-and-limitations-of-different-drawing-styles--1-. [Online]

Available at: https://studylib.net/doc/25296663/benefits-and-limitations-of-different-drawing-styles--1-

Anon., 2022. https://www.civilclick.com/isometric-projection/. [Online]

Available at: https://www.civilclick.com/isometric-projection/

Anon., 2022. https://www.civilclick.com/isometric-projection/. [Online]

Available at: https://www.civilclick.com/isometric-projection/

Anon., 2022. https://www.tasstudent.com/pictorial-drawing/#:~:text=It%20is%20a%20method%20of,traditional

%20drawing%20equipment%20is%20needed. [Online].

Anon., 2022. https://www.tasstudent.com/pictorial-drawing/#:~:text=It%20is%20a%20method%20of,traditional

%20drawing%20equipment%20is%20needed. [Online]
Available at: https://www.tasstudent.com/pictorial-drawing/

Anon., n.d. Auxiliary Views. [Online]

Available at: https://cabarrus.k12.nc.us
[Accessed 01 March 2022].

Branoff, T. J., 2016. Interpreting Engineering Drawings. 8th ed. Australia: Cengage Drawing.

Heusser, M., 2023. techtarget. [Online]

Available at: https://www.techtarget.com/searchsoftwarequality/definition/debugging
[Accessed 2 2023].

Tooley, M. & Dingle, L., 2002. BTEC NATIONAL ENGINEERING. 1st edition ed. Great britain: Newnes.

16