X

ﾘﾌｧｸﾀﾘﾝｸﾞすると全部ﾃｽﾄしろと言ってくるやつの矛盾

■ このスレッドは過去ログ倉庫に格納されています
0001仕様書無しさん
垢版 |
2018/04/15(日) 13:13:44.63
機能追加や変更した時に、全部テストしてるでしょ？
いつもやってることじゃん
0069仕様書無しさん
垢版 |
2018/04/17(火) 10:16:36.37
TDDってさ
組織的にガチガチにやるもんじゃなくて
設計者の間で守るべき密やかな秘密程度で
やったほうが良い気がすんのね。
0070仕様書無しさん
垢版 |
2018/04/17(火) 11:00:00.11
>>68
それはどんなコード変更のときでもやるべきことだから
リファクタリングの話とは関係ないという注意だけしておくね
0071仕様書無しさん
垢版 |
2018/04/17(火) 11:05:57.21
>>69
ようは、リファクタリング前に存在するテストコードが
リファクタリング後でも通ることで動きを変えてないことが
証明できれば良いのでTDDである必要はないよ。

具体的にはgit使えば歴史変えられるんで、
コード変更しつつテストコード書いて、
コード変更とテストコードでコミット分けて
あとでrebaseしてテストコードのコミットをコード変更の
コミットより前に持ってくれば良い
0074仕様書無しさん
垢版 |
2018/04/17(火) 12:26:04.15
>>72
> TDDは保護するためのテストじゃないから

TDDはテストではなく開発手法ですよ？

TDDという開発手法ではリファクタリングの前にテストを書き
書いたテストが、その後に行うリファクタリングが問題ないことを証明するんですよ

つまり
× TDD = 保護するためのテスト
○ TDD =「保護するためのテスト」を用いた開発手法

（あんたの言った「保護」がリファクタリングで壊さないように守るという意味である前提）

俺が>>71で言ったことは、TDDでやらなくてもテストで保護できると言ったんです。

https://postd.cc/test-driven-development/

> 簡単に言うと、TDDは機能を記述する前に自動テストを書く行為です。
> 例えば、Bobが素晴らしい新たなソーシャルネットワークのアイデアの
> ために新しい機能を開発する必要があるとしましょう。
>
> Bobは自動テストを書くことから始めますが、機能を正しく実装せずに、
> テストを失敗（赤色表示）させます。次に、Bobはテストを成功（緑色表示）
> させるための最小限のコードを記述します。緑色表示になったら、
> Bobはコードをきれいにし、テストを実行して機能が正しく
> 実装されたままであることを確認します（コードのリファクタリング）。
> 重複することなく、コードと自動テストは他の人も簡単に保守できます。
0075KAC
垢版 |
2018/04/17(火) 13:27:11.82
>>66
えーと、まずはスレタイの
「リファクタリングすると全部テスト」については、
「全部テストするのは当たり前」という理解でOK？

それなら、大筋では意見に違いは無い。
0076仕様書無しさん
垢版 |
2018/04/17(火) 13:49:22.47
>>75

before（リファクタリングしない場合）
　1. 機能追加やバグ修正などの変更依頼が来る
　2. 変更する
　3. 変更したので全部テストをする

after（リファクタリングする場合）
　1. 機能追加やバグ修正などの変更依頼が来る
　2. 変更する（リファクタリングもする）
　3. 変更したので全部テストをする


afterに対して、余計なことするな！
リファクタリングしたなら全部テストしろ！
と言われましても、beforeでも全部テストしてますよね？という話です。
0077仕様書無しさん
垢版 |
2018/04/17(火) 15:18:23.57
リファクタリングしたら(その時点で、機能改修する前に)(単体)テストしろって要求なんじゃね？

まあ普通やるけど。
0078仕様書無しさん
垢版 |
2018/04/17(火) 15:55:33.65
>>77
いやぁ、違うなぁ
リファクタリングさせないための方便として使ってるので
お前がリファクタリングするとテストする人が迷惑するんだぞ
だから余計なことするなという意味だろう。

