툴을 쫓는 사람들

“기본을 정확히 세우라. 천천히 유익한 툴에 익숙해지고, 그것을 사용하며 지속적으로 효과적인 상태를 유지하라.”

1. Make Tests Easy to Read and Maintain

function Test1() {
    vector<ScoredDocument> docs;
    docs.resize(5);
    docs[0].url = "http://example.com";
    docs[0].score = -5.0;
    docs[1].url = "http://example.com";
    docs[1].score = 1;

    docs[2].url = "http://example.com";
    docs[2].score = 4;
    docs[3].url = "http://example.com";
    docs[3].score = -99998.7;
    docs[4].url = "http://example.com";
    docs[4].score = 3.0;
    SortAndFilterDocs(docs);
    assert(docs.size() == 3);
    assert(docs[0].score == 4);
    assert(docs[1].score == 3.0);
    assert(docs[2].score == 1);

/*    There are at least eight different problems with this test code. By the end of the chapter, you’ll
    be able to identify and fix all of them.*/
}

//As a first step in cleaning this up, we could create a helper function like:
function MakeScoredDoc( ScoredDocument ,  score,  url) {
    ScoredDocument.score = score;
    ScoredDocument.url = url;
}

//Using this function, our test code becomes slightly more compact:
    void function() {
    vector<ScoredDocument> docs;
    docs.resize(5);
    MakeScoredDoc(docs[0], -5.0, "http://example.com");
    MakeScoredDoc(docs[1], 1, "http://example.com");
    MakeScoredDoc(docs[2], 4, "http://example.com");
    MakeScoredDoc(docs[3], -99998.7, "http://example.com");
    //...
}

void MakeScoredDoc( docs,  score) {
    var ScoredDocument ;
    ScoredDocument.score = score;
    ScoredDocument.url = "http://example.com";
    docs.push_back(sd);
}
//Using this function, our test code is even more compact:
function Test1() {
    vector<ScoredDocument> docs;
    AddScoredDoc(docs, -5.0);
    AddScoredDoc(docs, 1);
    AddScoredDoc(docs, 4);
    AddScoredDoc(docs, -99998.7);
    //...
}

 이 테스트는 어떤 점이 잘못되었을까?

 // 'Doc'를 내림차순으로 정렬하고 점수가 0보다 작은 문서를 제거한다.

 void SortAndFilterDocs(vector<ScoredDocument>* docs);

Void Tes1()

