Machine Learning Based Design Patterns Prediction

Abstract
In modern software development, design patterns serve as standardized
solutions to recurring architectural challenges. Predicting appropriate design
patterns during the early stages of software development can significantly
enhance code quality and maintainability. This Project explores the application
of machine learning techniques to predict design patterns based on software
requirements and context. By employing various algorithms such as decision
trees, support vector machines, and neural networks, we train models on a
dataset of software projects annotated with design patterns. Feature extraction
techniques, including code metrics and structural attributes, are used to inform
model training. The results demonstrate that machine learning models can
accurately predict design patterns in software systems, providing developers
with valuable insights during the design phase. This approach automates part of
the software engineering process, improving efficiency and reducing human
error in pattern selection.
Introduction
Design patterns play a critical role in software engineering by offering well-
established solutions to recurring design problems. They serve as blueprints that
help developers create robust, scalable, and maintainable software systems.
However, selecting the appropriate design pattern for a given problem can be a
complex task, often requiring a deep understanding of both the problem domain
and the design patterns themselves. This challenge is particularly pronounced
for less experienced developers, who may struggle to recognize and apply these
patterns effectively. In recent years, machine learning has emerged as a
powerful tool for automating and enhancing various aspects of software
development. Machine learning models can analyse large datasets, identify
patterns, and make predictions, making them well-suited for tasks such as
design pattern prediction. By leveraging machine learning techniques, we can
develop systems that assist developers in identifying suitable design patterns
based on the specific characteristics of their software projects. This Project
proposes a machine learning-based approach to predict design patterns for
software projects. Our system utilizes a dataset of annotated software projects to
train machine learning models, including decision trees, support vector
machines (SVMs), and neural networks. These models learn to recognize the
structural and behavioural attributes of design patterns from the code and
suggest appropriate patterns for new projects. Additionally, we incorporate
natural language processing (NLP) techniques to analyse project
documentation, further enhancing the accuracy of our predictions. The goal of
this research is to provide a tool that aids developers in making informed design
decisions, thereby improving the quality and efficiency of software
development. By automating the identification of design patterns, we aim to
reduce the cognitive load on developers, enabling them to focus on higher-level
design and implementation tasks. Furthermore, our system can serve as an
educational resource for less experienced developers, helping them to learn and
apply design patterns more effectively
Literature Survey
The importance of design patterns in software engineering has been widely
acknowledged since their formal introduction by the "Gang of Four" (Gamma et
al., 1994). These patterns provide reusable solutions to common design
problems and enhance the quality, maintainability, and scalability of software.
Over the years, various approaches have been proposed to facilitate the
identification and application of design patterns in software systems.
1. Manual and Semi-Automated Approaches
Early efforts to assist developers in selecting appropriate design patterns
focused on manual or semi-automated approaches. For instance, Buschmann et
al. (1996) and Gamma et al. (1995) presented design pattern catalogues to help
developers choose patterns based on problem descriptions. These methods,
while useful, rely heavily on the developer's expertise and often lead to
inconsistent results, particularly in large-scale projects or when developers are
unfamiliar with certain patterns.
Semi-automated tools such as Design Pattern Wizard and MAP (Pattern Wizard)
were introduced to guide developers by recommending patterns based on high-
level design inputs. However, these tools often require substantial manual
intervention, making them less scalable for complex software projects.
2. Rule-Based Approaches
To address the limitations of manual methods, several rule-based approaches
were developed. In these approaches, predefined rules are used to map software
design components to corresponding design patterns. For example, Zhang et al.
(2006) proposed a rule-based pattern recognition system that identifies design
patterns by analysing the structure of UML diagrams. Similarly, Dong et al.
(2009) created a system that automatically detects design patterns in code by
applying a set of heuristic rules.
While rule-based systems improved pattern identification, they struggled with
flexibility and adaptability. Rules are often domain-specific and must be
manually updated when dealing with new problem domains or design patterns.
Additionally, these systems often suffer from low accuracy in complex software
projects, where patterns might not strictly conform to predefined rules.
3. Graph-Based and Structural Approaches
Graph-based approaches have gained significant attention for design pattern
detection. These methods represent software systems as graphs, where nodes
represent classes or objects, and edges represent relationships such as
inheritance or associations. The work of Antonoil et al. (2004) used graph
matching techniques to identify design patterns based on graph isomorphism,
allowing for the detection of structural similarities between software
architectures and known design patterns. Moreover, patterns can be viewed as
recurring subgraphs in software designs.
Another structural approach was proposed by Tantali’s et al. (2006), who used
metrics and graph-based methods to detect design patterns in source code. They
focused on the structural relationships between code elements, enabling the
identification of patterns such as Singleton and Factory. These methods, while
powerful, are computationally intensive and often struggle with identifying
behavioural aspects of patterns.

4. Machine Learning-Based Approaches

Recent advancements in machine learning (ML) have paved the way for
automated design pattern detection. Machine learning models are particularly
suited for pattern recognition tasks due to their ability to learn from large
datasets and generalize across different domains. ML-based approaches
leverage features extracted from code or design representations and use these
features to train models for pattern prediction.
One of the earliest works in this domain was presented by Hammad et al.
(2013), who applied decision trees to predict design patterns based on structural
metrics. More recent work by Malhotra et al. (2017) applied support vector
machines (SVM) to detect design patterns by analysing class-level features,
such as method calls and inheritance structures. Their results demonstrated that
ML models could achieve high accuracy in pattern detection tasks,
outperforming traditional rule-based approaches.
Deep learning techniques have also been explored for this task. Chen et al.
(2019) applied convolutional neural networks (CNN) to extract features from
code snippets and predict design patterns in object-oriented systems. Their
results highlighted the potential of deep learning for automating the design
pattern detection process, especially for large and complex software projects.
5. Hybrid Approaches
Some researchers have explored hybrid approaches that combine rule-based and
machine learning methods. For example, a study by Kim et al. (2020) proposed
a hybrid framework that integrates rule-based filtering with a machine learning
classifier to improve design pattern detection accuracy. This method reduces the
search space by applying rules first and then refines the prediction using ML
models. Hybrid methods offer the flexibility of rule-based systems while
leveraging the adaptability and learning capabilities of machine learning.
Existing System
Current systems for design pattern identification in software engineering largely
rely on manual processes and the expertise of experienced developers.
Traditional approaches involve developers studying design pattern catalogues
and matching their project requirements with the characteristics of various
patterns. This process can be time-consuming and prone to errors, particularly
for less experienced developers who may lack the necessary knowledge and
intuition to select the most appropriate pattern. Additionally, existing tools that
assist with design pattern identification often rely on static code analysis and
predefined rules, which can be rigid and fail to adapt to the nuances of different
projects. These tools typically analyse the structure of the codebase to detect
known patterns, but they do not provide proactive recommendations or adapt to
the specific context of a given project. As a result, the effectiveness of these
tools is limited, and developers still face significant challenges in applying
design patterns correctly and efficiently. This underscores the need for more
intelligent, flexible, and adaptive systems to support design pattern
identification and application in software development.

DRAW BACKS:
1. Manual Effort and Expertise Required: Traditional methods for
identifying and applying design patterns rely heavily on the manual effort
and expertise of experienced developers. This can be time-consuming and
inefficient, especially for less experienced developers who may not be
familiar with all the patterns.
2. Static and Rigid Tools: Existing tools that assist with design pattern
identification often rely on static code analysis and predefined rules.
These tools lack flexibility and adaptability, making them unable to
handle the nuances and specific contexts of different software projects
Proposed System
The proposed system for predicting design patterns using machine learning aims
to overcome the limitations of existing methods by providing an intelligent,
flexible, and adaptive solution. This system leverages advanced machine
learning algorithms, including decision trees, support vector machines (SVMs),
and neural networks, trained on a comprehensive dataset of software projects
annotated with various design patterns. By extracting and analysing features
from the code, such as class relationships, method signatures, and structural
attributes, the system can recognize complex patterns and suggest appropriate
design patterns for new projects. Additionally, natural language processing
(NLP) techniques are employed to analyse project documentation, enhancing
the accuracy of predictions by considering both code structure and textual
descriptions. This integrated approach ensures that the system provides context-
aware, personalized recommendations. The proposed system continuously
learns from new data, improving its predictive capabilities over time, and offers
proactive recommendations during the design phase, significantly reducing the
cognitive load on developers and promoting best practices in software
engineering.