だがもともとテストするわけで矛盾になるんだよな
0081仕様書無しさん
垢版 |
2018/04/17(火) 16:59:00.97
>>79
じゃあどういうことか書けよｗ

>>80
でもどっちみちコード変更するんでしょ？
リファクタリングしない方がデグレさせる可能性高いし
0082仕様書無しさん
垢版 |
2018/04/17(火) 17:34:58.09
リリースしたらあとはそのシステムのことは知らん
だからリファクタリングする気もない
0083仕様書無しさん
垢版 |
2018/04/17(火) 18:30:58.65
>>81
いやリファクタリングすると触らなくていいとこまで変更するじゃん
既存コードを変更するって時点でまずい
0084仕様書無しさん
垢版 |
2018/04/17(火) 18:52:07.21
>>83
触らなくていいかどうかが重要なんですか？

重要なのはテストする所かどうかでしょう？
触った所でテストするなら、なにも問題ないはずですが？
0085仕様書無しさん
垢版 |
2018/04/17(火) 18:54:58.04
>>84
そうはいかねぇだろ
文章化されてないけど
クリアしてるいろんな仕様があんだからよ
長い間運用してるとそういうのあるわけよ
0086仕様書無しさん
垢版 |
2018/04/17(火) 19:09:26.69
>>84
触らなければテストもしなくていい
プロは余計なコードも書かないし、余計なテストもしない
0087KAC
垢版 |
2018/04/17(火) 19:26:39.52
>>76
イメージはあってそう（スレ建てた奴とは違う意見）に読めたので、
具体的な内容を書いてみる。

大規模で難解なプロジェクトの一部機能で、
一カ所の編集バッファの数が足りず、
長い氏名の編集に失敗する仕様となっていた。
メモリの使用率なども調査済みで、編集文字数を増やすという仕様変更案件の場合。

バッファサイズを増やして関連箇所の試験して完了。

リファクタリングしたら、統べての試験をやり直し。

リファクタリングの有無でどちらが安いのか、
時と場合によるって認識はあってる？
0088仕様書無しさん
垢版 |
2018/04/17(火) 20:51:10.01
WFとアジャイルとでも違うし
リファクタリングできる設計になってるの？
も大きな要素だが

動いているなら弄るなよは永遠の真理
0090仕様書無しさん
垢版 |
2018/04/17(火) 22:21:50.39
バッファサイズの変更でなにをリファクタするというんだ

文字編集がややこしいから途中量の計算が難しいから処理変更とか？
0091仕様書無しさん
垢版 |
2018/04/17(火) 23:28:38.99
>>85

リファクタリングの話は一旦おいておきましょう。


> そうはいかねぇだろ
> 文章化されてないけど
> クリアしてるいろんな仕様があんだからよ

それでどうやってコードを正しく変更できるんですか？
コードを変更する時に文書化されてない仕様を
間違って変えてしまうことがありますよね？

文書化されてない仕様をテストでどうやって
見つけるんですか？
0092仕様書無しさん
垢版 |
2018/04/17(火) 23:36:25.31
>>87

> バッファサイズを増やして関連箇所の試験して完了。
>
> リファクタリングしたら、統べての試験をやり直し。

え？なんで？先に修正して試験するのがいけないんじゃん


1. リファクタリングをする
2. バッファサイズを増やす
3. 関連箇所の試験して完了

基本はこうですよ？
実際にはこんな大雑把作業じゃなくもう少し細かく
（ユニットテストと）リファクタリングと修正を何回か繰り返しますが

コードの変更とリファクタリングは切り離せません

コードの変更とリファクタリングの間に「関連箇所の試験して完了」
なんてものは入らないし入れたらダメです。
0093仕様書無しさん
垢版 |
2018/04/17(火) 23:41:10.11
ちゃんと設計できてないから改修する度にいちいち事前のリファクタリングが必要になるんだろうな
0094仕様書無しさん
垢版 |
2018/04/17(火) 23:41:50.05
>>91
まさにそのスレでその話してるんだからおいとくなよ…

