<?xml version="1.0" encoding="utf-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
    <channel>
        <title>ddukddak.log</title>
        <link>https://velog.io/</link>
        <description>뚝딱뚝딱 FE</description>
        <lastBuildDate>Thu, 28 Jul 2022 03:44:19 GMT</lastBuildDate>
        <docs>https://validator.w3.org/feed/docs/rss2.html</docs>
        <generator>https://github.com/jpmonette/feed</generator>
        <image>
            <title>ddukddak.log</title>
            <url>https://images.velog.io/images/dev_tuktack/profile/10fa41cb-316a-45ed-b4ce-8dd7c56a91da/unnamed.jpg</url>
            <link>https://velog.io/</link>
        </image>
        <copyright>Copyright (C) 2019. ddukddak.log. All rights reserved.</copyright>
        <atom:link href="https://v2.velog.io/rss/dev_tuktack" rel="self" type="application/rss+xml"/>
        <item>
            <title><![CDATA[[클린코드] 13. 동시성]]></title>
            <link>https://velog.io/@dev_tuktack/%ED%81%B4%EB%A6%B0%EC%BD%94%EB%93%9C-13.-%EB%8F%99%EC%8B%9C%EC%84%B1</link>
            <guid>https://velog.io/@dev_tuktack/%ED%81%B4%EB%A6%B0%EC%BD%94%EB%93%9C-13.-%EB%8F%99%EC%8B%9C%EC%84%B1</guid>
            <pubDate>Thu, 28 Jul 2022 03:44:19 GMT</pubDate>
            <description><![CDATA[<p><strong>TIL (Today I Learned)</strong></p>
<p>2022.05.26</p>
<p><strong>오늘 읽은 범위</strong></p>
<ol start="13">
<li>동시성</li>
</ol>
<hr>
<h2 id="📖-책에서-기억하고-싶은-내용을-써보세요">📖 책에서 기억하고 싶은 내용을 써보세요.</h2>
<ul>
<li><p><strong>동시성과 깔끔한 코드는 양립하기 어렵다.</strong> 
다중 스레드는 시스템이 부하를 받기 전까지 멀쩡하게 돌아간다.</p>
</li>
<li><p><strong>동시성이 필요한 이유?</strong>
동시성은 결합(coupling)을 없애는 전략이다. 즉, 무엇(what)과 언제(when)를 분리한다.</p>
</li>
<li><p>웹 컨테이너가 제공하는 결합분리(decoupling )전략은 완벽과 거리가 아주 멀다.
So, 서블릿 프로그래머는 동시성을 정확히 구현하도록 각별한 주의와 노력 요구.
But, 그럼에도 서블릿 모델이 제공하는 구조적 이점은 아주 크다.</p>
</li>
<li><p><strong>대량으로 분석하는 시스템,</strong> 모든 정보를 처리한 후에 최종적인 답을 냄. **
→ 정보를 병렬로 처리하면 시스템 반응 시간 빨라짐.**</p>
<ul>
<li><p><em>ex 1 ) <em>웹 사이트에서 정보를 가져와 요약하는 정보 수집기</em></em>
매일 실행하므로 24시간 안에 끝나야 함. 웹 사이트를 계속 추가할 수록 정보 수집하는 시간도 늘어남.
→ 단일 스레드 수집기는 웹 소켓에서 입출력을 기다리는 시간이 아주 많다. 한 번에 한 사이트를 방문하는 대신 다중 스레드 알고리즘을 이용하면 수집기 성능을 높일 수 있다.</p>
</li>
<li><p><em>ex 2 ) <em>한 번에 한 사용자를 처리하는 시스템</em></em>
1user / 1sec → 사용자 수가 늘어날수록 시스템이 응답하는 속도도 늦어짐.
⇒ 많은 사용자를 동시에 처리하면 시스템 응답 시간을 높일 수 있다.</p>
</li>
</ul>
</li>
</ul>
<p>#</p>
<ul>
<li><p><strong>동시성 미신과 오해</strong></p>
<ol>
<li><p>동시성은 항상 성능을 높여준다. (X)
때로 성능을 높여준다. (O)
→ 대기 시간이 아주 길어 여러 스레드가 프로세서를 공유할 수 있거나, 여러 프로세서가 동시에 처리할 독립적인 계산이 충분히 많은 경우에만 성능이 높아진다.</p>
</li>
<li><p>동시성을 구현해도 설계는 변하지 않는다. (X)
무엇과 언제를 분리하면 시스템 구조가 크게 달라진다. (O)
→ 단일 스레드 시스템과 다중 스레드 시스템은 설계가 판이하게 다르다</p>
</li>
<li><p>웹 또는 EJB 컨테이너를 사용하면 동시성을 이해할 필요가 없다. (X)
→ 실 컨테이너 동작과 문제 해결방법을 이해해야 한다. (동시수정 해결법, 데드락 등)</p>
</li>
<li><p>동시성은 다소 부하를 유발한다.</p>
</li>
<li><p>동시성은 복잡하다.</p>
</li>
<li><p>동시성은 버그를 제현하기 어렵다. 
(→ 일회성 문제로 여겨 무시하기 쉽다.)</p>
</li>
<li><p>동시성을 구현하려면 흔히 근본적인 설계 전략을 재고해야 한다.</p>
</li>
</ol>
</li>
</ul>
<p>#</p>
<ul>
<li><p><strong>동시성 방어 원칙</strong></p>
<ol>
<li><p>단일 책임 원칙Single Responsibility Principle, SRP
: 동시성 코드는 독자적인 개발, 변경, 조율 주기가 있음. → 동시성 코드와 다른 코드는 분리.</p>
</li>
<li><p>따름 정리corollary: 
 a. 자료 범위를 제한하라.
   : 자료를 캡슐화(encapsulation ) &amp; 공유 자료를 최대한 줄이기.</p>
<p> b. 자료 사본을 사용하라 
   : 공유 객체를 피하는 방법 → 코드가 문제를 일으킬 가능성도 낮아짐.
   <em>(ex.객체를 복사해 읽기 전용으로 사용.)</em>
   <strong>if,</strong> 복사하는 시간과 부하가 걱정 → 진짜 문제인지 실측 필요.
   <strong>but,</strong> 내부 잠금을 없애 절약한 수행 시간이 사본 생성과 가비지 컬렉션에 드는 부하를 상쇄할 가능성이 크다.</p>
<ol start="3">
<li><p>스레드는 가능한 독립적으로 구현하라</p>
<p>: 독자적인 스레드로, 가능하면 다른 프로세서에서, 돌려도 괜찮도록 자료를 독립적인 단위로 분할.</p>
</li>
</ol>
</li>
<li><p>라이브러리를 이해하라</p>
</li>
</ol>
</li>
<li><p><strong>실행 모델을 이해하라</strong></p>
<ul>
<li>생산자-소비자 (Producer-Consumer)
: 하나 이상 생산자 스레드가 정보를 생성해 버퍼buffer나 대기열queue에 넣는다. 하나 이상 소비자 스레드가 대기열에서 정보를 가져와 사용.<ul>
<li>대기열 = 한정된 자원
#</li>
</ul>
</li>
<li>읽기-쓰기 (Readers-Writers)
:읽기 스레드를 위한 주된 정보원으로 공유 자원을 사용, 쓰기 스레드가 공유 자원을 이따금 갱신.<ul>
<li>처리율(throughput)이 문제의 핵심</li>
<li>처리율을 강조하면 → 기아starvation 현상 / 오래된 정보가 쌓인다. 
갱신을 허용하면 → 처리율에 영향을 미친다</li>
</ul>
</li>
</ul>
</li>
</ul>
<ul>
<li><p><strong>동기화하는 부분을 최대한 작게 만들어라</strong>
: <em>synchronized</em>를 사용하면 락을 설정한다. 같은 락으로 감싼 모든 코드 영역은 한 번에 한 스레드만 실행이 가능하다.</p>
<ul>
<li>락은 스레드를 지연시키고 부하를 가중시킨다.</li>
<li><em>synchronized</em>를 남발하는 코드는 바람직하지 않다.</li>
<li>임계영역은 반드시 보호. So, 임계영역 수 최소화.<ul>
<li>주의_ 하나의 거대한 임계 영역으로 통합하면 안됨. 
→ 이 영역을 사용하려고 하는 스레드도 늘어남. → 경쟁으로 이어지고 → 성능이 떨어지기 때문이다. (p. 236)</li>
</ul>
</li>
</ul>
</li>
<li><p><strong>스레드 코드 테스트 하기</strong></p>
<ul>
<li>문제를 노출하는 테스트 케이스 작성. (프로그램  설정, 시스템 설정, 부하 바꿔가며 자주 돌려라)</li>
<li>랜덤한 상황을 넣고 주기적으로 테스트를 진행해라. 스레드 코드는 다시 테스트 할 때는 성공하는 경우가 있을 수 있다. 그렇다고 해서 넘어가지 말고 원인을 꼼꼼히 파악하길 바란다.</li>
<li>시스템 실패를 ‘일회성’이라 치부하지 마라.<ul>
<li>일회성 문제란 존재하지 않는다고 가정하는 편이 안전하다. ‘일회성’ 문제를 계속 무시한다면 잘못된 코드 위에 코드가 계속 쌓인다.</li>
</ul>
</li>
</ul>
</li>
</ul>
<h3 id="결론"><strong>결론</strong></h3>
<p>다중 스레드 코드를 작성시, 주의하지 않으면 알 수 없는 오류에 직면할 수 있다.</p>
<p>SRP 준수:  스레드를 아는 코드와 스레드를 모르는 코드를 분리.</p>
<ul>
<li><p>테스트 할 때 스레드 코드를 테스트 할 때에는 스레드만 테스트한다.</p>
</li>
<li><p>즉 스레드 코드는 최대한 집약되고 작아야 한다.
#
동시성 오류를 일으키는 잠정적인 원인을 철저히 이해해야 한다.</p>
</li>
<li><p>여러 스레드가 공유 자료를 조작하거나 자원 풀을 공유할 때 동시성 오류가 발생한다.</p>
</li>
<li><p>루프 반복을 끝내거나 프로그램을 깔끔하게 종료하는 등 경계 조건의 경우 더 까다로우므로 특히 주의해야 한다.
#
사용하는 라이브러리와 기본 알고리즘을 이해한다.</p>
</li>
<li><p>특정 라이브러리 기능이 기본 알고리즘과 유사한 어떤 문제를 어떻게 해결하는지 파악한다.
#
보호할 코드 영역을 찾아내는 방법과 특정 코드 영역을 잠그는 방법을 이해한다. 또 공유하는 정보와 공유하지 않는 정보를 정확하게 이해한다.</p>
</li>
<li><p>잠글 필요가 없는 코드는 잠그지 않는다.</p>
</li>
<li><p>잠긴 영역에서 다른 잠긴 영역을 호출하지 않는다.</p>
</li>
<li><p>공유하는 객체 수와 버위를 최대한 줄인다.</p>
</li>
<li><p>클라이언트에게 공유 상태를 관리하는 책임을 떠넘기지 않는다.</p>
</li>
</ul>
<p>공유하는 정보: 공유하는 객체 수와 범위를 최대한 줄인다.</p>
<p>일회성 문제는 대개 시스템에 부하가 걸릴 때나 아니면 뜬금없이 발생한다. 그러므로 스레드 코드는 많은 플랫폼에서 많은 설정으로 반복해서 계속 테스트해야 한다.</p>
<hr>
<h2 id="🐱👓-오늘-읽은-소감은-떠오르는-생각을-가볍게-적어보세요">🐱‍👓 오늘 읽은 소감은? 떠오르는 생각을 가볍게 적어보세요.</h2>
<ul>
<li>안드로이드 블루투스 페어링 관련해서 작업하면서 java 스레드로 애먹었던 기억이 있어, 책에서 복잡한 거라고 말해줘서 고마웠다.. (나만 힘든게 아니었어-!)</li>
<li>이번에도 이해하려고 애썼지만 조금 어려웠다. 그래도 최대한 안드로이드 플젝 할 때의 기억과 js 상황(맞는진 모르겠지만 유사하다고 생각한 비동기 처리)에 대입해 보고자 하며 읽어보았다.</li>
<li>기능 구현하는 것도 어려운데.. ㅋㅋ 테스트코드 워후-! 할수있어...!<blockquote>
<p>(feat.동기화 단위를 최소화하라. 그러면 조금 낫다.)</p>
</blockquote>
</li>
<li>starvation, 페어링 구현하면서 경험해본적 있었다.. 개념에 대한 용어를 알고 생각해보니 생산자-소비자 모델이었는데, 생산자에서 오류가 발생하면 스레드 종료 처리를 해주지 못해 오류가 발생하는 상황이었다. 검색도 하고 선배 개발자 분에게 조언을 얻어 해결하긴 했었는데, 이번에 책을 읽으면서 다시 곱씹어 보니 당시 상황을 복기해보니 좀 더 이해가는 부분이 있었다.</li>
</ul>
<hr>
<h2 id="🧐-궁금한-내용이-있거나-잘-이해되지-않는-내용이-있다면-적어보세요">🧐 궁금한 내용이 있거나, 잘 이해되지 않는 내용이 있다면 적어보세요.</h2>
<ul>
<li><p>‘서블릿Servlet’ 모델</p>
<ul>
<li>서블릿: 웹 혹은 EJB 컨테이너라는 우산 아래서 돌아가는데, 이들 컨테이너는 동시성을 부분적으로 관리. 웹 요청이 들어올 때마다 웹 서버는 비동기식으로 서블릿을 실행함.</li>
</ul>
</li>
<li><p>결합분리(decoupling )전략</p>
</li>
<li><p>EJB 컨테이너</p>
</li>
<li><p>데드락</p>
<p>  : 여러 스레드가 서로가 끝나기를 기다린다. 모든 스레드가 각기 필요한 자원을 다른 스레드가 점유하는 바람에 어느 쪽도 더 이상 진행하지 못함.</p>
</li>
<li><p>JIT (Just In Time) 컴파일러</p>
</li>
</ul>
]]></description>
        </item>
        <item>
            <title><![CDATA[[클린코드] 12. 창발성]]></title>
            <link>https://velog.io/@dev_tuktack/%ED%81%B4%EB%A6%B0%EC%BD%94%EB%93%9C-12.-%EC%B0%BD%EB%B0%9C%EC%84%B1</link>
            <guid>https://velog.io/@dev_tuktack/%ED%81%B4%EB%A6%B0%EC%BD%94%EB%93%9C-12.-%EC%B0%BD%EB%B0%9C%EC%84%B1</guid>
            <pubDate>Thu, 28 Jul 2022 02:21:15 GMT</pubDate>
            <description><![CDATA[<p><strong>TIL (Today I Learned)</strong></p>
<p>2022.05.19</p>
<p><strong>오늘 읽은 범위</strong></p>
<ol start="12">
<li>창발성</li>
</ol>
<hr>
<h2 id="📖-책에서-기억하고-싶은-내용을-써보세요">📖 책에서 기억하고 싶은 내용을 써보세요.</h2>
<ul>
<li><p>모든 테스트를 실행하라
  ▪ 설계는 의도한 대로 돌아가는 시스템을 내놓아야 한다.
  ▪ 테스트가 불가능한 시스템은 검증도 불가능
  ▪ 테스트 케이스를 많이 작성할수록  도구를 사용할 수록 아래의 이점이 있음. (도구; DIP, 의존성 주입 (DI), 인터페이스, 추상화)</p>
<blockquote>
<p>1) 낮은 결합도와 높은 응집력
2) 설계 품질이 높아짐.
→ 객체 지향 방법론이 지향하는 목표를 저절로 달성</p>
</blockquote>
</li>
<li><p>리팩터링 순서)</p>
<pre><code> 1. 테스트 케이스 작성 </code></pre><ol start="2">
<li>코드와 클래스 정리</li>
<li>코드추가 </li>
<li>잠시 멈추고 설계를 조감</li>
</ol>
</li>
<li><p>중복을 없애라
  ▪ 중복 === 추가 작업, 추가 위험, 불필요한 복잡도
  ▪ 구현 중복 포함</p>