4. Advantages of the Proposed System

The proposed system offers several advantages over traditional and existing
machine learning-based approaches:
 Higher Accuracy: By incorporating both structural and behavioural
features, the system improves the accuracy of design pattern predictions,
particularly for dynamic patterns that are difficult to detect using
structural features alone.
 Reduced Manual Effort: The system automates the design pattern
selection process, reducing the reliance on the developer’s expertise and
minimizing the risk of human error.
 Scalability: The use of graph-based representations and deep learning
techniques enables the system to scale effectively to large, complex
software architectures.
 Generalization: The machine learning models are trained on diverse
datasets, enabling them to generalize across different types of software
projects and domains.
 Real-Time Assistance: When integrated into an IDE, the system can
provide real-time recommendations to developers, improving the overall
software design workflow.
System Requirements

H/W System Configuration: -

➢ Processor - Pentium –IV
➢ RAM - 4 GB (min)
➢ Hard Disk - 20 GB
➢ Key Board - Standard Windows Keyboard
➢ Mouse - Two or Three Button Mouse
➢ Monitor - SVGA

SOFTWARE REQUIREMENTS: -
 Operating system : Windows 7 Ultimate.
 Coding Language : Python.
 Front-End : Python.
 Back-End : Django-ORM
 Designing : Html, CSS, JavaScript.
 Data Base : MySQL (WAMP Server).
System Architecture
The overall architecture of the proposed system consists of the following major
components:
1. Data Collection Module
2. Feature Extraction Module
3. Model Training Module
4. Pattern Prediction Engine
5. User Interface (IDE Integration)
The system's architecture is illustrated as follows:

Here is an example of how the proposed system would work:

1. Data Input: The developer writes or uploads source code or design
specifications (UML diagrams) into the IDE.
2. Preprocessing and Feature Extraction: The system preprocesses the
input and extracts structural and behavioural features.
3. Pattern Prediction: The extracted features are sent to the trained model,
which analyses them and predicts the design patterns.
4. User Interaction: The predictions are displayed within the IDE as
recommendations, allowing the developer to view details or apply them
to the software architecture.
 5. Feedback Loop: The developer’s input (accepting or rejecting
recommendations) is fed back into the system to fine-tune the models
over time.

The system design of the proposed "Machine Learning Based Design Patterns
Prediction" framework focuses on modularity, scalability, and integration with
existing development environments. By automating the prediction and
recommendation of design patterns, this system promises to assist developers in
improving software architecture and design quality efficiently
UML Diagrams
Here are some commonly used UML diagrams that can represent the Machine
Learning Based Design Patterns Prediction system:

1. USE CASE DIAGRAM

A Use Case Diagram shows the interaction between users (actors) and the
system, illustrating the functional requirements. It highlights the key use cases,
such as uploading source code, feature extraction, model training, and pattern

Load Design Pattern Coad

Coad to Numaric Vector

User
Train ML Algorithms

Predict Design Patterns

prediction.

2. CLASS DIAGRAM:
In software engineering, a class diagram in the Unified Modeling Language
(UML) is a type of static structure diagram that describes the structure of a
system by showing the system's classes, their attributes, operations (or
methods), and the relationships among the classes. It explains which class
User.
Load Design Pattern Coad
Coad to Numaric Vector
Train ML Algorithms
Predict Design Patterns

contains information
3. SEQUENCE DIAGRAM:
A sequence diagram in Unified Modeling Language (UML) is a kind of
interaction diagram that shows how processes operate with one another and in
what order. It is a construct of a Message Sequence Chart. Sequence diagrams
are sometimes called event diagrams, event scenarios, and timing diagrams
User Database

Load Design Pattern Coad

Coad to Numaric Vector

Train ML Algorithms

Predict Design Patterns

4. COLLABRATION DIAGRAM:
Activity diagrams are graphical representations of workflows of stepwise
activities and actions with support for choice, iteration and concurrency. In the
Unified Modeling Language, activity diagrams can be used to describe the
business and operational step-by-step workflows of components in a system. An
activity diagram shows the overall flow of control.
 1: Load Design Pattern Coad
2: Coad to Numaric Vector
3: Train ML Algorithms
4: Predict Design Patterns
User System
App'n

System Study
1. Current State Analysis
The system study begins with an assessment of the current methods and
technologies used for design pattern prediction:
 Manual Methods: Involves developers manually selecting and applying
design patterns based on their expertise. This approach is error-prone and
not scalable for large or complex projects.
 Semi-Automated Tools: Tools like Design Pattern Wizard provide
recommendations based on user input but still require substantial manual
intervention and lack flexibility.
 Rule-Based Systems: Systems such as DP-Miner and SPQR use heuristic
rules to detect design patterns based on structural analysis. They are
limited by their rigid rules and inability to handle dynamic or behavioural
patterns.
 Graph-Based Approaches: Graph-based methods use structural graphs
to identify patterns but are computationally intensive and mainly focus on
static structures.
 Early Machine Learning Models: Preliminary models using decision
trees and SVMs have demonstrated some success but are limited by
feature selection and model accuracy.
2. Requirements Analysis
To design an effective machine learning-based design pattern prediction system,
the following requirements must be addressed:
 Functional Requirements:
o Data Collection: The system must gather and preprocess data from
diverse sources, including code repositories and design diagrams.
 o Feature Extraction: Extract relevant structural and behavioural
features from the software data.
o Model Training: Train and validate machine learning models to
predict design patterns.
o Pattern Prediction: Predict design patterns based on new code or
design specifications and provide recommendations.
o Integration: The system should integrate with development
environments (IDEs) to provide real-time predictions and
recommendations.
 Non-Functional Requirements:
o Performance: The system must handle large codebases efficiently
and provide predictions in a timely manner.
o Scalability: It should scale to accommodate complex and extensive
software projects.
o Accuracy: High prediction accuracy is essential to provide reliable
design pattern recommendations.
o Usability: The user interface must be intuitive and user-friendly,
particularly when integrated into IDEs.
o Maintainability: The system should be easy to update with new
design patterns or evolving machine learning techniques.
3. Feasibility Study
Technical Feasibility:
 Data Availability: Data from code repositories (e.g., GitHub) and design
documentation (UML diagrams) are accessible and can be used for
training and evaluation.
 Machine Learning Techniques: Advances in machine learning and deep
learning techniques are suitable for feature extraction and pattern
prediction. Tools and libraries (e.g., TensorFlow, Porch) support the
implementation of these techniques.
 Integration: IDE plugins or standalone applications can be developed
using existing development tools and APIs, allowing integration with
common IDEs like IntelliJ IDEA, Eclipse, and Visual Studio.
Economic Feasibility:
  Cost of Implementation: Costs include data acquisition, model
development, and system integration. Using open-source tools and pre-
existing machine learning libraries can help manage costs.
 Return on Investment: Automation of design pattern prediction can
significantly reduce development time, improve code quality, and
enhance maintainability, leading to a positive return on investment.
Operational Feasibility:
 User Acceptance: Developers are likely to appreciate tools that reduce
manual effort and provide accurate recommendations. The system should
be designed to seamlessly integrate into existing workflows.
 Training and Support: Adequate documentation and support must be