現に存在するものに文句言ったってしょうがないだろ
あるんだから
非機能要件のないソフトなんてない

改修部分が少なければ少ないほど踏んじゃうリスクは減るだろう
0095仕様書無しさん
垢版 |
2018/04/17(火) 23:48:58.45
> ちゃんと設計できてないから改修する度にいちいち事前のリファクタリングが必要になるんだろうな

そりゃリファクタリングの必要がない場合にはリファクタリングしませんよｗ

前提として、リファクタリングの必要があるコードだって
ちゃんと書きましょうか？ そうすればもっとわかりやすくなりますね。

・リファクタリングをしない場合
1. ちゃんとした設計になっていない
2. そのままで無理やりバッファサイズを増やす
3. やってることが意味不明。変更に自信が持てない。コードレビューも大変。
4. 変更で問題が出やすい。そのたびに意味不明なコードと格闘する。
5. 関連箇所の試験して完了。


・リファクタリングをする場合
1. ちゃんとした設計になっていない
2. 設計を修正する（リファクタリング）
3. ちゃんとした設計に自然な形でバッファサイズを増やす
4. やってることが明確。変更に自信が持てる。コードレビューも簡単。
5. 変更に問題が出にくい。仮に出たとしてもちゃんとした設計になってるのですぐに修正できる
6. 関連箇所の試験して完了。

リファクタリングしたことで1工程増えたように見えますが、
ちゃんとした設計になってないものを無理やり修正した複雑なコードは
バグが出やすく、修正も大変になって時間がかかります。
それはわかるでしょう？
0096仕様書無しさん
垢版 |
2018/04/17(火) 23:50:34.78
>>94
> 改修部分が少なければ少ないほど踏んじゃうリスクは減るだろう

改修部分をリファクタリングするんだから、
改修部分の量は同じですが？
0097仕様書無しさん
垢版 |
2018/04/17(火) 23:55:28.57
>>96
具体的なイメージがわからない

本当に改修部分だけ改修だったらリファクタ部分消えちゃうじゃない
それってただの改修では
0098仕様書無しさん
垢版 |
2018/04/18(水) 00:26:44.21
>>97
ちょっとなにかいいサンプルないか探したんだが
見つからなかったので、軽く例を書くわ


ある関数を改修部分することになった。これが100行を超える複雑なコード。
これをリファクタリングすると10行にできるとする
（ライブラリ使用の有無とかで、これぐらいざらにあるからｗ）

リファクタリングしない場合は無駄なコードで処理が入り組んでおり
入り組んだコードを時間をかけて頑張って解析し
そのまま修正するとなると数箇所を変更しなければいけなくなることが判明した
だが本当にその数箇所の変更で問題ないのか？ コードが複雑なのでよくわからない
レビュー依頼した所で時間をかけて解析したものを他の人がすぐに分かるはずもない
多くの時間を費やすることになった。

リファクタリングして10行にまで減らすと、コードはシンプルになりなにやってるのか一目瞭然になった。
テストコードがあるのでリファクタリングの前後でコードが壊れてないことはわかる。
リファクタリングしたため修正箇所もたったの一行になった。
他の人も何の修正をしたのかすぐに分かる
0099仕様書無しさん
垢版 |
2018/04/18(水) 01:15:38.23
>>98
おまいのレスが長すぎてリファクタリングしないと読めない
0101仕様書無しさん
垢版 |
2018/04/18(水) 01:43:53.78
>>95
リファクタリングの必要性をそこまで感じないってことは、俺の設計ってちゃんとしてるんだろうなぁ
0102仕様書無しさん
垢版 |
2018/04/18(水) 02:00:52.61
>>101
あと仕様変更がないってことだろうね。

