oh-my-oop 0.2.0

package/lessons/woowacourse-kotlin-blackjack/medAndro/143-2/353/213/250/352/263/204-/353/270/224/353/236/231/354/236/255.md

@@ -0,0 +1,678 @@
+# PR #143 — [블랙잭 2단계] 메다 미션
+
+- **Reviewee:** [@medAndro](https://github.com/medAndro)
+- **PR:** https://github.com/woowacourse/kotlin-blackjack/pull/143
+- **단계:** 2단계
+- **리뷰어:** [@hyemdooly](https://github.com/hyemdooly) (둘리) — 1단계 #130 동일 reviewer (학생 → reviewer 진화 2번째 사례)
+- **라인 코멘트:** 19 스레드 — *PR 본문 자가 의문 + 페어 학습 인용 + 슬랙 페토 글 인용 + `-0.0` Float IEEE 754 함정 자가 학습 (PR #131 결 재발견) + 3 인스턴스 변수 제약 학생 자가 비판 + *원래 그리던 꿈을 펼쳐볼까* 어휘 + custom get vs function 학생 자가 4 분류 + HandCards 승패 판단 + BetAmount.profit + Dealer 합산 (책임 분리) + ProfitRate enum + Profit value class*
+- **양 단계 완성 reviewee** (1단계 #130 batch 20 분석 완료 + 2단계 #143 = batch 21 추가).
+
+## 잘한 점 (설계 관점)
+
+### 1. PR 본문 자가 의문 + 페어 학습 + 슬랙 페토 글 인용
+
+PR 본문:
+
+> *"step1 피드백 반영할 수 있는 부분은 반영하고 step1 코멘트에 남긴 의문점들도 아직 남아있어서 반영되지 않은 부분도 있는데 답글 달아주시는대로 공부하며 리팩터링 해봐야겠습니다.*
+>
+> *Step2를 일단 기능을 빠르게 구현 완료하긴 했는데 의식의 흐름대로 짜서 이게 맞나 싶기도 한 코드가 된 것 같네요*
+>
+> *`3개 이상의 인스턴스 변수를 가진 클래스를 쓰지 않는다.`를 지키기 위해서 BetHistory를 따로 두었으며*
+> *`ProfitStatistics`에서 일단 getter를 써서 구현해 보았는데 언제 함수를 쓰고 언제 getter를 쓰는지는 슬랙의 페토의 글을 보고 주말에 공부좀 해봐야 될 것 같습니다.*
+>
+> *오늘 직접 방문해주셔서 이야기 나눌수 있어서 좋았어요 :)"*
+
+→ **학생 자가 학습 정점**:
+- *step1 의문점 미해결 자가 인정* — *학습 시간성*.
+- *의식의 흐름 코드 자가 인정* — *학습 한계 인정* (PR #139 *진흙탕 코드* 결).
+- *3 인스턴스 변수 제약 명시* — *형식 규칙 인지*.
+- *슬랙 페토 글 인용* — *외부 자료 자가 학습*.
+- *직접 방문 reviewer 만남* — *오프라인 페어 학습*.
+
+**MCP `oh-my-oop` *학습 = 시간 두고 반복* 어휘 정점**. PR #130 학생 자가 한계 4 종 인정 → PR #143 자가 한계 + 외부 자료 + 오프라인 만남 (4 자리). 누적 5+ PR 학생 자가 한계 인정.
+
+### 2. `BetAmount` (value class + invariant) + `Profit` (value class + Double) + `ProfitRate` (enum + calculate) — 책임 분리
+
+```kotlin
+@JvmInline value class BetAmount(val value: Int) {
+    init { require(value > MINIMUM_BET_AMOUNT) { ... } }
+    fun calculateProfit(profitRate: ProfitRate): Profit = Profit(profitRate.value * value)
+}
+
+@JvmInline value class Profit(val value: Double)
+
+enum class ProfitRate(val value: Double) {
+    BLACKJACK_WIN(1.5), NORMAL_WIN(1.0), DRAW(0.0), LOSE(-1.0);
+
+    companion object {
+        fun calculateProfitRate(winLoss: WinLoss, cardStatus: CardStatus): ProfitRate = when (winLoss) {
+            WinLoss.WIN -> if (cardStatus == CardStatus.BLACKJACK) BLACKJACK_WIN else NORMAL_WIN
+            WinLoss.LOSE -> LOSE
+            WinLoss.DRAW -> DRAW
+        }
+    }
+}
+```
+
+→ **3 객체 분리 + 각각 책임 명확**:
+- `BetAmount`: *invariant + Profit 계산*.
+- `Profit`: *value class + Double*.
+- `ProfitRate`: *enum + 결과/상태 조합 → rate*.
+
+reviewer (Thread 8) *"이런 1.5배, 1배 이런 것들도 어떤 한 클래스에 묶어 관리될 수 있을 것 같아요."* → 학생 자가 적용.
+
+#### 2.1. *PR #130·#35·#36·#87·#138 결의 *enum + cashOut* 어휘 합류*
+
+PR #142 (doabletuple) `GameResult.cashOut(player)` 와 *반대 시점 (`ProfitRate.value * betAmount` 직접 계산)* — *enum 책임 강화 정공*.
+
+### 3. `WinLoss` + `ProfitRate` 분리 — 결과 vs 수익률 분리
+
+```kotlin
+enum class WinLoss { WIN, DRAW, LOSE }
+
+enum class ProfitRate(val value: Double) { BLACKJACK_WIN, NORMAL_WIN, DRAW, LOSE }
+```
+
+→ **2 enum 분리** — *결과 (WIN/DRAW/LOSE 3 종) + 수익률 (4 종: 블랙잭 분기 포함)*. PR #142 (`GameResult` 5 멤버 단일) 와 *반대 시점 (분리)*.
+
+#### 3.1. *2 가지 트레이드오프*
+
+| 안 | 장점 | 단점 |
+|---|---|---|
+| `WinLoss` + `ProfitRate` 분리 (현재) | *결과 분류 + 수익률 분리 = 책임 명확* | *2 enum + calculateProfitRate 매핑 함수 필요* |
+| `GameResult` 5 멤버 단일 (PR #142) | *단일 객체 + 호출 간결* | *결과 + 수익률 한 자리 책임 ↑* |
+
+**MCP 룰 `result-vs-rate-enum-separation` 후보** — *결과 vs 수익률 분리 트레이드오프*.
+
+### 4. `data class GameParticipants(dealer, players)` + `profitInfos` computed property
+
+```kotlin
+data class GameParticipants(val dealer: Dealer, val players: List<Player>) {
+    val gameParticipants: List<GameParticipant> get() = listOf(dealer) + players
+
+    val profitInfos: List<ProfitInfo>
+        get() {
+            val dealerProfitInfo = ProfitInfo(dealer.name, dealer.allPlayersMatchProfit(players))
+            val playersProfitInfos = players.map { player -> ProfitInfo(player.name, player.dealerMatchProfit(dealer)) }
+            return listOf(dealerProfitInfo) + playersProfitInfos
+        }
+}
+```
+
+→ **`GameParticipants` 일급 컬렉션 + computed property** = PR #142 (Game 분리) 결의 *Scoreboard* 객체와 유사 패턴.
+
+### 5. 학생 자가 *원래 그리던 꿈을 펼쳐볼까* (Thread 15) — 형식 규칙 자가 비판
+
+reviewer (Thread 15): *"`participantInfo`의 존재 이유가 무엇일까요? 딜러는 `betAmount`가 필요없지 않을까요? 🤔"*
+
+학생:
+
+> *"대단한 이유는 없고 `3개 이상의 인스턴스 변수를 가진 클래스를 쓰지 않는다.`를 지키기 위해서 사용되었습니다. 둘리 외에 어떤 공룡 리뷰어가 `요구사항을 지켜야 하지만 좋은 설계라고 생각하면 가끔은 깨부셔도..?` 라며 원래 그리던 꿈을 펼쳐보라는 리뷰를 다시는 것을 보았는데 저도 원래 그리던 꿈을 펼쳐볼까 합니다."*
+
+→ **형식 규칙 자가 비판 + 다른 reviewer 어휘 인용 ("원래 그리던 꿈을 펼쳐보라")** = *PR #138 (rosemin928 *"인스턴스 변수 유지라는 요구사항에 맞추기 위해 묶지 않아도 될 것을 계속 묶고 있나?"*) 결의 *형식 규칙 부산물 자가 비판* 어휘 강화 + *다른 reviewer 어휘 cross-reference*.
+
+**MCP 룰 `form-rule-artificial-grouping-self-critique` 강화** 누적 2+ PR (#138·#143).
+
+**MCP 룰 `peer-reviewer-cross-reference` 후보** — *학생이 다른 reviewer 어휘 인용 + 자가 적용*.
+
+### 6. `-0.0f` Float IEEE 754 함정 학생 자가 학습 + 조사
+
+reviewer (Thread 5): *"-0 방지가 어떤 뜻인가요? 0.0f 더해주신 이유가 궁금해요!"*
+
+학생 자가 답변:
+
+> *"현재 딜러의 수익은 `플레이어의 수익의 합의 역`으로 계산하고 있어서 -를 붙이기 때문에 `플레이어의 수익의 합`이 0일 경우 0에 -를 붙여 -0으로 표시되는 문제가 발생하는걸 확인하였고 원인을 조사하다가 코틀린에서 float는 `-0.0f`와 `0.0f`를 구분한다는 것을 알게 되었습니다. 조건문을 걸어서 해결하는 방법도 있지만 `0.0f`를 더하는게 가장 간편한 해결책인것 같아서 추가하게 되었습니다."*
+
+```kotlin
+fun allPlayersMatchProfit(players: Collection<Player>): Profit {
+    val playersProfitSum = players.sumOf { player -> player.dealerMatchProfit(this).value }
+    return Profit(-playersProfitSum + 0.0)  // ← -0.0 방지
+}
+```
+
+→ **`-0.0` IEEE 754 함정 자가 학습 + 조사 + 해결책** = PR #131 (Leeyerin0210 *Double IEEE 754 함정 우회*) 결의 *학생 자가 재발견*. **MCP 룰 `negative-zero-floating-point-trap` 강화** 누적 2+ PR (#131·#143).
+
+#### 6.1. *학생 자가 학습 깊이*
+
+- 문제 인식 (`-0` 표시).
+- 원인 조사 (`-0.0f` vs `0.0f` 구분).
+- 해결책 비교 (조건문 vs `+ 0.0` 더하기).
+- 자가 선택 (간편한 해결책).
+
+**Kotlin/Java 어휘 깊은 자가 학습**.
+
+### 7. `dealerMatchProfit(dealer)` Tell-Don't-Ask + Player ↔ Dealer 자가 비교
+
+```kotlin
+fun dealerMatchProfit(dealer: Dealer): Profit {
+    val profitRate = ProfitRate.calculateProfitRate(this.winLoss(dealer), this.cardStatus)
+    return betAmount.calculateProfit(profitRate)
+}
+```
+
+→ **Player 가 dealer 와 자가 비교 + Profit 자가 계산 + Tell-Don't-Ask 정공** = PR #129·#138·#142·#126 결 합류.
+
+### 8. custom get vs function 학생 자가 4 분류
+
+reviewer (Thread 16):
+
+> *"커스텀 get() 프로퍼티로 구현하는 경우와 함수로 구현하는 경우는 어떻게 구분하면 좋을지 메다의 생각이 궁금해요!"*
+
+학생 자가 답변:
+
+> *"커스텀 get() 프로퍼티*
+> *- 클라이언트가 해당 값을 객체의 속성처럼 생각할 것 같을 경우*
+> *- 단순한 객체의 상태를 받아 올 경우*
+>
+> *함수*
+> *- 값을 가져오기 위해 파라미터가 필요한 경우*
+> *- 값을 가져오는것이 아닌 객체를 변화시키는 조정자로 쓰일 경우*
+>
+> *로 정리했습니다. 이 기준에 따라서 다른 코드들도 수정해봐야 할 것 같네요"*
+
+→ **Kotlin 어휘 자가 4 분류** = PR #117 (parkjiminnnn *property val vs computed property*) 결 + PR #138 (rosemin928 *value class @JvmInline*) 결의 *Kotlin 어휘 자가 학습 정점*.
+
+**MCP 룰 `property-vs-function-criteria` 후보** — *property (속성/상태) vs function (파라미터/조정자) 구분 기준 4 분류*.
+
+### 9. 추가 칭찬
+
+- Thread 12: *"이제 한번에 세팅해줄 수 있겠어요 👍"* (HandCards 부생성자 vararg).
+- Thread 16: *"Participant의 initCards 오버라이딩을 활용하여 다르게 보여주도록 구현했네요 👍"*.
+- 모든 19 스레드 학생 자가 답변 + commit SHA (일부 미적용 = 답변만).
+
+## 못한 점 (설계 관점)
+
+### 1. Deck 컨트롤러 외부 주입 vs 내부 생성
+
+reviewer (Thread 1): *"Deck을 컨트롤러 밖에서 생성해서 주입해준 이유가 있으신가요?"*
+
+학생 자가 답변:
+
+> *"덱을 만들어서 주입하면 더 유연하게 운영 가능하지 않을까 생각했습니다. 현재와 같이 생성자를 생략하면 52장의 랜덤 카드가 카지노에게 주어지고 경우에 따라서는 2벌의 카드를 섞어서 사용하거나 섞지 않고 줄 수도 있으니까요"*
+
+reviewer:
+
+> *"오호 그렇군요! 저는 덱 생성을 컨트롤러 안에서 해도 되지 않을까?라고 생각했어요!🤔"*
+
+→ **DI vs 내부 생성 트레이드오프**:
+
+| 안 | 장점 | 단점 |
+|---|---|---|
+| 외부 주입 (학생) | *유연성 (다른 Deck 가능) + 테스트* | *호출자가 Deck 어휘 알아야 함* |
+| 내부 생성 (reviewer) | *호출자 간결* | *유연성 ↓ + 테스트 어려움* |
+
+PR #138 (rosemin928 *Deck interface + DI*) 결의 *외부 주입 정공* 어휘 합류. **MCP 룰 `dependency-injection-vs-internal-creation` 후보**.
+
+다만 *reviewer 와 학생 의견 차이 = MCP `oop_propose_alternatives` 핵심 가치 합류*.
+
+### 2. `player.addCard(card)` Player 메서드 vs `deck.draw` 직접 (1단계 결 진화)
+
+reviewer (Thread 2): *"player에게 카드를 추가하라고 하는 것은 어떨까요?"*
+
+학생 자가 답변:
+
+> *"step1 PR에서 적은 궁금증에 관한 내용인 것 같습니다. (...) 와 같이 굳이? handCard에 메서드를 감싸는 쓸데없는 코드만 늘어나는것 아닌가 라는 생각으로 의도적으로 player에게 카드를 추가하라는 메서드는 만들지 않았습니다. (...) 현재 제가 생각한 대안으로*
+> ```kt
+> fun cardDraw(deck: Deck) {
+>     handCards.addCard(deck.getCard())
+> }
+> ```
+> *와 같이 deck을 player가 참조하게 해서 player객체에게 드로우 하라는 메시지를 보내는 방식이 괜찮을 것 같다고 생각했습니다."*
+
+학생 코드 (실제 적용):
+
+```kotlin
+fun fromDeckCardDraw(deck: Deck) {
+    handCards.cardAdd(deck.popCard())
+}
+```
+
+→ **Player.fromDeckCardDraw(deck)** = *Tell-Don't-Ask + 도메인 메시지* + *위임 메서드 (handCards.cardAdd) 추가 책임 X* = *학생 1단계 자가 의문 (위임 메서드 = 쓸데없는 코드) 자가 해결*.
+
+다만 **`fromDeckCardDraw` 명명 양가** — *영어 어순 어색 (`drawFromDeck` 정공)*. **MCP 룰 `english-word-order-naming` 후보**. PR #87 (Aginst), PR #130 (bulidPlayers) 결 합류.
+
+### 3. 카드 이니셜 = 비즈니스 vs View 학생 자가 의문
+
+reviewer (Thread 9): *"`intial`은 비즈니스 로직일까요, 뷰를 위한 로직일까요?"*
+
+학생 자가 답변:
+
+> *"현재로서는 View만을 위해 기능하고 있고 View를 위한게 맞는 것 같습니다. 다만 카드 이니셜은 고정된 값이고 앞으로도 변할 일이 없는 단순히 표시 목적을 넘어 카드의 본질적인 특성이라고 생각해서 가지고 있는 편이 좋을 것 같다고 생각했습니다. 가령 이니셜 스트링을 사용해서 Enum 객체를 가져올 수 있도록 만든다면 편리하겠네요"*
+
+→ **카드 이니셜 = 표시 vs 본질 양가** = *PR #126 (Verdict 출력 문자열) vs PR #142 (에러 메시지 = Model OK)* 결의 *변경 가능성 = View 책임 vs 도메인 본질 = Model OK* 트레이드오프 합류.
+
+**MCP 룰 `view-format-as-domain-invariant-tradeoff` 후보** — *표시 형식 vs 도메인 본질 트레이드오프*.
+
+### 4. `participantInfo` 인공 객체 자가 인지 — 형식 규칙 부산물
+
+§5 참조. 학생 자가 비판 + *원래 그리던 꿈을 펼쳐볼까* 어휘.
+
+다만 **`participantInfo` 가 *실제 코드에는 없음*** = *PR 본문에 *BetHistory* 언급 → 2단계 최종 코드는 `BetAmount` (Player 멤버)* — *형식 규칙 자가 비판 후 자가 제거 정공*. PR #138 (BlackJackTable 자가 제거) 결과 같은 패턴.
+
+### 5. `Player(name, betAmount)` 2 변수 vs Dealer 1 변수 — Dealer 가 BetAmount 없음
+
+```kotlin
+class Player(name: String = DEFAULT_NAME, private val betAmount: BetAmount) : GameParticipant(name = name)
+class Dealer(name: String = DEFAULT_NAME) : GameParticipant(name = name)
+```
+
+→ **Player ↔ Dealer 비대칭 (Dealer 는 BetAmount X)** = PR #87 (jaeyeongjo `DealerInfo.getBetAmount() = 0` Dummy zero) 결의 *반대 시점 (Dealer 가 BetAmount 멤버 자체 없음)* 정공.
+
+reviewer (Thread 19): *"`BetAmount`의 기본값이 왜 1이 되었을까요? 😢 딜러 때문이라면 딜러는 `BetAmount`를 안가져도 될 것 같아요!"*
+
+→ **reviewer 가 *Dealer 가 BetAmount 가져야 하는지* 추궁** = *학생의 1차 안 (BetAmount 기본값 1) → 2차 안 (Dealer 가 BetAmount 안 가짐)*.
+
+**MCP 룰 `dummy-zero-for-domain-absent` 강화** 누적 2+ PR (#87·#143). *Dealer 가 BetAmount 가짐 vs 안 가짐 양가 = 학생 자가 학습 진화*.
+
+### 6. `GameParticipant` `protected val handCards: HandCards = HandCards()` — 매 인스턴스 신규 생성 + 초기 카드 X
+
+```kotlin
+abstract class GameParticipant(val name: String) {
+    abstract val initCards: List<Card>
+    abstract val isDrawFinish: Boolean
+    protected val handCards: HandCards = HandCards()  // ← 매 인스턴스 신규 생성, 카드 X
+    ...
+    fun fromDeckCardDraw(deck: Deck) {
+        handCards.cardAdd(deck.popCard())
+    }
+}
+```
+
+→ **HandCards 초기 비어 있음 + 외부에서 cardAdd 호출** = *호출 순서 invariant 부재* (PR #142 lateinit, PR #139 var betAmount 결).
+
+대안: 
+- `GameParticipant(cards: List<Card>)` 생성자 인자 (초기 카드 보유).
+- `Player(name, cards, betAmount)` (3 변수 — 형식 규칙 위반? 도메인 정합).
+
+학생의 부생성자 `Player(betAmount, cards)` 활용 시 초기 카드 보유. *호출자 책임*.
+
+### 7. `ProfitRate.calculateProfitRate(winLoss, cardStatus)` companion 정적
+
+```kotlin
+companion object {
+    fun calculateProfitRate(winLoss: WinLoss, cardStatus: CardStatus): ProfitRate = when (winLoss) {
+        WinLoss.WIN -> if (cardStatus == CardStatus.BLACKJACK) BLACKJACK_WIN else NORMAL_WIN
+        WinLoss.LOSE -> LOSE
+        WinLoss.DRAW -> DRAW
+    }
+}
+```
+
+→ **enum companion 정적 메서드 + 외부 인자 2개 (winLoss, cardStatus)** = *Tell-Don't-Ask 부분 위반*. *Player 가 `ProfitRate.calculateProfitRate(this.winLoss(dealer), this.cardStatus)` 호출* = *외부 호출 + enum 정적*.
+
+대안: **`WinLoss.toProfitRate(cardStatus: CardStatus): ProfitRate`** (WinLoss enum 에 메서드) — *enum 책임 강화*.
+
+**MCP 룰 `enum-static-vs-instance-method-locator` 후보**.
+
+### 8. `BetAmount.MINIMUM_BET_AMOUNT = 0` (이전 1) — 학생 자가 학습 시점
+
+```kotlin
+private const val MINIMUM_BET_AMOUNT = 0
+```
+
+→ **`MINIMUM_BET_AMOUNT = 0` + `require(value > 0)`** = *베팅 ≥ 1원*. PR #138 (1000원), PR #142 (0원 가능) 결과 다른 값.
+
+**MCP 룰 `domain-rule-arbitrary-constant` 강화** 누적 4+ PR.
+
+### 9. `Player.initCards: List<Card> get() = cards.subList(0, 2)` — sublist 직접 노출
+
+```kotlin
+override val initCards: List<Card> get() = cards.subList(0, 2)
+```
+
+→ **`subList` 외부 노출 + `cards.subList(0, 2)` 직접 indexing** = *Tell-Don't-Ask 위반 (`cards` 외부 호출 + subList)*. *HandCards 가 자가 처리 (예: `handCards.firstN(2)`) 가 정공*.
+
+대안: `HandCards.initCardsOf(count: Int): List<Card>` (PR #138 `Hand.show(count)` 결).
+
+### 10. `Dealer.allPlayersMatchProfit(players: Collection<Player>)` — 외부 players 인자
+
+```kotlin
+fun allPlayersMatchProfit(players: Collection<Player>): Profit {
+    val playersProfitSum = players.sumOf { player -> player.dealerMatchProfit(this).value }
+    return Profit(-playersProfitSum + 0.0)
+}
+```
+
+→ **Dealer 가 외부 players 인자 받음 + Dealer 자체는 players 멤버 X** = *PR #142 (Scoreboard.dealerProfit(players) 외부 인자 vs 멤버) 결과 같은 *redundant-parameter-vs-member* 가 아닌 *외부 의존 명시 정공* 변형*. 
+
+**MCP 룰 `external-collection-as-method-arg-vs-member` 후보** — *외부 컬렉션 인자 = 의존 명시 vs 멤버 보유*.
+
+### 11. `GameParticipants.profitInfos: List<ProfitInfo> get() = ...` — computed property + 매 호출 시 재계산
+
+```kotlin
+val profitInfos: List<ProfitInfo>
+    get() {
+        val dealerProfitInfo = ProfitInfo(dealer.name, dealer.allPlayersMatchProfit(players))
+        val playersProfitInfos = players.map { ... }
+        return listOf(dealerProfitInfo) + playersProfitInfos
+    }
+```
+
+→ **`get()` 매 호출 시 재계산** = *비용 ↑* (PR #117·#143 결의 *property val vs computed property* 트레이드오프).
+
+대안: `val profitInfos = ...` (즉시 초기화) — *결과 1회 계산*. 다만 *players 변경 시 = stale*. **MCP 룰 `computed-property-vs-val-recompute-cost` 후보**.
+
+### 12. `GameParticipant.winLoss(rival)` `protected` — Player 만 호출
+
+```kotlin
+protected fun winLoss(rival: GameParticipant): WinLoss = handCards.versusRivalWinLoss(rival.cardStatus, rival.bestValue)
+```
+
+→ **`protected` 가시성** = *자식 (Player/Dealer) 만 호출* + *외부 차단*. PR #87·#117 결의 *protected 가시성 정공*.
+
+### 13. `HandCards.cardAdd(card)` 명명 양가 — `addCard` 가 정공
+
+```kotlin
+fun cardAdd(card: Card) { ... }
+```
+
+→ **`cardAdd` 영어 어순 어색** (`addCard` 정공). PR #87·#130 결의 *영문 명명 정확성*. **MCP 룰 `english-word-order-naming` 강화** 누적 2+ PR.
+
+### 14. `MutableList` 직접 사용 + 방어적 복사 자가 학습
+
+reviewer (Thread 12):
+
+> *"이제 한번에 세팅해줄 수 있겠어요 👍 다만 이렇게 MutableList로 받아서 바로 내부에서 사용한다면 어떤 문제가 있을까요?"*
+
+학생 자가 답변:
+
+> *"외부에서 참조를 가지고 있을 경우 HandCard 외부에서 내부의 값을 조작할 수 있겠네요. 방어적 복사를 적용 해보도록 하겠습니다."*
+
+→ **MutableList 외부 참조 위험 자가 인지 + 방어적 복사 자가 학습** = PR #21·#117·#138 (mutable-list-public-exposure) 결 합류.
+
+### 15. PlayerTest 사라짐 (Deck object 제거 부작용)
+
+reviewer (Thread 4):
+
+> *"PlayerTest가 사라졌군요 😢 이김에 participant 패키지에 있는 모델들 테스트 작성도 하면 좋을 것 같아요!"*
+
+학생:
+
+> *"Deck이 Object가 아니게 되면서 사라졌는데 말씀 주신대로 participant 패키지의 테스트들을 추가해야겠네요..."*
+
+→ **테스트 회귀 = Deck object 제거 부작용** + **테스트 추가 권유**. PR #87 (테스트 = 객체 설계 명세서) 결 + PR #130 (Singleton Deck 테스트 어려움) 결 합류.
+
+**MCP 룰 `test-regression-from-deck-refactor` 후보** — *Deck 리팩터링 = 테스트 영향*.
+
+### 16. `getFirstCard()` → `openInitialHand` 추상 메서드 자가 학습
+
+reviewer (Thread 11):
+
+> *"이쯤에서 한번 고민해보면 좋을 것 같아요. 딜러가 첫 턴에 카드를 두 장 뽑고나서 한 장만 보여주는 것은 비즈니스 로직일까요, 뷰의 로직일까요?"*
+
+학생:
+
+> *"비즈니스 로직이라고 생각해서 딜러 클래스에 getFirstCard()를 만들고 호출시켰는데 리뷰를 읽고 생각해보니 초기 카드를 가져오는 추상 메서드를 GameParticipant에 만들고 딜러와 플레이어 클래스에서 각각 구체화 시키는게 좋을 것 같네요"*
+
+학생 자가 적용 (실제 코드):
+```kotlin
+// Participant
+abstract val initCards: List<Card>
+
+// Player
+override val initCards: List<Card> get() = cards.subList(0, 2)
+
+// Dealer
+override val initCards: List<Card> get() = cards.subList(0, 1)
+```
+
+→ **카드 N장 공개 = 비즈니스 로직 + 추상 메서드 다형성** = PR #129·#126·#142 결 합류.
+
+### 17. `dealerMatchProfit(dealer: Dealer)` Player 만 호출 + 결과 부호 반전 — `Dealer.allPlayersMatchProfit` 호출
+
+```kotlin
+fun allPlayersMatchProfit(players: Collection<Player>): Profit {
+    val playersProfitSum = players.sumOf { player -> player.dealerMatchProfit(this).value }
+    return Profit(-playersProfitSum + 0.0)
+}
+```
+
+→ **Dealer 자가 결과 = -Players 합** = PR #36 (`operator fun not()`), PR #35 (`* -1`), PR #142 (`Scoreboard.dealerProfit`) 결 합류. **부호 반전 정공**.
+
+### 18. `winLoss` 메서드 Player 호출 / Dealer 미사용 — 비대칭
+
+```kotlin
+// GameParticipant
+protected fun winLoss(rival: GameParticipant): WinLoss = handCards.versusRivalWinLoss(...)
+
+// Player.dealerMatchProfit
+val profitRate = ProfitRate.calculateProfitRate(this.winLoss(dealer), this.cardStatus)
+```
+
+→ **Player.winLoss(dealer) 호출만** + **Dealer.allPlayersMatchProfit = Players 합 부호 반전** = *Dealer 자가 winLoss 호출 X*. **비대칭** = *학생의 *플레이어 결과 = 딜러 결과 부호 반전* 의도 일관*.
+
+다만 **PR #142 (양쪽 자가 비교 정공 = `compareAgainst`) 와 반대 시점 (Player 만 자가 비교)** = *Tell-Don't-Ask 부분 위반*.
+
+PR #87·#129·#142 결의 *대칭 자가 비교 정공* vs PR #143 (비대칭 = 부호 반전) 트레이드오프.
+
+**MCP 룰 `symmetric-compare-bidirectional-call` 강화** 누적 2+ PR (#142·#143). *반대 시점 트레이드오프*.
+
+### 19. `Profit(-playersProfitSum + 0.0)` `+ 0.0` 더하기 — `-0.0` 회피
+
+§6 참조.
+
+### 20. `versusRivalWinLoss(rival.cardStatus, rival.bestValue)` HandCards 메서드 — 외부 cardStatus + bestValue 인자
+
+```kotlin
+// GameParticipant
+protected fun winLoss(rival: GameParticipant): WinLoss = handCards.versusRivalWinLoss(rival.cardStatus, rival.bestValue)
+```
+
+→ **HandCards 가 *rival.cardStatus + rival.bestValue* 2 외부 인자 받음** = *PR #142 (lambda-multiple-args-tuple-leak) 결과 같은 *Tuple 누수 변형***. 
+
+대안: **`handCards.versusRivalWinLoss(rival.handCards)`** 또는 **`HandCards.compareAgainst(other: HandCards)`** — *HandCards ↔ HandCards 직접 비교*. **MCP 룰 `parameter-explosion-vs-object-passing` 후보**.
+
+### 21. 학생 자가 *isDrawFinish 활용* 의식
+
+reviewer (Thread 13): *"Player의 `isDrawFinish()` 를 활용해볼 수 있을까요?"*
+
+학생:
+
+> *"스스로 만들어놓고 정작 까먹고 안쓰는게 많은 것 같네요... 고치도록 노력해봐야겠습니다."*
+
+→ **자가 추상화 활용 부족 자가 인지** = *추상화 활용 점검 어휘 (PR #129·#138·#142)* 합류.
+
+### 22. `Player.isDrawFinish = this.cardStatus == CardStatus.BUST` — 21 시 hit 가능
+
+```kotlin
+override val isDrawFinish: Boolean
+    get() = this.cardStatus == CardStatus.BUST
+```
+
+→ **Player BUST 시 종료 = 21 시 hit 가능 (`<=` 21)**. PR #129·#138·#139·#126 결과 동일. PR #35 (21 시 stop) 반대 시점.
+
+### 23. `Dealer.DEALER_DRAW_LIMIT = 16` + `<= 16` 정공
+
+```kotlin
+override val isDrawFinish: Boolean
+    get() = handCards.bestCardValue <= DEALER_DRAW_LIMIT
+```
+
+→ **Dealer 16 시 stop 시점 = `<= 16`** = **블랙잭 룰 와전 가능 (PR #129 와 같음)**:
+
+- *블랙잭 표준 = Dealer 16 이하 hit / 17 이상 stop*.
+- *학생 코드 `<= 16 → isDrawFinish = true (종료)`* = *16 시 hit X = 와전*.
+
+대안: *`< 17` (PR #35 정공)* 또는 *`> 16` (16 시 hit, 17 시 stop)*.
+
+**MCP 룰 `blackjack-rule-fidelity-comparison` 강화** 누적 17+ PR ⭐⭐⭐. *학생 자가 룰 와전 = 17 미만 hit vs 17 이상 stop 양가성*.
+
+PR #126 (`HIT_THRESHOLD = 16` + `<= 16` hit), PR #138 (`DEALER_MAX_SCORE = 16` + `<= 16` hit) 의 *정공* 반대 시점.
+
+### 24. `cardSize: Int` private 멤버 — 외부 노출 X
+
+```kotlin
+private val cardSize: Int get() = handCards.cards.size
+```
+
+→ **`private val cardSize` 외부 노출 X** + **`val isInitHandCard: Boolean get() = cardSize == HandCards.INIT_CARD_SIZE`** = 외부 호출자는 *isInitHandCard 만 알면 됨* = *캡슐화 정공*.
+
+reviewer (Thread 3): *"GameParticipant에 이미 만들어두었던 함수를 활용해볼 수 있을 것 같아요!"*
+
+학생: *"`participant.cardSize() < INIT_CARD_SIZE`룰 `participant.isInitHandCard()` 로 바꿀 수 있겠네요...!"*
+
+→ **자가 추상화 활용 부족 자가 인지** (§21 결).
+
+### 25. ProfitStatistics 의 로직 분리 — 모델 자가 처리
+
+reviewer (Thread 7): *"ProfitStatistics의 로직들을 분리해서, 각 모델들이 일하게끔 만들 수 있겠다는 생각이 듭니다. 한번 고민해볼까요? 🤔"*
+
+학생: *"`ProfitStatistics`를 만들면서 딜러와 플레이어가 직접 수익이 얼마인지를 알려줄 수 있으면 좋을 것 같다고 생각했는데 구현을 고민해봐야겠습니다"*
+
+→ **god-object 회피 + 모델 자가 일** = *Player.dealerMatchProfit / Dealer.allPlayersMatchProfit* 자가 적용. PR #142 (Scoreboard) 결의 *반대 시점 (Scoreboard 통합 vs Player/Dealer 분산)*.
+
+## 리뷰어 의견 요지
+
+- **Deck 컨트롤러 외부 주입 vs 내부 생성** — *DI 트레이드오프*.
+- **player.addCard vs deck.draw 직접 (1단계 자가 의문 자가 진화)**.
+- **GameParticipant 기존 함수 활용 (isInitHandCard)** — *자가 추상화 활용 부족*.
+- **PlayerTest 사라짐 + participant 테스트 추가**.
+- **`-0` 방지 + `0.0f` 더하기** — *Float IEEE 754 함정 자가 학습*.
+- **상수화 (BetAmount 최소)** — *카지노 설정*.
+- **ProfitStatistics 로직 분리 → 모델 자가 처리**.
+- **1.5/1.0 배 = 한 클래스 묶음 (ProfitRate enum)**.
+- **카드 이니셜 = 비즈니스 vs View 양가 (학생 자가 본질 어휘)**.
+- **WinLossStatistics 추상화 (모델 자가 일)**.
+- **딜러 첫 턴 한 장 = 비즈니스 vs View → 추상 메서드 정공**.
+- **MutableList 외부 참조 위험 + 방어적 복사 자가 학습**.
+- **Player.isDrawFinish 활용 부족 자가 인지**.
+- **Kotlin 클래스 순서 컨벤션**.
+- **`participantInfo` 인공 객체 → Dealer BetAmount X 권유 + 학생 자가 *원래 그리던 꿈을 펼쳐볼까***.
+- **custom get vs function 학생 자가 4 분류**.
+- **HandCards 승패 판단 + BetAmount.profit 리턴 + Dealer 합산**.
+- **BetAmount 기본값 1 vs Dealer 가 BetAmount X**.
+
+## 대표 인용
+
+> [medAndro PR 본문]
+> *"Step2를 일단 기능을 빠르게 구현 완료하긴 했는데 의식의 흐름대로 짜서 이게 맞나 싶기도 한 코드가 된 것 같네요"*
+
+→ **학생 자가 *의식의 흐름 코드* 인정** = PR #139 (parkjiminnnn *진흙탕 코드*) 결 합류.
+
+> [medAndro PR 본문]
+> *"`ProfitStatistics`에서 일단 getter를 써서 구현해 보았는데 언제 함수를 쓰고 언제 getter를 쓰는지는 슬랙의 페토의 글을 보고 주말에 공부좀 해봐야 될 것 같습니다."*
+
+→ **슬랙 외부 자료 자가 학습**. *Kotlin 어휘 자가 학습 정점*.
+
+> [medAndro Thread 5]
+> *"코틀린에서 float는 `-0.0f`와 `0.0f`를 구분한다는 것을 알게 되었습니다. 조건문을 걸어서 해결하는 방법도 있지만 `0.0f`를 더하는게 가장 간편한 해결책인것 같아서 추가하게 되었습니다."*
+
+→ **Float IEEE 754 자가 학습 + 해결책 비교** — *깊은 자가 학습*. PR #131 결 재발견.
+
+> [medAndro Thread 15]
+> *"둘리 외에 어떤 공룡 리뷰어가 `요구사항을 지켜야 하지만 좋은 설계라고 생각하면 가끔은 깨부셔도..?` 라며 원래 그리던 꿈을 펼쳐보라는 리뷰를 다시는 것을 보았는데 저도 원래 그리던 꿈을 펼쳐볼까 합니다."*
+
+→ **다른 reviewer 어휘 cross-reference + 학생 자가 형식 규칙 비판** — *PR #138 결 강화 + 새로운 cross-reference 패턴*.
+
+> [medAndro Thread 16]
+> *"커스텀 get() 프로퍼티 - 클라이언트가 해당 값을 객체의 속성처럼 생각할 것 같을 경우 - 단순한 객체의 상태를 받아 올 경우. 함수 - 값을 가져오기 위해 파라미터가 필요한 경우 - 값을 가져오는것이 아닌 객체를 변화시키는 조정자로 쓰일 경우 로 정리했습니다."*
+
+→ **Kotlin 어휘 자가 4 분류 (property vs function)** — *학생 자가 학습 정점*.
+
+> [medAndro Thread 13]
+> *"스스로 만들어놓고 정작 까먹고 안쓰는게 많은 것 같네요... 고치도록 노력해봐야겠습니다."*
+
+→ **자가 추상화 활용 부족 자가 인지 (자가 비판 어휘)**.
+
+## 얻은 교훈 (보편)
+
+1. **PR 본문 자가 *의식의 흐름 코드* 인정 + 외부 자료 + 오프라인 만남** — *학습 적극성 정점*.
+
+2. **`-0.0` Float IEEE 754 함정 자가 학습 + 해결책 비교** — **MCP 룰 `negative-zero-floating-point-trap` 강화** 누적 2+ PR (#131·#143).
+
+3. **3 인스턴스 변수 제약 학생 자가 비판 + 다른 reviewer 어휘 cross-reference (*원래 그리던 꿈을 펼쳐볼까*)** — **MCP 룰 `form-rule-artificial-grouping-self-critique` 강화** 누적 2+ PR (#138·#143). **MCP 룰 `peer-reviewer-cross-reference` 후보**.
+
+4. **custom get vs function 학생 자가 4 분류** — *property (속성/상태) vs function (파라미터/조정자)*. **MCP 룰 `property-vs-function-criteria` 후보**.
+
+5. **WinLoss + ProfitRate enum 분리 (결과 vs 수익률)** — **MCP 룰 `result-vs-rate-enum-separation` 후보**. PR #142 (단일 GameResult) 반대 시점.
+
+6. **DI vs 내부 생성 (Deck)** — *유연성 vs 호출자 간결*. **MCP 룰 `dependency-injection-vs-internal-creation` 후보**.
+
+7. **Dealer 가 BetAmount X (반대 시점 1)** — *PR #87 (Dummy zero) 정공*. **MCP 룰 `dummy-zero-for-domain-absent` 강화** 누적 2+ PR.
+
+8. **블랙잭 1.5배 모델 (총 받음 1.5)** — *PR #36·#87·#138 결과 일치*. PR #35·#142 (순수익 0.5 모델) 와 반대 시점.
+
+9. **HandCards 외부 참조 위험 + 방어적 복사 자가 학습** — PR #21·#117·#138 결.
+
+10. **자가 추상화 활용 부족 자가 인지 (isDrawFinish 미사용)** — *학생 자가 비판*. **MCP 룰 `student-self-abstraction-underuse` 후보**.
+
+11. **양쪽 자가 비교 vs 부호 반전 (PR #142 양방 vs PR #143 부호 반전)** — *symmetric-compare 트레이드오프*. **MCP 룰 `symmetric-compare-bidirectional-call` 강화** 누적 2+ PR.
+
+12. **enum static vs instance method locator (ProfitRate.calculateProfitRate)** — **MCP 룰 후보**.
+
+13. **블랙잭 룰 와전 (`<= 16` = 16 시 stop, 룰 = 16 시 hit)** — **MCP 룰 `blackjack-rule-fidelity-comparison` 강화** 누적 17+ PR ⭐⭐⭐.
+
+14. **외부 컬렉션 인자 vs 멤버 (Dealer.allPlayersMatchProfit(players))** — **MCP 룰 `external-collection-as-method-arg-vs-member` 후보**.
+
+15. **테스트 회귀 (Deck object 제거 부작용)** — **MCP 룰 `test-regression-from-deck-refactor` 후보**.
+
+16. **카드 이니셜 = 표시 vs 본질 트레이드오프** — **MCP 룰 `view-format-as-domain-invariant-tradeoff` 후보**.
+
+17. **영어 어순 어색 (`cardAdd`, `fromDeckCardDraw`)** — **MCP 룰 `english-word-order-naming` 강화** 누적 2+ PR.
+
+18. **computed property 매 호출 재계산 비용** — **MCP 룰 `computed-property-vs-val-recompute-cost` 후보**.
+
+19. **HandCards 캡슐화 학생 자가 의문 (Thread 17)** — *Tell-Don't-Ask 캡슐화 양가*.
+
+20. **모든 19 스레드 학생 자가 답변 + 학생 자가 4-5 분류 + 학생 자가 한계 인지 + 외부 자료** — *2025 코호트 정점 유지*.
+
+## 얻은 교훈 (도메인)
+
+1. **블랙잭 1.5배 (총 받음) 모델** — `BLACKJACK_WIN(1.5)`. PR #36·#87·#138 정공.
+
+2. **딜러 hit 한계 16 = `<= 16` 종료** — *룰 와전 가능 (16 시 stop)*. PR #129 결과 같은 와전.
+
+3. **카드 이니셜 = 도메인 본질 (학생 자가 어휘)** — *변경 가능성 X = Model OK*.
+
+4. **`-0.0` Float 함정** — *블랙잭 도메인 X, Kotlin 어휘*.
+
+5. **Dealer 가 BetAmount 멤버 X (반대 시점 1)** — *Player 만 betAmount*. PR #87 Dummy zero 정공.
+
+6. **WinLoss + ProfitRate enum 분리** — *블랙잭 결과 (3 종) + 수익률 (4 종) 분리*.
+
+7. **Dealer 수익 = -Players 합** — PR #36·#87·#142·#143 결.
+
+## MCP 룰 후보 신규 + 강화 (PR #143)
+
+| 룰 | 신규 / 강화 | 누적 PR |
+|---|---|---|
+| `negative-zero-floating-point-trap` | 강화 | 2+ (#131·#143) |
+| `form-rule-artificial-grouping-self-critique` | 강화 | 2+ (#138·#143) |
+| `peer-reviewer-cross-reference` | 신규 | 1 (#143) |
+| `property-vs-function-criteria` | 신규 | 1 (#143) |
+| `result-vs-rate-enum-separation` | 신규 | 1 (#143) |
+| `dependency-injection-vs-internal-creation` | 신규 | 1 (#143) |
+| `dummy-zero-for-domain-absent` | 강화 | 2+ (#87·#143) |
+| `symmetric-compare-bidirectional-call` | 강화 | 2+ (#142·#143) |
+| `enum-static-vs-instance-method-locator` | 신규 | 1 (#143) |
+| `blackjack-rule-fidelity-comparison` | 강화 | 17+ ⭐⭐⭐ |
+| `external-collection-as-method-arg-vs-member` | 신규 | 1 (#143) |
+| `test-regression-from-deck-refactor` | 신규 | 1 (#143) |
+| `view-format-as-domain-invariant-tradeoff` | 신규 | 1 (#143) |
+| `english-word-order-naming` | 강화 | 2+ (#143·#87) |
+| `computed-property-vs-val-recompute-cost` | 신규 | 1 (#143) |
+| `student-self-abstraction-underuse` | 신규 | 1 (#143) |
+| `parameter-explosion-vs-object-passing` | 신규 | 1 (#143) |
+| `domain-rule-arbitrary-constant` | 강화 | 4+ |
+| `dsl-applicability-criteria` | (제거 추천) | (PR #35 결만) |
+
+## 메타 어휘 (14 reviewer + MCP 핵심 가치 합류 정점 유지)
+
+- ***학생 자가 *의식의 흐름 코드* 인정 + 외부 자료 + 오프라인 만남*** — medAndro PR #143 — *학습 적극성 정점*.
+- ***`-0.0` Float IEEE 754 자가 학습 + 해결책 비교*** — medAndro PR #143 — *Kotlin/Java 어휘 깊은 자가 학습*. PR #131 결 재발견.
+- ***다른 reviewer 어휘 cross-reference + 형식 규칙 자가 비판*** — medAndro PR #143 — *"둘리 외에 어떤 공룡 리뷰어가 ... 원래 그리던 꿈을 펼쳐보라는 리뷰를 다시는 것을 보았는데 저도 원래 그리던 꿈을 펼쳐볼까 합니다."*. **MCP 핵심 가치 합류 + 새로운 cross-reference 패턴**.
+- ***Kotlin 어휘 자가 4 분류 (property vs function)*** — medAndro PR #143 — *학생 자가 학습 정점*.
+- ***자가 추상화 활용 부족 자가 인지*** — medAndro PR #143 — *"스스로 만들어놓고 정작 까먹고 안쓰는게 많은 것 같네요..."*.
+
+→ **14 reviewer + MCP 핵심 가치 어휘 합류 정점 유지**. **batch 21 신규 발견 = *학생이 다른 reviewer 어휘 cross-reference (peer-reviewer-cross-reference)* + *학생 자가 Kotlin 어휘 N 분류*** = *학습 가시화 정점 + 학생 ↔ 다른 reviewer 어휘 합류*.
+
+## 비교 (PR #130 → #143 진화 — 사족 X, 안티패턴 명시만)
+
+- **1단계 #130 25 thread → 2단계 #143 19 thread** — *깊이 유지*.
+- **1단계 #130 PR 본문 자가 한계 4 종 → 2단계 #143 PR 본문 자가 *의식의 흐름 코드* + 슬랙 외부 자료 + 오프라인 만남** — *학생 자가 학습 정점 진화*.
+- **1단계 #130 Singleton Deck 자가 인지 → 2단계 #143 Deck DI + Player.fromDeckCardDraw 자가 적용** — *학습 시간성 정공*.
+- **1단계 #130 `Number` 클래스 명명 충돌 → 2단계 #143 유지 (자가 비판 + 시간 부족)** — *학습 시간성 부분 한계*.
+- **1단계 #130 outputView 함수 한번만 호출 학생/reviewer 자가 한계 → 2단계 #143 `versusRivalWinLoss` 외부 cardStatus/bestValue 인자 (Tuple 누수 변형)** — *Tell-Don't-Ask 진화 + 부분 위반*.
+- **1단계 #130 학생 자가 한계 4 종 → 2단계 #143 학생 자가 추상화 활용 부족 자가 인지** — *자가 비판 깊이 진화*.
+
+→ *진화 비교 = 사족 아님* + *학생 자가 학습 정점 진화 + 형식 규칙 자가 비판 + 다른 reviewer 어휘 cross-reference 신규 패턴*.