provided to help users understand and effectively utilize the system.
4. Potential Impact
 Improved Efficiency: Automating the design pattern prediction process
will streamline software development, reduce manual effort, and speed up
the design phase.
 Enhanced Code Quality: Accurate design pattern recommendations can
lead to better software architecture, resulting in higher-quality code that is
more maintainable and scalable.
 Reduced Human Error: By minimizing reliance on manual pattern
selection, the system reduces the risk of errors and inconsistencies in
software design.
 Knowledge Sharing: The system can help disseminate design best
practices and pattern knowledge, benefiting less experienced developers
and promoting standardized design approaches.
5. Risks and Mitigations
 Data Quality: Inaccurate or incomplete data can impact model
performance. Mitigation involves using diverse and high-quality datasets
and implementing robust preprocessing techniques.
 Model Accuracy: The system may initially have lower accuracy due to
limited training data or model limitations. Continuous improvement and
regular updates to the models can address this issue.
 Integration Challenges: Integrating with various IDEs may present
technical challenges. Developing a modular and flexible system
architecture will facilitate smoother integration.
System Testing
1. Testing Objectives
 Functionality: Verify that the system performs all intended functions,
such as data collection, feature extraction, model training, pattern
prediction, and integration with development environments.
 Performance: Assess the system's efficiency in handling large codebases,
providing timely predictions, and scaling with increased data and
complexity.
 Accuracy: Evaluate the precision of design pattern predictions and
recommendations.
 Usability: Ensure that the user interface is intuitive and integrates
seamlessly with IDEs or other development tools.
 Stability: Test the system’s reliability under various conditions and loads
to identify and fix potential issues.
2. Types of Testing
a. Functional Testing
 Unit Testing: Test individual components of the system (e.g., data
collection module, feature extraction, model training) to ensure that each
component performs as expected. Use unit tests to check functions,
methods, and classes.
 Integration Testing: Verify that different modules (data collection,
feature extraction, model training, prediction engine) work together
correctly. Ensure that data flows seamlessly between components and that
integrated functionalities perform as intended.
 System Testing: Evaluate the complete system as a whole to ensure that
all components interact correctly and that the system meets the specified
requirements. Test the end-to-end workflow, from data input to pattern
prediction and recommendation.
 Acceptance Testing: Conduct tests to confirm that the system meets the
business requirements and user needs. This includes validating features
against user stories and scenarios.
b. Performance Testing
 Load Testing: Assess how the system performs under expected and peak
loads. Measure the system’s response time and throughput when
processing varying volumes of data.
 Stress Testing: Evaluate the system's stability and performance under
extreme conditions or loads that exceed typical usage scenarios. Identify
potential failure points and system behaviour under stress.
 Scalability Testing: Test the system's ability to handle increasing
amounts of data and complexity. Ensure that performance remains
acceptable as the size of the codebase or number of design patterns
increases.
c. Accuracy Testing
 Model Accuracy: Measure the accuracy of the machine learning models
in predicting design patterns. Use metrics such as precision, recall, F1-
score, and confusion matrices to evaluate model performance.
 Cross-Validation: Perform cross-validation to assess the generalizability
of the models. Ensure that the models are not overfitting and can provide
accurate predictions across different datasets.
 Comparison Testing: Compare the predictions of the system with
known, manually identified design patterns to gauge accuracy and
identify any discrepancies.
d. Usability Testing
 User Interface Testing: Evaluate the user interface for usability,
intuitiveness, and ease of integration with IDEs. Test the interface with
actual users (e.g., developers) to gather feedback on user experience.
 Integration Testing with IDEs: Verify that the system integrates
properly with development environments and that real-time
recommendations work as expected. Ensure that the plugin or tool does
not interfere with the IDE’s functionality.
e. Stability Testing
 Error Handling: Test the system’s ability to handle errors and exceptions
gracefully. Ensure that the system provides meaningful error messages
and recovers from failures without crashing.
  Recovery Testing: Verify that the system can recover from unexpected
disruptions, such as network failures or data corruption, without losing
critical information or functionality.
3. Testing Procedures
a. Test Plan Development
 Test Cases: Develop detailed test cases for each type of testing. Each test
case should include a description, test steps, expected results, and criteria
for pass/fail.
 Test Data: Prepare test data that includes a variety of scenarios, including
normal cases, edge cases, and stress cases. Use both synthetic and real-
world datasets for comprehensive testing.
b. Test Execution
 Testing Environment: Set up a testing environment that mirrors the
production environment as closely as possible. Ensure that all necessary
tools, libraries, and dependencies are available.
 Test Execution: Execute the test cases according to the test plan. Record
the results and compare them with the expected outcomes.
 Defect Reporting: Document any defects or issues discovered during
testing. Provide detailed information about the issue, including steps to
reproduce, expected vs. actual results, and severity.
c. Test Results Analysis
 Results Review: Analyse the test results to identify patterns, recurring
issues, or areas for improvement. Review failed test cases and determine
the root cause of any defects.
 Model Evaluation: Assess the performance of machine learning models
based on accuracy metrics and compare results with baseline or
benchmark models.
 User Feedback: Gather feedback from users who participated in usability
testing to identify areas for improvement in the user interface or overall
user experience.
d. Test Reporting
 Test Summary Report: Prepare a summary report that includes an
overview of testing activities, test results, defect status, and
recommendations for improvements.
 Final Validation: Conduct a final round of validation to ensure that all
critical issues have been addressed and that the system meets all
requirements before deployment.
4. Continuous Testing
 Automated Testing: Implement automated testing for repetitive and
regression tests to streamline the testing process and ensure continuous
integration.
 Model Retraining: Periodically retrain machine learning models with
new data to maintain accuracy and adapt to evolving software patterns.
 Ongoing Monitoring: Monitor the system post-deployment to detect any
issues that arise in the production environment and address them
promptly.
 What is Python: -
Below are some facts about Python.

Python is currently the most widely used multi-purpose, high-level programming

language.

Python allows programming in Object-Oriented and Procedural paradigms. Python

programs generally are smaller than other programming languages like Java.

Programmers have to type relatively less and indentation requirement of the language,
makes them readable all the time.

Python language is being used by almost all tech-giant companies like – Google,
Amazon, Facebook, Instagram, Dropbox, Uber… etc.

The biggest strength of Python is huge collection of standard libraries which can be
used for the following –

 Machine Learning
 GUI Applications (like Kiry, Skinter, Pit etc.)
 Web frameworks like Django (used by YouTube, Instagram, Dropbox)
 Image processing (like OpenCV, Pillow)
 Web scraping (like Scrapy, Beautiful Soup, Selenium)
 Test frameworks
 Multimedia

Advantages of Python: -

Let’s see how Python dominates over other languages.

1. Extensive Libraries

Python downloads with an extensive library and it contain code for various purposes
like regular expressions, documentation-generation, unit-testing, web browsers,
threading, databases, CGI, email, image manipulation, and more. So, we don’t have
to write the complete code for that manually.
2. Extensible

As we have seen earlier, Python can be extended to other languages. You can write
some of your code in languages like C++ or C. This comes in handy, especially in
projects.
3. Embeddable

Complimentary to extensibility, Python is embeddable as well. You can put your

Python code in your source code of a different language, like C++. This lets us
add scripting capabilities to our code in the other language.
4. Improved Productivity

The language’s simplicity and extensive libraries render programmers more

productive than languages like Java and C++ do. Also, the fact that you need to write
less and get more things done.
5. IOT Opportunities

Since Python forms the basis of new platforms like Raspberry Pi, it finds the future
bright for the Internet of Things. This is a way to connect the language with the real
world.

6. Simple and Easy

When working with Java, you may have to create a class to print ‘Hello World’. But
in Python, just a print statement will do. It is also quite easy to learn, understand,
and code. This is why when people pick up Python, they have a hard time adjusting to
other more verbose languages like Java.
7. Readable