</li>
<li><p>표현하라
  ▪ 소프트웨어 프로젝트 비용 중, 대다수는 장기적인 유지보수.
  ▪ 시스템이 점차 복잡해지면서 유지보수 개발자가 시스템을 이해하느라 보내는 시간은 점점 늘어나고 동시에 코드를 오해할 가능성도 점점 커진다.
  ▪ 코드는 개발자의 의도를 분명히 표현해야 한다. 개발자가 코드를 명백하게 짤수록 다른 사람이 그 코드를 이해하기 쉬워진다. 
⇒ 결함감소 &amp; 유지보수 비용 절감.</p>
</li>
<li><p>클래스와 메서드 수를 최소로 줄여라
  ▪ SRP를 준수한다는 개념도 극단으로 치달으면 득보다 실이 많아진다.
  <em>ex. 클래스와 메서드 크기를 줄이자고 조그만 클래스와 메서드를 수없이 만드는 사례</em>
  ▪ 함수와 클래스 크기를 작게 유지하면서 동시에 시스템 크기도 작게 유지.</p>
</li>
</ul>
<hr>
<h2 id="🐱👓-오늘-읽은-소감은-떠오르는-생각을-가볍게-적어보세요">🐱‍👓 오늘 읽은 소감은? 떠오르는 생각을 가볍게 적어보세요.</h2>
<p>이쯤되니 책에서 계속해서 반복해 말하는 것들이 눈에 뜬다. 저자가 중요하게 말하고자 하는 개념이 뭔지 명확해 졌다. 좋은 이름, 크기랑 중복 줄이기, 단위테스트..
  이제 절반이상 읽었는데 지금까지 배운내용을 양분삼아 리팩토링 공부로 이어 나가면 되겠다.</p>
<hr>
<h2 id="🧐-궁금한-내용이-있거나-잘-이해되지-않는-내용이-있다면-적어보세요">🧐 궁금한 내용이 있거나, 잘 이해되지 않는 내용이 있다면 적어보세요.</h2>
<ul>
<li>창발
: 떠오름 현상은 하위 계층(구성 요소)에는 없는 특성이나 행동이 상위 계층(전체 구조)에서 자발적으로 돌연히 출현하는 현상</li>
</ul>
]]></description>
        </item>
        <item>
            <title><![CDATA[[클린코드] 11. 시스템]]></title>
            <link>https://velog.io/@dev_tuktack/%ED%81%B4%EB%A6%B0%EC%BD%94%EB%93%9C-11.-%EC%8B%9C%EC%8A%A4%ED%85%9C</link>
            <guid>https://velog.io/@dev_tuktack/%ED%81%B4%EB%A6%B0%EC%BD%94%EB%93%9C-11.-%EC%8B%9C%EC%8A%A4%ED%85%9C</guid>
            <pubDate>Mon, 25 Jul 2022 05:31:34 GMT</pubDate>
            <description><![CDATA[<p><strong>TIL (Today I Learned)</strong></p>
<p>2022.05.19</p>
<p><strong>오늘 읽은 범위</strong></p>
<ol start="11">
<li>시스템</li>
</ol>
<h2 id="">#</h2>
<h3 id="책에서-기억하고-싶은-내용을-써보세요">책에서 기억하고 싶은 내용을 써보세요.</h3>
<ul>
<li><p><strong>시스템 제작과 시스템 사용을 분리하라 (p.194)</strong></p>
<p>  SW는 <strong>준비 과정과 런타임으로</strong>  로직을 분리해야 한다.</p>
<ul>
<li><strong>준비 과정:</strong> 애플리케이션 객체를 제작하고 의존성을 서로 ‘연결’ 하는 로직</li>
<li><strong>런타임:</strong> 준비 과정 이후에 이어지는 로직</li>
</ul>
</li>
</ul>
<ul>
<li><p><strong>관심사 분리</strong></p>
</li>
<li><p><strong>초기화 지연Lazy Initialization (계산 지연Lazy Evaluation) 기법</strong></p>
<ol>
<li>실제로 필요할 때까지 객체를 생성하지 않으므로 불필요한 부하가 걸리지 않는다.</li>
<li>애플리케이션을 시작하는 시간이 그만큼 빨라진다.</li>
<li>어떤 경우에도 null 포인터를 반환하지 않는다.</li>
</ol>
</li>
<li><p>Main 분리</p>
<ul>
<li>생성과 관련한 코드: main이나 main이 호출하는 모듈로 이동.</li>
<li>나머지 시스템은 모든 객체가 생성되었고 모든 의존성이 연결되었다고 가정.<blockquote>
<p><img src="https://velog.velcdn.com/images/dev_tuktack/post/c12a13d8-5d13-40bf-a4c8-e0309340ad8b/image.png" alt=""></p>
</blockquote>
<h1 id="-1"></h1>
애플리케이션은 main이나 객체가 생성되는 과정을 전혀 모른다.</li>
</ul>
</li>
</ul>
<ul>
<li><strong>팩토리</strong><ul>
<li>때로는 객체가 생성되는 시점을 애플리케이션이 결정할 필요 有.</li>
<li>생성시점은 결정가능하나, 생성하는 코드는 애플리케이션이 알 수 없음.<blockquote>
<p><img src="https://velog.velcdn.com/images/dev_tuktack/post/c28fb8d5-cda7-42eb-9646-3dba8770a284/image.png" alt=""></p>
</blockquote>
</li>
</ul>
</li>
</ul>
<ul>
<li><p><strong>의존성 주입 (DI, Dependency Injection)</strong></p>
<ul>
<li>제어역전) 한 객체가 맡은 보조 책임 → 새로운 객체에게 전적으로 떠넘긴다. (SRP 지켜짐)</li>
<li>의존성 관리) 맥락에서 객체는의존성 자체를 인스턴스로 만드는 책임은 지지 않는다. 대신에 이런 책임을 다른 ‘전담’ 메커니즘에 넘겨야만 한다.</li>
</ul>
</li>
<li><p><strong>확장</strong></p>
<ul>
<li><p>성장할지 모른다는 기대로 비용을 정당화할 수 있을까? → NO.</p>
</li>
<li><p>‘처음부터 올바르게’ 시스템을 만들 수 있다는 믿음은 미신이다.</p>
<blockquote>
<p>오늘 주어진 사용자 스토리에 맞춰 시스템을 구현해야 한다. 내일은 새로운 스토리에 맞춰 시스템을 조정하고 확장하면 된다.
  <em>⇒ 이것이 반복적이고 점진적인 애자일 방식의 핵심</em>.</p>
</blockquote>
</li>
<li><p>시스템 아키텍처는 사전 계획이 필요하지 않을까.</p>
<p>  → ‘단순한 아키텍처를 복잡한 아키텍처로 조금씩 키울 수 없다’는 맞는 말 아닌가? NO.</p>
<p>  → 시스템은 수명이 짧아, 점진적으로 발전할 수 있다. YES.</p>
</li>
</ul>
</li>
</ul>
<ul>
<li><p><strong>자바 프록시</strong></p>
<ul>
<li>단순한 상황에 적합</li>
<li>ex. 개별 객체나 클래스에서 메서드 호출을 감싸는 경우</li>
<li>단점1) 코드가 상당히 많고 복잡함. → 깨끗한 코드 작성 어려움</li>
<li>단점2) 시스템 단위로 실행 ‘지점’을 명시하는 메커니즘도 제공하지 않음. (AOP 위반)</li>
</ul>
</li>
<li><p>POJO 장점</p>
<ul>
<li>(엔터프라이즈)프레임워크 &amp; 도메인에 의존하지 않음.</li>
<li>테스트가 개념적으로 더 쉽고 간단.</li>
<li>상대적으로 단순하기 때문에 사용자 스토리 구현 쉬움.
→ 미래 스토리에 맞춰 코드를 보수하고 개선하기 편리.</li>
</ul>
</li>
<li><p>테스트 주도 시스템 아키텍처 구축</p>
</li>
<li><p>BDUF (Big Design Up Front) → Not GOOD.</p>
<ul>
<li>정의) 구현을 시작하기 전에 앞으로 벌어질 모든 사항을 설계하는 기법.</li>
<li>단점) 처음에 쏟아 부은 노력을 버리지 않으려는 심리적 저항으로 인해, 그리고 처음 선택한 아키텍처가 향후 사고 방식에 미치는 영향으로 인해, 변경을 쉽사리 수용하지 못함.</li>
</ul>
</li>
<li><p><em>‘아주 <strong>단순</strong>하면서도’ 멋지게 <strong>분리된 아키텍처</strong>로 소프트웨어 프로젝트를 진행해 <strong>결과물을 재빨리 출시</strong>한 후, <strong>기반 구조를 추가하며 조금씩 확장</strong>해 나가도 괜찮다.</em></p>
</li>
</ul>
<ul>
<li><p><strong>프로젝트를 시작시 생각할 것</strong></p>
<ul>
<li>일반적인 범위,</li>
<li>목표, 일정</li>
<li>결과로 내놓을 시스템의 일반적인 구조도</li>
<li>변하는 환경에 대처해 진로를 변경할 능력도 반드시 유지.</li>
</ul>
</li>
<li><p>의사 결정을 최적화하라</p>
</li>
<li><p>때때로 가능한 마지막 순간까지 결정을 미루는 방법이 최선이다.</p>
<ul>
<li>최대한 정보를 모아 최선의 결정. / 성급한 결정은 불충분한 지식으로 내린 결정</li>
<li>너무 일찍 결정하면 고객 피드백을 더 모으고, 프로젝트를 더 고민하고, 구현 방안을 더 탐험할 기회가 사라진다.</li>
</ul>
</li>
<li><p>관심사를 <strong>모듈로 분리</strong>한 POJO 시스템은 <strong>기민함을 제공</strong>한다.</p>
<ul>
<li><p>기민성, 기민함 in 시스템</p>
<p>  p.211) 최신 정보에 기반해 최선의 시점에 최적의 결정을 내리기가 쉬움. and 결정의 복잡성도 줄어든다.</p>
<p>  p. 213) 기민성이 떨어지면, 생산성이 낮아져 TDD 제공하는 장점이 사라진다.</p>
</li>
</ul>
</li>
<li><p>시스템은 도메인 특화 언어가 필요하다.</p>
<ul>
<li>추상화 수준을 코드 관용구나 디자인 패턴 이상으로 끌어올린다.</li>
<li>개발자가 적절한 추상화 수준에서 코드 의도를 표현.</li>
</ul>
</li>
</ul>
<hr>
<h3 id="오늘-읽은-소감은-떠오르는-생각을-가볍게-적어보세요">오늘 읽은 소감은? 떠오르는 생각을 가볍게 적어보세요.</h3>
<ul>
<li><p>Java 관련 배경지식이 이 챕터를 이해하기에는 너-무 부족했었다. 모르는 것들 검색하면서 읽는시간 절반이상 쓴 것 같다. (휴.. 🤷‍♀️) 그중에서도 관점이라는 개념이 잘 와닿지 않아서 애먹었는데, 이해 될까 하다가도 뒤돌면 다시 까먹는것 같다.. 😹</p>
</li>
<li><p>이번 주 읽은 부분에서는 기민성, 지엽적, 창발.. 라는 단어가 나왔었는데, IT랑 전혀 상관없는 단어가 오히려 더 이해가 안됬다. 개발 공부하려면 국어공부도 같이 해야되나보다. (0개국어설..)</p>
</li>
</ul>
<hr>
<h3 id="궁금한-내용이-있거나-잘-이해되지-않는-내용이-있다면-적어보세요">궁금한 내용이 있거나, 잘 이해되지 않는 내용이 있다면 적어보세요.</h3>
<ul>
<li>자바 생명주기
<a href="https://minnnne.tistory.com/110">https://minnnne.tistory.com/110</a>
#</li>
<li><strong>XML 배포기술자 (deployment descriptors)</strong><ul>
<li>책) 영구 저장소에서 객체와 관계형 자료가 매핑되는 방식, 원하는 트랜택션 동작방식, 보안 제약조건이 들어감..</li>
<li>스프링 옛날 버전(스프링 부트 안 쓸 때) 배포를 어떤식으로 되게 할 건지 정의하는 거
#</li>
</ul>
</li>
<li><strong>엔티티 빈</strong><ul>
<li>데이터베이스로 부터 읽어드린 테이블의 데이터를 담는 빈 
<a href="https://kimseunghyun76.tistory.com/327">Entity Bean</a>
#</li>
</ul>
</li>
<li><strong>InvocationHandler</strong><ul>
<li>프록시 패턴으로 구현할 때 쓰는거.
#</li>
</ul>
</li>
<li>POJO (Plain Old Java Object)
<img src="https://velog.velcdn.com/images/dev_tuktack/post/53ec20a9-cd1b-4656-82fb-2aee5591ba76/image.png" alt="">
#</li>
<li><strong>프록시</strong><ul>
<li>원래 로직을 유지하면서 뭔가 더 공통적인 처리를 추가하는 방식.
(↓ 내가 이해 하려고 첨부한 초간단 예제 코드 )
<img src="https://velog.velcdn.com/images/dev_tuktack/post/007efd81-a0c6-4f70-a782-8b9621e6295e/image.PNG" alt=""></li>
</ul>
</li>
</ul>
<p>#</p>
<ul>
<li><p>관점 지향 프로그래밍  AOP, Aspect-Oriented Programming</p>
<blockquote>
<p><img src="https://velog.velcdn.com/images/dev_tuktack/post/4d3a487e-fb00-48fd-bbac-6686afc615a3/image.png" alt=""> 
횡단관심: 로깅, 보안, 트랜잭션 등등 다수의 모듈에서 반복적으로 나타나는 부분.</p>
</blockquote>
<blockquote>
</blockquote>
<p><img src="https://velog.velcdn.com/images/dev_tuktack/post/8d8c2a38-d66b-4e98-bef3-0b166479d107/image.png" alt=""> <img src="https://velog.velcdn.com/images/dev_tuktack/post/69ce08db-027f-450d-88de-008d0f351a71/image.png" alt=""><img src="https://velog.velcdn.com/images/dev_tuktack/post/c8e3e45f-8e31-4396-bc4f-6ecc671e123d/image.png" alt=""> 참고: <a href="https://expert0226.tistory.com/200">https://expert0226.tistory.com/200</a> [여름나라겨울이야기]
#</p>
</li>
<li><p><strong>관심사 분리</strong>  (<strong>SOC,</strong> separation of concerns)</p>
<ul>
<li>관심사: 컴퓨터 프로그램 코드에 영향을 미치는 정보의 집합.</li>
<li>Easy.ver) 프로그램을 기능 면에서 되도록 중복이 아닌 여러 모듈로 명확히 나누는 것.</li>
<li>모듈식 (== 관심사의 분리)는 정보를 잘 정의된 인터페이스가 있는 코드 부분 안에 캡슐화시킴으로써 달성함.</li>
</ul>
</li>
<li><p>기민성, 기민함 in 시스템</p>
<ul>
<li>p.211) 최신 정보에 기반해 최선의 시점에 최적의 결정을 내리기가 쉬워진다. 또한 결정의 복잡성도 줄어든다.</li>
<li>p. 213) 기민성이 떨어지면, 생산성이 낮아져 TDD 제공하는 장점이 사라진다.</li>
</ul>
</li>
<li><p>지엽적인 관리
  : 소스코드 중에서 비즈니스 로직 상 중요한 거랑 아닌거랑 나뉘는거.</p>
