I) Good morning esteemed panel of jurors,

I am Nassima Ait Mansour, and I am currently in the early stages of my doctoral journey in the
collaborative PhD program between the Faculty of Sciences and Techniques of Mohammedia and ENSIAS
at the prestigious Mohammed V University in Rabat. I am proudly affiliated with the 'Mathematics,
Computer Science, and Applications' laboratory, where I am beginning to delve into the world of
groundbreaking research. The subject of my thesis is 'Intelligent Discovery of Microservices based on
Data Mining Techniques.' Today, with a sense of enthusiasm and anticipation, I am presenting my paper
titled 'From Monolith to Microservices: A Decomposition Technique'. Through this work, I will analyze
the migration techniques proposed in the literature and propose our approach of migration based on
process mining.

I am eager to share the early fruits of my research with this esteemed panel. for that Let's get started
with my presentation.

II) Creating and managing complex software systems that can efficiently expand, adapt to
changing business objectives, and provide seamless user experiences is a challenge for
enterprises in today's fast-paced digital environment. Traditional monolithic programs,
which have a single codebase and closely connected components, frequently struggle to
achieve these requirements, which limits their agility, scalability, and creativity. To solve
these issues, The industry adoption of microservice architecture has accelerated rapidly,
with this architecture we take the large monolithic software and split it down into small,
autonomous, and loosely connected services. Each microservice is designed to perform a
specific function within the application and communicates with other microservices through
lightweight protocols such as HTTP or messaging. The foundation of the microservices
architecture is the separation of concerns, where each service is in charge of a particular
business function or feature and will be deploy in its container. This enables software
applications to be developed with increased flexibility, scalability, and agility.

monolithic application is a software architecture in which all functionality is contained within a single
program, making it impossible for its components to be performed individually. With this method, the
application normally consists of a single codebase with all functions and components packed together.
The resources and memory used by the application's components are shared

Simplicity The program will have a single codebase, making it easier to deploy and develop
because developers will have a clear grasp of the entire system.
Easier Testing and Error Tracing. also easier to spot errors when all transactions are logged
into one place.

Scalability Is Limited. when the application gets bigger, it becomes more and more difficult
to scale it up. As a result, as more people are going to use the software, there will be more
and more issues with handling requests.
Development Speed Goes Down. As the application gets larger due to how its structure is
tightly connected, it also gets more difficult to understand and modify. Even minor changes
require the whole system update.
Easier Testing and Error Tracing. With fewer variables, the risk for something to go wrong is much lower,
while it is also easier to spot errors when all transactions are logged into one place.

Small: Microservices have to be compact and concentrated on a particular piece of business

activity. Each microservice should not have many features; rather, it should be created to
carry out a single task inside the application. A fundamental tenet of microservices
architecture is that each service is in charge of a particular business function or feature.
• Autonomous: Each microservice should possess a distinct set of capabilities that allows it
to run without relying on any other microservices. In a microservice, autonomy is the
capacity to function independently of other microservices or a centralized authority.
• Cohesive: Each service should have a distinct, well-defined role that is connected to the
system's overall business functioning. Because it just needs to concentrate on its particular
role and responsibility when a service is cohesive, it is simpler to comprehend, test, manage
and grow.
• Loose coupling : The first benefit is that it enables individual microservices to develop and
alter without affecting the others. This implies that if one service has to be upgraded or
changed, it can be done without affecting the other services. This lowers the possibility of
introducing bugs or other problems while also making it simpler to maintain, test, and
deploy discrete services.

The last key word is the PM , so to reduce human interaction ,PM help to automattically discovery ,verify
and improve process model.

Is our woks we focused more on how to generate a business process by using log (process discovery )

III) Model-Driven (MD) techniques leverage design elements as input (for example, business
capabilities, business objects, domain entities, functional and non-functional requirements,
and data flow diagrams from business logic).

Dynamic analysis (DA) methods analyze system functionality during runtime.

In this section ,I present the state of art of work on decomposition techniques

This table consiste of comparing differents works according to the migration approach

hey focused on using model driven analysis to determinate the ideal number of a service in a
service-oriented architecture. Depending on their update pace, scaling rate, and technology
employed. The article provides a set of algorithms that break down business capabilities into
sub-business capabilities and constructs update and scaling matrices.
[2] This study found that The Data Flow Diagram (DFD) is a great choice for representing
monolithic systems in terms of business processes based on the Top-Down Analysis
Approach and the Dataflow-Driven Decomposition Algorithm.
 [3] Utilize the Dynamic analysis as a Migration Approach . they realize that the
decomposition is often conducted manually by software architects, with the little assistance
available based on static analysis of dependencies using tools such as Structure 1011.
However Static dependency analysis techniques cannot capture dynamic system behavior,
and run-time dependencies such as frequent method calls can have an impact on both
maintainability and performance. We can get a decent application decomposition using
process mining.
[4] They suggest combining known analytical methodologies for microservice decomposition,
such as the domain-driven design bounded context pattern, with dynamic software
visualization to determine optimal microservice boundaries.

IV) decomposing monolithic systems into microservices is a difficult and error-prone job that is
often undertaken manually by the software architect. There are numerous approaches for
migration, but onof the most essential and useful approaches for generating the
microservice architecture is the Dynamic method, which uses runtime execution to discover
all dependencies and classes utilized at runtime.The deconstruction may be done based on
the various user requests, as part of the mining process, this information can be stored in an
event log,and utilizing a
customizable business.

the swift adoption of microservice design within the industry has marked a significant shift in
software architecture. By transitioning from monolithic structures to small, independent, and
loosely coupled services, we stand at the forefront of enhancing scalability, agility, and
maintainability. The paradigm shift offered by microservices presents promising opportunities
for optimizing software development and deployment processes.

Looking ahead, I am committed to translating theory into practice. As I progress in my academic

journey, I aim to implement the principles of microservices architecture in real-world scenarios.
By decomposing substantial monolithic software into a constellation of nimble microservices, I
anticipate grappling with the intricacies of effective deployment, orchestration, and seamless
integration.

Furthermore, I remain dedicated to furthering my research endeavors. With a focus on refining

the decomposition process, both at the code and database level, I am excited to leverage
process mining techniques to ensure a methodical and well-considered approach. Through these
combined efforts, I aspire to contribute to the realm of software architecture, paving the way for
more efficient, adaptable, and innovative systems.

Thank you for your attention and engagement throughout this presentation."