Because it is not such a verbose language, reading Python is much like reading
English. This is the reason why it is so easy to learn, understand, and code. It also does
not need curly braces to define blocks, and indentation is mandatory. These further
aids the readability of the code.
8. Object-Oriented

This language supports both the procedural and object-oriented programming

paradigms. While functions help us with code reusability, classes and objects let us
model the real world. A class allows the encapsulation of data and functions into
one.
9. Free and Open-Source

Like we said earlier, Python is freely available. But not only can you download
Python for free, but you can also download its source code, make changes to it, and
even distribute it. It downloads with an extensive collection of libraries to help you
with your tasks.
10. Portable

When you code your project in a language like C++, you may need to make some
changes to it if you want to run it on another platform. But it isn’t the same with
Python. Here, you need to code only once, and you can run it anywhere. This is
called Write Once Run Anywhere (WORA). However, you need to be careful
enough not to include any system-dependent features.
11. Interpreted

Lastly, we will say that it is an interpreted language. Since statements are executed
one by one, debugging is easier than in compiled languages.
Any doubts till now in the advantages of Python? Mention in the comment section.

Advantages of Python Over Other Languages

1. Less Coding

Almost all of the tasks done in Python requires less coding when the same task is done
in other languages. Python also has an awesome standard library support, so you don’t
have to search for any third-party libraries to get your job done. This is the reason that
many people suggest learning Python to beginners.

2. Affordable

Python is free therefore individuals, small companies or big organizations can

leverage the free available resources to build applications. Python is popular and
widely used so it gives you better community support.

The 2019 GitHub annual survey showed us that Python has overtaken Java in the
most popular programming language category.

3. Python is for Everyone

Python code can run on any machine whether it is Linux, Mac or Windows.
Programmers need to learn different languages for different jobs but with Python, you
can professionally build web apps, perform data analysis and machine learning,
automate things, do web scraping and also build games and powerful visualizations. It
is an all-rounder programming language.
Disadvantages of Python

So far, we’ve seen why Python is a great choice for your project. But if you choose it,
you should be aware of its consequences as well. Let’s now see the downsides of
choosing Python over another language.

1. Speed Limitations

We have seen that Python code is executed line by line. But since Python is
interpreted, it often results in slow execution. This, however, isn’t a problem unless
speed is a focal point for the project. In other words, unless high speed is a
requirement, the benefits offered by Python are enough to distract us from its speed
limitations.
2. Weak in Mobile Computing and Browsers

While it serves as an excellent server-side language, Python is much rarely seen on

the client-side. Besides that, it is rarely ever used to implement smartphone-based
applications. One such application is called Carbon Nelle.
The reason it is not so famous despite the existence of Bryton is that it isn’t that
secure.

3. Design Restrictions

As you know, Python is dynamically-typed. This means that you don’t need to
declare the type of variable while writing the code. It uses duck-typing. But wait,
what’s that? Well, it just means that if it looks like a duck, it must be a duck. While
this is easy on the programmers during coding, it can raise run-time errors.
4. Underdeveloped Database Access Layers

Compared to more widely used technologies like JDBC (Java Database

Connectivity) and ODBC (Open Database Connectivity), Python’s database access
layers are a bit underdeveloped. Consequently, it is less often applied in huge
enterprises.
5. Simple

No, we’re not kidding. Python’s simplicity can indeed be a problem. Take my
example. I don’t do Java, I’m more of a Python person. To me, its syntax is so simple
that the verbosity of Java code seems unnecessary.

This was all about the Advantages and Disadvantages of Python Programming
Language.

History of Python: -

What do the alphabet and the programming language Python have in common? Right,
both start with ABC. If we are talking about ABC in the Python context, it's clear that
the programming language ABC is meant. ABC is a general-purpose programming
language and programming environment, which had been developed in the
Netherlands, Amsterdam, at the CWI (Centrum Wickenden &Informatica). The
greatest achievement of ABC was to influence the design of Python. Python was
conceptualized in the late 1980s. Guido van Rossum worked that time in a project at
the CWI, called Amoeba, a distributed operating system. In an interview with Bill
Venners1, Guido van Rossum said: "In the early 1980s, I worked as an implementer on
a team building a language called ABC at Centrum door Wickenden end Informatica
(CWI). I don't know how well people know ABC's influence on Python. I try to
mention ABC's influence because I'm indebted to everything I learned during that
project and to the people who worked on end on in the same Interview, Guido van
Rossum continued: "I remembered all my experience and some of my frustration with
ABC. I decided to try to design a simple scripting language that possessed some of
ABC's better properties, but without its problems. So, I started typing. I created a
simple virtual machine, a simple parser, and a simple runtime. I made my own version
of the various ABC parts that I liked. I created a basic syntax, used indentation for
statement grouping instead of curly braces or begin-end blocks, and developed a small
number of powerful data types: a hash table (or dictionary, as we call it), a list, strings,
and numbers."

What is Machine Learning: -

Before we take a look at the details of various machine learning methods, let's start by
looking at what machine learning is, and what it isn't. Machine learning is often
categorized as a subfield of artificial intelligence, but I find that categorization can
often be misleading at first brush. The study of machine learning certainly arose from
research in this context, but in the data science application of machine learning
methods, it's more helpful to think of machine learning as a means of building models
of data.

Fundamentally, machine learning involves building mathematical models to help

understand data. "Learning" enters the fray when we give these models tunable
parameters that can be adapted to observed data; in this way the program can be
considered to be "learning" from the data. Once these models have been fit to
previously seen data, they can be used to predict and understand aspects of newly
observed data. I'll leave to the reader the more philosophical digression regarding the
extent to which this type of mathematical, model-based "learning" is similar to the
"learning" exhibited by the human brain. Understanding the problem setting in
machine learning is essential to using these tools effectively, and so we will start with
some broad categorizations of the types of approaches we'll discuss here.

Categories Of Machine Leaning: -

At the most fundamental level, machine learning can be categorized into two main
types: supervised learning and unsupervised learning.
Supervised learning involves somehow modeling the relationship between measured
features of data and some label associated with the data; once this model is
determined, it can be used to apply labels to new, unknown data. This is further
subdivided into classification tasks and regression tasks: in classification, the labels
are discrete categories, while in regression, the labels are continuous quantities. We
will see examples of both types of supervised learning in the following section.

Unsupervised learning involves modeling the features of a dataset without reference

to any label, and is often described as "letting the dataset speak for itself." These
models include tasks such as clustering and dimensionality reduction. Clustering
algorithms identify distinct groups of data, while dimensionality reduction algorithms
search for more succinct representations of the data. We will see examples of both
types of unsupervised learning in the following section.

Need for Machine Learning

Human beings, at this moment, are the most intelligent and advanced species on earth
because they can think, evaluate and solve complex problems. On the other side, AI is
still in its initial stage and haven’t surpassed human intelligence in many aspects.
Then the question is that what is the need to make machine learn? The most suitable
reason for doing this is, “to make decisions, based on data, with efficiency and scale”.

Lately, organizations are investing heavily in newer technologies like Artificial

Intelligence, Machine Learning and Deep Learning to get the key information from
data to perform several real-world tasks and solve problems. We can call it data-
driven decisions taken by machines, particularly to automate the process. These data-
driven decisions can be used, instead of using programing logic, in the problems that
cannot be programmed inherently. The fact is that we can’t do without human
intelligence, but other aspect is that we all need to solve real-world problems with
efficiency at a huge scale. That is why the need for machine learning arises.
Challenges in Machines Learning: -

While Machine Learning is rapidly evolving, making significant strides with

cybersecurity and autonomous cars, this segment of AI as whole still has a long way
to go. The reason behind is that ML has not been able to overcome number of
challenges. The challenges that ML is facing currently are −