仕様変更があれば、少なからず設計を変更することになるから
0103仕様書無しさん
垢版 |
2018/04/18(水) 03:09:17.61
>>102
OCPができてないから仕様の変更がいろんなところに波及するんだよ
あとから直せばいいやじゃなくて、もう少し基本を身に付けよう
0104仕様書無しさん
垢版 |
2018/04/18(水) 03:41:28.10
>>103
最初から何でも考慮した過剰な設計は止めましょう
こっちが基本ですよ？ｗ
0105仕様書無しさん
垢版 |
2018/04/18(水) 07:33:52.26
言語からスクリプト言語が呼べるようにしておけば汎用性は無限
バグも無限
0106仕様書無しさん
垢版 |
2018/04/18(水) 07:50:27.25
>>98
リファクタの状況的にはありだけど

それって関数全体に手が入ってるわけだから改修量同じじゃないじゃん
テストで検出できない非機能要件を踏んじゃうリスクは明らかに増えてるよね？
0107仕様書無しさん
垢版 |
2018/04/18(水) 10:52:23.05
数年経ってもリファクタバカは相変わらずだなｗ
未だに賛同者が現れないｗｗｗｗ
しかも、リファクタリングそのものではなく、リファクタバカに対する非賛同が増殖ｗ

かたやリファクタすら許してもらえない信用と立場のリファクタバカが相変わらずの状態
かたや５年以上で完全に新規で作り直しの許可を与えられるようになった俺

技術書に溺れなくてよかった・・・。
0108KAC
垢版 |
2018/04/18(水) 12:55:46.41
>>98
あぁ、そういう事か。
「リファクタリング」という範囲のイメージが合ってなかったんだな。

関数単位のリファクタリングならそのイメージでだいたい合ってる。

「外部インタフェース変えずに内部の設計から見直す」事を前提に話してたよ。


それはそうとして、
関数の処理削減などで処理速度が変わったのなら、同期など含めてその観点での試験はちゃんとやれよ？
0110仕様書無しさん
垢版 |
2018/04/18(水) 19:52:23.21
関数レベルのリファクタリングしか語れないレベルだということはお察し
0112仕様書無しさん
垢版 |
2018/04/18(水) 22:40:51.02
>>106
> それって関数全体に手が入ってるわけだから改修量同じじゃないじゃん
> テストで検出できない非機能要件を踏んじゃうリスクは明らかに増えてるよね？

関数の中の1行を変えたとして、
その1行だけをテストして関数全体OKってできるんですか？

そもそも関数の中の1行だけをテストすることは不可能だと思います。

結局関数全体をテストするわけでしょう？
0113仕様書無しさん
垢版 |
2018/04/18(水) 22:42:05.86
>>108
> 関数の処理削減などで処理速度が変わったのなら、同期など含めてその観点での試験はちゃんとやれよ？

もともと修正すべき関数なんだから、リファクタリングしなくても
テスト必須でしょう？ なにを言ってるんでしょうか
0114仕様書無しさん
垢版 |
2018/04/18(水) 22:50:36.63
>>112
でもさ
ソースで見たとき処理の下の方をちょっと修正すればいいところで
上の方の関係なさ気な箇所がバグったら言い訳できねぇよ
差分見て

何でここ弄ったの？今回の修正と関係ないじゃん

って言われたらちょっと嫌な空気流れるよ
0115仕様書無しさん
垢版 |
2018/04/18(水) 22:52:17.90
>>106
> それって関数全体に手が入ってるわけだから改修量同じじゃないじゃん
「可読性」って言葉ご存知ですか？

「可読性」の二番目の文字は「読」です。
「書」ではないのです。

改修は「書く」ことですが、改修前には「読む」こと必須です。
では書く時間と読む時間、どちらが多くかかりますか？

もちろん読む方ですよね？
タイピングなんて1分間に200〜300なんて軽く行く

改修の書く量だけを見ても正解にはたどり着けませんよ。
改修量ではなく作業始めてからの改修時間を見るのが筋じゃないですかね？

リファクタリングは改修時間を短くします。
0117仕様書無しさん
垢版 |
2018/04/18(水) 22:58:24.94
>>112
具体的なシナリオをいうとだ

