模型学习与代码生成：重构软件实践的风险与高效方法

需积分: 10 184 浏览量更新于2024-07-16 收藏 875KB PDF 举报

本文档探讨了"Refactoring：软件模型学习与代码生成的实践应用"，着重于解决在重构（或称为软件重工程）过程中面临的挑战。重构是针对现有软件系统进行改进的一种技术，目的是提高代码质量、可读性和结构，但同时也伴随着风险，比如引入新的bug，以及其耗时且成本高昂的特点。作者Gijs van der Meijde在Master of Computing Science，软件科学专业背景下，针对ASML这样的企业背景进行研究，试图通过结合软件模型学习和代码生成的方法来减轻重构过程中的压力。在这个实践中，主要关注的是如何利用模型学习来自动化部分重构任务，从而减少人工干预的时间和出错可能性。模型学习可能涉及机器学习算法，如模式识别、自动代码分析，以及预测代码修改的效果，以便在保持功能不变的前提下，优化代码结构。这种方法旨在提升重构的效率和精确性，降低重构过程中因人为因素导致的问题。文章还可能涵盖了以下关键知识点： 1. **模型学习在重构中的角色**：介绍了如何通过训练模型理解现有的代码结构和行为，然后生成可能的重构建议。这可能包括代码风格转换、模块划分优化或异常处理改进等。 2. **风险评估与预防**：文中可能会详细讨论如何通过模型学习的结果进行风险评估，选择合适的重构策略，以最小化潜在的副作用。 3. **工具支持**：介绍可能开发或使用的工具，这些工具能够自动化模型学习和代码生成的过程，比如基于机器学习的代码分析工具和自动生成重构代码的IDE插件。 4. **案例研究**：可能包含实际项目中应用模型学习和代码生成进行重构的成功案例，展示这种方法的有效性和实用性。 5. **局限性与未来工作**：探讨当前方法的局限性，如数据依赖、模型复杂性管理和用户体验，以及如何在未来的研究中进一步改进和扩展。 6. **行业影响与价值**：论文会强调通过这种方法，软件工程师可以节省时间和精力，降低重构的成本，从而提高整个团队的生产力和软件项目的整体质量。这篇论文提供了一个创新的视角，将软件模型学习与实际的代码重构相结合，以应对软件开发中的复杂问题，为软件工程领域带来了新的解决方案。

1. INTRODUCTION

This deﬁnition assumes that a Mealy Machine is deterministic and input enabled, as is also

the case for our models. Formally, a Mealy Machine is described as a 6-tuple: (S, s

, Σ, Λ, T, G).

These 6-tuples consist of:

- S: A ﬁnite set of states.

- s

: An initial (start) state s

∈ S.

- Σ: A ﬁnite set of inputs.

- Λ: A ﬁnite set of outputs.

- T: A transition function T : S × Σ → S mapping a state and an input symbol to the

next state.

- G: An output function G : S × Σ → Λ mapping a state and an input symbol to an

output symbol.

An important rule for Mealy Machines is that for each state in S, for every input deﬁned in Σ

a transition is deﬁned. If an input does not make the system change its state, the corresponding

transition should loop back to the same state (See Figure 2: T (S

, b)). In this thesis the input

alphabet Σ of our models represents the functions we call on the external interface of the system.

The output alphabet Λ represents the return values of the functions that are called on the system.

Any symbol e /∈ Σ is not accepted by the system and will result in undeﬁned behavior. This means

it depends on the software how these inputs are handled, some programs for example might just

ignore these inputs while others might crash completely.

1.4 Research goal

This study was conducted at ASML to ﬁnd a uniform approach for their refactoring projects.

The goal of this research was to explore a method that assists engineers in refactoring legacy

code using model learning. In this thesis, we focus on the reasons for refactoring, the risks that

come with it and how to reduce these risks. We also present guidelines to assist engineers in

writing more maintainable code. If engineers adhere to these guidelines, this would beneﬁt future

refactoring.

To reduce the risks in refactoring, a method using a combination of model learning and

text/code generation was explored. This method uses the learned model to generate unit tests

and an anti-corruption layer that helps engineers gain conﬁdence in the behavior of the refactored

code. The generated unit-tests can help prove behavior preservation after refactoring, while the

anti-corruption layer is used to enforce certain behavior at run-time.

In addition to providing software engineers with a uniform approach for their refactoring

projects, the purpose of exploring this method is showing the current strengths and limitations

of the used model-based techniques in similar settings. To show these strengths and limitations,

the method was applied to an industrial case at ASML. This thesis discusses these and appoints

some possible solutions for the limitations.

1. INTRODUCTION

1.5 Research questions

The goal of this thesis is to apply model-based techniques and in particular model learning in

industrial settings. For this research, we chose to use these techniques to facilitate the refactoring

process of complex software components. We explored a practical application of model learning;

assisting engineers in refactoring legacy code. The direction this research takes is based on the

pre-conducted study on the problems in software refactoring described in the previous sections.

The main research questions addressed during this research are:

(RQ1) Can we provide engineers with a method to refactor legacy code based on model

learning?

(RQ2) Is model learning mature enough to be applied in an industrial setting?

(RQ3) When model learning is applied for refactoring industrial software, what are the ben-