Quality of data − Having good-quality data for ML algorithms is one of the biggest
challenges. Use of low-quality data leads to the problems related to data preprocessing
and feature extraction.

Time-Consuming task − Another challenge faced by ML models is the consumption

of time especially for data acquisition, feature extraction and retrieval.

Lack of specialist persons − As ML technology is still in its infancy stage,

availability of expert resources is a tough job.

No clear objective for formulating business problems − Having no clear objective

and well-defined goal for business problems is another key challenge for ML because
this technology is not that mature yet.

Issue of overfitting & underfitting − If the model is overfitting or underfitting, it

cannot be represented well for the problem.

Curse of dimensionality − Another challenge ML model faces is too many features

of data points. This can be a real hindrance.

Difficulty in deployment − Complexity of the ML model makes it quite difficult to

be deployed in real life.

Applications of Machines Learning: -

Machine Learning is the most rapidly growing technology and according to

researchers we are in the golden year of AI and ML. It is used to solve many real-
 world complex problems which cannot be solved with traditional approach. Following
are some real-world applications of ML −

 Emotion analysis
 Sentiment analysis
 Error detection and prevention
 Weather forecasting and prediction
 Stock market analysis and forecasting
 Speech synthesis
 Speech recognition
 Customer segmentation
 Object recognition
 Fraud detection
 Fraud prevention
 Recommendation of products to customer in online shopping

How to Start Learning Machine Learning?

Arthur Samuel coined the term “Machine Learning” in 1959 and defined it as
a “Field of study that gives computers the capability to learn without being
explicitly programmed”.
And that was the beginning of Machine Learning! In modern times, Machine Learning
is one of the most popular (if not the most!) career choices. According to Indeed,
Machine Learning Engineer Is the Best Job of 2019 with a 344% growth and an
average base salary of $146,085 per year.
But there is still a lot of doubt about what exactly is Machine Learning and how to
start learning it? So, this article deals with the Basics of Machine Learning and also
the path you can follow to eventually become a full-fledged Machine Learning
Engineer. Now let’s get started!!!

How to start learning ML?

This is a rough roadmap you can follow on your way to becoming an insanely talented
Machine Learning Engineer. Of course, you can always modify the steps according to
your needs to reach your desired end-goal!

Step 1 – Understand the Prerequisites

In case you are a genius, you could start ML directly but normally, there are some
prerequisites that you need to know which include Linear Algebra, Multivariate
Calculus, Statistics, and Python. And if you don’t know these, never fear! You don’t
need a Ph.D. degree in these topics to get started but you do need a basic
understanding.

(a) Learn Linear Algebra and Multivariate Calculus

Both Linear Algebra and Multivariate Calculus are important in Machine Learning.
However, the extent to which you need them depends on your role as a data scientist.
If you are more focused on application heavy machine learning, then you will not be
that heavily focused on math’s as there are many common libraries available. But if
you want to focus on R&D in Machine Learning, then mastery of Linear Algebra and
Multivariate Calculus is very important as you will have to implement many ML
algorithms from scratch.

(b) Learn Statistics

Data plays a huge role in Machine Learning. In fact, around 80% of your time as an
ML expert will be spent collecting and cleaning data. And statistics is a field that
 handles the collection, analysis, and presentation of data. So, it is no surprise that you
need to learn it!!!
Some of the key concepts in statistics that are important are Statistical Significance,
Probability Distributions, Hypothesis Testing, Regression, etc. Also, Bayesian
Thinking is also a very important part of ML which deals with various concepts like
Conditional Probability, Priors, and Posteriors, Maximum Likelihood, etc.

(c) Learn Python

Some people prefer to skip Linear Algebra, Multivariate Calculus and Statistics and
learn them as they go along with trial and error. But the one thing that you absolutely
cannot skip is Python! While there are other languages you can use for Machine
Learning like R, Scala, etc. Python is currently the most popular language for ML. In
fact, there are many Python libraries that are specifically useful for Artificial
Intelligence and Machine Learning such as Kera’s, TensorFlow, Scikit-learn, etc.
So, if you want to learn ML, it’s best if you learn Python! You can do that using
various online resources and courses such as Fork Python available Free on So,

Step 2 – Learn Various ML Concepts

Now that you are done with the prerequisites, you can move on to actually learning
ML (Which is the fun part!!!) It’s best to start with the basics and then move on to the
more complicated stuff. Some of the basic concepts in ML are:

(a) Terminologies of Machine Learning

 Model – A model is a specific representation learned from data by applying some

machine learning algorithm. A model is also called a hypothesis.
 Feature – A feature is an individual measurable property of the data. A set of numeric
features can be conveniently described by a feature vector. Feature vectors are fed as
 input to the model. For example, in order to predict a fruit, there may be features like
colour, smell, taste, etc.
 Target (Label) – A target variable or label is the value to be predicted by our model.
For the fruit example discussed in the feature section, the label with each set of input
would be the name of the fruit like apple, orange, banana, etc.
 Training – The idea is to give a set of inputs(features) and it’s expected
outputs(labels), so after training, we will have a model (hypothesis) that will then map
new data to one of the categories trained on.
 Prediction – Once our model is ready, it can be fed a set of inputs to which it will
provide a predicted output(label).

(b) Types of Machine Learning

 Supervised Learning – This involves learning from a training dataset with labelled
data using classification and regression models. This learning process continues until
the required level of performance is achieved.
 Unsupervised Learning – This involves using unlabelled data and then finding the
underlying structure in the data in order to learn more and more about the data itself
using factor and cluster analysis models.
 Semi-supervised Learning – This involves using unlabelled data like Unsupervised
Learning with a small amount of labelled data. Using labelled data vastly increases the
learning accuracy and is also more cost-effective than Supervised Learning.
 Reinforcement Learning – This involves learning optimal actions through trial and
error. So, the next action is decided by learning behaviours that are based on the
current state and that will maximize the reward in the future.
Advantages of Machine learning: -

1. Easily identifies trends and patterns -

Machine Learning can review large volumes of data and discover specific trends and
patterns that would not be apparent to humans. For instance, for an e-commerce
website like Amazon, it serves to understand the browsing behaviours and purchase
histories of its users to help cater to the right products, deals, and reminders relevant to
them. It uses the results to reveal relevant advertisements to them.

2. No human intervention needed (automation)

With ML, you don’t need to babysit your project every step of the way. Since it means
giving machines the ability to learn, it lets them make predictions and also improve
the algorithms on their own. A common example of this is anti-virus software’s; they
learn to filter new threats as they are recognized. ML is also good at recognizing
spam.

3. Continuous Improvement

As ML algorithms gain experience, they keep improving in accuracy and efficiency.

This lets them make better decisions. Say you need to make a weather forecast model.
As the amount of data you have keeps growing, your algorithms learn to make more
accurate predictions faster.

4. Handling multi-dimensional and multi-variety data

Machine Learning algorithms are good at handling data that are multi-dimensional and
multi-variety, and they can do this in dynamic or uncertain environments.

5. Wide Applications

You could be an e-tailer or a healthcare provider and make ML work for you. Where it
does apply, it holds the capability to help deliver a much more personal experience to
customers while also targeting the right customers.
Disadvantages of Machine Learning: -

1. Data Acquisition

Machine Learning requires massive data sets to train on, and these should be
inclusive/unbiased, and of good quality. There can also be times where they must wait
for new data to be generated.

2. Time and Resources

ML needs enough time to let the algorithms learn and develop enough to fulfill their
purpose with a considerable amount of accuracy and relevancy. It also needs massive
resources to function. This can mean additional requirements of computer power for
you.

3. Interpretation of Results

Another major challenge is the ability to accurately interpret results generated by the
algorithms. You must also carefully choose the algorithms for your purpose.

4. High error-susceptibility

