1 \documentclass[USenglish,draft]{ifimaster}
3 \usepackage[utf8]{inputenc}
4 \usepackage[T1]{fontenc,url}
5 \usepackage{lmodern} % using Latin Modern to be able to use bold typewriter font
7 \usepackage{babel,textcomp,csquotes,ifimasterforside,varioref,graphicx}
8 \usepackage[hidelinks]{hyperref}
10 \usepackage[style=numeric-comp,backend=bibtex]{biblatex}
12 \usepackage[obeyDraft]{todonotes}
19 \usepackage{perpage} %the perpage package
20 \MakePerPage{footnote} %the perpage package command
22 \theoremstyle{definition}
23 \newtheorem*{wordDef}{Definition}
25 \graphicspath{ {./figures/} }
27 \newcommand{\citing}[1]{~\cite{#1}}
28 \newcommand{\myref}[1]{\cref{#1} on \cpageref{#1}}
30 \newcommand{\definition}[1]{\begin{wordDef}#1\end{wordDef}}
31 \newcommand{\see}[1]{(see \myref{#1})}
32 \newcommand{\See}[1]{(See \myref{#1}.)}
33 \newcommand{\explanation}[3]{\noindent\textbf{\textit{#1}}\\*\emph{When:}
34 #2\\*\emph{How:} #3\\*[-7px]}
36 \newcommand{\type}[1]{\texttt{\textbf{#1}}}
37 \newcommand{\typeref}[1]{\footnote{\type{#1}}}
38 \newcommand{\typewithref}[2]{\type{#2}\typeref{#1.#2}}
39 \newcommand{\method}[1]{\type{#1}}
40 \newcommand{\methodref}[2]{\footnote{\type{#1}\method{\##2()}}}
41 \newcommand{\methodwithref}[2]{\method{#2}\footnote{\type{#1}\method{\##2()}}}
42 \newcommand{\var}[1]{\type{#1}}
44 \newcommand{\refactoring}[1]{\emph{#1}}
45 \newcommand{\ExtractMethod}{\refactoring{Extract Method}\xspace}
46 \newcommand{\MoveMethod}{\refactoring{Move Method}\xspace}
48 \newcommand\todoin[2][]{\todo[inline, caption={2do}, #1]{
49 \begin{minipage}{\textwidth-4pt}#2\end{minipage}}}
53 \author{Erlend Kristiansen}
55 \bibliography{bibliography/master-thesis-erlenkr-bibliography}
63 \todoin{\textbf{Remove all todos (including list) before delivery/printing!!!
64 Can be done by removing ``draft'' from documentclass.}}
65 \todoin{Write abstract}
73 The discussions in this report must be seen in the context of object oriented
74 programming languages, and Java in particular, since that is the language in
75 which most of the examples will be given. All though the techniques discussed
76 may be applicable to languages from other paradigms, they will not be the
77 subject of this report.
81 \chapter{What is Refactoring?}
83 This question is best answered by first defining the concept of a
84 \emph{refactoring}, what it is to \emph{refactor}, and then discuss what aspects
85 of programming make people want to refactor their code.
87 \section{Defining refactoring}
88 Martin Fowler, in his classic book on refactoring\citing{refactoring}, defines a
89 refactoring like this:
92 \emph{Refactoring} (noun): a change made to the internal
93 structure\footnote{The structure observable by the programmer.} of software to
94 make it easier to understand and cheaper to modify without changing its
95 observable behavior.~\cite[p.~53]{refactoring}
98 \noindent This definition assigns additional meaning to the word
99 \emph{refactoring}, beyond the composition of the prefix \emph{re-}, usually
100 meaning something like ``again'' or ``anew'', and the word \emph{factoring},
101 that can mean to isolate the \emph{factors} of something. Here a \emph{factor}
102 would be close to the mathematical definition of something that divides a
103 quantity, without leaving a remainder. Fowler is mixing the \emph{motivation}
104 behind refactoring into his definition. Instead it could be more refined, formed
105 to only consider the \emph{mechanical} and \emph{behavioral} aspects of
106 refactoring. That is to factor the program again, putting it together in a
107 different way than before, while preserving the behavior of the program. An
108 alternative definition could then be:
110 \definition{A \emph{refactoring} is a transformation
111 done to a program without altering its external behavior.}
113 From this we can conclude that a refactoring primarily changes how the
114 \emph{code} of a program is perceived by the \emph{programmer}, and not the
115 \emph{behavior} experienced by any user of the program. Although the logical
116 meaning is preserved, such changes could potentially alter the program's
117 behavior when it comes to performance gain or -penalties. So any logic depending
118 on the performance of a program could make the program behave differently after
121 In the extreme case one could argue that such a thing as \emph{software
122 obfuscation} is to refactor. If we where to define it as a refactoring, it could
123 be defined as a composite refactoring \see{compositeRefactorings}, consisting
124 of, for instance, a series of rename refactorings. (But it could of course be
125 much more complex, and the mechanics of it would not exactly be carved in
126 stone.) To perform some serious obfuscation one would also take advantage of
127 techniques not found among established refactorings, such as removing
128 whitespace. This might not even generate a different syntax tree for languages
129 not sensitive to whitespace, placing it in the gray area of what kind of
130 transformations is to be considered refactorings.
132 \section{The etymology of 'refactoring'}
133 It is a little difficult to pinpoint the exact origin of the word
134 ``refactoring'', as it seems to have evolved as part of a colloquial
135 terminology, more than a scientific term. There is no authoritative source for a
136 formal definition of it.
138 According to Martin Fowler\citing{etymology-refactoring}, there may also be more
139 than one origin of the word. The most well-known source, when it comes to the
140 origin of \emph{refactoring}, is the Smalltalk\footnote{\emph{Smalltalk},
141 object-oriented, dynamically typed, reflective programming language. See
142 \url{http://www.smalltalk.org}} community and their infamous \emph{Refactoring
143 Browser}\footnote{\url{http://st-www.cs.illinois.edu/users/brant/Refactory/RefactoringBrowser.html}}
144 described in the article \emph{A Refactoring Tool for
145 Smalltalk}\citing{refactoringBrowser1997}, published in 1997.
146 Allegedly\citing{etymology-refactoring}, the metaphor of factoring programs was
147 also present in the Forth\footnote{\emph{Forth} -- stack-based, extensible
148 programming language, without type-checking. See \url{http://www.forth.org}}
149 community, and the word ``refactoring'' is mentioned in a book by Leo Brodie,
150 called \emph{Thinking Forth}\citing{brodie1984}, first published in
151 1984\footnote{\emph{Thinking Forth} was first published in 1984 by the
152 \emph{Forth Interest Group}. Then it was reprinted in 1994 with minor
153 typographical corrections, before it was transcribed into an electronic edition
154 typeset in \LaTeX\ and published under a Creative Commons licence in 2004. The
155 edition cited here is the 2004 edition, but the content should essentially be as
156 in 1984.}. The exact word is only printed one place~\cite[p.~232]{brodie1984},
157 but the term \emph{factoring} is prominent in the book, that also contains a
158 whole chapter dedicated to (re)factoring, and how to keep the (Forth) code clean
162 \ldots good factoring technique is perhaps the most important skill for a
163 Forth programmer.~\cite[p.~172]{brodie1984}
166 \noindent Brodie also express what \emph{factoring} means to him:
169 Factoring means organizing code into useful fragments. To make a fragment
170 useful, you often must separate reusable parts from non-reusable parts. The
171 reusable parts become new definitions. The non-reusable parts become arguments
172 or parameters to the definitions.~\cite[p.~172]{brodie1984}
175 Fowler claims that the usage of the word \emph{refactoring} did not pass between
176 the \emph{Forth} and \emph{Smalltalk} communities, but that it emerged
177 independently in each of the communities.
179 \section{Motivation -- Why people refactor}
180 To get a grasp of what refactoring is all about, we can try to answer this
181 question: \emph{Why do people refactor?} Possible answers could include: ``To
182 remove duplication'' or ``to break up long methods''. Practitioners of the art
183 of Design Patterns\citing{designPatterns} could say that they do it to introduce
184 a long-needed pattern into their program's design. So it is safe to say that
185 peoples' intentions are to make their programs \emph{better} in some sense. But
186 what aspects of the programs are becoming improved?
188 As already mentioned, people often refactor to get rid of duplication. Moving
189 identical or similar code into methods, and maybe pushing methods up or down in
190 their class hierarchies. Making template methods for overlapping
191 algorithms/functionality and so on. It is all about gathering what belongs
192 together and putting it all in one place. The resulting code is then easier to
193 maintain. When removing the implicit coupling\footnote{When duplicating code,
194 the code might not be coupled in other ways than that it is supposed to
195 represent the same functionality. So if this functionality is going to change,
196 it might need to change in more than one place, thus creating an implicit
197 coupling between the multiple pieces of code.} between code snippets, the
198 location of a bug is limited to only one place, and new functionality need only
199 to be added to this one place, instead of a number of places people might not
202 A problem you often encounter when programming, is that a program contains a lot
203 of long and hard-to-grasp methods. It can then help to break the methods into
204 smaller ones, using the \ExtractMethod refactoring\citing{refactoring}. Then you
205 may discover something about a program that you were not aware of before;
206 revealing bugs you did not know about or could not find due to the complex
207 structure of your program. \todo{Proof?} Making the methods smaller and giving
208 good names to the new ones clarifies the algorithms and enhances the
209 \emph{understandability} of the program \see{magic_number_seven}. This makes
210 refactoring an excellent method for exploring unknown program code, or code that
211 you had forgotten that you wrote.
213 Most primitive refactorings are simple. Their true power is first revealed when
214 they are combined into larger --- higher level --- refactorings, called
215 \emph{composite refactorings} \see{compositeRefactorings}. Often the goal of
216 such a series of refactorings is a design pattern. Thus the \emph{design} can be
217 evolved throughout the lifetime of a program, as opposed to designing up-front.
218 It is all about being structured and taking small steps to improve a program's
221 Many software design pattern are aimed at lowering the coupling between
222 different classes and different layers of logic. One of the most famous is
223 perhaps the \emph{Model-View-Controller}\citing{designPatterns} pattern, or
224 \emph{MVC} for short. It is aimed at lowering the coupling between the user
225 interface and the business logic and data representation of a program. This also
226 has the added benefit that the business logic could much easier be the target of
227 automated tests, increasing the productivity in the software development
228 process. Refactoring is an important tool on the way to something greater.
230 Another effect of refactoring is that with the increased separation of concerns
231 coming out of many refactorings, the \emph{performance} can be improved. When
232 profiling programs, the problematic parts are narrowed down to smaller parts of
233 the code, which are easier to tune, and optimization can be performed only where
234 needed and in a more effective way.
236 Last, but not least, and this should probably be the best reason to refactor, is
237 to refactor to \emph{facilitate a program change}. If one has managed to keep
238 one's code clean and tidy, and the code is not bloated with design patterns that
239 are not ever going to be needed, then some refactoring might be needed to
240 introduce a design pattern that is appropriate for the change that is going to
243 Refactoring program code --- with a goal in mind --- can give the code itself
244 more value. That is in the form of robustness to bugs, understandability and
245 maintainability. Having robust code is an obvious advantage, but
246 understandability and maintainability are both very important aspects of
247 software development. By incorporating refactoring in the development process,
248 bugs are found faster, new functionality is added more easily and code is easier
249 to understand by the next person exposed to it, which might as well be the
250 person who wrote it. The consequence of this, is that refactoring can increase
251 the average productivity of the development process, and thus also add to the
252 monetary value of a business in the long run. The perspective on productivity
253 and money should also be able to open the eyes of the many nearsighted managers
254 that seldom see beyond the next milestone.
256 \section{The magical number seven}\label{magic_number_seven}
257 The article \emph{The magical number seven, plus or minus two: some limits on
258 our capacity for processing information}\citing{miller1956} by George A.
259 Miller, was published in the journal \emph{Psychological Review} in 1956. It
260 presents evidence that support that the capacity of the number of objects a
261 human being can hold in its working memory is roughly seven, plus or minus two
262 objects. This number varies a bit depending on the nature and complexity of the
263 objects, but is according to Miller ``\ldots never changing so much as to be
266 Miller's article culminates in the section called \emph{Recoding}, a term he
267 borrows from communication theory. The central result in this section is that by
268 recoding information, the capacity of the amount of information that a human can
269 process at a time is increased. By \emph{recoding}, Miller means to group
270 objects together in chunks and give each chunk a new name that it can be
271 remembered by. By organizing objects into patterns of ever growing depth, one
272 can memorize and process a much larger amount of data than if it were to be
273 represented as its basic pieces. This grouping and renaming is analogous to how
274 many refactorings work, by grouping pieces of code and give them a new name.
275 Examples are the fundamental \ExtractMethod and \refactoring{Extract Class}
276 refactorings\citing{refactoring}.
279 \ldots recoding is an extremely powerful weapon for increasing the amount of
280 information that we can deal with.~\cite[p.~95]{miller1956}
283 An example from the article addresses the problem of memorizing a sequence of
284 binary digits. Let us say we have the following sequence\footnote{The example
285 presented here is slightly modified (and shortened) from what is presented in
286 the original article\citing{miller1956}, but it is essentially the same.} of
287 16 binary digits: ``1010001001110011''. Most of us will have a hard time
288 memorizing this sequence by only reading it once or twice. Imagine if we instead
289 translate it to this sequence: ``A273''. If you have a background from computer
290 science, it will be obvious that the latest sequence is the first sequence
291 recoded to be represented by digits with base 16. Most people should be able to
292 memorize this last sequence by only looking at it once.
294 Another result from the Miller article is that when the amount of information a
295 human must interpret increases, it is crucial that the translation from one code
296 to another must be almost automatic for the subject to be able to remember the
297 translation, before \heshe is presented with new information to recode. Thus
298 learning and understanding how to best organize certain kinds of data is
299 essential to efficiently handle that kind of data in the future. This is much
300 like when humans learn to read. First they must learn how to recognize letters.
301 Then they can learn distinct words, and later read sequences of words that form
302 whole sentences. Eventually, most of them will be able to read whole books and
303 briefly retell the important parts of its content. This suggest that the use of
304 design patterns\citing{designPatterns} is a good idea when reasoning about
305 computer programs. With extensive use of design patterns when creating complex
306 program structures, one does not always have to read whole classes of code to
307 comprehend how they function, it may be sufficient to only see the name of a
308 class to almost fully understand its responsibilities.
311 Our language is tremendously useful for repackaging material into a few chunks
312 rich in information.~\cite[p.~95]{miller1956}
315 Without further evidence, these results at least indicate that refactoring
316 source code into smaller units with higher cohesion and, when needed,
317 introducing appropriate design patterns, should aid in the cause of creating
318 computer programs that are easier to maintain and has code that is easier (and
321 \section{Notable contributions to the refactoring literature}
322 \todoin{Update with more contributions}
325 \item[1992] William F. Opdyke submits his doctoral dissertation called
326 \emph{Refactoring Object-Oriented Frameworks}\citing{opdyke1992}. This
327 work defines a set of refactorings, that are behavior preserving given that
328 their preconditions are met. The dissertation is focused on the automation
330 \item[1999] Martin Fowler et al.: \emph{Refactoring: Improving the Design of
331 Existing Code}\citing{refactoring}. This is maybe the most influential text
332 on refactoring. It bares similarities with Opdykes thesis\citing{opdyke1992}
333 in the way that it provides a catalog of refactorings. But Fowler's book is
334 more about the craft of refactoring, as he focuses on establishing a
335 vocabulary for refactoring, together with the mechanics of different
336 refactorings and when to perform them. His methodology is also founded on
337 the principles of test-driven development.
338 \item[2005] Joshua Kerievsky: \emph{Refactoring to
339 Patterns}\citing{kerievsky2005}. This book is heavily influenced by Fowler's
340 \emph{Refactoring}\citing{refactoring} and the ``Gang of Four'' \emph{Design
341 Patterns}\citing{designPatterns}. It is building on the refactoring
342 catalogue from Fowler's book, but is trying to bridge the gap between
343 \emph{refactoring} and \emph{design patterns} by providing a series of
344 higher-level composite refactorings, that makes code evolve toward or away
345 from certain design patterns. The book is trying to build up the readers
346 intuition around \emph{why} one would want to use a particular design
347 pattern, and not just \emph{how}. The book is encouraging evolutionary
348 design. \See{relationToDesignPatterns}
351 \section{Tool support}\label{toolSupport}
353 \subsection{Tool support for Java}
354 This section will briefly compare the refatoring support of the three IDEs
355 \emph{Eclipse}\footnote{\url{http://www.eclipse.org/}}, \emph{IntelliJ
356 IDEA}\footnote{The IDE under comparison is the \emph{Community Edition},
357 \url{http://www.jetbrains.com/idea/}} and
358 \emph{NetBeans}\footnote{\url{https://netbeans.org/}}. These are the most
359 popular Java IDEs\citing{javaReport2011}.
361 All three IDEs provide support for the most useful refactorings, like the
362 different extract, move and rename refactorings. In fact, Java-targeted IDEs are
363 known for their good refactoring support, so this did not appear as a big
366 The IDEs seem to have excellent support for the \ExtractMethod refactoring, so
367 at least they have all passed the first refactoring
368 rubicon\citing{fowlerRubicon2001,secondRubicon2012}.
370 Regarding the \MoveMethod refactoring, the \emph{Eclipse} and \emph{IntelliJ}
371 IDEs do the job in very similar manners. In most situations they both do a
372 satisfying job by producing the expected outcome. But they do nothing to check
373 that the result does not break the semantics of the program \see{correctness}.
374 The \emph{NetBeans} IDE implements this refactoring in a somewhat
375 unsophisticated way. For starters, its default destination for the move is
376 itself, although it refuses to perform the refactoring if chosen. But the worst
377 part is, that if moving the method \method{f} of the class \type{C} to the class
378 \type{X}, it will break the code. The result is shown in
379 \myref{lst:moveMethod_NetBeans}.
383 \begin{minted}[samepage]{java}
396 \begin{minted}[samepage]{java}
406 \caption{Moving method \method{f} from \type{C} to \type{X}.}
407 \label{lst:moveMethod_NetBeans}
410 NetBeans will try to make code that call the methods \method{m} and \method{n}
411 of \type{X} by accessing them through \var{c.x}, where \var{c} is a parameter of
412 type \type{C} that is added the method \method{f} when it is moved. (This is
413 seldom the desired outcome of this refactoring, but ironically, this ``feature''
414 keeps NetBeans from breaking the code in the example from \myref{correctness}.)
415 If \var{c.x} for some reason is inaccessible to \type{X}, as in this case, the
416 refactoring breaks the code, and it will not compile. NetBeans presents a
417 preview of the refactoring outcome, but the preview does not catch it if the IDE
418 is about break the program.
420 The IDEs under investigation seems to have fairly good support for primitive
421 refactorings, but what about more complex ones, such as the \refactoring{Extract
422 Class}\citing{refactoring}? The \refactoring{Extract Class} refactoring works by
423 creating a class, for then to move members to that class and access them from
424 the old class via a reference to the new class. \emph{IntelliJ} handles this in
425 a fairly good manner, although, in the case of private methods, it leaves unused
426 methods behind. These are methods that delegate to a field with the type of the
427 new class, but are not used anywhere. \emph{Eclipse} has added (or withdrawn)
428 its own quirk to the Extract Class refactoring, and only allows for
429 \emph{fields} to be moved to a new class, \emph{not methods}. This makes it
430 effectively only extracting a data structure, and calling it
431 \refactoring{Extract Class} is a little misleading. One would often be better
432 off with textual extract and paste than using the Extract Class refactoring in
433 Eclipse. When it comes to \emph{NetBeans}, it does not even seem to have made an
434 attempt on providing this refactoring. (Well, it probably has, but it does not
437 \todoin{Visual Studio (C++/C\#), Smalltalk refactoring browser?,
438 second refactoring rubicon?}
440 \section{The relation to design patterns}\label{relationToDesignPatterns}
442 \emph{Refactoring} and \emph{design patterns} have at least one thing in common,
443 they are both promoted by advocates of \emph{clean code}\citing{cleanCode} as
444 fundamental tools on the road to more maintanable and extendable source code.
447 Design patterns help you determine how to reorganize a design, and they can
448 reduce the amount of refactoring you need to do
449 later.~\cite[p.~353]{designPatterns}
452 Although sometimes associated with
453 over-engineering\citing{kerievsky2005,refactoring}, design patterns are in
454 general assumed to be good for maintainability of source code. That may be
455 because many of them are designed to support the \emph{open/closed principle} of
456 object-oriented programming. The principle was first formulated by Bertrand
457 Meyer, the creator of the Eiffel programming language, like this: ``Modules
458 should be both open and closed.''\citing{meyer1988} It has been popularized,
459 with this as a common version:
462 Software entities (classes, modules, functions, etc.) should be open for
463 extension, but closed for modification.\footnote{See
464 \url{http://c2.com/cgi/wiki?OpenClosedPrinciple} or
465 \url{https://en.wikipedia.org/wiki/Open/closed_principle}}
468 Maintainability is often thought of as the ability to be able to introduce new
469 functionality without having to change too much of the old code. When
470 refactoring, the motivation is often to facilitate adding new functionality. It
471 is about factoring the old code in a way that makes the new functionality being
472 able to benefit from the functionality already residing in a software system,
473 without having to copy old code into new. Then, next time someone shall add new
474 functionality, it is less likely that the old code has to change. Assuming that
475 a design pattern is the best way to get rid of duplication and assist in
476 implementing new functionality, it is reasonable to conclude that a design
477 pattern often is the target of a series of refactorings. Having a repertoire of
478 design patterns can also help in knowing when and how to refactor a program to
479 make it reflect certain desired characteristics.
482 There is a natural relation between patterns and refactorings. Patterns are
483 where you want to be; refactorings are ways to get there from somewhere
484 else.~\cite[p.~107]{refactoring}
487 This quote is wise in many contexts, but it is not always appropriate to say
488 ``Patterns are where you want to be\ldots''. \emph{Sometimes}, patterns are
489 where you want to be, but only because it will benefit your design. It is not
490 true that one should always try to incorporate as many design patterns as
491 possible into a program. It is not like they have intrinsic value. They only add
492 value to a system when they support its design. Otherwise, the use of design
493 patterns may only lead to a program that is more complex than necessary.
496 The overuse of patterns tends to result from being patterns happy. We are
497 \emph{patterns happy} when we become so enamored of patterns that we simply
498 must use them in our code.~\cite[p.~24]{kerievsky2005}
501 This can easily happen when relying largely on up-front design. Then it is
502 natural, in the very beginning, to try to build in all the flexibility that one
503 believes will be necessary throughout the lifetime of a software system.
504 According to Joshua Kerievsky ``That sounds reasonable --- if you happen to be
505 psychic.''~\cite[p.~1]{kerievsky2005} He is advocating what he believes is a
506 better approach: To let software continually evolve. To start with a simple
507 design that meets today's needs, and tackle future needs by refactoring to
508 satisfy them. He believes that this is a more economic approach than investing
509 time and money into a design that inevitably is going to change. By relying on
510 continuously refactoring a system, its design can be made simpler without
511 sacrificing flexibility. To be able to fully rely on this approach, it is of
512 utter importance to have a reliable suit of tests to lean on. \See{testing} This
513 makes the design process more natural and less characterized by difficult
514 decisions that has to be made before proceeding in the process, and that is
515 going to define a project for all of its unforeseeable future.
519 \section{Classification of refactorings}
520 % only interesting refactorings
521 % with 2 detailed examples? One for structured and one for intra-method?
522 % Is replacing Bubblesort with Quick Sort considered a refactoring?
524 \subsection{Structural refactorings}
526 \subsubsection{Primitive refactorings}
529 \explanation{Extract Method}{You have a code fragment that can be grouped
530 together.}{Turn the fragment into a method whose name explains the purpose of
533 \explanation{Inline Method}{A method's body is just as clear as its name.}{Put
534 the method's body into the body of its callers and remove the method.}
536 \explanation{Inline Temp}{You have a temp that is assigned to once with a simple
537 expression, and the temp is getting in the way of other refactorings.}{Replace
538 all references to that temp with the expression}
540 % Moving Features Between Objects
541 \explanation{Move Method}{A method is, or will be, using or used by more
542 features of another class than the class on which it is defined.}{Create a new
543 method with a similar body in the class it uses most. Either turn the old method
544 into a simple delegation, or remove it altogether.}
546 \explanation{Move Field}{A field is, or will be, used by another class more than
547 the class on which it is defined}{Create a new field in the target class, and
548 change all its users.}
551 \explanation{Replace Magic Number with Symbolic Constant}{You have a literal
552 number with a particular meaning.}{Create a constant, name it after the meaning,
553 and replace the number with it.}
555 \explanation{Encapsulate Field}{There is a public field.}{Make it private and
558 \explanation{Replace Type Code with Class}{A class has a numeric type code that
559 does not affect its behavior.}{Replace the number with a new class.}
561 \explanation{Replace Type Code with Subclasses}{You have an immutable type code
562 that affects the behavior of a class.}{Replace the type code with subclasses.}
564 \explanation{Replace Type Code with State/Strategy}{You have a type code that
565 affects the behavior of a class, but you cannot use subclassing.}{Replace the
566 type code with a state object.}
568 % Simplifying Conditional Expressions
569 \explanation{Consolidate Duplicate Conditional Fragments}{The same fragment of
570 code is in all branches of a conditional expression.}{Move it outside of the
573 \explanation{Remove Control Flag}{You have a variable that is acting as a
574 control flag fro a series of boolean expressions.}{Use a break or return
577 \explanation{Replace Nested Conditional with Guard Clauses}{A method has
578 conditional behavior that does not make clear the normal path of
579 execution.}{Use guard clauses for all special cases.}
581 \explanation{Introduce Null Object}{You have repeated checks for a null
582 value.}{Replace the null value with a null object.}
584 \explanation{Introduce Assertion}{A section of code assumes something about the
585 state of the program.}{Make the assumption explicit with an assertion.}
587 % Making Method Calls Simpler
588 \explanation{Rename Method}{The name of a method does not reveal its
589 purpose.}{Change the name of the method}
591 \explanation{Add Parameter}{A method needs more information from its
592 caller.}{Add a parameter for an object that can pass on this information.}
594 \explanation{Remove Parameter}{A parameter is no longer used by the method
597 %\explanation{Parameterize Method}{Several methods do similar things but with
598 %different values contained in the method.}{Create one method that uses a
599 %parameter for the different values.}
601 \explanation{Preserve Whole Object}{You are getting several values from an
602 object and passing these values as parameters in a method call.}{Send the whole
605 \explanation{Remove Setting Method}{A field should be set at creation time and
606 never altered.}{Remove any setting method for that field.}
608 \explanation{Hide Method}{A method is not used by any other class.}{Make the
611 \explanation{Replace Constructor with Factory Method}{You want to do more than
612 simple construction when you create an object}{Replace the constructor with a
615 % Dealing with Generalization
616 \explanation{Pull Up Field}{Two subclasses have the same field.}{Move the field
619 \explanation{Pull Up Method}{You have methods with identical results on
620 subclasses.}{Move them to the superclass.}
622 \explanation{Push Down Method}{Behavior on a superclass is relevant only for
623 some of its subclasses.}{Move it to those subclasses.}
625 \explanation{Push Down Field}{A field is used only by some subclasses.}{Move the
626 field to those subclasses}
628 \explanation{Extract Interface}{Several clients use the same subset of a class's
629 interface, or two classes have part of their interfaces in common.}{Extract the
630 subset into an interface.}
632 \explanation{Replace Inheritance with Delegation}{A subclass uses only part of a
633 superclasses interface or does not want to inherit data.}{Create a field for the
634 superclass, adjust methods to delegate to the superclass, and remove the
637 \explanation{Replace Delegation with Inheritance}{You're using delegation and
638 are often writing many simple delegations for the entire interface}{Make the
639 delegating class a subclass of the delegate.}
641 \subsubsection{Composite refactorings}
644 % \explanation{Replace Method with Method Object}{}{}
646 % Moving Features Between Objects
647 \explanation{Extract Class}{You have one class doing work that should be done by
648 two}{Create a new class and move the relevant fields and methods from the old
649 class into the new class.}
651 \explanation{Inline Class}{A class isn't doing very much.}{Move all its features
652 into another class and delete it.}
654 \explanation{Hide Delegate}{A client is calling a delegate class of an
655 object.}{Create Methods on the server to hide the delegate.}
657 \explanation{Remove Middle Man}{A class is doing to much simple delegation.}{Get
658 the client to call the delegate directly.}
661 \explanation{Replace Data Value with Object}{You have a data item that needs
662 additional data or behavior.}{Turn the data item into an object.}
664 \explanation{Change Value to Reference}{You have a class with many equal
665 instances that you want to replace with a single object.}{Turn the object into a
668 \explanation{Encapsulate Collection}{A method returns a collection}{Make it
669 return a read-only view and provide add/remove methods.}
671 % \explanation{Replace Array with Object}{}{}
673 \explanation{Replace Subclass with Fields}{You have subclasses that vary only in
674 methods that return constant data.}{Change the methods to superclass fields and
675 eliminate the subclasses.}
677 % Simplifying Conditional Expressions
678 \explanation{Decompose Conditional}{You have a complicated conditional
679 (if-then-else) statement.}{Extract methods from the condition, then part, an
682 \explanation{Consolidate Conditional Expression}{You have a sequence of
683 conditional tests with the same result.}{Combine them into a single conditional
684 expression and extract it.}
686 \explanation{Replace Conditional with Polymorphism}{You have a conditional that
687 chooses different behavior depending on the type of an object.}{Move each leg
688 of the conditional to an overriding method in a subclass. Make the original
691 % Making Method Calls Simpler
692 \explanation{Replace Parameter with Method}{An object invokes a method, then
693 passes the result as a parameter for a method. The receiver can also invoke this
694 method.}{Remove the parameter and let the receiver invoke the method.}
696 \explanation{Introduce Parameter Object}{You have a group of parameters that
697 naturally go together.}{Replace them with an object.}
699 % Dealing with Generalization
700 \explanation{Extract Subclass}{A class has features that are used only in some
701 instances.}{Create a subclass for that subset of features.}
703 \explanation{Extract Superclass}{You have two classes with similar
704 features.}{Create a superclass and move the common features to the
707 \explanation{Collapse Hierarchy}{A superclass and subclass are not very
708 different.}{Merge them together.}
710 \explanation{Form Template Method}{You have two methods in subclasses that
711 perform similar steps in the same order, yet the steps are different.}{Get the
712 steps into methods with the same signature, so that the original methods become
713 the same. Then you can pull them up.}
716 \subsection{Functional refactorings}
718 \explanation{Substitute Algorithm}{You want to replace an algorithm with one
719 that is clearer.}{Replace the body of the method with the new algorithm.}
723 \section{The impact on software quality}
725 \subsection{What is software quality?}
726 The term \emph{software quality} has many meanings. It all depends on the
727 context we put it in. If we look at it with the eyes of a software developer, it
728 usually means that the software is easily maintainable and testable, or in other
729 words, that it is \emph{well designed}. This often correlates with the
730 management scale, where \emph{keeping the schedule} and \emph{customer
731 satisfaction} is at the center. From the customers point of view, in addition to
732 good usability, \emph{performance} and \emph{lack of bugs} is always
733 appreciated, measurements that are also shared by the software developer. (In
734 addition, such things as good documentation could be measured, but this is out
735 of the scope of this document.)
737 \subsection{The impact on performance}
739 Refactoring certainly will make software go more slowly\footnote{With todays
740 compiler optimization techniques and performance tuning of e.g. the Java
741 virtual machine, the penalties of object creation and method calls are
742 debatable.}, but it also makes the software more amenable to performance
743 tuning.~\cite[p.~69]{refactoring}
746 \noindent There is a common belief that refactoring compromises performance, due
747 to increased degree of indirection and that polymorphism is slower than
750 In a survey, Demeyer\citing{demeyer2002} disproves this view in the case of
751 polymorphism. He did an experiment on, what he calls, ``Transform Self Type
752 Checks'' where you introduce a new polymorphic method and a new class hierarchy
753 to get rid of a class' type checking of a ``type attribute``. He uses this kind
754 of transformation to represent other ways of replacing conditionals with
755 polymorphism as well. The experiment is performed on the C++ programming
756 language and with three different compilers and platforms. Demeyer concludes
757 that, with compiler optimization turned on, polymorphism beats middle to large
758 sized if-statements and does as well as case-statements. (In accordance with
759 his hypothesis, due to similarities between the way C++ handles polymorphism and
763 The interesting thing about performance is that if you analyze most programs,
764 you find that they waste most of their time in a small fraction of the
765 code.~\cite[p.~70]{refactoring}
768 \noindent So, although an increased amount of method calls could potentially
769 slow down programs, one should avoid premature optimization and sacrificing good
770 design, leaving the performance tuning until after profiling\footnote{For and
771 example of a Java profiler, check out VisualVM:
772 \url{http://visualvm.java.net/}} the software and having isolated the actual
775 \section{Composite refactorings}\label{compositeRefactorings}
776 \todo{motivation, examples, manual vs automated?, what about refactoring in a
777 very large code base?}
778 Generally, when thinking about refactoring, at the mechanical level, there are
779 essentially two kinds of refactorings. There are the \emph{primitive}
780 refactorings, and the \emph{composite} refactorings.
782 \definition{A \emph{primitive refactoring} is a refactoring that cannot be
783 expressed in terms of other refactorings.}
785 \noindent Examples are the \refactoring{Pull Up Field} and \refactoring{Pull Up
786 Method} refactorings\citing{refactoring}, that move members up in their class
789 \definition{A \emph{composite refactoring} is a refactoring that can be
790 expressed in terms of two or more other refactorings.}
792 \noindent An example of a composite refactoring is the \refactoring{Extract
793 Superclass} refactoring\citing{refactoring}. In its simplest form, it is composed
794 of the previously described primitive refactorings, in addition to the
795 \refactoring{Pull Up Constructor Body} refactoring\citing{refactoring}. It works
796 by creating an abstract superclass that the target class(es) inherits from, then
797 by applying \refactoring{Pull Up Field}, \refactoring{Pull Up Method} and
798 \refactoring{Pull Up Constructor Body} on the members that are to be members of
799 the new superclass. For an overview of the \refactoring{Extract Superclass}
800 refactoring, see \myref{fig:extractSuperclass}.
804 \includegraphics[angle=270,width=\linewidth]{extractSuperclassItalic.pdf}
805 \caption{The Extract Superclass refactoring}
806 \label{fig:extractSuperclass}
809 \section{Manual vs. automated refactorings}
810 Refactoring is something every programmer does, even if \heshe does not known
811 the term \emph{refactoring}. Every refinement of source code that does not alter
812 the program's behavior is a refactoring. For small refactorings, such as
813 \ExtractMethod, executing it manually is a manageable task, but is still prone
814 to errors. Getting it right the first time is not easy, considering the method
815 signature and all the other aspects of the refactoring that has to be in place.
817 Take for instance the renaming of classes, methods and fields. For complex
818 programs these refactorings are almost impossible to get right. Attacking them
819 with textual search and replace, or even regular expressions, will fall short on
820 these tasks. Then it is crucial to have proper tool support that can perform
821 them automatically. Tools that can parse source code and thus have semantic
822 knowledge about which occurrences of which names belong to what construct in the
823 program. For even trying to perform one of these complex task manually, one
824 would have to be very confident on the existing test suite \see{testing}.
826 \section{Correctness of refactorings}\label{correctness}
827 For automated refactorings to be truly useful, they must show a high degree of
828 behavior preservation. This last sentence might seem obvious, but there are
829 examples of refactorings in existing tools that break programs. I will now
830 present an example of an \ExtractMethod refactoring followed by a \MoveMethod
831 refactoring that breaks a program in both the \emph{Eclipse} and \emph{IntelliJ}
832 IDEs\footnote{The NetBeans IDE handles this particular situation without
833 altering ther program's beavior, mainly because its Move Method refactoring
834 implementation is a bit rancid in other ways \see{toolSupport}.}. The
835 following piece of code shows the target for the composed refactoring:
837 \begin{minted}[linenos,samepage]{java}
839 public X x = new X();
848 \noindent The next piece of code shows the destination of the refactoring. Note
849 that the method \method{m(C c)} of class \type{C} assigns to the field \var{x}
850 of the argument \var{c} that has type \type{C}:
852 \begin{minted}[samepage]{java}
861 The refactoring sequence works by extracting line 5 and 6 from the original
862 class \type{C} into a method \method{f} with the statements from those lines as
863 its method body. The method is then moved to the class \type{X}. The result is
864 shown in the following two pieces of code:
866 \begin{minted}[linenos,samepage]{java}
868 public X x = new X();
876 \begin{minted}[linenos,samepage]{java}
889 After the refactoring, the method \method{f} of class \type{C} is calling the
890 method \method{f} of class \type{X}, and the program now behaves different than
891 before. (See line 5 of the version of class \type{C} after the refactoring.)
892 Before the refactoring, the methods \method{m} and \method{n} of class \type{X}
893 are called on different object instances (see line 5 and 6 of the original class
894 \type{C}). After, they are called on the same object, and the statement on line
895 3 of class \type{X} (the version after the refactoring) no longer have any
896 effect in our example.
898 The bug introduced in the previous example is of such a nature\footnote{Caused
899 by aliasing. See \url{https://en.wikipedia.org/wiki/Aliasing_(computing)}}
900 that it is very difficult to spot if the refactored code is not covered by
901 tests. It does not generate compilation errors, and will thus only result in
902 a runtime error or corrupted data, which might be hard to detect.
904 \section{Refactoring and testing}\label{testing}
906 If you want to refactor, the essential precondition is having solid
907 tests.\citing{refactoring}
910 When refactoring, there are roughly two kinds of errors that can be made. There
911 are errors that make the code unable to compile, and there are the silent
912 errors, only popping up at runtime. Compile-time errors are the nice ones. They
913 flash up at the moment they are made (at least when using an IDE), and are
914 usually easy to fix. The other kind of error is the dangerous one. It is the
915 kind of error introduced in the example of \myref{correctness}. It is an error
916 sneaking into your code without you noticing, maybe. For discovering those kind
917 of errors when refactoring, it is essential to have good test coverage. It is
918 not a way to \emph{prove} that the code is correct, but it is a way to make you
919 confindent that it \emph{probably} works as desired. In the context of test
920 driven development, the tests are even a way to define how the program is
921 supposed to work. It is then, by definition, working if the tests are passing.
923 If the test coverage for a code base is perfect, then it should, theoretically,
924 be risk-free to perform refactorings on it. This is why tests and refactoring
925 are such a great match.
927 \section{Software metrics}
928 \todoin{Is this the appropriate place to have this section?}
931 %\chapter{Planning the project}
939 \section{The problem statement}
940 \section{Choosing the target language}
941 Choosing which programming language to use as the target for manipulation is not
942 a very difficult task. The language has to be an object-oriented programming
943 language, and it must have existing tool support for refactoring. The
944 \emph{Java} programming language\footnote{\url{https://www.java.com/}} is the
945 dominating language when it comes to examples in the literature of refactoring,
946 and is thus a natural choice. Java is perhaps, currently the most influential
947 programming language in the world, with its \emph{Java Virtual Machine} that
948 runs on all of the most popular architectures and also supports\footnote{They
949 compile to java bytecode.} dozens of other programming languages, with
950 \emph{Scala}, \emph{Clojure} and \emph{Groovy} as the most prominent ones. Java
951 is currently the language that every other programming language is compared
952 against. It is also the primary language of the author of this thesis.
954 \section{Choosing the tools}
955 When choosing a tool for manipulating Java, there are certain criterias that
956 have to be met. First of all, the tool should have some existing refactoring
957 support that this thesis can build upon. Secondly it should provide some kind of
958 framework for parsing and analyzing Java source code. Third, it should itself be
959 open source. This is both because of the need to be able to browse the code for
960 the existing refactorings that is contained in the tool, and also because open
961 source projects hold value in them selves. Another important aspect to consider
962 is that open source projects of a certain size, usually has large communities of
963 people connected to them, that are commited to answering questions regarding the
964 use and misuse of the products, that to a large degree is made by the cummunity
967 There is a certain class of tools that meet these criterias, namely the class of
968 \emph{IDEs}\footnote{\emph{Integrated Development Environment}}. These are
969 proagrams that is ment to support the whole production cycle of a cumputer
970 program, and the most popular IDEs that support Java, generally have quite good
973 The main contenders for this thesis is the \emph{Eclipse IDE}, with the
974 \emph{Java development tools} (JDT), the \emph{IntelliJ IDEA Community Edition}
975 and the \emph{NetBeans IDE}. \See{toolSupport} Eclipse and NetBeans are both
976 free, open source and community driven, while the IntelliJ IDEA has an open
977 sourced community edition that is free of charge, but also offer an
978 \emph{Ultimate Edition} with an extended set of features, at additional cost.
979 All three IDEs supports adding plugins to extend their functionality and tools
980 that can be used to parse and analyze Java source code. But one of the IDEs
981 stand out as a favorite, and that is the \emph{Eclipse IDE}. This is the most
982 popular\citing{javaReport2011} among them and seems to be de facto standard IDE
983 for Java development regardless of platform.
986 \chapter{Refactorings in Eclipse JDT: Design, Shortcomings and Wishful
987 Thinking}\label{ch:jdt_refactorings}
989 This chapter will deal with some of the design behind refactoring support in
990 Eclipse, and the JDT in specific. After which it will follow a section about
991 shortcomings of the refactoring API in terms of composition of refactorings. The
992 chapter will be concluded with a section telling some of the ways the
993 implementation of refactorings in the JDT could have worked to facilitate
994 composition of refactorings.
997 The refactoring world of Eclipse can in general be separated into two parts: The
998 language independent part and the part written for a specific programming
999 language -- the language that is the target of the supported refactorings.
1000 \todo{What about the language specific part?}
1002 \subsection{The Language Toolkit}
1003 The Language Toolkit, or LTK for short, is the framework that is used to
1004 implement refactorings in Eclipse. It is language independent and provides the
1005 abstractions of a refactoring and the change it generates, in the form of the
1006 classes \typewithref{org.eclipse.ltk.core.refactoring}{Refactoring} and
1007 \typewithref{org.eclipse.ltk.core.refactoring}{Change}. (There is also parts of
1008 the LTK that is concerned with user interaction, but they will not be discussed
1009 here, since they are of little value to us and our use of the framework.)
1011 \subsubsection{The Refactoring Class}
1012 The abstract class \type{Refactoring} is the core of the LTK framework. Every
1013 refactoring that is going to be supported by the LTK have to end up creating an
1014 instance of one of its subclasses. The main responsibilities of subclasses of
1015 \type{Refactoring} is to implement template methods for condition checking
1016 (\methodwithref{org.eclipse.ltk.core.refactoring.Refactoring}{checkInitialConditions}
1018 \methodwithref{org.eclipse.ltk.core.refactoring.Refactoring}{checkFinalConditions}),
1020 \methodwithref{org.eclipse.ltk.core.refactoring.Refactoring}{createChange}
1021 method that creates and returns an instance of the \type{Change} class.
1023 If the refactoring shall support that others participate in it when it is
1024 executed, the refactoring has to be a processor-based
1025 refactoring\typeref{org.eclipse.ltk.core.refactoring.participants.ProcessorBasedRefactoring}.
1026 It then delegates to its given
1027 \typewithref{org.eclipse.ltk.core.refactoring.participants}{RefactoringProcessor}
1028 for condition checking and change creation.
1030 \subsubsection{The Change Class}
1031 This class is the base class for objects that is responsible for performing the
1032 actual workspace transformations in a refactoring. The main responsibilities for
1033 its subclasses is to implement the
1034 \methodwithref{org.eclipse.ltk.core.refactoring.Change}{perform} and
1035 \methodwithref{org.eclipse.ltk.core.refactoring.Change}{isValid} methods. The
1036 \method{isValid} method verifies that the change object is valid and thus can be
1037 executed by calling its \method{perform} method. The \method{perform} method
1038 performs the desired change and returns an undo change that can be executed to
1039 reverse the effect of the transformation done by its originating change object.
1041 \subsubsection{Executing a Refactoring}\label{executing_refactoring}
1042 The life cycle of a refactoring generally follows two steps after creation:
1043 condition checking and change creation. By letting the refactoring object be
1045 \typewithref{org.eclipse.ltk.core.refactoring}{CheckConditionsOperation} that
1046 in turn is handled by a
1047 \typewithref{org.eclipse.ltk.core.refactoring}{CreateChangeOperation}, it is
1048 assured that the change creation process is managed in a proper manner.
1050 The actual execution of a change object has to follow a detailed life cycle.
1051 This life cycle is honored if the \type{CreateChangeOperation} is handled by a
1052 \typewithref{org.eclipse.ltk.core.refactoring}{PerformChangeOperation}. If also
1053 an undo manager\typeref{org.eclipse.ltk.core.refactoring.IUndoManager} is set
1054 for the \type{PerformChangeOperation}, the undo change is added into the undo
1057 \section{Shortcomings}
1058 This section is introduced naturally with a conclusion: The JDT refactoring
1059 implementation does not facilitate composition of refactorings.
1060 \todo{refine}This section will try to explain why, and also identify other
1061 shortcomings of both the usability and the readability of the JDT refactoring
1064 I will begin at the end and work my way toward the composition part of this
1067 \subsection{Absence of Generics in Eclipse Source Code}
1068 This section is not only concerning the JDT refactoring API, but also large
1069 quantities of the Eclipse source code. The code shows a striking absence of the
1070 Java language feature of generics. It is hard to read a class' interface when
1071 methods return objects or takes parameters of raw types such as \type{List} or
1072 \type{Map}. This sometimes results in having to read a lot of source code to
1073 understand what is going on, instead of relying on the available interfaces. In
1074 addition, it results in a lot of ugly code, making the use of typecasting more
1075 of a rule than an exception.
1077 \subsection{Composite Refactorings Will Not Appear as Atomic Actions}
1079 \subsubsection{Missing Flexibility from JDT Refactorings}
1080 The JDT refactorings are not made with composition of refactorings in mind. When
1081 a JDT refactoring is executed, it assumes that all conditions for it to be
1082 applied successfully can be found by reading source files that has been
1083 persisted to disk. They can only operate on the actual source material, and not
1084 (in-memory) copies thereof. This constitutes a major disadvantage when trying to
1085 compose refactorings, since if an exception occur in the middle of a sequence of
1086 refactorings, it can leave the project in a state where the composite
1087 refactoring was executed only partly. It makes it hard to discard the changes
1088 done without monitoring and consulting the undo manager, an approach that is not
1091 \subsubsection{Broken Undo History}
1092 When designing a composed refactoring that is to be performed as a sequence of
1093 refactorings, you would like it to appear as a single change to the workspace.
1094 This implies that you would also like to be able to undo all the changes done by
1095 the refactoring in a single step. This is not the way it appears when a sequence
1096 of JDT refactorings is executed. It leaves the undo history filled up with
1097 individual undo actions corresponding to every single JDT refactoring in the
1098 sequence. This problem is not trivial to handle in Eclipse.
1099 \See{hacking_undo_history}
1101 \section{Wishful Thinking}
1104 \chapter{Composite Refactorings in Eclipse}
1106 \section{A Simple Ad Hoc Model}
1107 As pointed out in \myref{ch:jdt_refactorings}, the Eclipse JDT refactoring model
1108 is not very well suited for making composite refactorings. Therefore a simple
1109 model using changer objects (of type \type{RefaktorChanger}) is used as an
1110 abstraction layer on top of the existing Eclipse refactorings.
1112 \section{The Extract and Move Method Refactoring}
1113 %The Extract and Move Method Refactoring is implemented mainly using these
1116 % \item \type{ExtractAndMoveMethodChanger}
1117 % \item \type{ExtractAndMoveMethodPrefixesExtractor}
1118 % \item \type{Prefix}
1119 % \item \type{PrefixSet}
1122 \subsection{The Building Blocks}
1123 This is a composite refactoring, and hence is built up using several primitive
1124 refactorings. These basic building blocks are, as its name implies, the
1125 \ExtractMethod refactoring\citing{refactoring} and the \MoveMethod
1126 refactoring\citing{refactoring}. In Eclipse, the implementations of these
1127 refactorings are found in the classes
1128 \typewithref{org.eclipse.jdt.internal.corext.refactoring.code}{ExtractMethodRefactoring}
1130 \typewithref{org.eclipse.jdt.internal.corext.refactoring.structure}{MoveInstanceMethodProcessor},
1131 where the last class is designed to be used together with the processor-based
1132 \typewithref{org.eclipse.ltk.core.refactoring.participants}{MoveRefactoring}.
1134 \subsubsection{The ExtractMethodRefactoring Class}
1135 This class is quite simple in its use. The only parameters it requires for
1136 construction is a compilation
1137 unit\typeref{org.eclipse.jdt.core.ICompilationUnit}, the offset into the source
1138 code where the extraction shall start, and the length of the source to be
1139 extracted. Then you have to set the method name for the new method together with
1140 which access modifier that shall be used and some not so interesting parameters.
1142 \subsubsection{The MoveInstanceMethodProcessor Class}
1143 For the Move Method the processor requires a little more advanced input than
1144 the class for the Extract Method. For construction it requires a method
1145 handle\typeref{org.eclipse.jdt.core.IMethod} from the Java Model for the method
1146 that is to be moved. Then the target for the move have to be supplied as the
1147 variable binding from a chosen variable declaration. In addition to this, one
1148 have to set some parameters regarding setters/getters and delegation.
1150 To make a whole refactoring from the processor, one have to construct a
1151 \type{MoveRefactoring} from it.
1153 \subsection{The ExtractAndMoveMethodChanger Class}
1154 The \typewithref{no.uio.ifi.refaktor.changers}{ExtractAndMoveMethodChanger}
1155 class, that is a subclass of the class
1156 \typewithref{no.uio.ifi.refaktor.changers}{RefaktorChanger}, is the class
1157 responsible for composing the \type{ExtractMethodRefactoring} and the
1158 \type{MoveRefactoring}. Its constructor takes a project
1159 handle\typeref{org.eclipse.core.resources.IProject}, the method name for the new
1160 method and a \typewithref{no.uio.ifi.refaktor.utils}{SmartTextSelection}.
1162 A \type{SmartTextSelection} is basically a text
1163 selection\typeref{org.eclipse.jface.text.ITextSelection} object that enforces
1164 the providing of the underlying document during creation. I.e. its
1165 \methodwithref{no.uio.ifi.refaktor.utils.SmartTextSelection}{getDocument} method
1166 will never return \type{null}.
1168 Before extracting the new method, the possible targets for the move operation is
1169 found with the help of an
1170 \typewithref{no.uio.ifi.refaktor.extractors}{ExtractAndMoveMethodPrefixesExtractor}.
1171 The possible targets is computed from the prefixes that the extractor returns
1173 \methodwithref{no.uio.ifi.refaktor.extractors.ExtractAndMoveMethodPrefixesExtractor}{getSafePrefixes}
1174 method. The changer then choose the most suitable target by finding the most
1175 frequent occurring prefix among the safe ones. The target is the type of the
1176 first part of the prefix.
1178 After finding a suitable target, the \type{ExtractAndMoveMethodChanger} first
1179 creates an \type{ExtractMethodRefactoring} and performs it as explained in
1180 \myref{executing_refactoring} about the execution of refactorings. Then it
1181 creates and performs the \type{MoveRefactoring} in the same way, based on the
1182 changes done by the Extract Method refactoring.
1184 \subsection{The ExtractAndMoveMethodPrefixesExtractor Class}
1185 This extractor extracts properties needed for building the Extract and Move
1186 Method refactoring. It searches through the given selection to find safe
1187 prefixes, and those prefixes form a base that can be used to compute possible
1188 targets for the move part of the refactoring. It finds both the candidates, in
1189 the form of prefixes, and the non-candidates, called unfixes. All prefixes (and
1190 unfixes) are represented by a
1191 \typewithref{no.uio.ifi.refaktor.extractors}{Prefix}, and they are collected
1192 into prefix sets.\typeref{no.uio.ifi.refaktor.extractors.PrefixSet}.
1194 The prefixes and unfixes are found by property
1195 collectors\typeref{no.uio.ifi.refaktor.extractors.collectors.PropertyCollector}.
1196 A property collector follows the visitor pattern\citing{designPatterns} and is
1197 of the \typewithref{org.eclipse.jdt.core.dom}{ASTVisitor} type. An
1198 \type{ASTVisitor} visits nodes in an abstract syntax tree that forms the Java
1199 document object model. The tree consists of nodes of type
1200 \typewithref{org.eclipse.jdt.core.do}{ASTNode}.
1202 \subsubsection{The PrefixesCollector}
1203 The \typewithref{no.uio.ifi.refaktor.extractors.collectors}{PrefixesCollector}
1204 is of type \type{PropertyCollector}. It visits expression
1205 statements\typeref{org.eclipse.jdt.core.dom.ExpressionStatement} and creates
1206 prefixes from its expressions in the case of method invocations. The prefixes
1207 found is registered with a prefix set, together with all its sub-prefixes.
1208 \todo{Rewrite in the case of changes to the way prefixes are found}
1210 \subsubsection{The UnfixesCollector}
1211 The \typewithref{no.uio.ifi.refaktor.extractors.collectors}{UnfixesCollector}
1212 finds unfixes within the selection. An unfix is a name that is assigned to
1213 within the selection. The reason that this cannot be allowed, is that the result
1214 would be an assignment to the \type{this} keyword, which is not valid in Java.
1216 \subsubsection{Computing Safe Prefixes}
1217 A safe prefix is a prefix that does not enclose an unfix. A prefix is enclosing
1218 an unfix if the unfix is in the set of its sub-prefixes. As an example,
1219 \texttt{``a.b''} is enclosing \texttt{``a''}, as is \texttt{``a''}. The safe
1220 prefixes is unified in a \type{PrefixSet} and can be fetched calling the
1221 \method{getSafePrefixes} method of the
1222 \type{ExtractAndMoveMethodPrefixesExtractor}.
1224 \subsection{The Prefix Class}
1226 \subsection{The PrefixSet Class}
1228 \subsection{Hacking the Refactoring Undo
1229 History}\label{hacking_undo_history}
1230 \todo{Where to put this section?}
1232 As an attempt to make multiple subsequent changes to the workspace appear as a
1233 single action (i.e. make the undo changes appear as such), I tried to alter
1234 the undo changes\typeref{org.eclipse.ltk.core.refactoring.Change} in the history
1235 of the refactorings.
1237 My first impulse was to remove the, in this case, last two undo changes from the
1238 undo manager\typeref{org.eclipse.ltk.core.refactoring.IUndoManager} for the
1239 Eclipse refactorings, and then add them to a composite
1240 change\typeref{org.eclipse.ltk.core.refactoring.CompositeChange} that could be
1241 added back to the manager. The interface of the undo manager does not offer a
1242 way to remove/pop the last added undo change, so a possible solution could be to
1243 decorate\citing{designPatterns} the undo manager, to intercept and collect the
1244 undo changes before delegating to the \method{addUndo}
1245 method\methodref{org.eclipse.ltk.core.refactoring.IUndoManager}{addUndo} of the
1246 manager. Instead of giving it the intended undo change, a null change could be
1247 given to prevent it from making any changes if run. Then one could let the
1248 collected undo changes form a composite change to be added to the manager.
1250 There is a technical challenge with this approach, and it relates to the undo
1251 manager, and the concrete implementation
1252 UndoManager2\typeref{org.eclipse.ltk.internal.core.refactoring.UndoManager2}.
1253 This implementation is designed in a way that it is not possible to just add an
1254 undo change, you have to do it in the context of an active
1255 operation\typeref{org.eclipse.core.commands.operations.TriggeredOperations}.
1256 One could imagine that it might be possible to trick the undo manager into
1257 believing that you are doing a real change, by executing a refactoring that is
1258 returning a kind of null change that is returning our composite change of undo
1259 refactorings when it is performed.
1261 Apart from the technical problems with this solution, there is a functional
1262 problem: If it all had worked out as planned, this would leave the undo history
1263 in a dirty state, with multiple empty undo operations corresponding to each of
1264 the sequentially executed refactoring operations, followed by a composite undo
1265 change corresponding to an empty change of the workspace for rounding of our
1266 composite refactoring. The solution to this particular problem could be to
1267 intercept the registration of the intermediate changes in the undo manager, and
1268 only register the last empty change.
1270 Unfortunately, not everything works as desired with this solution. The grouping
1271 of the undo changes into the composite change does not make the undo operation
1272 appear as an atomic operation. The undo operation is still split up into
1273 separate undo actions, corresponding to the change done by its originating
1274 refactoring. And in addition, the undo actions has to be performed separate in
1275 all the editors involved. This makes it no solution at all, but a step toward
1278 There might be a solution to this problem, but it remains to be found. The
1279 design of the refactoring undo management is partly to be blamed for this, as it
1280 it is to complex to be easily manipulated.
1284 \chapter{Related Work}
1286 \section{The compositional paradigm of refactoring}
1287 This paradigm builds upon the observation of Vakilian et
1288 al.\citing{vakilian2012}, that of the many automated refactorings existing in
1289 modern IDEs, the simplest ones are dominating the usage statistics. The report
1290 mainly focuses on \emph{Eclipse} as the tool under investigation.
1292 The paradigm is described almost as the opposite of automated composition of
1293 refactorings \see{compositeRefactorings}. It works by providing the programmer
1294 with easily accessible primitive refactorings. These refactorings shall be
1295 accessed via keyboard shortcuts or quick-assist menus\footnote{Think
1296 quick-assist with Ctrl+1 in Eclipse} and be promptly executed, opposed to in the
1297 currently dominating wizard-based refactoring paradigm. They are ment to
1298 stimulate composing smaller refactorings into more complex changes, rather than
1299 doing a large upfront configuration of a wizard-based refactoring, before
1300 previewing and executing it. The compositional paradigm of refactoring is
1301 supposed to give control back to the programmer, by supporting \himher with an
1302 option of performing small rapid changes instead of large changes with a lesser
1303 degree of control. The report authors hope this will lead to fewer unsuccessful
1304 refactorings. It also could lower the bar for understanding the steps of a
1305 larger composite refactoring and thus also help in figuring out what goes wrong
1306 if one should choose to op in on a wizard-based refactoring.
1308 Vakilian and his associates have performed a survey of the effectiveness of the
1309 compositional paradigm versus the wizard-based one. They claim to have found
1310 evidence of that the \emph{compositional paradigm} outperforms the
1311 \emph{wizard-based}. It does so by reducing automation, which seem
1312 counterintuitive. Therefore they ask the question ``What is an appropriate level
1313 of automation?'', and thus questions what they feel is a rush toward more
1314 automation in the software engineering community.