</li>
</ul>
]]></description>
        </item>
        <item>
            <title><![CDATA[[클린코드] 10. 클래스]]></title>
            <link>https://velog.io/@dev_tuktack/%ED%81%B4%EB%A6%B0%EC%BD%94%EB%93%9C-10.-%ED%81%B4%EB%9E%98%EC%8A%A4</link>
            <guid>https://velog.io/@dev_tuktack/%ED%81%B4%EB%A6%B0%EC%BD%94%EB%93%9C-10.-%ED%81%B4%EB%9E%98%EC%8A%A4</guid>
            <pubDate>Mon, 25 Jul 2022 04:56:25 GMT</pubDate>
            <description><![CDATA[<p><strong>TIL (Today I Learned)</strong></p>
<p>2022.05.17</p>
<p><strong>오늘 읽은 범위</strong></p>
<p>10장. 클래스</p>
<h3 id="책에서-기억하고-싶은-내용을-써보세요">책에서 기억하고 싶은 내용을 써보세요.</h3>
<ul>
<li><p>캡슐화 (p.172)</p>
<ul>
<li>변수와 유틸리티 함수는 가능한 공개하지 않는 편이 낫지만 반드시 숨겨야 한다는 법칙도 없다.</li>
<li>그 전에 비공개 상태를 유지할 온갖 방법을 강구한다. 캡슐화를 풀어주는 결정은 언제나 최후의 수단이다.
#</li>
</ul>
</li>
<li><p>클래스는 작아야 한다! (p.172-173)</p>
<ul>
<li>함수는 물리적인 행 수로 크기를 측정했다. 클래스는 맡은 책임을 센다.</li>
<li>클래스 이름은 해당 클래스 책임을 기술해야 한다.
: 간결한 이름이 떠오르지 않는다면 필경 클래스 크기가 너무 커서 그렇다. 클래스 이름이 모호하다면 필경 클래스 책임이 너무 많아서다.</li>
<li>클래스 설명은 만일(“if”), 그리고(“and”), -(하)며(“or”), 하지만(“but”)을 사용하지 않고서 25단어 내외로 가능해야 한다.
#</li>
</ul>
</li>
<li><p>단일 책임 원칙 (SRP, Single Responsibility Principle) (p.175-176)</p>
<ul>
<li><p>클래스는 책임, 즉 변경할 이유가 하나여야 한다.</p>
</li>
<li><p>문제는 프로그램이 돌아가면 일이 끝났다고 여기는 데 있다. 프로그램으로 되돌아가 만능 클래스를 단일 책임 클래스 여럿으로 분리하는 대신 다음 문제로 넘어가버린다.</p>
<blockquote>
<ul>
<li>SPR 단점
많은 개발자는 자잘한 단일 책임 클래스가 많아지면 큰 그림을 이해하기 어려워진다고 우려한다. 큰 그림을 이해하려면 이 클래스 저 클래스를 수없이 넘나들어야 한다고 걱정한다.</li>
</ul>
</blockquote>
<blockquote>
<ul>
<li>그럼에도 불구하고 써야하는 이유
규모가 어느 수준에 이르는 시스템은 논리가 많고도 복잡하다. 이런 복잡성을 다루려면 체계적인 정리가 필수다. 그래야 개발자가 무엇이 어디에 있는지 쉽게 찾는다. (변경을 가할 때) 직접 영향이 미치는 컴포넌트만 이해해도 충분함.</li>
</ul>
</blockquote>
<blockquote>
<ul>
<li>결론
큰 클래스 몇 개가 아니라 작은 클래스 여럿으로 이뤄진 시스템이 더 바람직하다. 작은 클래스는 각자 맡은 책임이 하나며, 변경할 이유가 하나며, 다른 작은 클래스와 협력해 시스템에 필요한 동작을 수행한다.</li>
</ul>
</blockquote>
</li>
</ul>
</li>
<li><p>응집도Cohesion (p.177)</p>
<ul>
<li>각 클래스 메서드는 클래스 인스턴스 변수를 하나 이상 사용해야 한다.</li>
<li>응집도가 높다 == 클래스에 속한 메서드와 변수가 서로 의존하며 논리적인 단위로 묶인다.</li>
<li>몇몇 메서드만이 사용하는 인스턴스 변수가 아주 많아진다. 이는 십중팔구 새로운 클래스로 쪼개야 한다는 신호다. 응집도가 높아지도록 변수와 메서드를 적절히 분리해 새로운 클래스 두세 개로 쪼개준다.
#</li>
</ul>
</li>
<li><p>변경하기 쉬운 클래스 (p.185)</p>
<ul>
<li>대다수 시스템은 지속적인 변경이 가해진다. 깨끗한 시스템은 클래스를 체계적으로 정리해 변경에 수반하는 위험을 낮춘다.</li>
</ul>
</li>
</ul>
<hr>
<h3 id="오늘-읽은-소감은-떠오르는-생각을-가볍게-적어보세요">오늘 읽은 소감은? 떠오르는 생각을 가볍게 적어보세요.</h3>
<blockquote>
<p>🔽 몇몇 메서드만이 사용하는 인스턴스 변수가 아주 많아진다. 이는 십중팔구 새로운 클래스로 쪼개야 한다는 신호다. 응집도가 높아지도록 변수와 메서드를 적절히 분리해 새로운 클래스 두세 개로 쪼개준다.</p>
</blockquote>
<ul>
<li>응집도가 높은 것이 바람직 한 것만은 아니겠군..<h1 id=""></h1>
</li>
<li>나는 클래스 분리를 선뜻 생각하지 않는 편이라, 클래스를 쪼개는 상황을 <code>기회가 생긴다.</code>라고 표현 한 것이 인상적이었다.
#
나는 보통 </li>
<li>로직 복잡도가 올라가거나, </li>
<li>코드 라인이 지나치게 길어질 때, </li>
<li>중복적으로 사용되는 부분이 많아 공통으로 분리할 때 </li>
<li>.. 
같은 경우에 꽤 고민 하다가 정 불가피하게 해야된다면 클래스로 분리했다.</li>
</ul>
<p>그래서 보통 로직이 골치아플때 많이 겪은 상황이라 이걸 긍정적으로 볼수도 있겠구나 싶었다. 아무래도 나는 개발 표준이라는 큰 틀을 벗어나고 싶지 않아 했던 것 같다. (클래스 분리를 한 코드에 개발표준 내에서 처리하라는 피드백을 받은 이후 부터 였던 듯 하다.)
클래스 분리가 개발 표준을 크게 해치는 것일까..? 오히려 가독성을 높여줘 코드 파악에는 더 도움이 될 수도 있을텐데 싶다. 
혼자서 개발하면 상관 없겠지만, 여러명이서 개발 할 때는 내 판단하에 분리를 할 수 없으니 서로 합의하에 이루어 된다고 생각한다.. 그러면 코드 작성 전이나 커밋 전에 협의 해서 정하는 걸까?</p>
<hr>
<h3 id="궁금한-내용이-있거나-잘-이해되지-않는-내용이-있다면-적어보세요">궁금한 내용이 있거나, 잘 이해되지 않는 내용이 있다면 적어보세요.</h3>
<ul>
<li><p><strong>최상위 GUI 윈도의 스윙 표현</strong></p>
<ul>
<li><strong>JFrame</strong></li>
</ul>
<p>참고 |  <a href="https://raccoonjy.tistory.com/17">자바(Java)의 기초 박살내기 - Java GUI②</a></p>
</li>
<li><p><strong>스윙 코드</strong></p>
</li>
<li><p><strong>버전 번호</strong></p>
</li>
</ul>
<p>(* 클래스 설계 원칙)</p>
<ul>
<li><strong>OCP (Open-Closed Principle)</strong> (p.188)
: 클래스는 확장에 개방적이고 수정에 폐쇄적이어야 한다는 원칙.</li>
<li><strong>DIP (Dependency Inversion Principle)</strong><ul>
<li>클래스가 상세한 구현이 아니라 추상화에 의존해야 한다는 원칙.</li>
</ul>
</li>
</ul>
]]></description>
        </item>
        <item>
            <title><![CDATA[[클린코드] 9. 단위 테스트]]></title>
            <link>https://velog.io/@dev_tuktack/%ED%81%B4%EB%A6%B0%EC%BD%94%EB%93%9C-9.-%EB%8B%A8%EC%9C%84-%ED%85%8C%EC%8A%A4%ED%8A%B8</link>
            <guid>https://velog.io/@dev_tuktack/%ED%81%B4%EB%A6%B0%EC%BD%94%EB%93%9C-9.-%EB%8B%A8%EC%9C%84-%ED%85%8C%EC%8A%A4%ED%8A%B8</guid>
            <pubDate>Mon, 25 Jul 2022 04:55:32 GMT</pubDate>
            <description><![CDATA[<p><strong>TIL (Today I Learned)</strong></p>
<p>2022.05.17</p>
<p><strong>오늘 읽은 범위</strong></p>
<p>9장 단위 테스트</p>
<h3 id="책에서-기억하고-싶은-내용을-써보세요">책에서 기억하고 싶은 내용을 써보세요.</h3>
<ul>
<li><p><strong>TDD 법칙 세 가지 (p.155)</strong>
·첫째 법칙: 실패하는 단위 테스트를 작성할 때까지 실제 코드를 작성하지 않는다.
·둘째 법칙: 컴파일은 실패하지 않으면서 실행이 실패하는 정도로만 단위 테스트를 작성한다.
·셋째 법칙: 현재 실패하는 테스트를 통과할 정도로만 실제 코드를 작성한다.</p>
</li>
<li><p>테스트 주기가 대략 30초 주기로 묶인다. (..) 이렇게 일하면 실제 코드를 사실상 전부 테스트하는 테스트 케이스가 나온다. 하지만 실제 코드와 맞먹을 정도로 방대한 <strong>테스트 코드는 심각한 관리 문제를 유발</strong>하기도 한다. (p.155)</p>
</li>
<li><p><strong>깨끗한 테스트 코드 유지하기 (p.156)</strong></p>
<ul>
<li>지저분한 테스트 코드를 내놓으나 테스트를 안 하나 오십보 백보라는, 아니 오히려 더 못하다.</li>
<li>실제 코드가 진화하면 테스트 코드도 변해야 한다. 그런데 테스트 코드가 지저분할수록 변경하기 어려워진다. 테스트 코드가 복잡할수록 실제 코드를 짜는 시간보다 테스트 케이스를 추가하는 시간이 더 걸리기 십상이다.</li>
<li>실제 코드를 변경해 기존 테스트 케이스가 실패하기 시작하면, 지저분한 코드로 인해, 실패하는 테스트 케이스를 점점 더 통과시키기 어려워진다.</li>
</ul>
</li>
<li><p><strong>테스트는 유연성, 유지보수성, 재사용성을 제공한다. (p.157)</strong></p>
<ul>
<li>테스트 코드를 깨끗하게 유지하지 않으면 결국은 잃어버린다.</li>
<li>단위테스트가 버팀목.
: 테스트 케이스가 없다면 모든 변경이 잠정적인 버그다. 아키텍처가 아무리 유연하더라도, 설계를 아무리 잘 나눴더라도, 테스트 케이스가 없으면 개발자는 변경을 주저한다.</li>
<li>실제 코드를 점검하는 자동화된 단위 테스트 슈트는 설계와 아키텍처를 최대한 깨끗하게 보존하는 열쇠다. 테스트 케이스가 있으면 변경이 쉬워지기 때문이다.</li>
<li>테스트 코드가 지저분하면 코드를 변경하는 능력이 떨어지며 코드 구조를 개선하는 능력도 떨어진다.</li>
</ul>
</li>
<li><p><strong>깨끗한 테스트 코드 (p.158)</strong></p>
<ul>
<li>깨끗한 테스트 코드를 만들려면? 가독성.</li>
<li>명료성, 단순성, 풍부한 표현력이 필요하다. 테스트 코드는 최소의 표현으로 많은 것을 나타내야 한다.</li>
</ul>
</li>
<li><p><strong>이중표준 (p.161-162)</strong></p>
<ul>
<li>테스트 API 코드에 적용하는 표준은 실제 코드에 적용하는 표준과 확실히 다르다. 단순하고, 간결하고, 표현력이 풍부해야 하지만, 실제 코드만큼 효율적일 필요는 없다. (..) 테스트 환경에서 돌아가는 코드이기 때문이다.</li>
<li>실제 환경에서는 절대로 안 되지만 테스트 환경에서는 전혀 문제없는 방식이 있다. 대개 메모리나 CPU 효율과 관련 있는 경우다. 코드의 깨끗함과는 철저히 무관함. (p.164)</li>
</ul>
</li>
<li><p><strong>테스트 당 assert 하나 (p.164)</strong></p>
<ul>
<li>assert 문이 단 하나인 함수는 결론이 하나라서 코드를 이해하기 쉽고 빠르다.</li>
</ul>
</li>
<li><p><strong>테스트 당 개념 하나 (p.166)</strong></p>
</li>
<li><p><strong>F.I.R.S.T. (p.168)</strong></p>
<ul>
<li><strong>빠르게F</strong>ast: 테스트가 느리면 자주 돌릴 엄두를 못 낸다. 자주 돌리지 않으면 초반에 문제를 찾아내 고치지 못한다.</li>
<li><strong>독립적으로I</strong>ndependent: 다음 테스트가 실행될 환경을 준비해서는 안 된다. 어떤 순서로 실행해도 괜찮아야 한다. 테스트가 서로에게 의존하면 하나가 실패할 때 나머지도 잇달아 실패하므로 원인을 진단하기 어려워지며 후반 테스트가 찾아내야 할 결함이 숨겨진다.</li>
<li><strong>반복가능하게R</strong>epeatable: 어떤 환경에서도 반복 가능해야 한다. (네트워크에 연결되지 않은) 노트북 환경에서도 실행할 수 있어야 한다.</li>
<li><strong>자가검증하는</strong>Self-Validating: 부울bool 값으로 결과를 내야 한다.</li>
<li><strong>적시에T</strong>imely: 코드를 구현하기 직전에 구현한다. 테스트가 불가능하도록 실제 코드를 설계할지도 모른다.</li>
</ul>
</li>
<li><p><strong>결론</strong> 
: 테스트 코드는 지속적으로 깨끗하게 관리하자. 표현력을 높이고 간결하게 정리하자. 테스트 API를 구현해 도메인 특화 언어Domain Specific Language, DSL를 만들자. (p.168)</p>
</li>
</ul>
<hr>
<h3 id="오늘-읽은-소감은-떠오르는-생각을-가볍게-적어보세요">오늘 읽은 소감은? 떠오르는 생각을 가볍게 적어보세요</h3>
<p><strong>오늘 읽은 소감은? 떠오르는 생각을 가볍게 적어보세요</strong></p>
<blockquote>
<p>반복가능하게Repeatable: 어떤 환경에서도 반복 가능해야 한다. (네트워크에 연결되지 않은) 노트북 환경에서도 실행할 수 있어야 한다.</p>
</blockquote>
<ul>
<li>발생한 의문점🤔 &gt; 네트워크에 연결되지 않은 상태에서도 테스트가 가능해야한다고..? 이정도 까지...? 데이터 통신하는 테스트는 ..? 예외처리로 제외하나 아니면 false 감안하고 하는 건가.</li>
</ul>
<blockquote>
<ul>
<li>깨끗한 테스트 코드 유지하기 (p.156)<ul>
<li>지저분한 테스트 코드를 내놓으나 테스트를 안 하나 오십보 백보라는, 아니 오히려 더 못하다.</li>
<li>실제 코드가 진화하면 테스트 코드도 변해야 한다. 그런데 테스트 코드가 지저분할수록 변경하기 어려워진다. 테스트 코드가 복잡할수록 실제 코드를 짜는 시간보다 테스트 케이스를 추가하는 시간이 더 걸리기 십상이다.</li>
<li>실제 코드를 변경해 기존 테스트 케이스가 실패하기 시작하면, 지저분한 코드로 인해, 실패하는 테스트 케이스를 점점 더 통과시키기 어려워진다.</li>
</ul>
</li>
</ul>
</blockquote>
<ul>
<li>너무 공감되었다.. 사이드 플젝을 하며 작성했던 TC 코드는 프로젝트 진행하면서 관리에 실패했다. 결국 허울 뿐인 TC코드가 되었고 빌드할 때.. 주석하고 돌리기도 했다.! 🙄😥 주 실패요인은 무엇보다 책에서 강조한 가독성이 좋지 않아서 인 듯하다. 
당시 Jest를 사용해 TC를 작성했었다. 당시 처음으로 TC 작성을 하는 거라 잘 모르는 상태로 작성하기 급급해 검색하며 덕지덕지 만든 코드였다. (😂) 
지금 생각해 보면, 간단한 기능 위주로 더 분리를 할 수 있었을 것 같다. 아마도, 한개의 테스트 케이스에 너무 많은 기능 테스트를 작성했던 것이 또 다른 실패 원인인듯 하다. 시나리오를 어느정도 작성해두고 코드로 옮기면 더 명료한 TC가 가능했을 것이다. 
(💬 음.. 시나리오는 사용자 행동패턴 위주로 짜는 게 좋을까 기능별로 테스트 하는 것이 좋은 걸까?)</li>
</ul>
<hr>
<h3 id="궁금한-내용이-있거나-잘-이해되지-않는-내용이-있다면-적어보세요">궁금한 내용이 있거나, 잘 이해되지 않는 내용이 있다면 적어보세요.</h3>
<ul>
<li><p><strong>테스트 슈트</strong></p>
</li>
<li><p><strong>Given-When-Then 패턴</strong>
: Test Code 스타일을 표현하는 방식.</p>
<ul>
<li><strong>Given</strong>
: 테스트를 위해 준비하는 과정.
<em>ex. 테스트에 사용하는 변수, 입력 값 등을 정의하거나, Mock 객체를 정의하는 구문</em></li>
</ul>
<ul>
<li><p><strong>When</strong>
: 구체화하고자 하는 그 행동. 실제로 액션을 하는 테스트를 실행하는 과정.
<em>ex. click, getData ..</em></p>
</li>
<li><p><strong>Then</strong>
: 테스트를 검증하는 과정. 예상한 값, 실제 실행을 통해서 나온 값을 검증.
<em>ex. equals, includes, hasClass..</em></p>
<blockquote>
<p>참고] Given-When-Then 패턴 |
<a href="https://kchanguk.tistory.com/40">https://kchanguk.tistory.com/40</a></p>
</blockquote>
</li>
</ul>
</li>
</ul>
<p>#</p>
<ul>
<li><p><strong>템플릿 메서드 패턴 (template method Pattern)</strong></p>
<p>  : 어떤 작업을 처리하는 일부분을 서브 클래스로 캡슐화해 전체 일을 수행하는 구조는 바꾸지 않으면서 특정 단계에서 수행하는 내역을 바꾸는 패턴</p>
<p>  given/when 부분을 부모 클래스에 두고 then 부분을 자식 클래스에 두면 된다. 아니면 완전히 독자적인 테스트 클래스를 만들어 @Before 함수에 given/when 부분을 넣고 @Test 함수에 then 부분을 넣어도 된다. (p.165)</p>
<blockquote>
<p>참고] Design Pattern 템플릿 메서드 패턴 |
<a href="https://gmlwjd9405.github.io/2018/07/13/template-method-pattern.html">https://gmlwjd9405.github.io/2018/07/13/template-method-pattern.html</a></p>
</blockquote>
</li>
</ul>
]]></description>
        </item>
        <item>
            <title><![CDATA[[클린코드] 8. 경계]]></title>
            <link>https://velog.io/@dev_tuktack/%ED%81%B4%EB%A6%B0%EC%BD%94%EB%93%9C-8.-%EA%B2%BD%EA%B3%84</link>
            <guid>https://velog.io/@dev_tuktack/%ED%81%B4%EB%A6%B0%EC%BD%94%EB%93%9C-8.-%EA%B2%BD%EA%B3%84</guid>
            <pubDate>Tue, 05 Jul 2022 05:05:13 GMT</pubDate>
            <description><![CDATA[<p><img src="https://velog.velcdn.com/images/dev_tuktack/post/48aa4ddd-7233-4e55-93ae-7de889aa5083/image.png" alt=""></p>
<p><strong>TIL (Today I Learned)</strong></p>
<p>2022.05.13</p>
<p><strong>오늘 읽은 범위</strong></p>
<p>8장. 경계</p>
<hr>
<h3 id="책에서-기억하고-싶은-내용을-써보세요"><strong>책에서 기억하고 싶은 내용을 써보세요.</strong></h3>
<ul>
<li><p>Map은 굉장히 다양한 인터페이스로 수많은 기능을 제공한다. (p.144)
(..) Map 클래스를 사용할 때마다 위와 같이 캡슐화하라는 소리가 아니다. Map과 같은경계 인터페이스를 이용할 때는 이를 이용하는 클래스나 클래스 계열 밖으로 노출되지 않도록 주의한다.</p>
</li>
<li><p>경계 살피고 익히기 (p.146)
우리가 사용할 코드를 테스트하는 편이 바람직하다.</p>
</li>
<li><p>학습테스트 (p.147)
: 우리쪽 코드를 작성해 외부 코드를 호출하는 대신 먼저 간단한 테스트 케이스를 작성해 외부 코드를 익히는 방법. (외부코드;사용라이브러리 코드)</p>
</li>
<li><p>학습 테스트는 패키지가 예상대로 도는지 검증한다. (..) 패키지가 우리 코드와 호환되리라는 보장은 없다. (..) 새 버전이 우리 코드와 호환되지 않으면 학습 테스트가 이 사실을 곧바로 밝혀낸다. (..) 실제 코드와 동일한 방식으로 인터페이스를 사용하는 테스트 케이스가 필요하다. (p.149-150)</p>
</li>
<li><p>아직 존재하지 않는 코드를 사용하기 (p.150)
: 아는 코드와 모르는 코드를 분리하는 경계다. (..) 저쪽 팀이 아직 API를 설계하지 않았으므로 구체적인 방법은 몰랐다. (aka.모르는 코드)</p>
</li>
<li><p>깨끗한 경계 (p.152)
경계에 위치하는 코드는 깔끔히 분리한다. 또한 기대치를 정의하는 테스트 케
이스도 작성한다. 이쪽 코드에서 외부 패키지를 세세하게 알아야 할 필요가 없
다. 통제가 불가능한 외부 패키지에 의존하는 대신 통제가 가능한 우리 코드에
의존하는 편이 훨씬 좋다.</p>
</li>
</ul>
<hr>
<h3 id="오늘-읽은-소감은-떠오르는-생각을-가볍게-적어보세요"><strong>오늘 읽은 소감은? 떠오르는 생각을 가볍게 적어보세요</strong></h3>
<ul>
<li>TC가 필요한 이유.. 라이브러리 사용에 대한 최소한의 보험.!
(* 새 버전이 우리 코드와 호환되지 않으면 학습 테스트가 이 사실을 곧바로 밝혀낸다. .. 링크)</li>
<li>아직 존재하지 않는 코드를 사용하기 (링크)
: 아.. 너무 공감 된다. 오늘만 해도 구현되지 않은 API의 데이터구조를 상상하며 작업을 하였다. 프로젝트를 진행하다 보면, 여러사람들과 같이 일하게 되기에, 불가피하지만 충분히 일어날 수 있는 상황이다. 
저자가 인터페이스 구현에 있어 코드 가독성도 높아지고 코드 의도도 분명해진다고 말한건, 발상의 전환 그자체였다.. 뭐 그렇게 보면 장점도 있겠다 싶었다. 완전히 분리된 설계가 가능해 지니까.. 수정가능성도 여부에 두고 작업을 하게 되니 API 변경여부에 대해서도 유연하게 대응할 수 있겠다 생각했다.</li>
</ul>
<hr>
<h3 id="궁금한-내용이-있거나-잘-이해되지-않는-내용이-있다면-적어보세요"><strong>궁금한 내용이 있거나, 잘 이해되지 않는 내용이 있다면 적어보세요.</strong></h3>
<p><strong>학습테스트</strong> (p.147)
: 우리쪽 코드를 작성해 외부 코드를 호출하는 대신 먼저 간단한 테스트 케이스를 작성해 외부 코드를 익히는 방법. (외부코드; 사용라이브러리 코드)</p>
<p>#</p>
<p><strong>ADAPTER 패턴</strong> </p>
<ul>
<li>정의) 한 클래스의 인터페이스를 클라이언트에서 사용하고자하는 다른 인터페이스로 변환한다.
어댑터를 이용하면 인터페이스 호환성 문제 때문에 같이 쓸 수 없는 클래스들을 연결해서 쓸 수 있다.</li>
<li><strong>클라이언트와</strong> 구현된 <strong>인터페이스를 분리</strong>시킬수 있으며, <strong>향후 인터페이스가 바뀌더라도 그 변경 내역은 어댑터에 캡슐화</strong> 되기 때문에 클라이언트는 바뀔 필요가 없어진다.
<img src="https://velog.velcdn.com/images/dev_tuktack/post/5b921f50-b821-4a8e-a2b4-2514d0656bb0/image.png" alt="">
<a href="https://jusungpark.tistory.com/22">디자인패턴_어댑터 패턴(adapter pattern) 참고 블로그</a></li>
</ul>
]]></description>
        </item>
        <item>
            <title><![CDATA[[클린코드] 7. 오류 처리]]></title>
            <link>https://velog.io/@dev_tuktack/%ED%81%B4%EB%A6%B0%EC%BD%94%EB%93%9C-7.-%EC%98%A4%EB%A5%98-%EC%B2%98%EB%A6%AC</link>
            <guid>https://velog.io/@dev_tuktack/%ED%81%B4%EB%A6%B0%EC%BD%94%EB%93%9C-7.-%EC%98%A4%EB%A5%98-%EC%B2%98%EB%A6%AC</guid>
            <pubDate>Tue, 05 Jul 2022 05:04:41 GMT</pubDate>
            <description><![CDATA[<p><img src="https://velog.velcdn.com/images/dev_tuktack/post/1ce37487-4b68-4d38-81aa-fc6e3d20e2d8/image.png" alt=""></p>
<p><strong>TIL (Today I Learned)</strong>
2022.05.09</p>
<p><strong>오늘 읽은 범위</strong>
7장. 오류 처리</p>
<hr>
<h3 id="책에서-기억하고-싶은-내용을-써보세요"><strong>책에서 기억하고 싶은 내용을 써보세요.</strong></h3>
<ul>
<li>오류 코드보다 예외를 사용하라 (p.130)
#</li>
<li>Try-Catch-Finally 문부터 작성하라. (p.132)<ul>
<li>try 블록에서 무슨 일이 생기든지 호출자가 기대하는 상태를 정의하기 쉬워진다.
#</li>
</ul>
</li>
<li>먼저 강제로 예외를 일으키는 테스트 케이스를 작성한 후 테스트를 통과하게 코드를 작성하는 방법을 권장한다. 그러면 자연스럽게 try 블록의 트랜잭션 범위부터 구현하게 되므로 범위 내에서 트랜잭션 본질을 유지하기 쉬워진다. (p.133)
#</li>
<li>미확인 예외를 사용하라. (p.133)<ul>
<li>확인된 예외 (..) 메서드 모두가 선언부에 해당 예외를 정의해야 한다. (..) 하위 단계에서 코드를 변경하면 상위 단계 메서드 선언부를 전부 고쳐야 한다. (..) ! throws 경로에 위치하는 모든 함수가 최하위 함수에서 던지는 예외를 알아야 하므로 캡슐화가 깨진다.
#</li>
</ul>
</li>
<li>null을 반환하지 마라 (p.139)<ul>
<li>메서드에서 null을 반환하고픈 유혹이 든다면 그 대신 예외를 던지거나 특수 사례 객체를 반환한다. 사용하려는 외부 API가 null을 반환한다면 감싸기 메서드를 구현해 예외를 던지거나 특수 사례 객체를 반환하는 방식을 고려한다.
#</li>
</ul>
</li>
<li>null을 전달하지 마라. (p.140-141)<ul>
<li>대다수 프로그래밍 언어는 호출자가 실수로 넘기는 null을 적절히 처리하는
방법이 없다. 그렇다면 애초에 null을 넘기지 못하도록 금지하는 정책이 합리적
이다. 즉, 인수로 null이 넘어오면 코드에 문제가 있다는 말이다. </li>
</ul>
</li>
</ul>
<hr>
<h3 id="오늘-읽은-소감은-떠오르는-생각을-가볍게-적어보세요"><strong>오늘 읽은 소감은? 떠오르는 생각을 가볍게 적어보세요.</strong></h3>
<h4 id="😏-확인된-예외-구체적인-오류처리를-하면-장점만-있다고-생각했다">😏 확인된 예외, 구체적인 오류처리를 하면 장점만 있다고 생각했다.</h4>
<p>오류 case를 잡아내는 것에만 중점을 둬서, 자세하고 확실한 경우를 잡아내는 것이 우선이라고만 생각했다. 기존 코드를 수정하는 것도 비용에 포함된다고는 생각을 못했었다. 기회비용을 잘 따져 선택하는 것이 중요하다 생각이 되었다. 
책을 읽을수록 당연하다고 생각하고 신경쓰지 않았던 것들을 의식하게 되어서 너무 좋다.</p>
<hr>
<h3 id="궁금한-내용이-있거나-잘-이해되지-않는-내용이-있다면-적어보세요"><strong>궁금한 내용이 있거나, 잘 이해되지 않는 내용이 있다면 적어보세요.</strong></h3>
<ul>
<li><p><strong>asset</strong>
  : Assert는 개발/테스트 단계에서 파라미터가 제대로 넘어왔는지 계산이 제대로 됬는지 혹은 특정 메소드가 작동하는 한계상황(Null이 들어오면 작동안함)을 정하는 용도로 사용한다.</p>
<p>  <a href="https://yeh35.github.io/blog.github.io/documents/java/java-assert/">참고 블로그 | Java에서 assert 제대로 쓰기</a></p>
</li>
</ul>
]]></description>
        </item>
        <item>
            <title><![CDATA[[클린코드] 6. 객체와 자료구조]]></title>
            <link>https://velog.io/@dev_tuktack/%ED%81%B4%EB%A6%B0%EC%BD%94%EB%93%9C-6.-%EA%B0%9D%EC%B2%B4%EC%99%80-%EC%9E%90%EB%A3%8C%EA%B5%AC%EC%A1%B0</link>
            <guid>https://velog.io/@dev_tuktack/%ED%81%B4%EB%A6%B0%EC%BD%94%EB%93%9C-6.-%EA%B0%9D%EC%B2%B4%EC%99%80-%EC%9E%90%EB%A3%8C%EA%B5%AC%EC%A1%B0</guid>
            <pubDate>Tue, 05 Jul 2022 05:01:47 GMT</pubDate>
            <description><![CDATA[<p><img src="https://velog.velcdn.com/images/dev_tuktack/post/a79951d8-107c-4b98-b1da-20eab26c389b/image.png" alt=""></p>
<p><strong>TIL (Today I Learned)</strong></p>
<p>2022.05.13</p>
<p><strong>오늘 읽은 범위</strong>
 6. 객체와 자료구조</p>
<hr>
<h2 id="📖-책에서-기억하고-싶은-내용을-써보세요">📖 <strong>책에서 기억하고 싶은 내용을 써보세요.</strong></h2>
<ul>
<li>구현을 감추려면 추상화가 필요하다! P.119
 : 추상 인터페이스를 제공해 사용자가 구현을 모른 채 자료의 핵심을 조작할 수 있어야 진정한 의미 의 클래스다.<h1 id=""></h1>
</li>
</ul>
<ul>
<li><p>자료/객체 비대칭 (p.119-122) (a: 객체지향 / b: 자료구조)
  a. 객체는 추상화 뒤로 자료를 숨긴 채 자료를 다루는 함수만 공개한다.
  b. 자료 구조 는 자료를 그대로 공개하며 별다른 함수는 제공하지 않는다. </p>
<hr>
<p>  a. 객체 지향 코드는 기존 함수를 변경하지 않으면 서 새 <strong>클래스</strong>를 추가하기 쉽다.
  b. (자료 구조를 사용하는) 절차적인 코드는 기존 자료 구조를 변경하지 않으면서 새 <strong>함수</strong>를 추가하기 쉽다.</p>
<hr>
<p>  a. 객체 지향 코드는 새로운 함수를 추가하기 어렵다. 그러려면 모든 클 래스를 고쳐야 한다.
  b. 절차적인 코드는 새로운 자료 구조를 추가하기 어렵다. 그러려면 모든 함수를 고 쳐야 한다.</p>
<p>  #</p>
</li>
<li><p>잡종 구조 (p.124)
: 단점만 모아놓은 구조. (..) 프로그래머가 함수나 타입을 보호할지 공개할지 확인하지 못해 내놓은 설계.</p>
</li>
</ul>
<ul>
<li>구조체 감추기. (p.125)
: 객체라면 내부구조를 감춰야한다.
<img src="https://velog.velcdn.com/images/dev_tuktack/post/3f43699f-d20c-4bba-a547-969104a69556/image.png" alt=""></li>
</ul>
<h2 id="🐱👓-오늘-읽은-소감은-떠오르는-생각을-가볍게-적어보세요">🐱‍👓 <strong>오늘 읽은 소감은? 떠오르는 생각을 가볍게 적어보세요</strong></h2>
<p> 내가 혹여나 알고 있던 개념이더라도 줄 글로 읽으니 이해 하기가 어려웠다. 코드예제를 같이 보니 좀 나았다. </p>
<p> 그리고 객체.. 굉장히 기본적인 개념인데 책 읽다보니.. 아는 것이라고 볼 수 없겠더라.  객체와 자료구조.. 책도 별도로 있을 만큼 방대하게 다룰 수 있는 주제인데.. 중요한 내용만 함축된 것으로 접해서 그런지 이해하기 어려운 부분이 있었다. 또 멋모르고 개발 했던 내 스스로를 되돌아 보게됬다. (나는 얼마나 무지랭이로 개발 했던가.. 후후)</p>
<p> 자료구조는 프로그래밍을 건축으로 치면 기본 뼈대를 잡는 것이라고 많이들 이야기한다. 아기 돼지 삼형제 이야기가 생각난다. 나는 지금까지 첫째 돼지가 집짓는 것 처럼 코딩했었다. 앞으로는 형식만 내는 것이 아닌, 위기가 오더라도 견딜 수 있는 견고한 프로그래밍을 하고 싶다. 벽돌집을 짓는 그날 까지 화이팅하자. 🔥👊</p>
<h2 id="🧐-궁금한-내용이-있거나-잘-이해되지-않는-내용이-있다면-적어보세요">🧐 <strong>궁금한 내용이 있거나, 잘 이해되지 않는 내용이 있다면 적어보세요.</strong></h2>
<ul>
<li><strong>객체와 자료구조 차이.</strong>
: 책에서 말하는 개념을 내 나름대로 재정의 해보았다.
<img src="https://velog.velcdn.com/images/dev_tuktack/post/77f7e6a2-e7a9-47b8-b4fb-12c13f78b09b/image.png" alt=""></li>
</ul>
<p>#</p>
<ul>
<li><strong>다형polymorphic 메서드</strong>
: 하나의 객체가 여러 가지 타입을 가질 수 있는 것을 의미합니다. 자바에서는 이러한 다형성을 부모 클래스 타입의 참조 변수로 자식 클래스 타입의 인스턴스를 참조할 수 있도록 하여 구현. 다형성은 상속, 추상화와 더불어 객체 지향 프로그래밍을 구성하는 중요한 특징 중 하나.
<a href="https://whatisthenext.tistory.com/34">[JAVA] 다형성(polymorphism)</a></li>
</ul>
<p>#</p>
<ul>
<li><strong>디미터 법칙</strong> (p.123)
: 객체는 자료를 숨기고 함수를 공개한다. 즉, 객체는 조회 함수로 내부 구조를 공개하면 안 된다.<blockquote>
<p>객체 지향적로 함수를 통해서 접근하는 것이 좋음. 
 (기차충돌; 내부상황 모두 공유하거나 객체안의 모습을 보여주면, 나중에 상태변환하기 힘들다.)</p>
</blockquote>
</li>
</ul>
]]></description>
        </item>
        <item>
            <title><![CDATA[[클린코드] 5. 형식 맞추기]]></title>
            <link>https://velog.io/@dev_tuktack/%ED%81%B4%EB%A6%B0%EC%BD%94%EB%93%9C-5.-%ED%98%95%EC%8B%9D-%EB%A7%9E%EC%B6%94%EA%B8%B0</link>
            <guid>https://velog.io/@dev_tuktack/%ED%81%B4%EB%A6%B0%EC%BD%94%EB%93%9C-5.-%ED%98%95%EC%8B%9D-%EB%A7%9E%EC%B6%94%EA%B8%B0</guid>
            <pubDate>Tue, 05 Jul 2022 04:01:51 GMT</pubDate>
            <description><![CDATA[<p><img src="https://velog.velcdn.com/images/dev_tuktack/post/d6f27b48-3153-4e21-b19d-93fce0b85ab3/image.png" alt=""></p>
<p><strong>TIL (Today I Learned)</strong></p>
<p>2022.05.09</p>
<p><strong>오늘 읽은 범위</strong></p>
<p>5장. 형식 맞추기</p>
<hr>
<h2 id="📖-책에서-기억하고-싶은-내용을-써보세요">📖 <strong>책에서 기억하고 싶은 내용을 써보세요.</strong></h2>
<p><strong>서론</strong></p>
<ul>
<li>코드 형식을 맞추기 위한 간단한 규칙을 정하고따라야 한다</li>
<li>팀 이 합의해 규칙을 정하고 모두가 그 규칙을 따라야 한다</li>
<li>필요하다면 규칙을 자동으로 적용하는 도구를 활용한다.</li>
</ul>
<p>#</p>
<p><strong>형식을 맞추는 목적</strong></p>
<blockquote>
<p>융통성 없이 맹목적으로 따르면 안됨. 
코드 형식 === 의사소통의 일환
의사소통은 전문 개발자의 일차적인 의무.</p>
</blockquote>
<p>코드가 바뀌어도 <u>맨 처음 잡아놓은 구현 스타일과 가독성 수준은</u>
유지보수 용이성과 확장성에 <u>계속 영향을 미친다.</u></p>
<blockquote>
</blockquote>
<p>aka. 코드는 사라질지라도 개발자의 스타일과 규율은 사라지지 않는다</p>
<p>#</p>
<p><strong>적절한 행 길이를 유지하라</strong>
큰 파일보다 작은 파일이 이해하기 쉽다.</p>
<details>
  <summary><b>신문 기사처럼 작성하라</b></summary>
<div markdown="1">
위에서 아래로
  </br>
  1. 최상 단에 기사를 몇 마디로 요약하는 표제</br>
  2. 첫 문단은 전체 기사 내용을 요약</br>
  3. 쭉 읽으며 내려가면 세세한 사실이 조금씩 드러남.</br>
</div>
</details>

<p>#</p>
<details>
<summary><b>코드에 반영하면</b></summary>
<div markdown="1">
    이름은 간단하면서도 설명이 가능하게 짓는다.</br>
    이름만 보고도 올바른 모듈을 살펴보고 있는지 아닌지를 판단 가능해야 함.</br></br>
    1. 파일 첫 부분은 고차원 개념과 알고리즘을 설명 </br>
    2. 아래로 내려갈수록 의도를 세세하게 묘사 </br>
    3. 마지막에는 가장 저차원 함수와 세부 내역이 나온다. </br>
</div>
</details>

<p>#</p>
<p><strong>개념은 빈 행으로 분리</strong>
일련의 행 묶음은 완결된 생각 하나를 표현한다. 
생각 사이는 빈 행을 넣어 분리. 
빈 행은 새로운 개념을 시작한다는 시각적 단서 → 가독성 good</p>
<p>#</p>
<p><strong>세로 밀집도</strong>
줄바꿈 = 분리 
세로 밀집도 = 연관성</p>
<p>#</p>
<p><strong>수직 거리</strong>
서로 밀접한 개념은 세로로 가까이 둬야 한다. (protected 변수를 피해야 하는 이유)</p>
<p>#</p>
<p><strong>연관성</strong>이란,
: 한 개념을 이해하는 데 다른 개념이 중요한 정도.
<u>연관성이 깊은 개념이 멀리 떨어져 있으면</u> 코드를 읽는 사람이 소스 파일과 클래스 를 여기저기 뒤지게 된다.
👉 어디에 있는지 찾고 기억 → <u>시간과 노력이 소모됨.</u></p>
<p>#</p>
<p><strong>변수 선언</strong></p>
<ul>
<li>변수는 사용하는 위치에 최대한 가까이 선언</li>
<li>지역 변수는 각 함수 맨 처음에 선언</li>
<li>루프를 제어하는 변수는 흔히 루프 문 내부에 선언</li>
<li>다소 긴 함수에서 블록 상단이나 루프 직전에 변수를 선언</li>
<li>인스턴스 변수클래스 맨 처음에 선언</li>
<li>코드 읽다가 중간에 변수 발견하는 일은 없어야 함.</li>
</ul>
<p>#</p>
<p><strong>종속 함수</strong>
한 함수가 다른 함수를 호출 → 두 함수는 세로로 가까이 배치.
규칙 일관적으로 적용 시, 코드를 읽는사람이 방금 호출한 함수, 뒤에서 정의되리라는 사실을 예측.</p>
<blockquote>
<p>🔎 효과</p>
</blockquote>
<ul>
<li>호출되는 함수를 찾기가 쉬움.</li>
<li>모듈 전체의 가독성도 높아진다.</li>
</ul>
<p>#</p>
<p><strong>개념적 유사성</strong>
개념적인 친화도가 높을수록 코드를 가까이 배치.</p>
<blockquote>
<p>📌 Ex. </p>
</blockquote>
<ul>
<li>한 함수가 다른 함수를 호출해 생기는 직접적인 종속성</li>
<li>비슷한 동작을 수행</li>
<li>명명법이 똑같고 기본 기능이 유사</li>
</ul>
<p>#</p>
<p><strong>세로 순서</strong>
호출되는 함수 먼저 배치 &amp; 호출하는 함수 나중 배치
⇒ 소스 코드 모듈이 고차원 에서 저차원으로 자연스럽게 내려감.</p>
<p>#</p>
<h3 id="가로-형식-맞추기"><strong>가로 형식 맞추기</strong></h3>
<p><strong>1. 가로 정렬</strong>
정렬이 필요할 정도로 목록이 길다? → 목록 길이가 문제.
선언부가 너무 길면, 클래스를 쪼개야 함.</p>
<p><strong>2. 들여쓰기</strong>
범위(scope)로 이뤄진 계층을 표현하기 위함. 
코드가 속해있는 범위를 시각적으로 표현.
계층에서 각 수준은 이름을 선언하는 범위이자 선언문과 실행문을 해석하는 범위</p>
<blockquote>
<p>🔎 범위 Example</p>
</blockquote>
<ul>
<li>파일 전체에 적용</li>
<li>파일 내 개별 클래스에 적용</li>
<li>클래스 내 각 메서드에 적용</li>
<li>블록 내 블록에 재귀적으로 적용</li>
</ul>
<p>#</p>
<p><strong>팀규칙</strong></p>
<ol>
<li>팀과 마주 앉아 구현 스타일을 논의.</li>
<li>어디에 괄호를 넣을지, 들여쓰기는 몇 자 로 할지, 클래스와 변수와 메서드 이름은 어떻게 지을지 등을 결정.</li>
<li>정한 규칙으로 IDE 코드 형식기를 설정한 후 지금까지 사용</li>
</ol>
<hr>
<h2 id="🐱👓-오늘-읽은-소감은-떠오르는-생각을-가볍게-적어보세요">🐱‍👓 <strong>오늘 읽은 소감은? 떠오르는 생각을 가볍게 적어보세요</strong></h2>
<p>👆 책에서는 신문기사로 예시를 들어 줬지만, 소설이든 에세이든, 잘쓰여진 글은 쉽게 읽히는 글이라고들 한다. (공감하는 바)
 잘 짜여진 코드는 줄 글읽듯 서사에 맞게 아래로 쭉읽혀야 하며, 사용된 변수는 곧 뒤에 나올거라는 신뢰관계가 있어야 한다 는 이야기가 참 재미 있었다.</p>
<p>✌ 프로그래밍도 컴퓨터랑 나, 그리고 나와 다른 개발자들이 소통하는 언어인 만큼 사회적인 작업이라 생각이 된다. 우리가 얼린 물을 &#39;삼다수바&#39;라 하지않고 &#39;얼음&#39;이라고 부르는 것처럼 팀원들과의 사회적 약속을 잘 지키는 프로그래밍을 하자-!</p>
<hr>
<h2 id="🧐-궁금한-내용이-있거나-잘-이해되지-않는-내용이-있다면-적어보세요">🧐 <strong>궁금한 내용이 있거나, 잘 이해되지 않는 내용이 있다면 적어보세요.</strong></h2>
]]></description>
        </item>
        <item>
            <title><![CDATA[[클린코드] 4. 주석 ]]></title>
            <link>https://velog.io/@dev_tuktack/%ED%81%B4%EB%A6%B0%EC%BD%94%EB%93%9C-4.-%EC%A3%BC%EC%84%9D</link>
            <guid>https://velog.io/@dev_tuktack/%ED%81%B4%EB%A6%B0%EC%BD%94%EB%93%9C-4.-%EC%A3%BC%EC%84%9D</guid>
            <pubDate>Tue, 05 Jul 2022 03:55:14 GMT</pubDate>
            <description><![CDATA[<p><strong>TIL (Today I Learned)</strong></p>
<p>2022.06.02</p>
<p><strong>오늘 읽은 범위</strong></p>
<p>4장. 주석</p>
<hr>
<h2 id="📖-책에서-기억하고-싶은-내용을-써보세요">📖 <strong>책에서 기억하고 싶은 내용을 써보세요.</strong></h2>
<p>#</p>
<ul>
<li><p><strong>주석사용 = 코드로 의도표현 실패</strong>
→ 주석을 가능한 줄이도록 꾸준히 노력</p>
</li>
<li><p><strong>주석은 나쁜 코드를 보완하지 못한다</strong>
코드에 주석을 추가하는 일반적인 이유 = 코드 품질이 나쁘기 때문
주석달기 &lt;&lt; 코드 정리</p>
</li>
<li><p><strong>코드로 의도를 표현하라!</strong></p>
</li>
</ul>
<p>#</p>
<h4 id="좋은-주석-🔽">좋은 주석 🔽</h4>
<p><strong>1. 법적인 주석</strong>
소스 파일 첫머리에 주석으로 들어가는 저작권 정보와 소유권 정보는 필요하며 타당하다. </p>
<p><strong>2. 정보를 제공하는 주석</strong>
가능하다면, 함수 이름에 정보를 담는 편이 더 좋다. 
(+클래스를 만들어 코드를 옮겨주면 더 좋고 더 깔끔함.)</p>
<p><strong>3. 의도를 설명 &amp; 명료하게 밝히는 주석</strong>
인수나 반환값 자체를 명확하게 만들면 best, 
인수나 반환값이 표준 라이브러리나 변경하지 못하는 코드에 속한다면 의미를 명료하게 밝히는 주석이 유용하다.</p>
<p><strong>4. 결과를 경고하는 주석</strong></p>
<blockquote>
<p>Ex. 특정 테스트 케이스를 꺼야 하는 이유를 설명 → 여유 시간이 충분하지 않다면 실행하지 마십시오.</p>
</blockquote>
<p>요즘은 주석 대신 테스트 케이스를 꺼버림. (@Ignore 사용)</p>
<p><strong>5. TODO 주석</strong></p>
<ul>
<li>필요하나, 당장 구현하기 어려운 업무 </li>
<li>더 이상 필요 없는 기능을 삭제하라는 알림, </li>
<li>누군가에게 문제를 봐달 라는 요청, </li>
<li>더 좋은 이름을 떠올려달라는 부탁, </li>
<li>앞으로 발생할 이벤트에 맞춰 코드를 고치라는 주의</li>
</ul>
<p>But, 어떤 용도든, 시스템에 나쁜 코드를 남겨 놓는 핑계가 되면 안됨.</p>
<p><strong>6. 중요성을 강조하는 주석</strong>
대수롭지 않다고 여겨질 뭔가의 중요성을 강조.</p>
<p><strong>7. 공개 API에서 Javadocs</strong>
Javadocs도 잘못된 정보 전달 가능성 있음.
<code>ex.독자를 오도, 잘못 위치..</code></p>
<h4 id="나쁜-주석-🔽">나쁜 주석 🔽</h4>
<p><strong>1. 주절거리는 주석</strong>
의미없음 → 다른 사람들에게 전달되지 않는다.</p>
<p><strong>2. 같은 이야기를 중복하는 주석</strong>
(코드파악 시간 &lt;&lt;&lt; 주석을 읽는 시간)
코드만 지저분하고 정신 없게 만든다.
<code>Ex. 쓸모없고 중복된 Javadocs</code></p>
<p><strong>3. 오해할 여지가 있는 주석</strong>
주석에 담긴 ‘살짝 잘못된 정보’로 인해 
프로그래머는 코드가 돌아가는 이유를 찾느라 골머리를 앓는다.</p>
<p><strong>4. 의무적으로 다는 주석</strong>
코드만 헷갈리게 만들며, 거짓말할 가능성을 높이며, 
잘못된 정보를 제공할 여지만 만듦.
특별한 이유 없이 의무감으로 다는 주석은 === 시간낭비.</p>
<p><strong>5. 이력을 기록하는 주석</strong>
이전에는 소스 코드 관리 시스템이 없었으니까 괜찮음. 
지금은 필요 없음.</p>
<p><strong>6. 있으나 마나 한 주석</strong>
:당연한 사실을 언급하며 새로운 정보를 제공하지 못하는 주석.
→ 개발자가 주석을 무시하는 습관에 빠진다. 결국 코드가 바뀌면서 주석은 거짓말로 변함.
함수나 변수로 표현할 수 있다면 주석을 달지 말 것.</p>
<p><strong>7. 위치를 표시하는 주석</strong>
배너 아래 특정 기능을 모아놓으면 유용한 경우도 있긴 함.
배너는 눈에 띄며 주의를 환기 
뒷부분에 슬래시(/)로 이어지는 잡음은 제거하는 편이 좋다.
반드시 필요할 때만, 아주 드물게 사용하기
<code>Ex. // Actions //////////////////////////////////</code></p>
<p><strong>8. 닫는 괄호에 다는 주석</strong> 
중첩이 심하고 장황한 함수라면 의미가 있을지도 모르지만 작고 캡슐화된 함수에는 잡음 함수를 줄이려 시도</p>
<blockquote>
<p>코드 예제
<img src="https://velog.velcdn.com/images/dev_tuktack/post/38233a76-ce19-4961-b9a5-b5c2bef6568e/image.png" alt="코드예제"></p>
</blockquote>
<p><strong>9. 공로를 돌리거나 저자를 표시하는 주석</strong>
이제는 소스 코드 관리 시스템으로 대체.
→ 주석은 그냥 오랫동안 코드에 방치되어 점차 부정 확하고 쓸모없는 정보로 변하기 쉽다.</p>
<p><strong>10. 주석으로 처리한 코드</strong>
이유가 있어 남겨 놓았으리라고 생각함 &amp; 중요하니까 지우면 안 된다고 생각. → 계속 불필요하게 메모리 차지 &amp; 코드 지저분.. </p>
<p><strong>11. HTML 주석</strong>
HTML 태그를 삽입해야 하는 책임은 프로그래머가 아니라 도구가 져야 한다.</p>
<blockquote>
<p>Ex. 코드예제
   <img src="https://velog.velcdn.com/images/dev_tuktack/post/0d7ba64d-6777-47b2-b3c8-6b210c82e4c2/image.png" alt=""></p>
</blockquote>
<p><strong>12. 모호한 관계</strong>
주석과 주석이 설명하는 코드는 둘 사이 관계가 명백해야 한다.</p>
<p><strong>13. 함수 헤더</strong>
짧고 + 한 가지 역할만 수행 + 굿 네이밍 함수 → 주석으로 헤더추가한 함수</p>
<p><strong>14. 비공개 코드에서 Javadocs</strong>
공개하지 않을 코드라면 Javadocs는 쓸모가 없다.</p>
<p>#</p>
<p>⛳<strong>결론</strong>
변수 이름을 바꾸거나,
코드 구조를 조정해 이유를 명확하게 설명할 방법을 찾지 못했다. 
→ 주석 필요.</p>
<hr>
<h2 id="🐱👓-오늘-읽은-소감은-떠오르는-생각을-가볍게-적어보세요">🐱‍👓 <strong>오늘 읽은 소감은? 떠오르는 생각을 가볍게 적어보세요</strong></h2>
<p>“주석보다는 전달하는 메세지가 명료한 코드가 낫다” 는 결론. 
그만큼 코드가 읽기 쉽게 잘 짜여져야 된다는 이야기로도 들렸다.  </p>
<hr>
<h2 id="🧐-궁금한-내용이-있거나-잘-이해되지-않는-내용이-있다면-적어보세요">🧐 <strong>궁금한 내용이 있거나, 잘 이해되지 않는 내용이 있다면 적어보세요.</strong></h2>
]]></description>
        </item>
        <item>
            <title><![CDATA[[클린코드] 3장. 함수]]></title>
            <link>https://velog.io/@dev_tuktack/%ED%81%B4%EB%A6%B0%EC%BD%94%EB%93%9C-3%EC%9E%A5.-%ED%95%A8%EC%88%98</link>
            <guid>https://velog.io/@dev_tuktack/%ED%81%B4%EB%A6%B0%EC%BD%94%EB%93%9C-3%EC%9E%A5.-%ED%95%A8%EC%88%98</guid>
            <pubDate>Mon, 27 Jun 2022 13:34:15 GMT</pubDate>
            <description><![CDATA[<p><img src="https://velog.velcdn.com/images/dev_tuktack/post/6a5e71b1-ab4c-41ef-b5d2-0bc3a152ec01/image.png" alt=""></p>
<p><strong>TIL (Today I Learned)</strong></p>
<p>2022.05.09</p>
<p><strong>오늘 읽은 범위</strong></p>
<p>3장. 함수</p>
<hr>
<h2 id="📖-책에서-기억하고-싶은-내용을-써보세요">📖 <strong>책에서 기억하고 싶은 내용을 써보세요.</strong></h2>
<ul>
<li>함수는 한 가지를 해야 한다. 그 한 가지를 잘 해야 한다. 그 한 가지만을 해야 한다. (p.44)</li>
<li>함수가 확실히 <strong>‘한 가지’ 작업만 하려면 함수 내</strong> 모든 문장의 <strong>추상화 수준이 동일해야 한다.</strong><ul>
<li>한 함수 내에 추상화 수준을 섞으면 코드를 읽는 사람이 헷갈린다. 근본 개념과 세부사항을 뒤섞기 시작하면, 깨어진 창문처럼 사람들이 함수에 세부사항을 점점 더 추가한다. (p.45-46)</li>
</ul>
</li>
<li>코드는 위에서 아래로 이야기처럼 읽혀야 좋다. (p.46)</li>
<li>길고 서술적인 이름이 길고 서술적인 주석보다 좋다. (p.49)</li>
<li>최선은 입력 인수가 없는 경우이며, 차선은 입력 인수가 1개뿐인 경우다. (p.51)</li>
<li>플래그 인수는 추하다. (...) 함수가 한꺼번에 여러 가지를 처리한다고 대놓고 공표하는 셈이니까! 플래그가 참이면 이걸 하고 거짓이면 저걸 한다는 말이니까! (p.52)</li>
<li>어떤 코드든 절대로 무시하면 안되니까. 무시한 코드에 오류가 숨어드니까. (p.52)</li>
<li>부수 효과를 일으키지 마라! (p.55)<ul>
<li>함수에서 한 가지를 하겠다고 약속하고선 (..) 예상치 못하게 클래스 변수를 수정한다.</li>
<li>만약 시간적인 결합이 필요하다면 함수 이름에 분명히 명시한다.</li>
</ul>
</li>
</ul>
<hr>
<h2 id="🐱👓-오늘-읽은-소감은-떠오르는-생각을-가볍게-적어보세요">🐱‍👓 <strong>오늘 읽은 소감은? 떠오르는 생각을 가볍게 적어보세요</strong></h2>
<ul>
<li>추상화 수준이 동일해야한다.
: 맞는말이다. 지금껏 의식하지 못했던 사항이라 이제부터 추상화 레벨에 대해 신경써서 개발 해야겠다.
#</li>
<li>시스템 구현하면서도 계속 함수 세분화를 의식하면서 하는 것이 중요하다. 깨어진 창문논리가 공감이 많이 되었다. 책에서 이야기하는 개발 방식은 신경과 정성이 많이 들어갈 수밖에 없는데, 한번 괜찮겠지.. 급하니까 라고 생각하다보면 어느 새 겉잡을 수 없는 스파게티 소스가 되어버렸다.. 그리고 날잡고 리팩토링을 하는 수 밖에.. 오히려 리소스가 더 많이 들어가니 틈틈히 하자..!</li>
</ul>
<blockquote>
<h4 id="깨진-창문-p45-46"><strong>깨진 창문 (p.45-46)</strong></h4>
<p> 한 함수 내에 추상화 수준을 섞으면 코드를 읽는 사람이 헷갈린다. 근본 개념과 세부사항을 뒤섞기 시작하면, 깨어진 창문처럼 사람들이 함수에 세부사항을 점점 더 추가한다. </p>
</blockquote>
<ul>
<li>인수를 최소화 하는 것이 좋다는 것은, Object 타입의 인수를 넘겨 함수에서 구조분해할당으로 사용하는 방식에도 해당되는 것일까?
  : Object내 필요 property만 선언해 사용하다 보면 Object내 전체 항목을 파악하는 것이 어려울 때가 있다. (Object 항목이 많을 때, 추가적으로 호출이 필요하다면, 상위 함수를 추적해 전체 데이터를 확인해야하는 불상사가 간혹 있었다.) 이 경우에는 인수는 하나지만, 저자가 말하는 다중 인수의 부작용과 비슷한 상황이 있을 수 있는 경우라 생각했다.<h1 id=""></h1>
</li>
<li>🤔❔ 타입스크립트를 사용하는 것으로 해결을 할 수도 있다. 만약 vue 컴포넌트를 사용한다면 컴포넌트 생성할 때 prop 타입을 지정해 주는 것으로 어느 정도의 가이드라인이 될 수 있겠다. 지금 사내 프로젝트에서는 어떻게 보완할수 있을까..
#</li>
<li>🤔❔ 아니면 근본적인 원인해결, object 내 선언하는 property 갯수 한정..? 어디까지 허용되게 할 것인가.</li>
</ul>
<hr>
<h2 id="🧐-궁금한-내용이-있거나-잘-이해되지-않는-내용이-있다면-적어보세요">🧐 <strong>궁금한 내용이 있거나, 잘 이해되지 않는 내용이 있다면 적어보세요.</strong></h2>
<ul>
<li><strong>TO 문단</strong> (내려가기 규칙사용) (p.46)</li>
</ul>
<pre><code>A와B를 하려면 C를 해야한다.
   A를 하기위해서는 D를 해야한다.
   D를 하기위해서는 F를 해야한다.
   F를 하기위해서는 H를 해야한다.
        H를 하기위해서는 I를 해야한다.
        I를 하기위해서는 O를 해야한다.
   B를 하기위해서는 Q를 해야한다.
....
...</code></pre><ul>
<li><strong>SRP</strong> (Single Responsibility Principle)
:단일 책임 원칙, 모든 클래스는 하나의 책임만 가지며 클래스는 그 책임을 완전히 캡슐화해야 함을 일컫는다.</li>
<li><strong>OCP</strong> (Open Closed Principle)
:개방 폐쇄 원칙, 소프트웨어 객체(클래스, 모듈, 함수 등등)는 확장에 대해 열려 있어야 하며 수정에 대해서는 닫혀있어야 한다.</li>
<li><strong>추상 팩토리</strong> (Abstract Factory)
:구체적인 클래스에 의존하지 않고 서로 연관되거나 의존적인 객체들의 조합을 만드는 인터페이스를 제공하는 패턴</li>
</ul>
]]></description>
        </item>
        <item>
            <title><![CDATA[[클린코드] 2장. 의미있는 이름]]></title>
            <link>https://velog.io/@dev_tuktack/%ED%81%B4%EB%A6%B0%EC%BD%94%EB%93%9C-2%EC%9E%A5.-%EC%9D%98%EB%AF%B8%EC%9E%88%EB%8A%94-%EC%9D%B4%EB%A6%84</link>
            <guid>https://velog.io/@dev_tuktack/%ED%81%B4%EB%A6%B0%EC%BD%94%EB%93%9C-2%EC%9E%A5.-%EC%9D%98%EB%AF%B8%EC%9E%88%EB%8A%94-%EC%9D%B4%EB%A6%84</guid>
            <pubDate>Thu, 23 Jun 2022 17:17:58 GMT</pubDate>
            <description><![CDATA[<p><img src="https://velog.velcdn.com/images/dev_tuktack/post/a9497d2d-4ab6-4f78-b615-0b143df84499/image.png" alt=""></p>
<p><strong>TIL (Today I Learned)</strong></p>
<p>2022.05.04</p>
<p><strong>오늘 읽은 범위</strong></p>
<p>2장. 의미있는 이름</p>
<hr>
<h2 id="📖-책에서-기억하고-싶은-내용을-써보세요">📖 <strong>책에서 기억하고 싶은 내용을 써보세요.</strong></h2>
<ul>
<li>의도를 분명히 밝혀라.<ul>
<li>따로 주석이 필요하다면 의도를 분명히 드러내지 못했다는 말이다. (p.22)</li>
</ul>
</li>
<li>그릇된 정보는 피해라.</li>
<li>의미있게 구분하라.<ul>
<li>연속된 숫자를 덧붙이거나 불용어(noise word)를 추가하는 방식은 적절하지 못하다. ... 아무런 정보를 제공하지 못하는 이름 ... (p.26)</li>
</ul>
</li>
<li>발음하기 쉬운 이름은 중요하다. 프로그래밍은 사회 활동이기 때문이다. (p.27)</li>
<li>검색하기 쉬운 이름을 사용하라.<ul>
<li>이런 관점에서는 긴 이름이 짧은 이름 보다 좋다. (p.28)</li>
</ul>
</li>
<li>전문가 프로그래머는 명료함이 최고라는 사실을 이해한다. 전문가 프로그래머는 자신의 능력을 좋은 방향으로 사용해 남들이 이해하는 코드를 내놓는다. (p. 31)</li>
</ul>
<hr>
<h2 id="🐱👓-오늘-읽은-소감은-떠오르는-생각을-가볍게-적어보세요">🐱‍👓 <strong>오늘 읽은 소감은? 떠오르는 생각을 가볍게 적어보세요</strong></h2>
<ul>
<li><strong>“검색하기 좋은 변수명과 의도를 분명하게 하기. ” chapter를 보며든 생각.</strong>
프로그램이 확장되면 추후에 비슷한 기능을 하는 변수명 네이밍시, 잘못된 예시와(Ex. getList getListItem getListItemCustom..) 굉장히 유사한 변수 네이밍을 한적이 있다. (꽤 있다..)
조회 매서드 내 기능이 확장되면서 불가피하게 이런 식으로 한적이 있었는데 구현에 급급해 찜찜하면서도 넘어갔었다. 검색을 위해 중복되지는 않게 했지만 의도가 분명하게 드러나는 네이밍은 아니었다. 추후에는 직관적이면서도 확장성있는 네이밍을 고민하게 될 것 같다.</li>
</ul>
<h2 id="🧐-궁금한-내용이-있거나-잘-이해되지-않는-내용이-있다면-적어보세요">🧐 <strong>궁금한 내용이 있거나, 잘 이해되지 않는 내용이 있다면 적어보세요.</strong></h2>
<ul>
<li><strong>grep</strong>
: 입력으로 전달된 파일의 내용에서 특정 문자열을 찾고자할 때 사용하는 리눅스 명령어.</li>
</ul>
<blockquote>
<p>📝참고 <a href="https://recipes4dev.tistory.com/157">리눅스 grep 명령어 사용법. (Linux grep command) - 리눅스 문자열 검색</a></p>
</blockquote>
]]></description>
        </item>
        <item>
            <title><![CDATA[[클린코드] 1장. 깨끗한 코드]]></title>
            <link>https://velog.io/@dev_tuktack/%ED%81%B4%EB%A6%B0-%EC%BD%94%EB%93%9C-1%EC%9E%A5.-%EA%B9%A8%EB%81%97%ED%95%9C-%EC%BD%94%EB%93%9C</link>
            <guid>https://velog.io/@dev_tuktack/%ED%81%B4%EB%A6%B0-%EC%BD%94%EB%93%9C-1%EC%9E%A5.-%EA%B9%A8%EB%81%97%ED%95%9C-%EC%BD%94%EB%93%9C</guid>
            <pubDate>Thu, 23 Jun 2022 17:09:56 GMT</pubDate>
            <description><![CDATA[<p><strong>TIL (Today I Learned)</strong></p>
<p>2022.05.04</p>
<p><strong>오늘 읽은 범위</strong>
1장. 깨끗한 코드 </p>
<hr>
<h2 id="📖-책에서-기억하고-싶은-내용을-써보세요">📖 <strong>책에서 기억하고 싶은 내용을 써보세요.</strong></h2>
<ul>
<li><p>코드는 요구사항을 상세히 표현하는 수단이다.</p>
</li>
<li><p>빨리 가는 유일한 방법은 언제나 코드를 최대한 깨끗하게 유지하는 습관이다. (p.7)</p>
<blockquote>
<p>🎿 The only way to go fast, is to go well</p>
</blockquote>
</li>
<li><p>깨끗한 코드 === 명쾌한 추상화. 
  코드를 읽는 사람에게 프로그래머가 단호하다는 인상을  줘야한다. (p.11)</p>
</li>
<li><p>중복을 피하라. 한 기능만 수행하라. 제대로 표현하라. 작게 추상화하라. (p.14)</p>
</li>
<li><p>새코드를 짜면서 우리는 끊임 없이 기존 코드를 읽는다. 
...읽기 쉬우면 새 코드를 짜기도 쉽다. (p.18)</p>
</li>
</ul>
<hr>
<h2 id="🐱👓-오늘-읽은-소감은-떠오르는-생각을-가볍게-적어보세요">🐱‍👓 <strong>오늘 읽은 소감은? 떠오르는 생각을 가볍게 적어보세요</strong></h2>
<ul>
<li>나쁜 코드의 원인을 촉박한 프로젝트 일정 등, 외부 요인으로 핑계를 돌리지 말자. 전문가라면 상황을 탓하기 보다 상황에 맞는 해결책을 제시하는 것이 바람직하다.</li>
<li>프로덕트 설계/기획 단계와 별개로 개발자 본인도 개발 전, 어느 정도 레벨의 설계는 필요하다. (Ex. 컴포넌트 분리 레벨, 메서드 중복.. )<ul>
<li><a href="https://www.notion.so/p-7-50cf1ff4083743c29a75a5bbb95971b0">빨리 가는 유일한 방법은 언제나 코드를 최대한 깨끗하게 유지하는 습관이다. (p.7)</a></li>
</ul>
</li>
<li>클린코드가 왜 필요한 지에 대해 한 번더 생각해보게 됨. 
필요하다..! 같이 개발하는 동료 개발자를 위해서, 유지보수를 위해서 라고만 생각 했지만, 내 개발 효율을 위해서도 필요했다. 의식하고 있지 않았던 것 뿐이지 내 코드를 가장 많이 보는 사람은 나였다. 기능 추가가 이루어 지더라도, 기존 코드에 대한 분석이 필수적이기에 해당 내용이 많이 공감되었다. 클린코드가 잘 이루어진다면 최대 수혜자는 당사자가 아닐까-!</li>
</ul>
<hr>
<h2 id="🧐-궁금한-내용이-있거나-잘-이해되지-않는-내용이-있다면-적어보세요">🧐 <strong>궁금한 내용이 있거나, 잘 이해되지 않는 내용이 있다면 적어보세요.</strong></h2>
<ul>
<li>경쟁 상태(Race Condition)
: 두 개 이상의 프로세스(혹은 스레드)들이 하나의 자원(리소스)에 접근하기 위해 경쟁하는 상태를 말합니다.<ul>
<li>임계영역(Critical Section): 경쟁 상태에서 아무나 접근하지 못하도록 보호되어야 하는 부분.</li>
</ul>
</li>
</ul>
<blockquote>
<h4 id="경쟁-상태-해결-조건">경쟁 상태 해결 조건</h4>
</blockquote>
<ol>
<li>Mutual Exclusion (상호 배제) 
 : 어떤 프로세스가 임계 영역을 수행 중이면, 다른 모든 프로세스들은 그 임계 영역에 들어가지 못하게 막는 것.</li>
<li>Progress(진행)
 : 임계 영역에 들어간 프로세스가 없는 상태에서, 임계영역에 들어가려는 프로세스가 있으면 들어가게 해주어야 함. 
 임계 영역에 있는 프로세스 외에는 다른 프로세스가 임계영역에 진입하는 것을 방해하면 안됨.</li>
<li>Bounded Waiting(한정 대기)
 : 기아(starvation) 상태를 방지하기 위해 프로세스가 임계 영역에 들어가려고 요청한 후부터, 다른 프로세스들이 임계 영역에 들어가는 횟수 한계 필요. 임계영역에 한 번 들어갔다온 프로세스는 다음 들어갈 때 제한 있음.</li>
</ol>
]]></description>
        </item>
        <item>
            <title><![CDATA[JS userAgent / navigator]]></title>
            <link>https://velog.io/@dev_tuktack/JS-userAgent-navigator</link>
            <guid>https://velog.io/@dev_tuktack/JS-userAgent-navigator</guid>
            <pubDate>Mon, 01 Nov 2021 04:58:10 GMT</pubDate>
            <description><![CDATA[<p>var ua = navigator.userAgent;</p>
<p><a href="https://developer.mozilla.org/en-US/docs/Web/API/Navigator/userAgent">https://developer.mozilla.org/en-US/docs/Web/API/Navigator/userAgent</a></p>
<p><a href="https://webzz.tistory.com/82">https://webzz.tistory.com/82</a></p>
]]></description>
        </item>
        <item>
            <title><![CDATA[[Android] 안드로이드 30 apache Http 추가]]></title>
            <link>https://velog.io/@dev_tuktack/Android</link>
            <guid>https://velog.io/@dev_tuktack/Android</guid>
            <pubDate>Mon, 18 Oct 2021 07:43:55 GMT</pubDate>
            <description><![CDATA[<h3 id="1">#1</h3>
<p>기존 소스의 재사용을 위해 아파치 Http 라이브러리의 사용이 필요한 상황. 
안드로이드 6.0 (API 23)까지 지원. -&gt; build.gradle에 dependency 추가</p>
<blockquote>
</blockquote>
<pre><code>dependencies {
    api &#39;com.github.ok2c.hc4.android:httpclient-android:0.1.0&#39;
    ...
}</code></pre><h3 id="2-error">#2 Error</h3>
<h4 id="msg--span-stylecolorreduses-sdkminsdkversion-22-cannot-be-smaller-than-version-26-declared-in-libraryspan">Msg :: <span style="color:red">uses-sdk:minSdkVersion 22 cannot be smaller than version 26 declared in library</span></h4>
<h3 id="3">#3</h3>
<p>추가해준 apache Lib 최소 API 26이상부터 사용가능함. build.gradle의 minSdk를 26으로 수정해 줌. </p>
<blockquote>
</blockquote>
<pre><code>android {
    defaultConfig {
        applicationId &quot;&quot;
        minSdk 26
    }
}</code></pre><hr>
<p>[참고]</p>
<p><a href="https://docko.tistory.com/entry/%EC%95%88%EB%93%9C%EB%A1%9C%EC%9D%B4%EB%93%9C-%EC%8A%A4%ED%8A%9C%EB%94%94%EC%98%A4-minSdkVersion-%EC%98%A4%EB%A5%98-%ED%95%B4%EA%B2%B0%EB%B0%A9%EB%B2%95">안드로이드 스튜디오 - minSdkVersion 오류 해결방법</a></p>
]]></description>
        </item>
        <item>
            <title><![CDATA[[Android] bluetooth StartDiscovery() false :: 새로운 기기 검색 구현시 오류]]></title>
            <link>https://velog.io/@dev_tuktack/Android-bluetooth-StartDiscovery-false-%EC%83%88%EB%A1%9C%EC%9A%B4-%EA%B8%B0%EA%B8%B0-%EA%B2%80%EC%83%89-%EA%B5%AC%ED%98%84%EC%8B%9C-%EC%98%A4%EB%A5%98</link>
            <guid>https://velog.io/@dev_tuktack/Android-bluetooth-StartDiscovery-false-%EC%83%88%EB%A1%9C%EC%9A%B4-%EA%B8%B0%EA%B8%B0-%EA%B2%80%EC%83%89-%EA%B5%AC%ED%98%84%EC%8B%9C-%EC%98%A4%EB%A5%98</guid>
            <pubDate>Fri, 15 Oct 2021 08:18:04 GMT</pubDate>
            <description><![CDATA[<h4 id="bluetooth-startdiscovery-always-returns-false">Bluetooth StartDiscovery() always returns false</h4>
<p>이미 페어링되어 있는 기기의 경우 잘 불러와지나, 
새로운 기기 검색 리스트만 계속 조회 실패 한 경우.. 
계속 해서 빈 배열만 리턴되어따..;;</p>
<h4 id="결론">결론)</h4>
<p>안드로이드 10 이상부터 관련 권한 체크를 필수적으로 해주어야했음.
세상에 권한 체크로직 넣으니 정상적으로 주변 기기들을 검색해 오는 것이었음..</p>
<h4 id="블루투스-제어시-필요-권한">블루투스 제어시 필요 권한</h4>
<pre><code>&lt;uses-permission android:name=&quot;android.permission.BLUETOOTH&quot;/&gt;
&lt;uses-permission android:name=&quot;android.permission.BLUETOOTH_ADMIN&quot;/&gt;
&lt;uses-permission android:name=&quot;android.permission.ACCESS_COARSE_LOCATION&quot;/&gt;
&lt;uses-permission android:name=&quot;android.permission.ACCESS_FINE_LOCATION&quot;/&gt;</code></pre><p>: location 관련 권한은 왜 필수일까.. 
하지만 정상작동을 위해 아래 두 항목 꼭 필요하다. 넣어주도록 하자. </p>
<h4 id="참고">[참고]</h4>
<p> <a href="https://m.blog.naver.com/cosmosjs/221374465893">- 안드로이드 스튜디오 - 블루투스 통신</a></p>
<p><a href="https://stackoverflow.com/questions/61984202/android-bluetooth-startdiscovery-always-returns-false">- Error 참고 </a></p>
<h3 id="-추가">+++ 추가</h3>
<p>위치 설정 ON-!!
<a href="https://stackoverflow.com/questions/58428763/android-10-not-working-with-ble-bluetooth-scanning">https://stackoverflow.com/questions/58428763/android-10-not-working-with-ble-bluetooth-scanning</a></p>
]]></description>
        </item>
        <item>
            <title><![CDATA[[Vue]생성자 함수]]></title>
            <link>https://velog.io/@dev_tuktack/%EC%83%9D%EC%84%B1%EC%9E%90-%ED%95%A8%EC%88%98</link>
            <guid>https://velog.io/@dev_tuktack/%EC%83%9D%EC%84%B1%EC%9E%90-%ED%95%A8%EC%88%98</guid>
            <pubDate>Tue, 05 Oct 2021 13:04:32 GMT</pubDate>
            <description><![CDATA[<p>함수를 이용해서 어떤 정보를 담은 객체를 생성 
= 생성자 함수의 객체 생성 패턴-!</p>
<p>매번 생성해서 사용하는 것이 아닌, 미리 정의한 함수를 가져다가 사용할 수 있음. 
-&gt; Vue에서는 생성함수로 API &amp; 속성들을 정의. 
-&gt; 추후 가져와서 사용함으로써 재사용성 용이.</p>
<ul>
<li><p><a href="https://developer.mozilla.org/ko/docs/Web/JavaScript/Reference/Global_Objects/Function">MDN 생성자 함수 관련 Docs</a></p>
</li>
<li><p><a href="https://developer.mozilla.org/ko/docs/Web/JavaScript/Reference/Global_Objects/Object/constructor">MDN Prototype Docs</a> </p>
</li>
</ul>
]]></description>
        </item>
        <item>
            <title><![CDATA[VS Code 단축키]]></title>
            <link>https://velog.io/@dev_tuktack/VS-Code-%EB%8B%A8%EC%B6%95%ED%82%A4</link>
            <guid>https://velog.io/@dev_tuktack/VS-Code-%EB%8B%A8%EC%B6%95%ED%82%A4</guid>
            <pubDate>Tue, 05 Oct 2021 11:38:48 GMT</pubDate>
            <description><![CDATA[<h4 id="html-기본-포맷">HTML 기본 포맷</h4>
<blockquote>
<p>! + Tab</p>
</blockquote>
<h4 id="html-id가-있는-tag-생성">HTML id가 있는 tag 생성</h4>
<blockquote>
<p>div#app
➡ <code>&lt;div id=&quot;app&quot;&gt;&lt;/div&gt;</code></p>
</blockquote>
]]></description>
        </item>
        <item>
            <title><![CDATA[[Vue] v-model / v-bind / v-on 차이]]></title>
            <link>https://velog.io/@dev_tuktack/Vue-v-model-v-bind-v-on-%EC%B0%A8%EC%9D%B4</link>
            <guid>https://velog.io/@dev_tuktack/Vue-v-model-v-bind-v-on-%EC%B0%A8%EC%9D%B4</guid>
            <pubDate>Fri, 10 Sep 2021 02:16:41 GMT</pubDate>
            <description><![CDATA[<h3 id=""></h3>
<p><strong>v-bind</strong>: 뷰 인스턴스의 데이터 속성을 해당 HTML 요소에 연결할 때 사용
<strong>v-on</strong>: 해당 HTML 요소의 이벤트를 뷰 인스턴스의 로직과 연결할 때 사용 
<strong>v-model</strong>: v-bind와 v-on의 조합</p>
<h3 id="html-입력-요소의-종류에-따른-v-model-속성">HTML 입력 요소의 종류에 따른 <code>v-model</code> 속성</h3>
<p>(1) input 태그에는 <code>value / input</code>
(2) checkbox 태그에는 <code>checked / change</code>
(3) select 태그에는 <code>value / change</code></p>
<h3 id="-v-model의-한계">** v-model의 한계</h3>
<p>: IME(한국어, 일본어, 중국어) 입력시 한 글자에 대한 입력이 끝나야지만, data 속성값과 input박스의 텍스트가 동기화됨. 
<a href="https://kr.vuejs.org/v2/guide/forms.html">Vue 공식문서</a>에서는 한국어 입력을 다룰 때 v-bind:value와 v-on:input을 직접 연결해서 사용하는 것을 권고.</p>
<p><a href="https://joshua1988.github.io/web-development/vuejs/v-model-usage/">[참고] 캡틴판교-v-model의 동작 원리와 활용 방법</a></p>
]]></description>
        </item>
        <item>
            <title><![CDATA[[Vue] v-bind:click과 @click의 차이]]></title>
            <link>https://velog.io/@dev_tuktack/Vue-v-bindclick%EA%B3%BC-click%EC%9D%98-%EC%B0%A8%EC%9D%B4</link>
            <guid>https://velog.io/@dev_tuktack/Vue-v-bindclick%EA%B3%BC-click%EC%9D%98-%EC%B0%A8%EC%9D%B4</guid>
            <pubDate>Tue, 31 Aug 2021 07:38:33 GMT</pubDate>
            <description><![CDATA[<p>차이 없음 단축어임!</p>
]]></description>
        </item>
    </channel>
</rss>