Machine Learning is autonomous but highly susceptible to errors. Suppose you train
an algorithm with data sets small enough to not be inclusive. You end up with biased
predictions coming from a biased training set. This leads to irrelevant advertisements
being displayed to customers. In the case of ML, such blunders can set off a chain of
errors that can go undetected for long periods of time. And when they do get noticed,
it takes quite some time to recognize the source of the issue, and even longer to correct
it.

Python Development Steps: -

 Guido Van Rossum published the first version of Python code (version 0.9.0) at
Altisource’s in February 1991. This release included already exception handling,
functions, and the core data types of lists, duct, str and others. It was also object
oriented and had a module system.
Python version 1.0 was released in January 1994. The major new features included in
this release were the functional programming tools lambda, map, filter and reduce,
which Guido Van Rossum never liked. Six and a half years later in October 2000,
Python 2.0 was introduced. This release included list comprehensions, a full garbage
collector and it was supporting Unicode. Python flourished for another 8 years in the
versions 2.x before the next major release as Python 3.0 (also known as "Python
3000" and "Py3K") was released. Python 3 is not backwards compatible with Python
2.x. The emphasis in Python 3 had been on the removal of duplicate programming
constructs and modules, thus fulfilling or coming close to fulfilling the 13th law of the
Zen of Python: "There should be one -- and preferably only one -- obvious way to do
Unicode. Python changes in Python 7.3:

 Print is now a function

 Views and iterators instead of lists
 The rules for ordering comparisons have been simplified. E.g. a heterogeneous list
cannot be sorted, because all the elements of a list must be comparable to each
other.
 There is only one integer type left, i.e. int. long is int as well.
 The division of two integers returns a float instead of an integer. "//" can be used to
have the "old" behaviour.
 Text Vs. Data Instead of Unicode Vs. 8-bit

Purpose: -
 We demonstrated that our approach enables successful segmentation of intra-retinal
layers—even with low-quality images containing speckle noise, low contrast, and
different intensity ranges throughout—with the assistance of the ANIS feature.

Python

Python is an interpreted high-level programming language for general-purpose

programming. Created by Guido van Rossum and first released in 1991, Python has a
design philosophy that emphasizes code readability, notably using significant
whitespace.

Python features a dynamic type system and automatic memory management. It

supports multiple programming paradigms, including object-oriented, imperative,
functional and procedural, and has a large and comprehensive standard library.

 Python is Interpreted − Python is processed at runtime by the interpreter. You do not

need to compile your program before executing it. This is similar to PERL and PHP.
 Python is Interactive − you can actually sit at a Python prompt and interact with the
interpreter directly to write your programs.
Python also acknowledges that speed of development is important. Readable and terse
code is part of this, and so is access to powerful constructs that avoid tedious
repetition of code. Maintainability also ties into this may be an all but useless metric,
but it does say something about how much code you have to scan, read and/or
understand to troubleshoot problems or tweak behaviors. This speed of development,
the ease with which a programmer of other languages can pick up basic Python skills
and the huge standard library is key to another area where Python excels. All its tools
have been quick to implement, saved a lot of time, and several of them have later been
patched and updated by people with no Python background - without breaking.

Modules Used in Project: -

TensorFlow
 TensorFlow is a free and open-source software library for dataflow and differentiable
programming across a range of tasks. It is a symbolic math library, and is also used
for machine learning applications such as neural networks. It is used for both research
and production at Google.‍

TensorFlow was developed by the Google Brain team for internal Google use. It was
released under the Apache 2.0 open-source license on November 9, 2015.

NumPy

NumPy is a general-purpose array-processing package. It provides a high-performance

multidimensional array object, and tools for working with these arrays.

It is the fundamental package for scientific computing with Python. It contains various
features including these important ones:

 A powerful N-dimensional array object

 Sophisticated (broadcasting) functions
 Tools for integrating C/C++ and Fortran code
 Useful linear algebra, Fourier transform, and random number capabilities
Besides its obvious scientific uses, NumPy can also be used as an efficient multi-
dimensional container of generic data. Arbitrary data-types can be defined using
NumPy which allows NumPy to seamlessly and speedily integrate with a wide variety
of databases.

Pandas

Pandas is an open-source Python Library providing high-performance data

manipulation and analysis tool using its powerful data structures. Python was majorly
used for data munging and preparation. It had very little contribution towards data
analysis. Pandas solved this problem. Using Pandas, we can accomplish five typical
steps in the processing and analysis of data, regardless of the origin of data load,
prepare, manipulate, model, and analyze. Python with Pandas is used in a wide range
of fields including academic and commercial domains including finance, economics,
Statistics, analytics, etc.

Matplotlib

Matplotlib is a Python 2D plotting library which produces publication quality figures

in a variety of hardcopy formats and interactive environments across platforms.
Matplotlib can be used in Python scripts, the Python and I Python shells,
the Jupiter Notebook, web application servers, and four graphical user interface
toolkits. Matplotlib tries to make easy things easy and hard things possible. You can
generate plots, histograms, power spectra, bar charts, error charts, scatter plots, etc.,
with just a few lines of code. For examples, see the sample plots and thumbnail
gallery.

For simple plotting the pilot module provides a MATLAB-like interface, particularly
when combined with I Python. For the power user, you have full control of line styles,
font properties, axes properties, etc., via an object-oriented interface or via a set of
functions familiar to MATLAB users.

Scikit – learn

Scikit-learn provides a range of supervised and unsupervised learning algorithms via a

consistent interface in Python. It is licensed under a permissive simplified BSD license
and is distributed under many Linux distributions, encouraging academic and
commercial use. Python

Python is an interpreted high-level programming language for general-purpose

programming. Created by Guido van Rossum and first released in 1991, Python has a
design philosophy that emphasizes code readability, notably using significant
whitespace.

Python features a dynamic type system and automatic memory management. It

supports multiple programming paradigms, including object-oriented, imperative,
functional and procedural, and has a large and comprehensive standard library.
 Python is Interpreted − Python is processed at runtime by the interpreter. You do not
need to compile your program before executing it. This is similar to PERL and PHP.
 Python is Interactive − you can actually sit at a Python prompt and interact with the
interpreter directly to write your programs.
Python also acknowledges that speed of development is important. Readable and terse
code is part of this, and so is access to powerful constructs that avoid tedious
repetition of code. Maintainability also ties into this may be an all but useless metric,
but it does say something about how much code you have to scan, read and/or
understand to troubleshoot problems or tweak behaviors. This speed of development,
the ease with which a programmer of other languages can pick up basic Python skills
and the huge standard library is key to another area where Python excels. All its tools
have been quick to implement, saved a lot of time, and several of them have later been
patched and updated by people with no Python background - without breaking.

Install Python Step-by-Step in Windows and Mac:

Python a versatile programming language doesn’t come pre-installed on your computer

devices. Python was first released in the year 1991 and until today it is a very popular
high-level programming language. Its style philosophy emphasizes code readability with
its notable use of great whitespace.
The object-oriented approach and language construct provided by Python enables
programmers to write both clear and logical code for projects. This software does not
come pre-packaged with Windows.

How to Install Python on Windows and Mac:

There have been several updates in the Python version over the years. The question is
how to install Python? It might be confusing for the beginner who is willing to start
learning Python but this tutorial will solve your query. The latest or the newest version
of Python is version 3.7.4 or in other words, it is Python 3.
Note: The python version 3.7.4 cannot be used on Windows XP or earlier devices.

Before you start with the installation process of Python. First, you need to know about
your System Requirements. Based on your system type i.e. operating system and based
processor, you must download the python version. My system type is a Windows 64-bit
operating system. So, the steps below are to install python version 3.7.4 on Windows 7
device or to install Python 3. Cheat sheet steps on how to install Python on Windows 10,
8 and 7 are divided into 4 parts to help understand better.

Download the Correct version into the system

Step 1: Go to the official site to download and install python using Google Chrome or
any other web browser. OR Click on the following link: https://www.python.org
Now, check for the latest and the correct version for your operating system.

Step 2: Click on the Download Tab.

Step 3: You can either select the Download Python for windows 3.7.4 button in Yellow
Color or you can scroll further down and click on download with respective to their
version. Here, we are downloading the most recent python version for windows 3.7.4

Step 4: Scroll down the page until you find the Files option.

Step 5: Here you see a different version of python along with the operating system.
• To download Windows 32-bit python, you can select any one from the three options:
Windows x86 embeddable zip file, Windows x86 executable installer or Windows x86
web-based installer.
•To download Windows 64-bit python, you can select any one from the three options:
Windows x86-64 embeddable zip file, Windows x86-64 executable installer or
Windows x86-64 web-based installer.
Here we will install Windows x86-64 web-based installer. Here your first part regarding
which version of python is to be downloaded is completed. Now we move ahead with
the second part in installing python i.e. Installation
Note: To know the changes or updates that are made in the version you can click on the
Release Note Option.
Installation of Python
Step 1: Go to Download and Open the downloaded python version to carry out the
installation process.
Step 2: Before you click on Install Now, make sure to put a tick on Add Python 3.7 to
PATH.

Step 3: Click on Install NOW After the installation is successful. Click on Close.
With these above three steps on python installation, you have successfully and correctly
installed Python. Now is the time to verify the installation.
Note: The installation process might take a couple of minutes.

Verify the Python Installation

Step 1: Click on Start
Step 2: In the Windows Run Command, type “cod”.
Step 3: Open the Command prompt option.
Step 4: Let us test whether the python is correctly installed. Type python –V and press
Enter.

Step 5: You will get the answer as 3.7.4

Note: If you have any of the earlier versions of Python already installed. You must first
uninstall the earlier version and then install the new one.

Check how the Python IDLE works

Step 1: Click on Start
Step 2: In the Windows Run command, type “python idle”.
Step 3: Click on IDLE (Python 3.7 64-bit) and launch the program
Step 4: To go ahead with working in IDLE you must first save the file. Click on File >
Click on Save

Step 5: Name the file and save as type should be Python files. Click on SAVE. Here I
have named the files as Hey World.
Step 6: Now for e.g. enter print

SYSTEM TEST

The purpose of testing is to discover errors. Testing is the process of trying to discover
every conceivable fault or weakness in a work product. It provides a way to check the
functionality of components, sub-assemblies, assemblies and/or a finished product It is
the process of exercising software with the intent of ensuring that the Software system
meets its requirements and user expectations and does not fail in an unacceptable
manner. There are various types of tests. Each test type addresses a specific testing
requirement.

TYPES OF TESTS

Unit testing
Unit testing involves the design of test cases that validate that the internal program
logic is functioning properly, and that program inputs produce valid outputs. All
decision branches and internal code flow should be validated. It is the testing of
individual software units of the application .it is done after the completion of an
individual unit before integration. This is a structural testing, that relies on knowledge
of its construction and is invasive. Unit tests perform basic tests at component level
and test a specific business process, application, and/or system configuration. Unit
tests ensure that each unique path of a business process performs accurately to the
documented specifications and contains clearly defined inputs and expected results.

Integration testing
Integration tests are designed to test integrated software components to determine if
they actually run as one program. Testing is event driven and is more concerned with
the basic outcome of screens or fields. Integration tests demonstrate that although the
components were individually satisfaction, as shown by successfully unit testing, the
combination of components is correct and consistent. Integration testing is specifically
aimed at exposing the problems that arise from the combination of components.

Functional test
Functional tests provide systematic demonstrations that functions tested are available
as specified by the business and technical requirements, system documentation, and
user manuals.
Functional testing is cantered on the following items:
 Valid Input: identified classes of valid input must be accepted.

Invalid Input: identified classes of invalid input must be rejected.

Functions: identified functions must be exercised.

Output : identified classes of application outputs must be exercised.

Systems/Procedures: interfacing systems or procedures must be invoked.

Organization and preparation of functional tests is focused on

requirements, key functions, or special test cases. In addition, systematic coverage
pertaining to identify Business process flows; data fields, predefined processes, and
successive processes must be considered for testing. Before functional testing is
complete, additional tests are identified and the effective value of current tests is
determined.

System Test
System testing ensures that the entire integrated software system meets
requirements. It tests a configuration to ensure known and predictable results. An
example of system testing is the configuration-oriented system integration test. System
testing is based on process descriptions and flows, emphasizing pre-driven process
links and integration points.

White Box Testing

White Box Testing is a testing in which in which the software tester has
knowledge of the inner workings, structure and language of the software, or at least its
purpose. It is purpose. It is used to test areas that cannot be reached from a black box
level.
 Black Box Testing
Black Box Testing is testing the software without any knowledge of the inner
workings, structure or language of the module being tested. Black box tests, as most
other kinds of tests, must be written from a definitive source document, such as
specification or requirements document, such as specification or requirements
document. It is a testing in which the software under test is treated, as a black box. you
cannot “see” into it. The test provides inputs and responds to outputs without
considering how the software works.

Unit Testing
Unit testing is usually conducted as part of a combined code and unit test phase of the
software lifecycle, although it is not uncommon for coding and unit testing to be
conducted as two distinct phases.

Test strategy and approach

Field testing will be performed manually and functional tests will be

written in detail.
Test objectives
 All field entries must work properly.
 Pages must be activated from the identified link.
 The entry screen, messages and responses must not be delayed.

Features to be tested
 Verify that the entries are of the correct format
 No duplicate entries should be allowed
 All links should take the user to the correct page.
Integration Testing
Software integration testing is the incremental integration testing of two or more
integrated software components on a single platform to produce failures caused by
interface defects.
The task of the integration test is to check that components or software applications,
e.g. components in a software system or – one step up – software applications at the
company level – interact without error.

Test Results: All the test cases mentioned above passed successfully. No defects
encountered.

Acceptance Testing

User Acceptance Testing is a critical phase of any project and requires significant
participation by the end user. It also ensures that the system meets the functional
requirements.

Test Results: All the test cases mentioned above passed successfully. No defects
encountered.
Input and Output Screens
Successful software development fully dependent on Design Patterns as this
reduce development work by reusing already developed software’s functions.
Incorrect design patterns often lead to failure and inexperience often fall prey
for incorrect design pattern selection.
To overcome from these issues, we are employing Machine Learning and WEB
modules functions which will read source code as input from the user through
web interface and then ML algorithms will rank source code to find suitable
design pattern and then display predicted design pattern as output.
This ML models can be applied on UI/NON-UI based design patterns selection
and for accurate selection we have evaluated performance of multiple ML
algorithms like SVM, Random Forest and Decision Tree and each algorithm
performance is evaluated in terms of accuracy, precision, recall and FCSORE.
To train above algorithms we have utilized Design Patterns prediction dataset
downloaded from GITHUB URL and in below screen showing dataset details

In above screen we have java code from 13 different designs patterns and all
those patterns’ names we can see in below file
In above file first row represents column names like Project Name, source code
class name and the pattern that class is following and remaining rows contains
dataset values.
So, by using above java source code we will train algorithms to predict design
patterns. Each pattern will be selected by employing ontology based ranking
calculations which will calculate rank between dataset source code and user
uploaded source code and based in highest ranking Design Pattern will be
selected.
By using this project developers can upload existing or current source code files
and then application will predict Design Patterns and by using this prediction
Developer can what type of code follow what patterns so for his next project he
will choose correct patterns.
We have implemented this project as REST based web services which consists
of following modules
1) User Login: user can login to system using username and password as
‘admin and admin’.
2) Load Design Patterns Code: after login user will run this module to
upload dataset to application
3) Code to Numeric Vector: all codes will be converted to numeric vector
which will replace each word occurrence with its average frequency.
 4) Train ML Algorithms: processed numeric vector will be split into train