日付をこりこり自前でデコードして値つくってる１００行近いまぬけコードを
Ｊａｖａのライブラリつかって数行にしてホルホルしてたら
ついうっかり見たことないようなフォーマットも受け入れちゃうようになってて
そんなん存在もわかんないからテストしてるわけなくて
でもユーザーは何の気なしに入れちゃうと入るからそのまま入れて、想定と異なるへんなデータが蓄積していって
集計バッチの演算とかにちょっとづつ毒虫のように影響を与え続けて
気が付いたらえらいことになってたりとか
0119KAC
垢版 |
2018/04/18(水) 23:03:03.55
>>113
修正内容に応じてテスト観点増やさないの？
費用対効果考えながらテスト計画立てないと破綻するぞ？
0120仕様書無しさん
垢版 |
2018/04/18(水) 23:04:52.45
>>117
それはリファクタリングしなくても起こる話ですね。

何度も言うように、そこが修正箇所です。
リファクタリングしなかったとしても修正する場所です。

修正して、ついうっかり見たことないようなフォーマットも受け入れちゃうようになってて
そんなん存在もわかんないからテストしてるわけなくて
でもユーザーは何の気なしに入れちゃうと入るからそのまま入れて、想定と異なるへんなデータが蓄積していって
リファクタリングと何の関係もない話ですよね

>>118
> 理解できたらもとに戻してもいいのよ？
次修正する時、また改修時間（読む時間）がかかりますよね？
0121仕様書無しさん
垢版 |
2018/04/18(水) 23:06:20.06
>>118
もとに戻すと改修時間（読む時間）が無駄になるだけですね。
次回修正するときも、また改修時間がかかります。

バグが見つかったら、また改修時間がかかります。
0122仕様書無しさん
垢版 |
2018/04/18(水) 23:07:43.72
>>119
> 修正内容に応じてテスト観点増やさないの？

少ししか修正してないから、テスト減らしていいとでも？

変更したコードの量は少しでも、その影響範囲は
修正の量とは無関係です。

どれくらい影響があるか、それはコードが複雑であれば
有るほど不明です。
0123KAC
垢版 |
2018/04/18(水) 23:17:24.91
>>122
テスト計画建てたこと無いの？
「全ての条件を網羅したらバグは無くなる」
は真だけど、それができないからみんな工夫してるんだよ。

バグのないものは存在しない

なんてのは、この業界の常識。
0124仕様書無しさん
垢版 |
2018/04/18(水) 23:22:51.13
>>120
リファクタだけの問題じゃないが、リファクタも修正のうち
修正する以上人間がやらかすリスクはある

だったら修正は極力限定されているほうがいいだろ


>次修正する時、また改修時間（読む時間）がかかりますよね？
そしてリファクタ最大の問題
コードの読みやすさや理解しやすさは人の主観に大きく依存する

else取っ払ってタプル戻り値の関数に変えようとするやつもいるんだぞ

リファクタ後に修正したほうがテスト工数が削減できるとか、規約が新たにできたから合わせるとか
なにかしら明白な理由がないと
0125仕様書無しさん
垢版 |
2018/04/18(水) 23:23:52.53
あとどうもやっぱりリファクタリングを
単なるコードの修正の意味で使ってるように見えるんだよねｗ

リファクタリングは、コードの修正、コードを綺麗にするを
英語にした言葉じゃないよ？

リファクタリングっていうのはやり方が決まってる。
スタート（修正前）とゴール（修正後）は自分で決めるけど
スタートからゴールへ至る道へは、決まったやり方を使って修正する
その決まったやり方っていうのは、動きを変えないための方法

数学の等式の変形みたいなもんだ
x - 2 = 8 を「移行」して
x = 8 + 2 に変形しても意味は変わらない

こういう「移行」みたいに変形しても意味が変わらないやり方に
ご丁寧に名前までつけてカタログ化されてる。

テスト書いて決められたやり方で式を変形するんだから
無計画なコードの修正なんかよりもずっと安全に変形できる
0126仕様書無しさん
垢版 |
2018/04/18(水) 23:24:38.02
>>123
いや、だから、一行の変更なら
テスト減らせるってわけじゃないよって言ってるんだが？
0127仕様書無しさん
垢版 |
2018/04/18(水) 23:25:40.46
>>124
> コードの読みやすさや理解しやすさは人の主観に大きく依存する

