Avoid copy and paste programming, what pattern to use? [closed]

Question

I have a small software that generates some Word documents. It reads a template, runs a few SqL procedures to get the data, generates the documents and then sends them via e-mail. It's quite simple.

Right now I want to apply that logic to generate another type of report, the base word template will change and it will run different queries. I can do this (wrongly) by copy pasting the code, but I want to extend the current app to generate both reports.

What I can't figure out is what software pattern I need to apply to solve this situation.

Answer 1

The usual way is to refactor the common functionality into its own method or class, and then call that method or class from those two places, passing the required information to the class through its method or constructor parameters.

See Also
Refactoring on Wikipedia

Answer 2

To add to what @Robert says, I think of this as seeking a parameterization technique that allows the common code to be written once (so it can be maintained in one place) and then reused instead of pasting.

However, you have to determine the kind of parameterization that will let you factor the common part to be written just once.

Often function parameters suffice, but that's not the only approach.

There are also classes and methods as @Robert says. Sometimes we use overrides and/or interfaces: I think of overrides and interfaces as a form of parameterization: The use of base class or interface serves to express a bundle of formal parameters and the concrete subclass or interface implementation serves binding of the bundle of actual parameters.

Don't forget that in many (esp. functional) languages we can have higher-order functions, meaning functions can take parameters that refer to functions, which enables other use cases. Abstract and interface methods act a lot like function parameters, perhaps with a bit more structure.

Another tool that some languages provide is generic types. Sometimes common code cannot be expressed with normal parameters: what differs between scenarios is the types being operated over, even if the code is the same in any case. In those situations generics help.

You can discuss some design pattern in terms of parameterization, such as a Observer and Visitor pattern, which abstracts specific data structure or its traversal from an action to be performed. These can be implemented by OOP techniques (using overrides or interfaces) and also by higher-order functions.

And still, other techniques (monads) allow other kinds of common code to be collected so as to be written only once. There is ongoing research in other kinds of parameterization.

In general, though, I think one can make a mental link of many of the techniques to reduce copied (pasted) code to variations on parameterization.