{

vector<ScoreDocument> docs;

docs.resize(50;

doc[0].url= "http://example.com":

doc[0].score = -5.0;

doc[1].url= "http://example.com":

doc[1].score = 1;

doc[2].url= "http://example.com":

doc[2].score = 4;

}

1.Describing Logic Clearly

$is_admin = is_admin_request();
if ($document) {
    if (!$is_admin && ($document['username'] != $_SESSION['username'])) {
        return not_authorized();
    }
} else {
    if (!$is_admin) {
        return not_authorized();
    }
}
// continue rendering the page ...

//Here is an alternative solution inspired by this description:

    if (is_admin_request()) {
// authorized
    } elseif ($document && ($document['username'] == $_SESSION['username'])) {
// authorized
} else {
    return not_authorized();
}

// continue rendering the page ...

1.Extracting Values from an Object

var old = function () {

    var place = location_info["LocalityName"]; // e.g. "Santa Monica"

    if (!place) {
        place = location_info["SubAdministrativeAreaName"]; // e.g. "Los Angeles"
    }
    if (!place) {
        place = location_info["AdministrativeAreaName"]; // e.g. "California"
    }
    if (!place) {
        place = "Middle-of-Nowhere";
    }
    if (location_info["CountryName"]) {
        place += ", " + location_info["CountryName"]; // e.g. "USA"
    } else {
        place += ", Planet Earth";
    }
    return place;
}

//we rewrote the original code to solve each of these tasks independently.

var town = location_info["LocalityName"]; // e.g. "Santa Monica"
var city = location_info["SubAdministrativeAreaName"]; // e.g. "Los Angeles"
var state = location_info["AdministrativeAreaName"]; // e.g. "CA"
var country = location_info["CountryName"]; // e.g. "USA"

// Start with the default, and keep overwriting with the most specific value.

var RefactoredCode = function () {

    var second_half = "Planet Earth";
    if (country) {
        second_half = country;
    }
    if (state && country === "USA") {
        second_half = state;
    }

    var first_half = "Middle-of-Nowhere";
    if (state && country !== "USA") {
        first_half = state;
    }
    if (city) {
        first_half = city;
    }
    if (town) {
        first_half = town;
    }

    return first_half + ", " + second_half;
}

var RefactoredCode2 = function () {

    var second_half = "Planet Earth";
    if (country) {
        second_half = country;
    }
    if (state && country === "USA") {
        second_half = state;
    }

    var first_half = "Middle-of-Nowhere";
    if (state && country !== "USA") {
        first_half = state;
    }
    if (city) {
        first_half = city;
    }
    if (town) {
        first_half = town;
    }

    return first_half + ", " + second_half;
}

2. Tasks Can Be Small

/*
When the user clicks one of the buttons (to make/change her vote), the following JavaScript
is called:
    vote_changed(old_vote, new_vote); // each vote is "Up", "Down", or ""
This function updates the total score and works for all combinations of old_vote/new_vote:*/

var vote_changed = function (old_vote, new_vote) {
    var score = get_score();
    if (new_vote !== old_vote) {
        if (new_vote === 'Up') {
            score += (old_vote === 'Down' ? 2 : 1);
        } else if (new_vote === 'Down') {
            score -= (old_vote === 'Up' ? 2 : 1);
        } else if (new_vote === '') {
            score += (old_vote === 'Up' ? -1 : 1);
        }
    }
    set_score(score);
};

/*
We can make the code easier to read by solving each task separately. The following code solves
the first task, of parsing the vote into a numerical value:*/

var vote_value = function (vote) {
    if (vote === 'Up') {
        if (vote === 'Down') {
            return -1;
        }
        return 0;
    }
}

//Now the rest of the code can solve the second task, updating score:
var vote_changed = function (old_vote, new_vote) {
    var score = get_score();
    score -= vote_value(old_vote); // remove the old vote
    score += vote_value(new_vote); // add the new vote
    set_score(score);
}
/*As you can see, this version of the code takes a lot less mental effort to convince yourself that
it works. That’s a big part of what makes code “easy to understand.”*/

1. find Closest Location

// Return which element of 'array' is closest to the given latitude/longitude.
// Models the Earth as a perfect sphere.
var findClosestLocation = function (lat, lng, array) {
    var closest;
    var closest_dist = Number.MAX_VALUE;

    for (var i = 0; i < array.length; i += 1) {
// Convert both points to radians.
        var lat_rad = radians(lat);
        var lng_rad = radians(lng);
        var lat2_rad = radians(array[i].latitude);
        var lng2_rad = radians(array[i].longitude);

// Use the "Spherical Law of Cosines" formula.
        var dist = Math.acos(Math.sin(lat_rad) * Math.sin(lat2_rad) +
            Math.cos(lat_rad) * Math.cos(lat2_rad) *
                Math.cos(lng2_rad - lng_rad));
        if (dist < closest_dist) {
            closest = array[i];
            closest_dist = dist;
        }
    }

    return closest;
};

/*
Most of the code inside the loop is working on an unrelated subproblem: Compute the spherical
distance between two lat/long points. Because there is so much of that code, it makes sense to
extract it into a separate spherical_distance() function:
*/

var spherical_distance = function (lat1, lng1, lat2, lng2) {
    var lat1_rad = radians(lat1);
    var lng1_rad = radians(lng1);
    var lat2_rad = radians(lat2);
    var lng2_rad = radians(lng2);
// Use the "Spherical Law of Cosines" formula.

    return Math.acos(Math.sin(lat1_rad) * Math.sin(lat2_rad) +
        Math.cos(lat1_rad) * Math.cos(lat2_rad) *
            Math.cos(lng2_rad - lng1_rad));
};

var findClosestLocation = function (lat, lng, array) {
    var closest;
    var closest_dist = Number.MAX_VALUE;
    for (var i = 0; i < array.length; i += 1) {

        var dist = spherical_distance(lat, lng, array[i].latitude, array[i].longitude);
        if (dist < closest_dist) {
            closest = array[i];
            closest_dist = dist;
        }
    }
    return closest;
};

2.Other General-Purpose Code

ajax_post({
    url: 'http://example.com/submit',
    data: data,
    on_success: function (response_data) {
        var str = "{\n";
        for (var key in response_data) {
            str += " " + key + " = " + response_data[key] + "\n";
        }
        alert(str + "}");
// Continue handling 'response_data' ...
    }
});

/*The high-level goal of this code is, Make an Ajax call to the server, and handle the response. But a
lot of the code is solving the unrelated subproblem, Pretty-print a dictionary. It’s easy to extract
that code into a function like format_pretty(obj):*/

var format_pretty = function (obj) {
    var str = "{\n";
    for (var key in obj) {
        str += " " + key + " = " + obj[key] + "\n";
    }
    return str + "}";
};

//adding this functionality is easy. Here’s what the improved code looks like:

var format_pretty_1 = function (obj, indent) {
// Handle null, undefined, strings, and non-objects.
    if (obj === null) return "null";
    if (obj === undefined) return "undefined";
    if (typeof obj === "string") return '"' + obj + '"';
    if (typeof obj !== "object") return String(obj);
    if (indent === undefined) indent = "";
// Handle (non-null) objects.
    var str = "{\n";
    for (var key in obj) {
        str += indent + " " + key + " = ";
        str += format_pretty(obj[key], indent + " ") + "\n";
    }
    return str
}

1.Eliminating Intermediate Results

//Here’s an example of a JavaScript function that removes a value from an array:
    var remove_one = function (array, value_to_remove) {
        var index_to_remove = null;
        for (var i = 0; i < array.length; i += 1) {
            if (array[i] === value_to_remove) {
                index_to_remove = i;
                break;
            }
        }
        if (index_to_remove !== null) {
            array.splice(index_to_remove, 1);
        }
    };

//sometimes be eliminated by handling the result as soon as you get it:
    var remove_one = function (array, value_to_remove) {
        for (var i = 0; i < array.length; i += 1) {
            if (array[i] === value_to_remove) {
                array.splice(i, 1);
                return;
            }
        }
    };

2. if Statement Scope in C++

//the person reading this
//code might keep info in mind, wondering if/how it will be used again.
PaymentInfo* info = database.ReadPaymentInfo();
if (info) {
    cout << "User paid: " << info->amount() << endl;
}
// Many more lines of code below ...

//Now the reader can easily forget about info after it goes out of scope.
if (PaymentInfo* info = database.ReadPaymentInfo()) {
    cout << "User paid: " << info->amount() << endl;
}

3. Shrink the Scope of Your Variables

//two methods, in the following way:
    class LargeClass {

    string str_;

    void Method1() {
        str_ = ...;
        Method2();
    }
    void Method2() {
// Uses str_
    }
// Lots of other methods that don't use str_ ...
};

//For this case, it may make sense to “demote” str_ to be a local variable:
    class LargeClass {
    void Method1() {
        string str = ...;
        Method2(str);
    }

    void Method2(string str) {
// Uses str
    }
// Now other methods can't see str.
};

1. Another Creative Way to Simplify Expressions

void AddStats(const Stats& add_from, Stats* add_to) {

 add_to->set_total_memory(add_from.total_memory() + add_to->total_memory());
 add_to->set_free_memory(add_from.free_memory() + add_to->free_memory());
 add_to->set_swap_memory(add_from.swap_memory() + add_to->swap_memory());
 add_to->set_status_string(add_from.status_string() + add_to->status_string());
 add_to->set_num_processes(add_from.num_processes() + add_to->num_processes());
 ...

 }

 After ten seconds of careful scrutiny, you might realize that each line is doing the same thing,
 just to a different field each time:

 add_to->set_XXX(add_from.XXX() + add_to->XXX())

 In C++, we can define a macro to implement this:

 void AddStats(const Stats& add_from, Stats* add_to) {
 #define ADD_FIELD(field) add_to->set_##field(add_from.field() + add_to->field())
 ADD_FIELD(total_memory);
 ADD_FIELD(free_memory);
 ADD_FIELD(swap_memory);
 ADD_FIELD(status_string);
 ADD_FIELD(num_processes);
 ...
 #undef ADD_FIELD
 }

2. Breaking Down Giant Statements

var update_highlight = function (message_num) {

    if ($("#vote_value" + message_num).html() === "Up") {
        $("#thumbs_up" + message_num).addClass("highlighted");
        $("#thumbs_down" + message_num).removeClass("highlighted");
    } else if ($("#vote_value" + message_num).html() === "Down") {
        $("#thumbs_up" + message_num).removeClass("highlighted");
        $("#thumbs_down" + message_num).addClass("highlighted");
    } else {
        $("#thumbs_up" + message_num).removeClass("highighted");
        $("#thumbs_down" + message_num).removeClass("highlighted");
    }
};

//his is also an instance of the DRY—Don’t Repeat Yourself—principle):

var update_highlight = function (message_num) {

    var thumbs_up = $("#thumbs_up" + message_num);
    var thumbs_down = $("#thumbs_down" + message_num);
    var vote_value = $("#vote_value" + message_num).html();

    var hi = "highlighted";

    if (vote_value === "Up") {
        thumbs_up.addClass(hi);
        thumbs_down.removeClass(hi);
    } else if (vote_value === "Down") {
        thumbs_up.removeClass(hi);
        thumbs_down.addClass(hi);
    } else {
        thumbs_up.removeClass(hi);
        thumbs_down.removeClass(hi);
    }
};

3. Explaining Variables

Here is an example:
    if line.split(':')[0].strip() == "root":
...
Here is the same code, now with an explaining variable:
    username = line.split(':')[0].strip()
    if username == "root":

4. Summary Variables

var CleanReply = function (request,  reply)
{
    //For example, consider the expressions in this code:
    if (request.user.id == document.owner_id) {
        // user can edit this document...
    }

    if (request.user.id != document.owner_id) {
        // document is read-only...
    }

    //stated more clearly by adding a summary variable:
    var user_owns_document = (request.user.id == document.owner_id);

    if (user_owns_document) {
        // user can edit this document...
    }

    if (!user_owns_document) {
        // document is read-only...
    }

}

5.Using De Morgan’s Laws (positive is easy to readable)

var Contains = function (request,  reply)
{
/*    1) not (a or b or c) ⇔ (not a) and (not b) and (not c)
    2) not (a and b and c) ⇔ (not a) or (not b) or (not c)*/

    //You can sometimes use these laws to make a boolean expression more readable. For instance,
    //if your code is:
    if (!(file_exists && !is_protected)) Error("Sorry, could not read file.");

    //It can be rewritten to:
    if (!file_exists || is_protected) Error("Sorry, could not read file.");
}

1.Conditional Expression

var CleanReply = function (request,  reply)
{
    //Here’s a case where the ternary operator is readable and compact:

    time_str += (hour >= 12) ? "pm" : "am";

    //Avoiding the ternary operator, you might write:
    if (hour >= 12) {
        time_str += "pm";
    } else {
        time_str += "am";
    }

    //these expressions can quickly become difficult to read:
    exponent >= 0 ? mantissa * (1 << exponent) : mantissa / (1 << -exponent);

    //Spelling out the logic with an if/else statement makes the code more natural:

    if (exponent >= 0) {
        return mantissa * (1 << exponent);
    } else {
        return mantissa / (1 << -exponent);
    }

}

2.don’t” is drowned out by the more unusual

var CleanReply = function (request,  reply)
{
    if (!url.HasQueryParameter("expand_all")) {
        response.Render(items);
    } else {
        for (var i = 0; i < items.size(); i++) {
            items[i].Expand();
        }

    }

/*    it’s the more interesting case (and it’s the
    positive case, too), let’s deal with it first:*/
    if (url.HasQueryParameter("expand_all")) {
        for (var i = 0; i < items.size(); i++) {
            items[i].Expand();
        }

    }else {
        response.Render(items);
    }
}

3.Removing Nesting Inside Loops

var Contains = function (request,  reply)
{
/*    here’s a case of code
    nested in a loop:*/
    for (var i = 0; i < results.size(); i++) {
        if (results[i] != NULL) {
            //non_null_count++
            if (results[i].name != "") {
                //cout << "Considering candidate..." << endl;

            }

        }
    }

    //Inside a loop, the analogous technique to returning early is to continue:
    for (int i = 0; i < results.size(); i++) {
        if (results[i] == NULL) continue

            //non_null_count++;
        if (results[i].name == "") continue;
            //cout << "Considering candidate..." << endl;

    }

}

4. Removing Nesting by Returning Early

var CleanReply = function (request,  reply)
{
    //if you notice yourself looking back up to doublecheck
    //which block conditions you’re in:
    if (user_result == SUCCESS) {
        if (permission_result != SUCCESS) {
            reply.WriteErrors("error reading permissions");
            reply.Done();
            return;
        }
        reply.WriteErrors("");
    } else {
        reply.WriteErrors(user_result);
    }
    reply.Done();

    //Nesting like this can be removed by handling the “failure cases”
    //as soon as possible and returning early from the function:

    if (user_result != SUCCESS) {
        reply.WriteErrors(user_result);
        reply.Done();
        return;
    }
    if (permission_result != SUCCESS) {
        reply.WriteErrors(permission_result);
        reply.Done();
        return;
    }
    reply.WriteErrors("");
    reply.Done();

}

5. Returning Early from a Function

//Returning early from a function is perfectly fine—and often desirable. For example:

var Contains = function (request,  reply)
{
    if (str == null || substr == null) return false;
    if (substr.equals("")) return true;

}

cf) 반환 포인트를 하나만 두려는 건 함수의 끝부분에서 실행되는 cleanup 코드의 호출을 보장하려는 의도다. 

    하지만 현대의 언어는 클린업 코드를 실행시키는 더 정교한 방법을 제공한다. C# 의 Using / try finally

    그러므로 여러 곳에서 반환하는 것도 바람직 할 수 있다.

 6. 아래와 같은 구조가 차지하는 것이 많은 프로그램은 흐름을 쫒아가기 어려워질 수 있다. 이 비율이 너무 놓지 않아야한다.

  쓰레딩                        - 어느 코드가 언제 실행되는지 불분명

  시그널/ 인터럽트 핸들러 - 어느 코드가 어떤 시점에 실행될지 모른다.

  예외                           - 예외 처리가 여러 함수 호출을 거치면서 실행될 수 있다.

  함수 포인터 & 익명함수  - 실행할 함수가 런타임에 결정되기 때문에 컴파일 과정에서는 어떤코드가 실행될지 알기 어렵다.

  가상 메소드                  - object.virtualmethod() 알려지지 않은 하위클래스의 코드를 호출할지도 모른다.