じゃあ主観に依存しないものを採用すればいいだけでは？

コードメトリクスを計測せよ
0128仕様書無しさん
垢版 |
2018/04/18(水) 23:27:30.62
>>125
そうだね
リスクはひくいよ
Eclipseのリファクタ機能使うならなおさらだ

それでもたまにやらかすだろ！
0130仕様書無しさん
垢版 |
2018/04/18(水) 23:33:22.64
>>128
> それでもたまにやらかすだろ！

複雑なコードをそのまま修正するほうが
やらかします。

その場合、いくら修正してもバグはなおらないし
直したそばから別のバグが発生するし、
時間もかかるしで、良いことはまったくありません。

重要なのは改修量ではなく改修時間な
0131仕様書無しさん
垢版 |
2018/04/18(水) 23:34:59.93
マーチン本に書いてある手続きいちいち守ってたら日が暮れる
現実的には既存のユニットテストのコードを信用して
手続きを頭に置きつつ直観でつくり変えていくことになる
そんで流して結果変わってなきゃＯＫと

理想が定義されているからといって現実に耐えうるかというと
0132仕様書無しさん
垢版 |
2018/04/18(水) 23:36:04.44
>>129
基本的にメトリクス測定ツールは、基準値超えたら
アラート出してくれるはずだからそれに従えばいいと思うけど、
俺はCyclomatic複雑度を重視するね。
0133仕様書無しさん
垢版 |
2018/04/18(水) 23:51:21.89
>>130
改修による単体工数の削減はあるかもしらんが

時間重視ならなおのことリファクタやってるひまなんかないだろ
あれほどの時間泥棒もない

よく考えたら書くほうが早いっつったって
結局その前に理解しないと書き直せないんだから一緒じゃねーか！
だまされるとこだった
0134仕様書無しさん
垢版 |
2018/04/18(水) 23:59:21.26
> よく考えたら書くほうが早いっつったって
> 結局その前に理解しないと書き直せないんだから一緒じゃねーか！

だから、たった一行の修正とか言っても、
その修正にかかる時間は、理解する時間が大半を占めるんだから
リファクタリングしても大差ないって話だよ。

大差ないどころか、複雑なものを複雑なまま、頭の中で理解するほうが
時間かかると思うがね


そして理解した結果をコードに反映させないで、レビューにかかる時間
次に修正する時間、バグ出た時に読み返す時間を費やするか
コードに反映させて、その後にある時間を減らすかどうか
0135仕様書無しさん
垢版 |
2018/04/19(木) 00:04:04.23
>>134
で？結局リファクタやると具体的に何がいいんだっけ？
色々話してるとメリットが全く見えなくなっちゃう
0137仕様書無しさん
垢版 |
2018/04/19(木) 00:22:17.21
>>135
> で？結局リファクタやると具体的に何がいいんだっけ？

まず改修時間はさほど変わらない。
変更リスクもどちらにしろテストする場所なので変わらないし
行数が少ないほうが影響範囲が小さいってこともない

リファクタリングでバグ入れそうなコードは
リファクタリングしなかったらもっとバグを入れやすい

そして、レビューやバグがあったときの読み返し時間の削減
修正内容に自信が持てる。今後の修正の時の改修時間の減少
0138仕様書無しさん
垢版 |
2018/04/19(木) 00:24:02.42
>>137
いや全然わからない
普通に改修する場合と比べて何がいいの？
0139仕様書無しさん
垢版 |
2018/04/19(木) 00:25:04.88
1行の修正でこんなにお金がかかるんですか！
っていう顧客の声がまんまリファクタリングしない場合にあてはまるな

1行の修正だからリスクが少ないとお考えか！？

1行の修正でもお金がかかるってことは、1行だからって
なにかを減らせるわけじゃないんですよ。
0140仕様書無しさん
垢版 |
2018/04/19(木) 00:28:14.81
>>138
そこで普通に改修っていうのは
リファクタリングをしないってこと