and test with a ratio of 80:20. 80% dataset will be input to training
algorithms to train a model and this model will be applied on 20% test
data to calculate accuracy
5) Predict Design Patterns: user will upload test source code files and then
ML algorithms will rank test file to predict accurate design patterns.
SCREEN SHOTS
To run code, install python 3.7 and then install all packages given in
requirements.txt file. Now double click on ‘run.bat’ file to start WEB REST
server and get below output

In above screen python server started and now open browser and enter URL as
http://127.0.0.1:8000/index.html and press enter key to get below page
In above screen click on ‘User Login’ link to get below login page

In above screen user is login by using username and password as ‘admin and
admin’ and then click on ‘Login’ button to get below page
In above screen click on ‘Load Design Pattern Code’ link to load dataset and get
below output

In above screen dataset loaded and now click on ‘Code to Numeric Vector’ link
to convert dataset into numeric vector and get below output
In above screen entire dataset converted to numeric vector and then click on
‘Train ML Algorithms’ link to train ML and get below output

In above screen can see each algorithm performance in tabular and graph format
and in all algorithms Random Forest got high accuracy and in graph x-axis
represents algorithm names and y-axis represents accuracy and other metrics in
different colour bars and now click on ‘Predict Design Patterns’ link to get
below page
In above screen select and uploading any java source code in UI/non-UI format
and then click on ‘Submit’ button to predict names of design pattern

