Change object behaviour...but just some lines!?

Question

Hello there freaks & geeks. Here comes my question again, thanks for helping!.

Lets suppose i have an object Foo, which method foo() does about 100 lines.

foo() { ... qwert yuiop asdfg zxcvb nmhjk ... }

If a developer wants to add some code to foo(), it can be easily done with inheritance, composing or a Decorator Pattern.

But in the case he wants to modify "one line" in the middle of the code (changing a property value, invoking a method before something...), whats the best way to do it?

foo2() { ... qwert yuiop ASDFG zxcvb nmhjk ... }

The goal is to let the original developer to define a behavior without worriying about what others will modify/change.

The new developer should be able to change the object/method/property without retyping the code.

Inserting breaks or predefining steps with callbacks/listeners or dividing the code into smaller pieces is not the desired option, cause it involves the first developer, which is sleeping. :P

What about a commit environment where the changes made to the object need a commit to apply? foo() does normal, then foo2 just change the desired properties and make commit.

Any other alternatives?

Thanks!

Answer 1

Depending on what the function a() does, I would probably make an optional parameter to a() that takes a function that is run instead of asdf.

Python-ish:

def a(foo=None):
    qert
    yuiop
    if foo is None:
        asdf
    else:
        foo()
    zxcvb
    nmhjk

a(foo=lambda: ASDF)

Answer 2

Break the function up into smaller steps. Chances are that a 100 line function does more than one thing (and if it doesn't there would't be a need to change a line halfway though).

Answer 3

Encapsulate steps that change the behaviour of the object. In C++ land policy-based design is often used if you don't need to decide on the behaviour at run-time. The control-flow is defined in the class and what is actually done at some points depends on the template parameters.

The important and hardest part is to split up your methods accordingly and often depends on the customizability that you require. Keep YAGNI in mind when doing something like this.

Answer 4

Depending on what the other developer needs to insert, this may be a candidate to introduce hooks in your system using an observer pattern.

Answer 5

But in the case he wants to modify "one line" in the middle of the code (changing a property, invoking a new function before something...), decorator it is not an option.

What do you think is the correct approach to achieve this?(modify 2 lines of 100 without retyping all)

Retyping the lines of code is not the issue, because the chances are it will be just a copy&paste. You need to eliminate code duplication. So make you function overrideable (so the next developer can inherit from it or extend it), and factor out all the common code into smaller separate functions.

If you are using .Net then you could also consider refactoring the function to accept a delegate or lambda as one of its parameters, and that delegate/lambda gets executed at the critical spot (this may be your best option). You may also be able to achieve your aim with partial classes - you write some of the code of the class, the other developer writes the rest, although this may be a messy solution for your problem.

Should i design a() with 100 listeners/callbacks? Should i define some "known steps" and use something like "insertCodeBefore/After(step)"?

This is likely to also be a very messy and inefficient solution.

Answer 6

@Koen yes...its more or less what i want.

I code my part, u code yours, but can use part of mine.

Its not the objetive, buts looks like the workflow.