リファクタリングが「理解や修正が簡単になるように、内部構造を改善すること」
なのだからリファクタリングしないってこうのは
理解や修正が簡単になるように改善をしないってこと

元からすでに改善済みのものをリファクタリングしろとは言ってない
理解や修正が難しいコードであることは大前提


で「普通に改修」というのは改善なしに複雑なまま修正ということになるのだから
>>137で言ったようなメリットが有る

複雑なものをそのままにして手を入れたら
もっと複雑になるよ。
0141仕様書無しさん
垢版 |
2018/04/19(木) 00:34:51.32
複雑なコードは壊すのがこわいからリファクタできない
簡単なコードは意味がないからリファクタできない
0142仕様書無しさん
垢版 |
2018/04/19(木) 00:37:19.05
>>141
重要なのは手遅れになる前にこまめにやることだよね

大規模リファクタリングなんてのはあってはだめ
リファクタリングだけのための作業なんて持っての他

そうやって手遅れにするから、リファクタリングのための
工数なんて取れるかーみたいな話になる

リファクタリングは、機能追加や変更に伴う作業に
含まれているべきものですよ
0143仕様書無しさん
垢版 |
2018/04/19(木) 02:08:38.73
>>142
今どきリファクタリングするのは機能追加や変更のタイミングに限らないよ
DDDやってる？機能の変更がなくても、業務にモデルを合わせるために日々リファクタリングするのが常識
0144仕様書無しさん
垢版 |
2018/04/19(木) 02:28:05.80
こんな事が書いてあるのかｗ

http://hideoku.hatenablog.jp/entry/2013/03/07/223727

変更を完全に正当化できるまで待つのは、待ちすぎというものである。
プロジェクトはすでに重いコストを負っていて、先延ばしにすると変更するのがより
困難になる。対象となるコードには今より手が入り、さらに多くの他のコードに組み込まれることになるからだ。

継続的なリファクタリングは「ベストプラクティス」と考えられるようになってきたが、
ほとんどのプロジェクトチームは依然として慎重すぎる。コードを変更するリスクと、変更にかかる開発者の時間のコストを見込んでいるためだ。

しかし、それほど簡単に見抜けないのが、設計をぎこちないままにしておくリスクと、
その設計を何とかするためのコストである。

リファクタリングを行いたい開発者は、その決定が正統なものであると証明するよう求められることが多い。
こうした要求は理にかなっているように見えるが、もともと難しいものを不可能なほど難しくして、
リファクタリングを抑制する（または見えない所で行わせる）傾向がある。

ソフトウェア開発は、変更することで得られる利益や変更しないことで生じるコストを
正確に割り出せるような、予測可能なプロセスではない。
0145仕様書無しさん
垢版 |
2018/04/19(木) 07:16:17.90
リファクタリングがだめなのではなく
おまえらがやるからだめなのだ
0146仕様書無しさん
垢版 |
2018/04/19(木) 07:34:45.44
>>144
駄目コード（ウィルスみたいなもん）をばら撒いてから治療なんて無理だからねえ。
0147仕様書無しさん
垢版 |
2018/04/19(木) 08:13:02.34
結局は客がデグレを笑って許してくれるかどうかな気がしてきた
0148仕様書無しさん
垢版 |
2018/04/19(木) 09:20:08.21
でかくてモノリシックなシステムを複数のマイクロサービスにリファクタリングしたけど、
デグレなんて起きなかったな
0149仕様書無しさん
垢版 |
2018/04/19(木) 09:40:04.23
>>147
だからデグレは複雑なコードのまま変更するほうが
リスク高いんですってばw
0150仕様書無しさん
垢版 |
2018/04/19(木) 09:44:31.35
>>149
リファクタリングは処理の内容を変えないで
コードをわかりやすく再配置するだけだから
デグレのリクスはすごく低いんだよね