In above screen in blue colour text can see Design pattern predicted from
uploaded source code as ‘Builder’ and similarly you can upload and test any
other source code. Below is another example
Uploading another code and below is the output

In above screen pattern detected as “Façade”

In above screen another code patterns predicted as ‘Factory Method’.
Conclusion
In this study, we explored the development of a machine learning-based system
for design pattern prediction, focusing on automating and enhancing the
accuracy of design pattern recommendations in software development. Design
patterns play a crucial role in building scalable and maintainable software
systems, but manual selection often leads to inefficiencies and human error.
By leveraging machine learning techniques, we were able to automate the
process of identifying both structural and behavioural design patterns. The
system efficiently collects data, extracts meaningful features, trains predictive
models, and provides real-time pattern recommendations. This approach
significantly reduces the dependency on developer expertise and improves code
quality by ensuring the correct patterns are applied in the right context.
Key contributions of the system include:
1. Automated Pattern Prediction: Using advanced machine learning
algorithms, the system predicts design patterns based on software
features, reducing manual intervention.
2. Behavioural and Structural Pattern Identification: Unlike traditional
rule-based systems, our approach identifies both structural and
behavioural patterns, increasing accuracy in dynamic software
architectures.
3. Scalability and Usability: The system is designed to integrate seamlessly
into IDEs, providing real-time feedback and scaling to handle large and
complex codebases.
Overall, this system offers a more accurate, efficient, and scalable solution for
design pattern prediction, ultimately improving the software design process.
Future Scope
The proposed system, while promising, opens up several avenues for future
research and development. Below are key areas that can be explored to extend
the capabilities and impact of this work:
1. Enhancing Model Accuracy and Adaptability:
o Deep Learning Approaches: Future work can involve the
application of more sophisticated deep learning techniques like
Graph Neural Networks (GNNs) and Recurrent Neural Networks
(RNNs) to capture even more complex relationships between code
components, leading to improved prediction accuracy.
o Self-Learning Systems: Implementing reinforcement learning or
active learning mechanisms where the system improves based on
user feedback and interactions over time.
2. Incorporating Contextual and Domain-Specific Patterns:
o The current system works well with general design patterns, but
future versions could be tailored to identify domain-specific
design patterns, such as those used in specialized fields like
artificial intelligence, embedded systems, or web development.
o Context-Aware Predictions: Future models can be trained to
consider the specific context of the project (e.g., software type,
performance requirements) to make more tailored
recommendations.
3. Expanding Dataset and Continuous Learning:
o Expanding the dataset by incorporating a broader range of open-
source projects or proprietary software can improve the model’s
ability to generalize. The system can be designed to continuously
learn from new projects and patterns, keeping it up-to-date with
emerging design trends.
o Automated Data Labelling: Developing techniques to automate
the annotation and labelling of design patterns in software
repositories will reduce manual labour in expanding training
datasets.
4. Integration with More Development Tools:
 o While current integration is focused on popular IDEs like IntelliJ
IDEA, Eclipse, and Visual Studio, expanding support to other
development environments (e.g., cloud-based IDEs, mobile
development platforms) would make the system more accessible.
o Collaborative Platforms: Integration with collaborative
development platforms like GitHub or GitLab could allow teams to
receive real-time design pattern recommendations during code
reviews or pull requests.
5. Real-Time Pattern Detection in Code Repositories:
o Future iterations of the system could actively monitor ongoing
software development projects in real-time, scanning for potential
design pattern usage or anti-patterns in continuous integration
pipelines.
o Code Quality Feedback: Expanding the system to detect
violations of design principles or identify areas where patterns can
improve software quality will enhance its utility in both legacy
codebases and new projects.
6. Explainability and Developer Insights:
o Incorporating explainable AI techniques to provide insights into
why specific design patterns are recommended will enhance trust
in the system. Developers can benefit from understanding the
rationale behind predictions, leading to better learning outcomes.
o Pattern Visualization: Providing graphical representations of
design patterns within the codebase can help developers better
visualize and understand pattern application and structure.
7. Supporting Code Refactoring:
o An extension of the system could provide automated refactoring
suggestions, ensuring that developers not only identify potential
design patterns but also receive guidance or automated scripts to
refactor the code accordingly.
8. Security Patterns Prediction:
o Future work could focus on extending the system to detect
security-related design patterns (e.g., patterns for secure software
design) and help developers implement secure code by
recommending patterns that mitigate specific security risks.
References
1. Gamma, E., Helm, R., Johnson, R., & Vlassises, J. (1994). Design
Patterns: Elements of Reusable Object-Oriented Software. Addison-
Wesley Professional.
2. Buschmann, F., Meunier, R., Rohnert, H., Sommerlad, P., & Stal, M.
(1996). Pattern-Oriented Software Architecture, Volume 1: A System of
Patterns. Wiley.
3. Antoniol, G., Fiutem, R., & Cristoforetti, L. (1998). Design pattern
recovery in object-oriented software. Proceedings of the 6th International
Workshop on Program Comprehension (IWPC), 153-160.
4. Dong, J., Yang, Y., & Zhang, K. (2009). Design pattern detection by
template matching. Proceedings of the 2009 ACM symposium on Applied
Computing, 765-769.
5. Hammad, M., Alnusair, A., & Zhao, L. (2013). Using machine learning
techniques for design patterns recognition. Journal of Software
Engineering and Applications, 6(6), 313-320.
6. Zhang, J., Zhang, H., & Gu, X. (2006). A rule-based automatic approach
to detecting design patterns. Proceedings of the 2006 Asia-Pacific
Software Engineering Conference (APSEC), 489-496.
7. Tsantalis, N., Chatzigeorgiou, A., Stephanie’s, G., & Halides, S. T.
(2006). Design pattern detection using similarity scoring. IEEE
Transactions on Software Engineering, 32(11), 896-909.
8. Malhotra, R., Bansal, A., & Bajaj, K. (2017). A machine learning
approach for detecting design patterns. Journal of King Saud University-
Computer and Information Sciences, 29(2), 182-193.
9. Chen, Q., Zhang, L., & Sun, C. (2019). Detecting design patterns with
deep learning. Proceedings of the 41st International Conference on
Software Engineering (ICSE), 999-1010.
10.Kim, M., Cai, Y., & Schurles, W. (2020). Hybrid approach to design
pattern detection using rule-based and machine learning techniques.
Journal of Systems and Software, 162, 110510.