eﬁts and the limitations?

(RQ4) Based on experience gained in the industry, can we provide engineers with general

guidelines for software refactoring?

(RQ5) Can we automatically generate tests from a learned model to assist engineers in refac-

toring legacy code in a test driven way?

a) If so, what is the most convenient test framework to use?

(RQ6) Can we use models to guarantee behavior preservation when deploying the refactored

code?

Some of the subjects mentioned above are also treated by M.T.W. Schuts in his doctoral

thesis [13] at Phillips. However, as he describes in his thesis, his research was focused on a speciﬁc

industrial case. The industrial case used in this thesis yields valuable experience from a diﬀerent

perspective, that can be used to shed a diﬀerent light on Model Learning in industrial applications.

1.6 Outline of this thesis

This thesis is structured as follows: prior to this research, a literature study was conducted to gain

a better understanding of the problems and importance of refactoring software. The ﬁndings of

this study are discussed in the introduction of this thesis (Chapter 1). Next, we propose a solution

by brieﬂy describing a method for reducing the risks of refactoring in Chapter 2. To support our

method we applied it to an industrial case study at ASML. Chapter 3 explains our industrial case

in more detail and Chapter 4 explains how the case was prepared for model learning.

To help overcome the problems in software refactoring, we use a combination of model learning

techniques, explained in Chapter 5, and code/test generation to assist engineers in refactoring

legacy code. The learned model can also be used by the engineers to gain a better understanding

of the behavior of the system.

In Chapter 6 we show it is possible to generate tests from a learned model to help preserve

behavior when refactoring. These tests can be used to refactor legacy code in a test-driven way.

Chapter 7 introduces an anti-corruption layer that can also be generated from the learned model.

This anti-corruption layer is used to protect the system from ‘illegal’ behavior at run-time and

thus further reduces the risks of refactoring.

To put our method to the test we carried out some light refactoring in Chapter 8. While doing

so we encountered some limitations which are discussed in this chapter.

Finally, we end this thesis in Chapter 9 by reﬂecting on the research and discuss our proposed

methods strengths and weaknesses and possible extensions to improve the method.

2. METHODOLOGY

2 Methodology

In this chapter, we propose a method to refactor software in a safe manner. The diﬀerent com-

ponents of this method are explained in more detail in their own chapters. Figure 17 shows an

overview of the steps for refactoring the system as explained below.

Figure 3: Proposed refactoring method

1.) Model learning is a technique to learn the

behavior of a system from a black-box perspective.

The piece (slice) of software you want to learn the

behavior of, depends strongly on the type of refac-

toring you want to apply (Section 1.2) and the way

the legacy software is structured. If, for example,

the components of the software are strongly con-

nected but contain little logic it might prove more

eﬀective to learn bigger chunks of, or even the en-

tire, software at once. If the software contains a lot

of logic, like in our industrial case, it might prove

more eﬀective to isolate a smaller module of the

software and learn its behavior ﬁrst. Thus refactor-

ing the software step by step.

To learn the behavior of a software module us-

ing automated learning tools, these tools need to

be able to communicate with the software mod-

ule. This means an adapter to replace the system

that normally calls the module by the learning tool

needs to be created. To properly learn the behavior

of this single software module and not that of its

dependencies, the dependencies should be replaced

using so-called stubs. The chosen module may also

contain cyclic dependencies with other modules. In

order to isolate the desired component these cyclic

dependencies need to be resolved. By generating

a graph of all dependencies and distinguishing all

strongly connected components in this graph, it is

possible to see how strong or loose the diﬀerent

modules of a system are coupled. This helps in iden-

tifying the speciﬁc functions that need to be refac-

tored to uncouple a speciﬁc component. In Chapter

4, we describe the method we applied for isolating

the module in our industrial case.

2.) To learn the behavior of the legacy module

as precisely as possible, we used a combination of

model learning and analysis of system traces from our industrial case (trace analysis). Model

learning is a black box method to learn the behavior of a system, but because it is black box it is

not guaranteed to learn the complete behavior of the system. If, for example, a system responds

identically the ﬁrst 100 times a button is pressed but responds diﬀerently the 101st time, most

model learning algorithms will already have stopped ‘exploring’ that button and not discover this

change in behavior. On the other hand, model learning tries to learn all possible combinations

of actions on the system. This means it might also learn behavior that should not occur during

a normal run of the system. This might be because of defensive programming (the software just

ignores illegal moves) or because the original developer never expected someone to use the module

in this way.

剩余59页未读，继续阅读

luck_girl

粉丝: 0
资源: 5

模型学习与代码生成：重构软件实践的风险与高效方法

构建用户界面：从零开始，重视功能而非布局，关注细节，不过度设计，个性选择。

"C藏经阁-XPY：自动化性能测试框架的设计与实现

Java代码助手Codetool：提升开发效率的利器

Refactoring Improving the Design of the Existing code

Refactoring Improving the Design of Existing Code

Refactoring Improving The Design of Existing Code

refactoring improving the design of existing code.

Refactoring Improving the Design of Existing Code.pdf

Refactoring Improving The Design Of Existing Code

重构（Refactoring Improving the Design of Existing Code）

最新资源