>>145
リファクタリングがだめなのではなく
闇雲に修正するのがだめなのだ
0151仕様書無しさん
垢版 |
2018/04/19(木) 10:41:14.32
>>150
> リファクタリングは処理の内容を変えないで
> コードをわかりやすく再配置するだけだから

外側は変えないけど内容は変えますよ
なに言ってるんですか
0152KAC
垢版 |
2018/04/19(木) 15:09:42.31
>>149
難解なコードを読み解いて修正前に正しく把握するのは難しいという主張？
0153仕様書無しさん
垢版 |
2018/04/19(木) 16:40:47.18
リファクタ厨はその時々でリファクタリングの定義を変えるので話にならない
正反対のことを平気でメリットとして主張してくる
0154仕様書無しさん
垢版 |
2018/04/19(木) 20:32:34.99
>>144
わからないことや見えないことを逆に肯定理由にする
宗教家と同じ手口だな！
0155仕様書無しさん
垢版 |
2018/04/19(木) 21:36:48.00
ある程度経過したコードは捨てろ。
リファクタなんぞせず。

さらにある程度経過したシステムは捨てろ。
リファクタなんぞせず。
0156仕様書無しさん
垢版 |
2018/04/19(木) 21:39:51.72
>>151
実装は変えるけど、処理の内容は変えませんよｗ
処理の内容っていうのは、1から1000までの数を足すとかいうことです。

forループを使うとか、計算式を使うっていうのは
実装であって処理の内容じゃありません
0157仕様書無しさん
垢版 |
2018/04/19(木) 21:40:23.43
>>152
> 難解なコードを読み解いて修正前に正しく把握するのは難しいという主張？

違う。時間がかかるという主張
0158仕様書無しさん
垢版 |
2018/04/19(木) 21:45:12.79
コーダーの時間が現実のリスクとのトレードオフに値するだろうか？
0159KAC
垢版 |
2018/04/19(木) 21:49:39.33
>>157
解読せずにリファクタリングすると酷いことになるだけだぞ？
0160仕様書無しさん
垢版 |
2018/04/19(木) 21:52:17.10
>>156
どのように実装するかというのが処理の内容だから
リファクタリングで変更しないのは外部仕様な
内側は変えていいんですよ
0161仕様書無しさん
垢版 |
2018/04/19(木) 21:56:06.09
改修のためのリファクタリングって15年前ぐらいの考え方
今さら熱く語るようなトピックでもない
0162仕様書無しさん
垢版 |
2018/04/19(木) 21:57:46.81
>>159
> 解読せずにリファクタリングすると酷いことになるだけだぞ？

リファクタリングする時に解読しないなんて誰が言ったの？

そもそも解読が必要になってるのはリファクタリングしてなかったからなんだが、
まあそんなこと言ってもしょうがない。過去の話だ。

今手元にあるのは解読が必要なほど複雑なコード
リファクタリングをしないということは、複雑なコードをそのままに
さらに複雑にする行為。それをレビューしてもらったって、できるわけがない。
なにせ解読が必要なほど複雑なコードなんだから、

そして、せっかく時間を書けて解読しても、その解読をコードに反映させないなら
次回修正する時にまた時間がかかる。そして次回修正はそんなに先のことじゃないかもしれない
なぜなら複雑なコードをさらに複雑にしたのだから、デグレのリスクも高い


せっかく時間かけて解読したのだから、それをコードに反映（リファクタリング）させましょう。
読むのは時間かかるが、書くのは大して時間はかからない。
そうすれば、リファクタリングしなかった場合の時間がかかるという問題が解決できる。

何回も同じこと言ってるんだけどなｗ
0163仕様書無しさん
垢版 |
2018/04/19(木) 22:01:18.70
あと解読するときも、最初から最後まで想像して解読するよりも
簡単なところから一歩ずつやったほうがいいよ
0166仕様書無しさん
垢版 |
2018/04/19(木) 22:11:04.54
まったり普通にまともなこと言っても誰も相手してくんないし
■ このスレッドは過去ログ倉庫に格納されています
ニューススポーツなんでも実況