<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Kay Lin on Medium]]></title>
        <description><![CDATA[Stories by Kay Lin on Medium]]></description>
        <link>https://medium.com/@k1.0?source=rss-9073be24eb0------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*5simC_-6i-Bn3znU7i3ytw.jpeg</url>
            <title>Stories by Kay Lin on Medium</title>
            <link>https://medium.com/@k1.0?source=rss-9073be24eb0------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 17:31:57 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@k1.0/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Embark on a Quantum Leap Release in July: ChatGPT’s Code Interpreter and Custom Interactions]]></title>
            <link>https://medium.com/@k1.0/embark-on-a-quantum-leap-release-in-july-chatgpts-code-interpreter-and-custom-interactions-5aeccd8ed137?source=rss-9073be24eb0------2</link>
            <guid isPermaLink="false">https://medium.com/p/5aeccd8ed137</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[code-interpreter]]></category>
            <category><![CDATA[openai]]></category>
            <dc:creator><![CDATA[Kay Lin]]></dc:creator>
            <pubDate>Fri, 28 Jul 2023 04:11:59 GMT</pubDate>
            <atom:updated>2023-07-28T04:11:59.897Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-IgJSdXwxFC8KizHsJ2IfQ.png" /><figcaption>Chart Generated by Code Interpreter</figcaption></figure><h3>Introduction</h3><p>In the midst of remarkable AI progress, ChatGPT took a significant step forward in July. The introduction of “Code Interpreter” and “Custom Interactions” features marked a pivotal moment in language models. These features have made AI+X commercialization increasingly accessible with its cutting-edge capabilities.</p><h3>Code Interpreter</h3><p>While people think of ChatGPT as a pure chatbot with language capabilities, it is much more than that. It now turns out that ChatGPT pushes these boundaries even further by not just assisting in code writing, but also executing commands and presenting results. This feature enables GPT-4 to analyze given datasets and generate python function codes to match. It’s not merely suggesting the next line of code; it’s understanding the task at hand, generating a suitable code, executing it, and outputting the result.</p><h4>Basic Functionality with AAPL stock history</h4><p>Intrigued by the capabilities of Code Interpreter, I decided to put it to the test with AAPL stock history data. To my amazement, ChatGPT effortlessly delved into chart drawing and data analysis, proving itself as a versatile tool. Even when I sought its insights into stock prediction modeling, it provided a proficient basic statistical analysis model. Having previously experimented with machine learning approaches, I encountered computational constraints that hindered progress. However, Code Interpreter’s ability to overcome resource limitations offered a breath of fresh air, opening up new possibilities for innovative exploration.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-IgJSdXwxFC8KizHsJ2IfQ.png" /><figcaption>Chart Generated by Code Interpreter</figcaption></figure><h4>Wondering Why? SHOW WORK</h4><p>An enthralling aspect of Code Interpreter is its “Show Work” feature, which offers users an exceptional opportunity to explore the mechanics of code execution. By clicking the “Show Work” button, the underlying Python code used for program execution is revealed. This transparency grants users valuable insights into each step of the process, aiding comprehension of the code’s logic and decision-making. From beginners to seasoned developers, “Show Work” fosters a community of learners passionate about code implementation. It empowers users to experiment, optimize their algorithms, and embrace the spirit of exploration and discovery.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EFdreuwunxeQP4En8Mi1jw.png" /><figcaption>Python Code Reveal</figcaption></figure><h3>Custom Interactions</h3><p>The Custom Interactions feature takes its conversational abilities to a new level. This feature allows the AI to gauge what type of response the user is seeking, enabling it to customize its replies accordingly.</p><h4>Tell Chat GPT WHO you are and WHAT you want</h4><p>Custom Interactions revolutionize the way we interact with ChatGPT, allowing us to introduce ourselves and specify our intentions.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jGiaQ3Yg1JscButxpWj71Q.png" /><figcaption>Specify The Need of Custom Interactions</figcaption></figure><p>By simply introducing ourselves, we are coming up with a more tailored dialogue. Whether you’re a software engineer like me, a data scientist, a curious learner, or a professional from any domain, Custom Interactions cater to your unique needs and interests. This level of personalization sets the stage for a more productive and fulfilling interaction, where ChatGPT can truly understand and address your specific queries. Below is the result of me being a software engineer and expecting ChatGPT to interact with me as a colleague.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fkxX4EEzuGTLaXFbARN_dw.png" /><figcaption>Tailored Response from Custom Interactions</figcaption></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5aeccd8ed137" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[系統日誌與監控(2) — Docker & Fluentd]]></title>
            <link>https://medium.com/@k1.0/%E7%B3%BB%E7%B5%B1%E6%97%A5%E8%AA%8C%E8%88%87%E7%9B%A3%E6%8E%A7-2-docker-fluentd-63c581df91b9?source=rss-9073be24eb0------2</link>
            <guid isPermaLink="false">https://medium.com/p/63c581df91b9</guid>
            <category><![CDATA[logging-and-monitoring]]></category>
            <category><![CDATA[fluentd]]></category>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[system-design-project]]></category>
            <category><![CDATA[logging]]></category>
            <dc:creator><![CDATA[Kay Lin]]></dc:creator>
            <pubDate>Mon, 05 Sep 2022 16:48:45 GMT</pubDate>
            <atom:updated>2022-09-05T16:48:45.991Z</atom:updated>
            <content:encoded><![CDATA[<h3>系統日誌與監控(2) — Docker &amp; Fluentd</h3><p>本系列文主要介紹一個系統的日誌產出與監控機制，目標是把一個系統從 log 如何產出，到監控鏈路的接通，最終到告警機制全部都介紹一輪。繼第一篇的<a href="https://medium.com/@kaiyi0/%E7%B3%BB%E7%B5%B1%E6%97%A5%E8%AA%8C%E8%88%87%E7%9B%A3%E6%8E%A7-1-java-logback-slf4j-6e23bc6729a7">系統日誌與監控 (1) — Java logback + SLF4J </a>以後，我們這次就利用第一篇習得的技能來繼續進行下去。所有的程式碼都會放在 Github 上面：</p><p><a href="https://github.com/kaiyee0/learn-efk">GitHub - kaiyee0/learn-efk: efk demo project</a></p><h3>Fluentd</h3><p>Fluentd 可以說是今天的大主角，如果有聽過 EFK 大家族的話，F 就是指 Fluentd 或是 Fluent-bit。那麼 Fluentd 是幹嘛的呢？我們可以先用一張非常簡單明瞭的官網圖片解釋：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lO3VRYfrCEiNaPp1SnX73w.png" /><figcaption><a href="https://www.fluentd.org/architecture">What is Fluentd? | Fluentd</a></figcaption></figure><p>Fluentd 存在的意義就是為了要解決所有的 logging 問題，不然今天在寫系統的人，Apache 有自己的 log、資料庫有自己的 log…，想像一下如果今天有 N 個服務，光是要做一個監控系統便需要 N 套 log-監控的對應機制，若是有 M 套監控與告警系統，需要的便是 NxM 組合的 log-監控/告警 的對照。</p><p>因此 Fluentd 跳出來決定要當中間層，專門去統一收集所有的日誌，並統一分配到各個需要的系統，這樣原本需要寫 NxM 個對應機制，馬上就簡化成了 N + M 種（每一個 log 與系統只需要面對 Fluentd 即可）。</p><p>接下來我們直接先用實際的案例來 demo 會比較快。我們在這次的 demo 中，會先簡易的寫了一個 Server 並包裝成 docker image 以後，接收請求並在接到 request 的同時：<br>(1) 打印日誌出來；<br>(2) Fluentd 接到 log ，再接續傳往下一層 (ElasticSearch)。</p><h4>Micro Service Demo — Java HelloController</h4><p>我們首先先利用 Java 寫了一個可以簡易互動的 Server，一切最重要的就是要能夠收到 Request，然後把 log 印出來。如下圖，夠簡單了吧！</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dNRqCjoxd-9Pw8YT5Jn5CA.png" /><figcaption>Demo Server</figcaption></figure><p>由於我們要將產出來的 log 變成 JSON 的型態，以利後續 fluentd 接收我們的 log 再傳出去，我們直接在 Java 層加入一個自定義的 EncoderLayout ，讓 log 的產出可以是 json 型態：</p><pre>{&quot;<a href="http://twitter.com/timestamp">@timestamp</a>&quot;:&quot;2022-08-09T13:36:47.778Z&quot;,&quot;createTime&quot;:&quot;2022-08-09 21:36:47.778&quot;,&quot;level&quot;:&quot;INFO&quot;,&quot;className&quot;:&quot;com.example.demo.DemoApplication - 61&quot;,&quot;msg&quot;:&quot;Started DemoApplication in 1.991 seconds (JVM running for 3.9)\n&quot;}</pre><p>有興趣看實作的話可以參考 github 專案內的 logback.xml 與 pom.xml，並搭配第一篇的內容作參考。若是對於 Java 不太熟悉的話，也可以直接使用 Docker Image 去運行這一個專案就好。</p><h4>Docker 容器化</h4><p>我們借助容器化的技術將 jar 檔直接變成一個 docker image，把所有的流程串的擬真一點，像是一個真的微服務。在這邊我們先忽略掉 Docker 的運作原理，不然要講應該講不完 XD 主要的包裝流程為：</p><pre>cd demo<br>mvn clean install<br>docker build -f devops/Dockerfile -t efk-demo-jar .<br>docker run -d -p 8888:8080 efk-demo-jar:latest</pre><p>以上的三步驟，個別的意義是 maven 打包這次的專案、透過 devops/Dockerfile 內規定的流程去 build docker image，並加上 efk-demo-jar 的 tag、最後將此 image 在背景內運行，如果成功的話應該利用 docker ps 就可以看到有剛剛建立過的 efk-demo-jar 。如果要確認服務有沒有順利運行，可以透過 curl -X GET &quot;http://127.0.0.1:8888/hello&quot; 進行驗證。</p><h3>Fluentd (Docker)</h3><p>接下來我們利用 fluentd 的 <a href="https://hub.docker.com/r/fluent/fluentd/">docker image</a> 建立起 fluentd：</p><pre>docker pull fluent/fluentd</pre><pre># change &quot;~/Learning/learn-efk&quot; to your system path<br>docker run -p 127.0.0.1:24224:24224 -v ~/Learning/learn-efk/fluentd/tmp:/fluentd/etc efk/fluentd -c /fluentd/etc/fluentd.conf</pre><p>這邊大致上的意思就是，我們使用了 fluentd/etc/fluentd.conf 的檔案作為 fluentd 最主要的參數檔，內容如下：</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/6a306a4a98860623cd4939f234187aa0/href">https://medium.com/media/6a306a4a98860623cd4939f234187aa0/href</a></iframe><p>我們可以先針對幾個欄位進行說明：</p><h4>Source</h4><p>source 為 fluentd 的資料來源，主要可以分為 forward 與 http 兩種。forward 與 http 最大的差異就是 forward 是提供了 tcp 的事件監聽。在這邊我們指定為 port 24224。</p><h4>Match</h4><p>可以簡單的想像成，資料從 source 來，再看 match 到哪裡並做什麼事。由於這邊我們希望 fluentd 監聽所有 log 訊息，因此設為 *.** 。在這邊我們設定了進入 match 以後，會分成兩種處理方式，第一種是將資料丟入 elasticsearch，第二種是會將 log 資料印出來（stdout）</p><p>其他還有一些業務比較複雜的 filter , system , worker 跟 buffer 等等，在這邊先不提太多，有興趣可以去<a href="https://docs.fluentd.org/configuration/config-file">官網</a>上了解。</p><p>那麽要怎麼確認我們所運行的 fluentd 真的有順利的在跑呢？在這邊我們先移除掉一開始的 efk-demo-jar 的服務，並根據以下指令重啟一次：<br>docker run --log-driver=fluentd -d -p 8888:8080 efk-demo-jar:latest 。在這次的版本中，我們利用 docker 的<a href="https://docs.docker.com/config/containers/logging/fluentd/"> log-driver</a> 指定 driver 為 fluentd。</p><p>再重新 curl 一次後，應該要能夠發現 fluentd 的 terminal 會多了來自 efk-demo-jar 的 log：</p><pre>2022-09-05 15:38:56.000000000 +0000 ae817bdb5720: {&quot;source&quot;:&quot;stdout&quot;,&quot;log&quot;:&quot;{\&quot;<a href="http://twitter.com/timestamp">@timestamp</a>\&quot;:\&quot;2022-09-05T15:38:56.121Z\&quot;,\&quot;createTime\&quot;:\&quot;2022-09-05 15:38:56.121\&quot;,\&quot;level\&quot;:\&quot;INFO\&quot;,\&quot;className\&quot;:\&quot;c.e.demo.controller.HelloController - 12\&quot;,\&quot;msg\&quot;:\&quot;a hello is received\\n\&quot;}&quot;,&quot;container_id&quot;:&quot;ae817bdb5720e3a8a1ed4833063a797a75db983e0495fd49df39d22f0eae97ea&quot;,&quot;container_name&quot;:&quot;/jovial_lederberg&quot;}</pre><p>在以上，我們已經可以簡單的把系統的 log 往外輸出到 fluentd，下一篇便會開始接續將 fluentd 的資料傳到下一層去。</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=63c581df91b9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[系統日誌與監控 (1)— Java logback + SLF4J]]></title>
            <link>https://medium.com/@k1.0/%E7%B3%BB%E7%B5%B1%E6%97%A5%E8%AA%8C%E8%88%87%E7%9B%A3%E6%8E%A7-1-java-logback-slf4j-6e23bc6729a7?source=rss-9073be24eb0------2</link>
            <guid isPermaLink="false">https://medium.com/p/6e23bc6729a7</guid>
            <category><![CDATA[logback]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[logging]]></category>
            <category><![CDATA[system-design-interview]]></category>
            <category><![CDATA[slf4j]]></category>
            <dc:creator><![CDATA[Kay Lin]]></dc:creator>
            <pubDate>Mon, 08 Aug 2022 15:08:11 GMT</pubDate>
            <atom:updated>2022-08-08T15:08:11.517Z</atom:updated>
            <content:encoded><![CDATA[<p>本系列文主要介紹一個系統的日誌產出與監控機制，目標是把一個系統從 log 如何產出，到監控鏈路的接通，最終到告警機制全部都介紹一輪。</p><p>對於原生 Java 的工程師說，相信大家對於 System.out 與 System.err 都不陌生，因為這是最原始寫 log 去記錄與 debug 的方法。然而若以現在的 log 要求大家對於自己的服務都需要有一些自定義的 log pattern，如加上時間、thread、甚至是訊息的內容都要有分級，若自定義 function 固然可行，但等於自己系統的業務範疇以外，還需要處理 log 之類的『雜事』，因此就有一些套件開始出來給大家引入來使用啦。</p><h3>Java Logging 的過去</h3><p>最一開始出現比較有名的當然屬於 Apache log4j 了，由於是 Apache 加上這是第一個較具規模的 Logging Framework，因此大家都開始使用 log4j。然而，對於工程師來說，直接調用 log4j 作為唯一的 logging 是一個比較不好的事情，因為若是未來要切換 log4j 到別的框架時就會需要改非常多 code 與組件；加上因為 Java 自己也出了一個 java.util.logging，因此 Apache 就推出了 Jakarta Commons Logging (JCL) 作為一個接口，並在啟動時去尋找是需要調用 log4j 或是 JCL 的方法來產日誌。（有人在 StackOverflow 提出了為什麼不想用 jdk 的 logging: <a href="https://stackoverflow.com/questions/11359187/why-not-use-java-util-logging">Why not use java.util.logging? — Stack Overflow</a>，大家可以來參考ＸＤ）</p><p>雖然 log4j + commons-logging 是一個至今非常常見的組合，但是誠如剛剛所說，commons-logging 是利用 run-time 去動態綁定找到現在使用的框架，因此也有一些人遇到綁定失敗問題；除此之外，還有一些其他次要的效能問題。<strong>因此 SLF4J 出來決定要取代 commons-logging</strong>。SLF4J 的全名是 Simple Logging Facade for Java，可以從字面上的意思看出來一個 Facade 就是另外一個接口面向。而 SLF4J 主要使用引用 jar 檔的方式去處理 classloading 的問題，因此改善了原本 run-time binding 的弊病，而是在 compile-time 就去找出適用的框架。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5kpproTsKPz-9b3HNFKn-A.png" /><figcaption>Java log 發展簡史</figcaption></figure><p>但是 log4j + SLF4J 的搭配在後來又被 logback 的出現給打破了，<strong>logback 的出現就是要取代 log4j </strong>，不管是性能上或 IO 的處理上都優於後者（而且 logback 作者就是 log4j 的作者 Ceki Gülcü）。因此現在大家也開始轉向 logback + SLF4J 的組合去做日誌使用。我們也正式進入了本篇的主題。</p><h3>logback 的原理與實現</h3><p>在 logback 的世界裡，最需要關心的核心主要為：Logger, Level, Appender, Layout 與 Filter，以下將需要針對這幾個元件一一作介紹。</p><h4>Logger</h4><p>Logger 可以算是 SLF4J 裡最重要的基礎，一切你看得到與看不到的東西基本上都是附加在 logger 上面。如下面會提到的 Appender ，實際上一個 logger 可以有多個 appender，如 FileAppender 與 ConsoleAppender ，讓日誌系統可以同時做到兩種寫 log 的方式。在所有自定義的 logger 之上，都有一層 root logger，所以要是沒有指定的話實際上都是在對 root logger 做事。</p><h4>Level</h4><p>logback 將 log 的主要等級分成以下幾種 TRACE, DEBUG, INFO, WARN 與 ERROR。這些等級的繼承關係是 TRACE &lt; DEBUG &lt; INFO &lt; WARN &lt; ERROR，意思是假設在環境中定義的是 INFO level，如果今天有 DEBUG 等級的 log 的話就不會印出來。</p><h4>Appender</h4><p>Appender 可以想成當有 log 產生時，需要『<strong>將 log append 到哪裡去</strong>』時，就需要哪一種 Appender，所以在概念上有一點像是 consumer 的角色（但功能讓還是差很多啦…）。<br>logback 最核心的 Appender 莫屬於 OutputStreamAppender 了，顧名思義，他主要的作用就是 append events 到 java.io.OutputStream 裏面。而同時他也是另外三個 Appender 的 super-class: ConsoleAppender , FileAppender 與 RollingFileAppender。 ConsoleAppender 實際上就是將 event 送到 System.out 或是 System.err 去處理；另外兩個 Appender 從字面上就可以看出基本上都是做 log file 的處理的。</p><h4>Layout</h4><p>在我們程式碼當中，若要客製化每一筆印出來的 log 紀錄，我們可以透過不同的 Layout 來呈現，我個人最常用的是 PatternLayout 。此外，也可以透過 extends logback 中原有的 LayoutBase&lt;&gt; 去自定義想要的日誌條。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LV7zws6QF2pJPaqVV1Jq1w.png" /><figcaption>TTLLLayout.java</figcaption></figure><h4>Filter</h4><p>Filter 是我們能夠根據客製化的判斷，來去決定是否將某行 log 印出來。 如判斷這一條 log 是否包含一些指定字詞、Level 是否高於某一個等級等等，只要看得到的參數都可以作為 Filter 的依據。<br>在 logback 中有出現一個比較少聽過的詞叫做 Marker，具體的作用是類似一個 tag 識別。如你可以根據在觸發 info() 事件時，若有機敏資料加上一個 confidential marker，最終 Filter 可以根據是否出現 confidential marker決定要不要將此 log 印出。</p><p>那麼我們來看一下 logback 把 log 印出來的流程吧：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sH07l7T0ooESYjXX8siZkg.png" /><figcaption>logback 生產 log 流程</figcaption></figure><p>1. 每一個 logger 在觸發了如 info() 或是 debug() 以後，會喚起 TurboFilter 進行過濾。可以看出在 Filter 內有一個 decide() function，主要是拿來決定這個 log 是否能夠繼續往下一步走，回應主要分為 DENY, NEUTRAL, ACCEPT 。若為 DENY 則直接捨棄掉這則 log，Neutral 則將 log 送進 Level Rules決策， Accept 則直接接受這則 log。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lefv2U-m2oTyvYS9fNQnVQ.png" /></figure><p>2. 如上一步所述：若是 FilterReply 為 Neutral ，則將 log 送至 Level Rules 決策。在上面的 Levels 也介紹過了，log 的 Level 為 TRACE &lt; DEBUG &lt; INFO &lt; WARN &lt; ERROR，因此若此環境為 INFO ，則 TRACE 與 DEBUG 都不會被接受。</p><p>3. 若是在 1., 2. 的步驟都通關了，那麼就會組成一個名為 LoggingEvent 的物件。這個 LoggingEvent 會再 trigger 一個 doAppend() 的 function，向所有需要知道的 Appenders 宣告此 log 要被印出來。此外，若有客製化的 Filters 時也會在各 Appenders 底下自己做過濾。</p><p>4. 最終在確定此 log 要被印出以後，各個 Appenders 需要自己將 log 整理成自己定義出的 Layout 形式，再根據各 Appenders 不同的作用將 log 送至各自的地方（如 Console Append, File Output 等等）。</p><p>由於使用的參數檔（主要為 xml）在網路上應該都可以找到許多不錯的資源，所以在這邊主要解釋最核心的原理為何，若有興趣研究更深的話可以直接看 Logback 的官網或是 source code。</p><p>參考資料：<br><a href="https://logback.qos.ch/">Logback Home (qos.ch)</a><br><a href="https://github.com/qos-ch/logback">GitHub — qos-ch/logback: The reliable, generic, fast and flexible logging framework for Java.</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6e23bc6729a7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Case Study — Airbnb at Scale 服務導向架構設計]]></title>
            <link>https://medium.com/@k1.0/case-study-airbnb-at-scale-%E6%9C%8D%E5%8B%99%E5%B0%8E%E5%90%91%E6%9E%B6%E6%A7%8B%E8%A8%AD%E8%A8%88-459c6a381bf0?source=rss-9073be24eb0------2</link>
            <guid isPermaLink="false">https://medium.com/p/459c6a381bf0</guid>
            <category><![CDATA[程式設計]]></category>
            <category><![CDATA[system-architecture]]></category>
            <category><![CDATA[系統設計]]></category>
            <category><![CDATA[系統架構]]></category>
            <dc:creator><![CDATA[Kay Lin]]></dc:creator>
            <pubDate>Sun, 12 Jun 2022 09:57:26 GMT</pubDate>
            <atom:updated>2022-06-12T09:57:26.458Z</atom:updated>
            <content:encoded><![CDATA[<h3>Case Study — Airbnb at Scale 服務導向架構設計</h3><p>Airbnb 身為全世界最大的民宿訂房平台，系統架構固然是一個很好的參考案例。在本篇 Case Study 中<a href="https://www.youtube.com/watch?v=pnHiVFYpLzs">參考了 Airbnb 的分享</a>，講述 Airbnb 的架構設計發展史：Airbnb 如何從一開始的 Single Web Application 慢慢的發展成現在的 Service Oriented Architecture (SOA)，若有興趣可以再去觀看原影片。</p><p>在 2008 年 Airbnb 剛起步之時，主體最先採取的便是 Ruby on Rails 的 Single Web Application 與 MVC 架構。然而在業務發展日漸擴張的情境下，漸漸的會發現在無論是開發或是維運成本都會逐漸上升，因此在 2018 年時 Airbnb 針對這種技術債進行了全公司的『革新』，並使用了以服務為導向的設計。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Iop9zXRDakoiTUsSGnpomA.png" /><figcaption>RoR 系統架構</figcaption></figure><p>在這次的分享中，主要以 Host Reservation Details 為範例。</p><p>首先，可以在下圖看到在 View Page 終將會有以下資訊：包括 User, Payment, Listing, Reviews, Trust, User 等等，這些都需要經過經過層層 Service 與 API 溝通，方能夠展現在前端頁面上。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*u-wpGkOCRAuAorsqzc2Brg.png" /><figcaption>Front-End Web Page</figcaption></figure><p>在這次的 Host Reservation Details 內部，整體服務被解構成好幾塊不同的服務區域：若將 Host Reservation Details 視為一個大的 Service 提供給前端進行 Render，則在 Reservation Service 中就包括了需要處理寫入的服務（如訂單成立或取消）與讀取的服務（獲得房東、預約等），依照服務屬性的不同做隔離。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bkJGgnI23fGL0zzrr-Mc5g.png" /><figcaption>API Design Framework</figcaption></figure><p>因此，在一個 Host Reservation Details 的頁面中，需要的服務除了預約以外，還包括了 User, Listing（如一開始的前端顯示頁面），因此可以看出構建出一個頁面需要做多個 Service 的 Request 才能夠拿到該資訊。</p><figure><img alt="API Design Framework" src="https://cdn-images-1.medium.com/max/1024/1*L3WaSVRiZaNLhHneSTt5LA.png" /><figcaption>API Design Framework</figcaption></figure><p>那麼知道概念了，Airbnb 又是怎麼實作這些的呢？講者分享了四個關鍵與建議：<em>Invest in common infrastructure early,</em> S<em>implify service dependencies, Platformize data hydration, Unify client-facing API</em>，以下將會針對這四點做介紹。</p><h3><em>Invest in Common Infrastructure Early</em></h3><p>『萬丈高樓平地起』，這句話真的很貼切的形容了一家公司的所有系統架構與服務，否則再華麗的裝飾沒有好的地基，再雄偉的建築也會倒塌。首先，要建立好架構就要從 infra 層做起。</p><h4>API Framework</h4><p>首先可以發現由於業務邏輯被拆分成了好幾塊不同的 Service，而若是有拆分，就一定會面臨跨服務的溝通。在 Airbnb 的服務模組中，運用了 <strong><em>Thrift</em></strong> 去做彼此的溝通橋樑。透過 Thrift 讓工程師可以很輕鬆的處理好請求介面，讓有需要的人直接進行 Service Request。除此之外，Airbnb 也建立了一套良好的 API 探索工具，讓大家可以輕鬆地找到自己需要的 API 文件與工具。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aV07LK1MikwH_jHZ5MBt9Q.png" /><figcaption>Service 間的溝通</figcaption></figure><h4>Powergrid</h4><p>Powergrid 主要是 Airbnb 的一個 in-house library，專門去處理 Parallel Tasks（這樣聽起來有點像是 Airflow 類的東西），並且將所有的任務變成 DAG (Directed Acyclic Graph)。這邊直接拿例子來看：今天 Airbnb 要判斷是否提供 Special Offer 給用戶，在最一開始系統會先去抓取 Listing Service 去抓取 Listing ID，並根據拿到的資料去下游服務『同步』做各種驗證。</p><p>透過這個 Powergrid Library，系統能夠去做到如找出系統的 Bottleneck 在哪裡、個別子服務的 Tracing…，但我自己認為最好的地方他把針對同步任務去做成了一個標準化的 Library，並且能夠讓所有人都透過這個 Library 很簡單的處理 IO 與同步問題。</p><figure><img alt="Powergird" src="https://cdn-images-1.medium.com/max/1024/1*nEFVN_U6oQ5pVO7bluzTnQ.png" /></figure><h4>OneTouch</h4><p>相信 CI/CD 一直都是每一間公司會認真看待的一個問題（尤其是現在的 MicroService 蓬勃發展的時代），Airbnb 透過 Kubernetes 延伸出了一套部署架構：所有的參數檔案都放在了 configs 包裡面，內容包括了 dependency, alerts, logging, <strong>cpu resources</strong>（連這個都可以…），所以軟體工程師可以更專注在撰寫商業邏輯上，而 infra 則是負責持續交付的穩定性。</p><p>另外在部署上，Airbnb 運用了 Kubernetes 撰寫了一套 Magic Tool，即是可以一鍵快速產出部署參數、建構 App 與建立 cluster。所以我自己猜叫 OneTouch 的意思就是可以超級輕鬆地做到專案部署動作吧！</p><figure><img alt="OneTouch" src="https://cdn-images-1.medium.com/max/1024/1*ePnH4JNc9SHBHTQNZkw-8w.png" /></figure><h4>Spinnaker</h4><p>Spinnaker 最初是由 Netflix 開發成的一套持續交付平台，在每一次的部署時，都會有舊有的 Snapshot 與新完成的服務一起上正式站，並且透過分流的方式來進行 Routing，將少部分比例的流量導至新服務。在最終確認沒有問題之餘，才會進行切換。</p><figure><img alt="Spinnaker" src="https://cdn-images-1.medium.com/max/1024/1*_lTt-DOOthIihsLOEVQa6w.png" /><figcaption>Spinnaker</figcaption></figure><h3>Simplify Service Dependencies</h3><p>在這樣的系統架構下，Airbnb 雖然在短時間內成功地轉入了 SOA 的架構中，但隨之而來也面臨到了一些問題。首先，因為現在的 Service 間幾乎是沒有任何限制的，所以所有的 Service Flow 反而會變得比以前更加錯綜複雜；甚至再到更糟之時，若是有一個 Service 因改動遇到了問題，又因為彼此間的依賴關係，導致拖垮了所有的服務，更是得不償失。</p><p>因此，為了解決上述的問題，Airbnb 將服務拆成了不同層的 Tier Service, 如 Presentation Tier, Mid-Tier, Data 等等，並將服務加入了 Layers 的概念，做了分層以後，便定義出了服務的特性與本質，如越下層的服務便應該是穩定性越高、更迭率最小、最通用的 API 設計等等。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tPEO_eI-pdbsyweVCzt7nw.png" /></figure><p>然而，只定義這些遠遠不夠，因此 Airbnb 也為不同的 Layer 定義了 Service Blocks，看起來應該就是將業務邏輯封裝起來，並且透過 Abstraction 的概念將 API 對外，而上層的人則不需要去管理業務邏輯，只需做好串接的動作。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CdqEyF-8mAwpPj1moGux8w.png" /></figure><h3>Platformize Data Hydration</h3><p>由於一個 Service 可能會需要去 Request 好幾個 Service 才能夠得到自己想要的東西，並且許多流程甚至資料都是重複的，因此 Airbnb 加入了一層 Platformized Data Access Layer。這層 Layer 講簡單一些，便是直接做好一個 GraphQL 的介面，讓 Service 在獲取資料之時不必再處理過多的資料邏輯，而是直接透過 interface 去做 read/write。因此，原本的 Presentation Service 就會直接被這層 Data Access Layer 給取代。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2v0kPq-jf7A21R3mJlEmdg.png" /></figure><p>透過這種方式，Airbnb 的工程師們不必再去做太多的 coding，反而可以直接撰寫 Query 去獲取如 Reservations 的資料。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7MIJFEhmmzPxzU_5wywIcw.png" /></figure><h3>Unify Client-Facing API</h3><p>在前端的呈現中，最大的問題就是常常會遇到『重複造輪子』的情況。為了避免掉這種問題，Airbnb 將呈現頁面高度模組化，主要的概念就是將前端顯示頁面切分成多塊 Sections，如此一來所有的顯示都按照這套 Section 的定義去使用，可以讓使用者的體驗達到最佳化。除此之外，Airbnb 更定義了一套 Service Driven 的 UI System — App Framework。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ucNwYauCb9JJxSAzfuRKGA.png" /></figure><h4>Standardized API Response</h4><p>在 App Framework 中，前端的 API Response 也是高度模組化的（如下圖）：所有需要在頁面中呈現的 Section 都會顯示在 Sections — Section IDs 裡面，並且 Response 會同步規範好每一個 Layout 的顯示位置與方法。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gPXFz7ONGNPStp3L_Efjpg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-9FwFp-nP7fC1g0AiRFWPA.png" /></figure><p>Airbnb 的整體設計架構大概如下，主要包括了大方向的 Infra 架構、Backend 的抽象化設計與 Frontend 的模組化。不過個人認為雖然 SOA 是一個很好的架構，但是不一定適用在每一家公司上（尤其是業務更迭頻繁的公司），否則一套架構設計完成後，要再進行改動可能又是幾年不見了，或許這也是微服務慢慢開始起來的原因吧！</p><p>參考資料：<a href="https://www.youtube.com/watch?v=pnHiVFYpLzs">https://www.youtube.com/watch?v=pnHiVFYpLzs</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=459c6a381bf0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[深入 Java Default Sorting Algorithm — Dual-Pivot Quick Sort  (1)]]></title>
            <link>https://medium.com/@k1.0/%E6%B7%B1%E5%85%A5-java-default-sorting-algorithm-dual-pivot-quick-sort-1-f3d353bd3987?source=rss-9073be24eb0------2</link>
            <guid isPermaLink="false">https://medium.com/p/f3d353bd3987</guid>
            <category><![CDATA[algorithms]]></category>
            <category><![CDATA[sorting-algorithms]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[演算法]]></category>
            <dc:creator><![CDATA[Kay Lin]]></dc:creator>
            <pubDate>Fri, 27 May 2022 05:06:12 GMT</pubDate>
            <atom:updated>2022-05-27T05:07:09.854Z</atom:updated>
            <content:encoded><![CDATA[<h3>深入 Java Default Sorting Algorithm — Dual-Pivot Quick Sort</h3><p>最近工作上因業務需求在撰寫一些 Sorting Function 時，突然很好奇到底在 Java 預設是如何做排序的。這就回想起大學時候學的 Sorting Algorithm 有大概快十多種，但在做服務時常常直接使用 JDK 的預設方法，如 Arrays.sort() 與 Collections.sort() 等等，並直接 Override compare method 與交給 Callbacks 處理而已，因此決定開始針對 JDK 的方法來做一些研究與紀錄。</p><blockquote>對於排序來說，不存在『<strong>最佳</strong>』的演算法，而是在不同的情況下，我們會針對現有的資料去做『可能最好』的方法。</blockquote><p>Java 在 Primitive data type 與 Wrapper class 實際上有不同處理方法，前者主要是利用 Quick Sort 去實作排序問題，而後者則是 Merge Sort。兩者的差別在於，使用到 Wrapper class 基本上都是 Object，因此在 Sorting 上需要 stable（畢竟在業務場景上，我們常常會需要針對好幾個參數去做排序），而 Primitive type 則不須顧慮這些。</p><p>在這篇會針對 Dual-Pivot Quick Sort 來做介紹，不過開始之前，先提一下JDK 於 Dual-Pivot QuickSort 在實作時，並非完全使用 QuickSort 而已，若遇到不同情境則會切換演算法，主要有兩者如下：</p><h4>Insertion Sort</h4><p>在 Dual-Pivot QuickSort 裡面，對於遞迴到較小陣列時，也會使用 Insertion Sort，大概是因為在小陣列中如果用 Insertion Sort，不用再經過太多的 Overhead 與 Memory Usage，雖然 big O 乍看之下更大，但實際上可能比 Quick Sort 還要快。</p><h4>Heap Sort</h4><p>大家都知道，雖然 Quick Sort 在一般的情況下來說很快，但是真的遇到 Worst Case 的時候會達到 O(n²)。所以在 Dual-Pivot Quick Sort 裡，他會紀錄一個參數 bits，可以想成類似於已經 Recursion 的次數，如果達到一個 Threshold 的話，就會直接使用 Heap Sort 處理，畢竟 Heap Sort 的保證是 O(nlog(n))。</p><p>接下來進入我們的主角：<strong>Dual-Pivot Quick Sort</strong>。</p><blockquote>步驟 1: 選定兩個 Pivot</blockquote><p>這兩個 Pivot 定為 pLow 與 pHigh，並將兩者跟整組陣列去做比較，並類似於 Quick Sort 的做法，把陣列分成 (1) 小於 pLow (2) 介於 pLow 與 pHigh 中間 (3) 大於 pHigh 三個。</p><pre>+-------------------------------------------------------------+<br>|   (1) &lt; pLow   |   (2) pLow &lt;= ? &lt;= pHigh   |   (3) pHigh   |<br>+-------------------------------------------------------------+</pre><blockquote>步驟 2: 遞迴</blockquote><p>將分出來的三個子陣列 (1), (2), (3) 再丟入步驟 1，直到完全 Sort 完為止。以下可以透過一個簡單的例子來說明運作邏輯。</p><p>給定一陣列 {75, 24, 3, 50, 19, 33, 90, 41, 25}，流程如下：<br>1. 選定 75 與 25 做 Pivot,( pLow, pHigh)，若發現前者大於後者，則交換。<br>2. 陣列依序從左至右輪詢，遇到比 pLow 大時則紀錄，並且同時與 pHigh 比較。若比 pHigh 還小，則在之後與比 pLow 小的值做 swap；反之，則從後面 Swap。因此在圖一中的交換邏輯是 50 與 19 swap (50 &lt; 75 )。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5iv04Daf1-QvnyPbEPMpQw.gif" /></figure><p>3. 接續下去的比較，會遇到 25 &lt; 90 且 75 &lt; 90 的情況，這時則觸發 2. 的後者條件，與後面的元素作 swap，並在判斷 swap 後的值是否 &lt; 25。<br>4. 最終會將數列拆成三組與兩個 Pivot，{25} {24, 3, 19}, {50, 33, 41}, {90}, {75}，再讓 Pivot 與數組中的值 swap (25 與 19、90 與 75)，得到 {19, 24, 3, 25, 50, 33, 41, 75, 90}。<br>5. 將左側的 {19, 24, 3} 帶入演算法。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RRr-ndrto7NHmhrfUB52PQ.gif" /></figure><p>輕鬆介紹完演算法以後，接下來就會進入比較複雜的領域了。</p><blockquote>Quick Sort vs Dual-Pivot Quick Sort</blockquote><p>不管是一般的 Quick Sort 或是 Dual-Pivot Quick Sort，怎麼挑選到好的 Pivot 都是一個至關重要的決定。在 JDK 的 Quick Sort 中運用了 <em>Tukey’s Ninther</em>，即挑選中位數的中位數的概念來選擇；Dual-Pivot Quick Sort 中則是使用 <em>Vladimir Yaroslavskiy </em>的 <em>tertiles of five</em>。</p><p>雖然在理論上來說，Quick Sort 的期待元素比較次數是 2 <em>N</em>ln<em>N</em>，不過在綜合了 JDK 的方法以後，Quick Sort 最終的元素比較次數是 1.5697 <em>N</em>ln<em>N</em>，反而比 Dual-Pivot Quick Sort 的比較次數 1.7043 <em>N</em>ln<em>N </em>要來得低。那麼這樣為什麼還要使用 Dual-Pivot 呢？</p><h4>Cache Miss</h4><p>先稍微來提一下何謂 Cache Miss，意思即是當 CPU 沒辦法在 Cache 讀到他想要的資料時，就必須去其他記憶體地方找到 Block，並將資料複製到 Cache 後才能將資料傳給 CPU，中間的找不到資料就是 Miss。那麼如果遇到了 Cache Miss 時，就需要花更多的時間去處理 Read / Write 的動作。</p><p>在論文［<a href="https://arxiv.org/pdf/1511.01138.pdf">Why Is Dual-Pivot Quicksort Fast?</a>］有提出一個觀點：</p><p><em>Memory speed has not fully kept pace with improvements in processing power. This growing imbalance forces us to economize on memory accesses in algorithms that were almost entirely CPU-bound in the past, and calls for new cost models for the analysis of algorithms.</em></p><p>大致上的意思就是，雖然 CPU 處理速度不斷的在往前進步，但是 Memory 的存取機制上卻沒有 CPU 進步的那麼迅速。因此即時我們在理論上感覺比較越多次，就應該花越多時間，但我們卻忽略了 CPU 在比較時所需要使用的 Cache 機制。</p><p>所以在 Sorting 的時候，我們都只有將比較次數納入我們的時間複雜度裡面，但是若是遇到 Cache Miss 的情況之時，我們還需要花一些時間去讀資料，而這些卻不是當初做實驗時我們會納入考量的點。</p><p>因此此篇論文的作者提出了 Scanned Element 這個衡量標準：<em>An element scan is essentially an accesses “A[i]” to the input array A, but we count all accesses as one that use the same index variable i and the same value for i</em>.</p><p>在以 Scanned Element 作為比較標準的情況下，反而發現比較結果變成了 1.5697 <em>N</em>ln<em>N</em> vs. 1.4035 <em>N</em>ln<em>N</em>。雖然這並不一定能夠百分之百當成為什麼 Dual-Pivot Quick Sort 一定比較快的原因，但也另外證明了在衡量演算法時，絕對不是只有理論而已，有很多現實的因素也須考量進去。</p><p>因為這篇牽涉到的數學公式與論文較多，將參考資料附上：</p><ol><li><a href="https://arxiv.org/pdf/1511.01138.pdf">Why Is Dual-Pivot Quicksort Fast?</a></li><li><a href="https://kluedo.ub.uni-kl.de/frontdoor/deliver/index/docId/3463/file/wild-master-thesis.pdf">Java 7’s Dual Pivot Quicksort</a></li><li><a href="https://arxiv.org/pdf/1412.0193v1.pdf">Analysis of Pivot Sampling in Dual-Pivot Quicksort</a></li><li><a href="https://arxiv.org/pdf/1403.6602.pdf">Pivot Sampling in Dual-Pivot Quicksort</a></li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f3d353bd3987" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Annotation — 淺談 Java Reflection 與實作]]></title>
            <link>https://medium.com/@k1.0/annotation-%E6%B7%BA%E8%AB%87-java-reflection-%E8%88%87%E5%AF%A6%E4%BD%9C-7506aa82b3e2?source=rss-9073be24eb0------2</link>
            <guid isPermaLink="false">https://medium.com/p/7506aa82b3e2</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[spring-boot]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[reflections]]></category>
            <dc:creator><![CDATA[Kay Lin]]></dc:creator>
            <pubDate>Sun, 15 May 2022 10:23:51 GMT</pubDate>
            <atom:updated>2022-05-15T10:24:27.830Z</atom:updated>
            <content:encoded><![CDATA[<h3>Annotation — 淺談 Java Reflection 與實作</h3><p>還記得在初次接觸到 Java Spring Boot 的時候，每一個 Class 宣告時，常常都會加上一些 Annotation: @Service, @Data, @SneakyThrows 等等的，但那時候的我對於這些 Annotation 的原理像是霧裡看花一般，直到後來才越來越知道自己在幹嘛，所以在這篇我整理了一些簡單的想法與寫了一個客製化的 Annotation。一如既往，所有的 source code 都會放在 <a href="https://github.com/kaiyee0/Reflection-Annotation-Demo">github</a>。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hncqP5WbiDldwZNbDK8Wkg.png" /></figure><p>那就先從最常見的 Lombok @Data 的拆解來開始看好了，如果使用 IDE 進去則可以看到如下</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/0c7933620d5e95c1d74d382086f12dc6/href">https://medium.com/media/0c7933620d5e95c1d74d382086f12dc6/href</a></iframe><p>主要存在的元件有三個：@Target, @Retention, @interface。我們下面會一一來介紹這三個 Annotation 的必備元件：</p><blockquote>@Target</blockquote><p>Target 是用來告訴 Java 你的 Annotation 是想要標記在哪一些元素類別上，包括 TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, ANNOTATION_TYPE 等等…。在一般來說，我們最常用的應該也是有列出來的這些，像是 TYPE 其實就包括了我們常用的 Class, Interface, Enum 了。</p><pre>public enum ElementType <em>{<br>    TYPE</em>,<em><br>    FIELD</em>,<em><br>    METHOD</em>,<em><br>    PARAMETER</em>,<em><br>    CONSTRUCTOR</em>,<em><br>    LOCAL_VARIABLE</em>,<br><em>    ANNOTATION_TYPE</em>,<em><br>    PACKAGE</em>,<br><em>    TYPE_PARAMETER</em>,<em><br>    TYPE_USE</em>,<em><br>    MODULE</em>,<em><br>    RECORD_COMPONENT</em>;<br><em>}</em></pre><p>如 @Data 為什麼宣告是用 ElementType.TYPE 就是因為我們在宣告時都是加在我們的 Class 上面。</p><blockquote>@Retention</blockquote><p>Retention 字面上的意思是『保留』，而實際上真的也是在做 Annotation 的保留策略，主要有以下三種策略：SOURCE, CLASS (default), RUNTIME。</p><p>SOURCE 的意思就是你所使用的 Annotation 在 compile 後會被丟掉，如果要以最簡單的看法去理解這件事，可以看 IDE 在幫你 compile 後的 target 資料夾，會發現 @Data 的標記不見了，反而多了很多 Getter Setter。</p><p>另外 CLASS 與 RUNTIME 的差別就在 VM 是否會記得你所寫的 Annotation，並且只有<strong>後者</strong>能夠透過 reflection 去存取與使用元件。所以一般你若是需要進行一些業務邏輯的處理時，則都會宣告 ElementType.RUNTIME（但這就會很好奇為什麼 CLASS 會是預設值了）…。</p><blockquote><strong>@interface</strong></blockquote><p>如果說 interface 是一個給 implemented class 的介面，那 @interface 就是一個給 Annotation 互動的介面，因此所有的 Annotation 在宣告時都需要使用 @interface。並且在現在會有越來越多人不想寫 Comment，反而透過這種方式寫註解。</p><h4>Custom Annotation</h4><p>那我們自己也來試寫一個 Annotation 吧！我們這次做一個簡單的 Object 轉 Json String 並且加上自定義的驗證 Annotation。</p><p>首先我們先建立我們想使用的 @interface : @JsonObject 與 @Retention，其中 JsonObject 是用來將 Class 轉換為 Json String，而 Retention 則是用來驗證數字是否為正值。另外可以發現 JsonObject 的 ElementType 是 Type；PositiveNumber 的則是 FIELD。</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/2444c5033dd6267b1020dbdda1d39572/href">https://medium.com/media/2444c5033dd6267b1020dbdda1d39572/href</a></iframe><p>接下來我們宣告一個 Person Class，內含 Lombok 的 @Data、我們自己的 @JsonObject 與 @PositiveNumber 。</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/520555169ffd45abc280b2e43c01e8ea/href">https://medium.com/media/520555169ffd45abc280b2e43c01e8ea/href</a></iframe><p>最後我們來定義我們的 PersonService 的 function，其中做的流程如下：<br>1. 帶入此函式的參數是否有 JsonObject 的 Annotation<br>2. 找出所有的 Fields（需要 setAccessible，否則無法訪問 private）<br>3. 若是 Field 有加入 PositiveNumber 時，則開始驗證此欄位的數字<br>4. 回傳 jsonString</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/4d6a02d49119802cfca01f049a8dbbcc/href">https://medium.com/media/4d6a02d49119802cfca01f049a8dbbcc/href</a></iframe><p>最終就可以看到結果如下了：</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/bfe922411e15585c60a5de025344b7bf/href">https://medium.com/media/bfe922411e15585c60a5de025344b7bf/href</a></iframe><p>其實常常在寫 Mockito 測試的時候也需要使用 reflection 的方式去使用一些 Method，最常見的就是 java.lang.reflect.Method。只能說我們之所以能夠那麼輕鬆地寫 Spring Boot，也都是靠前人的肩膀再往前走啊～</p><p><a href="https://github.com/kaiyee0/Reflection-Annotation-Demo">GitHub - kaiyee0/Reflection-Annotation-Demo: Implement custom annotation using reflection.</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7506aa82b3e2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I/O 請求原理實作 — Java BIO / NIO]]></title>
            <link>https://medium.com/@k1.0/i-o-%E8%AB%8B%E6%B1%82%E5%8E%9F%E7%90%86%E5%AF%A6%E4%BD%9C-java-bio-nio-c6468507b593?source=rss-9073be24eb0------2</link>
            <guid isPermaLink="false">https://medium.com/p/c6468507b593</guid>
            <category><![CDATA[sockets]]></category>
            <category><![CDATA[軟體開發]]></category>
            <category><![CDATA[nio]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[non-blocking-io]]></category>
            <dc:creator><![CDATA[Kay Lin]]></dc:creator>
            <pubDate>Mon, 18 Apr 2022 15:40:22 GMT</pubDate>
            <atom:updated>2022-04-18T15:41:55.654Z</atom:updated>
            <content:encoded><![CDATA[<h3>I/O 請求原理實作 — Java BIO / NIO</h3><p>其實本來是單純想研究 Netty 這個框架而已，但不知道為什麼越研究越深，最後直接進入了 NIO 的世界，甚至還回去翻了以前<strong>作業系統</strong>這門課的東西，驀然有種 “<strong>少壯不努力，老大徒傷悲</strong>” 之感。</p><p>這次的 Demo Code 都放在文章最後的 Repo，有興趣可以再進去看，不過我也需要直接很老實的說，這個離真正能夠運行的服務還天差地遠，所以要真的運行的話還是乖乖用框架吧哈哈。</p><blockquote>Server / Client</blockquote><p>開始介紹以前，可以先從最原始的 Socket Server / Client 來做最原始的舉例，這邊先實作一個最基礎的 Server / Client。其實 Server 與 Client 的溝通與建立流程大致上如下：</p><p>1. 啟動 Server 並監聽 Socket<br>2. Client 端發動連線請求<br>3. 連線建立以後，彼此之間可以成功傳遞訊息</p><p>示範的程式碼如下：</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/051dff9be39075850f48a68b7e1a0927/href">https://medium.com/media/051dff9be39075850f48a68b7e1a0927/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ff04296f2d823b354d247a75c16dbdac/href">https://medium.com/media/ff04296f2d823b354d247a75c16dbdac/href</a></iframe><p>啟動後，我們的 Server 會開始監聽 Socket 中的資料，在 BioServer.java 中可以看到是以一個 while loop 不斷去監聽連線。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kQeJj4FGi2X-tB8P8DryeA.png" /></figure><blockquote><strong>BIO 阻塞式請求</strong></blockquote><p>BIO 的全名是 Blocking I/O，顧名思義就是他的所有請求都是阻塞的，需要等待前一個 Request 處理完之後才能繼續下一個處理。因此我們將剛剛的 Server / Client 加上 Sleep 模擬工作以及請求加入 uuid<em> </em>的字串。在同時發出 2 個請求後，可以看到結果如下：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*kvEyf55oBG858kUEIkQ4nQ.gif" /></figure><p>Server 會等第一個 client request 處理完以後，才去處理下一個，對於我們現在寫的這種小東西當然沒關係，但是如果今天是一個完整的軟體服務的話，總不可能說大家都慢慢進來排隊等待吧，不然你去 momo 上面買東西還要像去量販店一樣排隊買東西嗎 XD</p><blockquote>Thread</blockquote><p>最直觀的想法是直接用 Thread 來解決這個問題，我們這邊使用 ThreadPoolExecutor 試試看：</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/0a409826e42d3aec4c3922fd29cd0502/href">https://medium.com/media/0a409826e42d3aec4c3922fd29cd0502/href</a></iframe><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*j66OpFquD-7y9LCiqEdH3w.gif" /><figcaption>透過 Thread 處理後的結果</figcaption></figure><p>在調用了 Thread 以後，可以發現 Server 一次可以透過多個 Thread 處理多個 Request。不過開了很多 Thread 只為了專門處理 I/O 會造成極大的資源浪費，並且機器能夠負擔的 Thread 總量終究有限，那麼遇到更多的請求要怎麼辦？</p><blockquote><strong>NIO 非阻塞式請求</strong></blockquote><p>終於進到了比較現代的做法了，Java 在 1.4 以後開始引入了 nio，並且可以讓 Client 端的 Request 達到非阻塞式的方法（補充一下，Java 這邊的 NIO 全名是 New I/O 而不是 Non-blocking I/O，不過在理解上很多人會直接把它定為 Non-blocking I/O 以便跟 BIO 區別）。這邊就來介紹一下 NIO 到底是怎麼運行的。首先，在 NIO 中定義了三個最重要的組件：<em>Buffer</em>, <em>Channel</em>, <em>Selector</em>，以下就來一一介紹：</p><h4>Buffer</h4><p>Buffer 其實可以被想像是一個資料暫存緩衝區，也是在 NIO 裡面最重要的資料溝通方法。如果對於 OS 熟悉的話，那我覺得可以把它想成跟 OS 中的 Shared-Memory Systems 裡面的 Buffer。那麼到底什麼是 Buffer？根據 <a href="https://docs.oracle.com/javase/8/docs/api/java/nio/Buffer.html">oracle</a>：</p><blockquote>A buffer is a linear, finite sequence of elements of a specific primitive type.</blockquote><p>所以可以想成是一種陣列型態的參數，裡面會存放 <em>position</em>, <em>limit</em> 與 <em>capacity</em>，最後在 NIO 要去做資料讀取或寫入時都會進入 buffer 去做操作，更多的介紹可以參考<a href="https://docs.oracle.com/javase/7/docs/api/java/nio/Buffer.html">這邊</a>。</p><h4>Channel</h4><p>被建立起來的 I/O 連線就是 Channel，無論是 file 類別或是 socket 的 I/O 都是被涵蓋在 Channel 裡面，因此在 NIO 的 Server 中，可以想像成是 Channel 建立連線後，把資料透過 Channel 送進去了 Buffer 裡面。</p><p>Channel 主要的類別有：<strong><em>FileChannel</em></strong>（負責檔案處理）、<strong><em>DatagramChannel</em></strong>（UDP）、<strong><em>SocketChannel</em></strong>（TCP）、<strong><em>ServerSocketChannel</em></strong>（監聽 TCP），這次實作我們會使用到 <em>SocketChannel</em> 與 <em>ServerSocketChannel</em>。</p><h4>Selector</h4><p>既然知道了 Buffer 跟 Channel 的關係以後，那麼最後一個元件就是 <strong><em>Selector</em></strong>。它存在的意義是在不斷的檢查現有的 Channels 中哪些是可以進行讀或是寫的動作，所以有點像是 Channels 的管理者，去做分配動作的任務，概念如下圖所示：Selector 不斷輪詢監聽，隨時會有人向他說需要建立 Channel（<em>#register</em>）；Selector 負責管理 Channel，其中 Channel 的資料緩存由 Buffer 所負責儲存。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HRgDDE41ZYw99JS_E-tSGA.png" /><figcaption>Nio Schema</figcaption></figure><p>在 NIO 的世界中，Server Side 負責的東西會相對地比較複雜一些，在這邊我們讓 Server 只做很簡單的讀取 Client 請求資料與回覆，並且一樣使用 Sleep 來模擬工作：</p><p>1. Server 會先宣告一個 Selector 與 ServerSocketChannel，接著將 Channel <em>register </em>到 Selector 上，並和 Selector 說這個 Channel 是負責監聽連線的。<br>2. 開始不斷的輪詢，若有新進入的連線則直接 register 一個 SocketChannel 負責 Read 的動作。<br>3. 負責 Read 的 Channel 在讀取完所有資料以後，再關閉 Channel。</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/76d469ccec0eff83edac3fb256ce3c7d/href">https://medium.com/media/76d469ccec0eff83edac3fb256ce3c7d/href</a></iframe><p>那麼到底結果會長怎麼樣呢，我們先對 BioServer 同時發出 5 個請求（其中我們在 BioServer 中加入了 Sleep 去讓 output 的順序比較明顯），發現基本上 BioSever 就是依序消化進來的 Request。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*7TCAIjjnQzSh_57EoFUKPA.gif" /></figure><p>接者我們來看一下 NioServer 的狀態，會發現並不會等待前一個 Request 都處理完以後才處理下一個 Request（還好是這樣，不然不就是 BIO 了嗎…）。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*KcoBgWXtVqHTwmpsKY_xnQ.gif" /></figure><p>上面所列的 NioServer 依然是以單一個 Thread 來去處理任務（Sleep），而在較大型的系統裡，會直接讓 Selector 去管理多個 Thread，進而提升效能（不過現在寫的跟真正的 API 框架還是有很大的差距啦…）。我們在下面的程式碼大致上展現一下：</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e03fd31321777e9eb2fc9ff6685f0600/href">https://medium.com/media/e03fd31321777e9eb2fc9ff6685f0600/href</a></iframe><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*B3FaEE-R9y-5jKqeX2H0xw.gif" /><figcaption>NioServer 加入 Service Thread</figcaption></figure><p>在上面的結果中，我們可以很輕易地發現這次的訊息感覺都是『蹦』然後一起出現，與沒有開 Service Thread 形成了一個強烈的對比，速度也是天差地遠。在 Netty 中，主要也是分成了兩種 Thread：Boss Thread 與 Worker Thread，而 Boss Thread 就是我們在這邊負責分派任務的角色（Selector）。</p><blockquote>總結</blockquote><p>實際上，若今天只有單一個 Thread 能做事的時候，那一定是 NIO 的速度會比較快。這個感覺就像是，你今天有兩件事要做：買早餐跟寫報告。BIO 的概念就是你先去買早餐，買完早餐再去公司寫報告，但如果你在早餐店等很久的話也沒辦法；NIO 就是你先去早餐店點了早餐，回公司寫報告，好了之後再去早餐店拿早餐，速度一定就是比前者好。</p><p>但是在真正的應用服務中，NIO 一定還是要搭配其他的 Thread 去處理其他服務。所以常常會有人誤會使用 NIO 就一定是單線程的服務，只能說半對而已，因為他比較是運用 Selector 的 Thread 去控制多個 Service Thread。</p><p>Demo Code Repo:</p><p><a href="https://github.com/kaiyee0/medium-io-demo">GitHub - kaiyee0/medium-io-demo: Demo Code for I/O Intro.</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c6468507b593" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[以白話文解析區塊鏈 — 區塊、交易]]></title>
            <link>https://medium.com/@k1.0/%E4%BB%A5%E7%99%BD%E8%A9%B1%E6%96%87%E8%A7%A3%E6%9E%90%E5%8D%80%E5%A1%8A%E9%8F%88-%E5%8D%80%E5%A1%8A-%E4%BA%A4%E6%98%93-44da73686167?source=rss-9073be24eb0------2</link>
            <guid isPermaLink="false">https://medium.com/p/44da73686167</guid>
            <category><![CDATA[區塊鏈]]></category>
            <category><![CDATA[blockchain]]></category>
            <category><![CDATA[交易]]></category>
            <dc:creator><![CDATA[Kay Lin]]></dc:creator>
            <pubDate>Sun, 10 Apr 2022 16:40:38 GMT</pubDate>
            <atom:updated>2022-04-10T16:40:38.567Z</atom:updated>
            <content:encoded><![CDATA[<h3>以白話文解析區塊鏈 — 區塊、交易</h3><p>之所以會有這系列文章是因為先前跟公司分享了區塊鏈是什麼，以及未來能夠有哪些落地的應用。不過最近和一些非相關領域的朋友聊天，他們對於區塊鏈更陌生，所以想一想後覺得這個分享可以記錄下來給更多有興趣的人知道，尤其在台灣好像很少以比較『白話』的角度直接做探討的文章，所以把分享內容寫在這邊。</p><p>這篇主要會介紹區塊與交易的產生，若是想了解區塊鏈如何理解合約的話，可以進入另一篇文章觀看。</p><p><a href="https://medium.com/@kaiyi0/%E4%BB%A5%E7%99%BD%E8%A9%B1%E6%96%87%E8%A7%A3%E6%9E%90%E5%8D%80%E5%A1%8A%E9%8F%88-%E5%90%88%E7%B4%84-evm-73040804868f">以白話文解析區塊鏈 — 合約、EVM</a></p><h4>區塊 (Block)</h4><p>如果把區塊鏈根據名字拆解出來的話，就是『用區塊串成的鏈』，那麼什麼是區塊？如果以比較好理解的話來說，其實 Block 就是一個小小資料庫，可以存放 Transaction 的紀錄，並且會有額外的一些 Argument 在內，像是 Block Hash、Previous Hash、Timestamp、Difficulty 等等。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KbPX5nTxnrBwS7G0dDgr6A.png" /><figcaption>Block 內的資料</figcaption></figure><h4><strong>交易 (Transaction)</strong></h4><p>Transaction 主要紀錄的就是每一筆資料，最常讓人誤會的是 Transaction 的發生不一定是交易，而是用戶行為都可以被紀錄成 Transaction (只是因為以區塊鏈來說確實主要原因都是為了交易啦…)，主要紀錄的方式是利用 <strong>Merkle Tree</strong>，而也因為這樣的設計模式讓區塊鏈的『不可改動性』增強了許多。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*q-BkwIPcCMhd59asCmpw2A.png" /><figcaption>Transaction 紀錄</figcaption></figure><p>這邊需要先稍微跳出，提一下 Merkle Tree，其實他就是 binary tree 的一種，所以其實就是一個資料結構。這個 Tree 透過不斷地 hash 進而產生出了 Merkle Root。如下：</p><pre>Tx(A) 經過 H 產生出 H(TxA), BCD 亦然<br>H(TxA) 與 H(TxB) 再進入 H() 產生出 H(AB), CD 亦然<br>最終 H(AB) 與 H(CD) 再一同進入 H() 產生出 H(ABCD)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nfJLIUcoM3NV_C-GvCaOng.png" /></figure><blockquote>Block 的 Transaction</blockquote><p>既然知道了 Transaction 與 Block 個別是什麼以後，接下來看一下是怎麼一起運作的。</p><p>化簡後的流程大致上如下：<br>1. 有一筆交易 (Transaction: <em>小羅想要轉帳給小品</em>) 被 propagated （可以把它想成『廣播』）出來 ，通知所有礦工 (Miners)，並且被 network node 承認<br>2. 礦工看到了交易 (<em>小羅想要轉帳給小品這件事</em>)，把這筆交易納入下一個區塊 (Block)<br>3. 礦工開始做挖礦 (Mining:<em> 開始記錄小羅想要轉帳給小品</em>) 的動作<br>4. 上鏈成功，新的區塊被產出 (資料庫內有一筆資料: <em>小羅想要轉帳給小品</em>)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*tKhVJ_2EUHyI6nNASJG1Yw.gif" /><figcaption>Transaction being mined</figcaption></figure><p>PS. 如果第一次聽到挖礦的話（包括我），都會一直聯想到『真的挖礦』。但其實不是，挖礦的英文其實是 Mining，所以其實做的事情比較像是寫資料庫的感覺。（就好像 data mining 不會有人翻譯叫做『資料挖礦』吧…)</p><p>所以現在知道 Transaction 是怎麼被紀錄的下來的了，並且<strong>成功上鏈</strong>了。但在實務上常常會發現小羅的餘額跟小品的餘額在當下都還不會變動，為什麼呢？</p><blockquote>因為區塊還未經過確認</blockquote><p>簡單來說，就是即使這個交易被紀錄了，但是你難以確認這個交易的『有效性』: 有沒有別人紀錄一樣的事情？有沒有可能別人想要竄改數據成為另外一個新 Block 推翻這個 Transaction？</p><p>所以為了確保資料的正確性，通常都會要求需要有區塊確認，也就是這個 Block 後面要繼續迭代好幾個 Block ，如中本聰當初提出 6 個確認（因為據計算要 6 個區塊確認的破壞機率是微乎其微的）。這也是為什麼區塊鏈的交易普遍來說沒辦法即時的原因（不過有$$$就可以即時，等等會再說明）。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*CM2EBEC8iGkajrJgQ2e_ag.gif" /><figcaption>區塊確認</figcaption></figure><p>這邊要先來回顧一下剛剛提到的 hashMerkleRoot 了！每一個 Merkle Root 都是 Block 內所有的 Transaction Hash 出來的 Node，而下面的 Block 要接在你後面繼續傳接下去，就是需要用到這個 Root 進行加密，進而產生出代表這個 Block 的值。</p><p>舉一個極端的例子，假設小羅想賴帳，把原本自己要轉錢給小品的紀錄偷偷改寫，這樣會出現兩個大問題：<br>1. 在本身的 Merkle Root 會完全對不起來<br>2. 即使真的做到了改動，後面的 Block 也會對不起來</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*fv328ufQT2h2ufC2wnOjpg.gif" /><figcaption>所以不用想著要竄改區塊鏈了…吃錢不討好</figcaption></figure><h4>礦工 (Miner)</h4><p>呼～先來統整一下，所以現在我們知道了: Transaction 的發生、Block 紀錄 Transaction、Block 的產生、Block 怎麼變成 BlockChain 了。那麼現在的下一個問題是：誰來負責做這個『<strong>挖礦</strong>』的動作？也就是成為礦工？</p><p>這個問題如果拆解一下的話，其實會發現以技術的角度來翻譯：誰負責做寫資料，並且 Hash 起來發佈出去的動作？</p><h4>PoW: Proof of Work</h4><p>其實在區塊鏈的世界中，有很多種不同的決定方式誰來當這個寫礦工，這邊就先以最原味的 PoW 來跟大家解釋（另外一種常見的是 PoS，有時間再來寫）。最快的理解方式就是：PoW 就是一個『<strong>猜數字遊戲</strong>』!!!</p><pre>PoW 其實是一個很複雜的猜數字遊戲。<br>給定參數，並猜出 Nonce、Target，求出 Hash Value &lt; Target</pre><pre>SHA256(Version, hashPrevBlock, hashMerkleRoot,Timestamp,..., <strong>Nonce</strong>) &lt;= <strong>Target</strong></pre><p>假設剛剛這筆 Transaction，有三個人自願來紀錄：小禹、小本跟老謝。猜數字題目叫做：大家用 A 公式算出來的東西不可以比 “50781234” 還大。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4AMOxaRzA4EynW5uDU2idg.png" /></figure><p>這時小禹的 Nonce 猜 1111，公式算出來的值是 99999999；小本猜 104，公式算出來的值是 60123456；老謝用 591，結果算出來 32221222。那麼老謝最終就可以獲得這個『權利』紀帳。那為什麼大家要搶記帳？結論就是因為『<strong>記帳有錢賺</strong>』。</p><p>PoW 的意識就是，因為這個猜數字很難，但也因此區塊鏈才安全。所以你為了能夠幫區塊鏈算一個安全的 Hash，去花很多計算機成本計算（害我在研究所的時候要買一個網卡跑 AI 都很難買…），要好好獎勵你。以下是獎勵金：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iAnejfoprvz7Iu7v1dMCKw.png" /><figcaption>Mining 獎勵</figcaption></figure><p>這時候你也不得不佩服中本聰，設計出這套機制。簡單來說，在 2012/11 前（第 210,000 個 Block 被產出前），你只要成功成為一個 Block，就賞 50 個 BTC，但只要 Block 每產出 210,000 個，獎勵就減半。這讓比特幣：<br>1. 不會無限發放，而且越後面的 Block 越難算（猜）<br>2. 早期吸引大家進入<br>3. 越多人進入，大家越相信，BTC 價值越被承認</p><p>所以這邊統整一下區塊鏈，其實我覺得他就是一個<strong>分散式資料庫</strong>的系統設計，只是透過代幣的發行讓這資料庫得以分散到每個人都能夠參與，進而更提昇去中心化、共識、安全性與有效性。</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=44da73686167" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[以白話文解析區塊鏈 — 合約、EVM]]></title>
            <link>https://medium.com/@k1.0/%E4%BB%A5%E7%99%BD%E8%A9%B1%E6%96%87%E8%A7%A3%E6%9E%90%E5%8D%80%E5%A1%8A%E9%8F%88-%E5%90%88%E7%B4%84-evm-73040804868f?source=rss-9073be24eb0------2</link>
            <guid isPermaLink="false">https://medium.com/p/73040804868f</guid>
            <category><![CDATA[智能合約]]></category>
            <category><![CDATA[以太坊]]></category>
            <category><![CDATA[區塊鏈]]></category>
            <category><![CDATA[solidity]]></category>
            <category><![CDATA[blockchain]]></category>
            <dc:creator><![CDATA[Kay Lin]]></dc:creator>
            <pubDate>Sun, 10 Apr 2022 16:34:14 GMT</pubDate>
            <atom:updated>2022-04-10T16:48:39.227Z</atom:updated>
            <content:encoded><![CDATA[<h3>以白話文解析區塊鏈 — 合約、EVM</h3><p>有蠻多人好奇我對於區塊鏈的看法，但大家很容易把幣與區塊鏈全部都站在同一個角度去看，而我認為這樣是有失公允的。首先，區塊鏈的本質是一個技術，所以技術如果有能夠解決的問題，那麼他就一定有存在的可能與必要性，所以我非常看好區塊鏈；但是幣比較像是區塊鏈孕育而生的一項產品，不見得一定成功或失敗，端看這個幣的發行者對於幣的價值賦予，或是其他人對於這個幣的價值認同決定。</p><p>這邊主要會帶大家來看看什麼是合約，以及機器是如何理解合約的。建議可以先了解區塊與交易，對於這邊的理解會更得心應手。</p><p><a href="https://medium.com/@kaiyi0/%E4%BB%A5%E7%99%BD%E8%A9%B1%E6%96%87%E8%A7%A3%E6%9E%90%E5%8D%80%E5%A1%8A%E9%8F%88-%E5%8D%80%E5%A1%8A-%E4%BA%A4%E6%98%93-44da73686167">以白話文解析區塊鏈 — 區塊、交易</a></p><h4>合約 (Contract)</h4><p>我記得我在跟一個朋友聊天的時候，他問我說</p><p>『最近在幹嘛？』<br>『就因為對區塊鏈蠻有興趣的，所以我在研究那些東西』我回答。<br>『那你可以告訴我，為什麼合約要放到網路上嗎？不就兩個人簽一簽各拿一份就好了？』</p><p>雖然我也不知道那個人會不會看到這篇文章，但我覺得確實區塊鏈很多命名對於非這個領域的人都會很容易誤會（礦工、交易、挖礦）。總之，</p><blockquote>合約就是程式碼。</blockquote><p>所以現在在網路上運行的合約都是每個人寫出來的程式碼，內容當然參差不齊，就跟大家用不同 App 一樣，難用的就刪掉，好的就會被使用。因此區塊鏈的東西如果要大家繼續認同與承認，就必須要繼續維持高品質。</p><p>在 2017 年時發生過一個蠻大的事件，據說在當時造成了 50 萬ETH 的損失 (那現在不就更高了)，主因只是因為有一個函示權限管理沒有設好，導致每一個人都可以去把那份合約 kill 掉，也因為區塊鏈生態的匿名性，不會有人知道是誰做的，事主甚至在原本有問題的<a href="https://github.com/openethereum/parity-ethereum/issues/6995">合約</a>上留言…</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*yOlg4lIH1-VVvRD4" /><figcaption>發生在 2017 年的漏洞，原因就是程式碼的權限沒設好</figcaption></figure><p>總之，結合區塊鏈的不可竄改性，合約上鏈以後基本上就無法再被更改了，若有些合約有 v1, v2…之分的話，通常是運用了一層 Proxy Contract 去做更新的: 所以要放合約上鏈一定要非常非常小心啊…。</p><p>那麼下面就要進入宅宅的世界，帶大家了解到底一個合約是怎麼被運行的，首先先來帶大家認識 Solidity 跟 EVM 了。</p><h4>Solidity</h4><p>Solidity 就是一種程式語言，主要就是拿寫合約的，有人把他發明叫做 Contract-Oriented Language，因為他也只會拿來寫合約啊…。總之，在接觸過一陣子後我認為他具有以下的特性：</p><p>1. 他是一個非常聰明的高階程式語言<br>2. 綜合 C++ 跟 JavaScript 的一些特性與語法<br>3. 運行在 Ethereum 上面，並透過 EVM 為他編譯與執行</p><h4>EVM</h4><p>EVM 的全名是 Ethereum Virtual Machine，翻譯應該叫做以太坊虛擬機器。簡單來說，就是今天有人寫了一份程式碼，最終就是把這份程式碼解析了以後送給 EVM 去做處理。</p><p>那麼合約整體的運作流程便是這樣：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*2Ogjc9TokOcQCECdThwIUw.gif" /><figcaption>EVM 合約建立</figcaption></figure><p>1. 有人寫好了一份 Solidity 合約，也就是程式碼<br>2. 這份程式碼被解析成 ByteCode<br>3. ByteCode 最終傳入 EVM<br>4. EVM 解析這份 ByteCode 後，提供 ABI 給外部方使用</p><p>所以其實我們在做很多區塊鏈上的動作，如付款、轉帳、質押等等，都透過 ABI 與合約互動 (ABI 其實就很像軟體工程的 API)。以下用一個簡單的例子來做直接做說明：</p><pre>// SPDX-License-Identifier: GPL-3.0<br>// RevertTest.sol</pre><pre>pragma solidity &gt;=0.7.0 &lt;0.9.0;<br>contract test {<br> uint public a = 0;</pre><pre>// a is still a<br> function addRevert() public<br> {<br>  a += 1;<br>  goRevert();<br> }</pre><pre>// a = a + 1<br> function addNoRevert() public{<br>  a += 1;<br> }</pre><pre>function goRevert() pure public{<br>  revert();<br> }<br>}</pre><p>這是我自己寫的一份 RevertTest 的 Solidity 合約（程式碼），經過編譯後會變成以下的 ByteCode:</p><pre>// bytecode<br>60806040526000805534801561001457600080fd5b506101c5806100246000396000f3fe608060405234801561001057600080fd5b506004361061004c5760003560e01c80630dbe671f146100515780634f715f3d1461006f578063586f932e14610079578063a0aea92b14610083575b6000…</pre><p>好了這些東西，感覺根本不是人看的吧…。但你必須知道，這個真的不是給人看的，而是要讓 EVM 去理解的 Code，不過既然機器要理解，一定也會有一些規則，所以這邊要提到另外一個東西叫做 opcode。</p><blockquote>opcode</blockquote><p>如果有寫過 Assembly Language (組合語言)的話，那應該就會對這個覺得又恨又熟悉。opcode 的全名是 operation code，顧名思義就是操作的指令，每兩碼 bytecode 可以對應一組 opcode，內容包括了 POP, PUSH, ADD, SUB… 共 140 多種，有興趣可以來這邊看 <a href="https://ethereum.org/en/developers/docs/evm/opcodes/">Opcodes for the EVM</a>。因此上面那一串 bytecode 中其實就包括了超級多指令，這邊我們直接來針對前 10 碼解釋: <strong>6080604052</strong></p><pre>// bytecode to opcode<br>60 | 80 | 60 | 40 | 52<br>60: 0x60 - Operation: PUSH1<br>80: 0x80 參數<br>60: 0x60 - Operation: PUSH1<br>40: 0x40 參數<br>52: MSTORE</pre><p>其實這 10 碼非常常見，概念上就是一個合約的初始，再專業一點的話就是 Free Memory Pointer 的操作，在很多語言的情境都會使用。</p><p>那麼以上大概就是針對區塊鏈的基礎介紹，之後若有機會再來針對區塊鏈去做更多介紹。</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=73040804868f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[系統架構三高 — 高併發、高可用、高效能 (1)]]></title>
            <link>https://medium.com/@k1.0/%E7%B3%BB%E7%B5%B1%E6%9E%B6%E6%A7%8B%E4%B8%89%E9%AB%98-%E9%AB%98%E4%BD%B5%E7%99%BC-%E9%AB%98%E5%8F%AF%E7%94%A8-%E9%AB%98%E6%95%88%E8%83%BD-1-1b6b6fcea219?source=rss-9073be24eb0------2</link>
            <guid isPermaLink="false">https://medium.com/p/1b6b6fcea219</guid>
            <category><![CDATA[load-balancing]]></category>
            <category><![CDATA[程式設計]]></category>
            <category><![CDATA[nginx]]></category>
            <category><![CDATA[系統架構]]></category>
            <category><![CDATA[dns]]></category>
            <dc:creator><![CDATA[Kay Lin]]></dc:creator>
            <pubDate>Sat, 09 Apr 2022 11:47:34 GMT</pubDate>
            <atom:updated>2022-04-10T16:37:35.543Z</atom:updated>
            <content:encoded><![CDATA[<h3>系統架構三高 — 高併發、高可用、高效能 (1)</h3><p>最近針對自己所建立的程式系統架構開始思考要怎麼去做更好的設計與優化，畢竟萬丈高樓平地起，要有好的服務不是只靠 Coding 就能夠解決問題的，還需要有好的架構才能讓服務有更好的使用率與效能。</p><blockquote><em>那麼先來談談</em><strong><em>高併發</em></strong></blockquote><p>其實大家對於併發好像也沒有一個很明確的定義，我自己對他的解釋為『在一定的時間內，系統能夠同時處理請求的量級數』。一般來說，多以 QPS (Query per Second，每秒) 與 Response Time (回應時間）作為一個衡量的基準；在既定的業務需求下，就是盡可能地提升 QPS 與縮短 RT。而高併發則是在一個特定的時間，會有大量的請求湧入，如雙 11 的搶購、演唱會搶票等等，若是系統不堪負荷的話則會造成異常。</p><p>假設工程師小品完成了一個 Service，能夠同時乘載 N 個請求，但是今天若是有第 N+1 個請求進入 Service，則可能會遇到系統瓶頸或異常。這時候我們通常會有兩種解法，分為『<strong>垂直擴展</strong>』與『<strong>水平擴展』</strong>。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iJSzji5Mb---fWem9s6rew.png" /><figcaption>一台機器併發用戶數最多只能支援到 N 個用戶而已</figcaption></figure><blockquote><strong>垂直擴展</strong></blockquote><p>垂直擴展的定義其實就是直接把機器升級，讓 Service 能夠接受更多請求與進行更快地處理，像是原本是 32 core 就升到 64 core、SSD 升級等等，並且運用新設備進行更有效率的 Cache 處理不必要的 I/O。雖然我覺得定義叫做垂直擴展沒有很好，但我想應該是為了要能夠跟水平擴展剛好有一個相反的名字吧 XD</p><p>在一般業務剛發展的公司，都以垂直擴展為最佳解（前提是錢是小事…)，畢竟打不贏就課金買裝最快。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cGZpm6lKh736w0sgVPAbZQ.png" /><figcaption>垂直擴展：機器設備做更好的升級</figcaption></figure><blockquote><strong>水平擴展</strong></blockquote><p>當業務趨近起飛時，由於單一台機器的效能終究有極限，還是需要進入水平擴展，但涉及的層面也就更多了。就個人的經驗上來看，</p><blockquote>高併發最常出現在 Load Balance 與資料庫處理中。</blockquote><p>但因為資料庫的應對狀況根據不同的 DB (MySQL, MSSQL, sqlite, mongoDB) 會有不同的問題與處理方式，不過簡單的原則不外乎就是要有好的讀寫機制、減少直接針對資料庫進行計算、分庫分表等等，在這邊先不多做著墨。</p><p><strong>Load Balance</strong></p><p>Load Balance 翻譯叫做負載均衡，實際上就是把所有的請求分攤到各個子機器（服務）中。那麼先回顧一下剛剛的情境，小品跟公司申請加機器以後，那新增的機器要怎麼共同分擔服務的 Loading 呢？這邊就必須先來談談 DNS 與反向代理。</p><ul><li>DNS (Domain Name Service)</li></ul><p>DNS 的中文是網域名稱系統（我自己翻的啦…)，其實可以把它想成就是一個 網域名稱 — 伺服器 IP 的查詢系統，因此包括我們現在在打 <a href="https://medium.com/">https://medium.com</a> 時都是由 DNS 跟我們說要去哪一個機器處理我們的請求。所以我們可以透過 DNS 來跟我們說，今天小品有一半的請求要到舊機器、一半的請求要到新機器。</p><p>但由於 DNS 並非可以自己定義的 load balance 策略，因此若是有自定義的輪詢方法，甚至需要去做機器監控等等，都會比較麻煩，所以一般反而不建議用 DNS 做 load balance。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ra_VtJ-xH5f0gn_rIghN-Q.png" /><figcaption>透過 DNS 處理 load balance</figcaption></figure><ul><li>nginx</li></ul><p>講到反向代理，最耳熟能詳的應該就是 nginx 吧！主要的運作邏輯就是除了主服務以外，再加入一台代理伺服器專門轉發需求。所以可以想像成從 DNS 拿到了 IP 之後，請求再進入代理伺服器，由代理伺服器決定最終要到哪裡去做訪問。大家之所以喜歡 nginx ，除了高流量級的轉發以外，還能夠自定義輪詢規則（決定要去哪台機器訪問）、健康偵測（看哪一台機器有沒有壞掉）等等。</p><p>通常來說，好好使用 nginx 就能完美處理一定的併發量。不過就上述來看，也會發現其實 nginx 就是另外一個服務，並且是透過 OSI Layer 7 做轉發，需要經過 handshake，因此流量過大仍然會遇到瓶頸。但若是以上真的對於系統負載均衡高併發還未能有解的話，接下來可能就是透過更複雜一點的方式處理了……。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*13zBOOPIaCfVgHy2RO2EiA.png" /><figcaption>透過 nginx 處理 load balance</figcaption></figure><ul><li>LVS (linux virtual server)</li></ul><p>LVS 的工作原理是提供一組 VIP (virtual ip) 給使用者，再經過轉換到 RIP（Real Server IP，真的能夠提供服務的機器）上面，主要的方法有 DR, NAT, TUN, FullNAT，若有興趣可以再去研究一下，主要的差異就是轉發流程的差異。總之，再白話一點的話，很像是有一個請求進來以後，LVS 把 VIP 改成 RIP 。因為 LVS 是透過 OSI Layer 4 去進行轉發，且不會去看到 http 的具體 Request，所以不需要進行 handshake，效能會比 nginx 更好。</p><p>因此，究極一點的做法就是直接搭配使用 LVS + nginx ，讓 LVS 先做第一層的轉發後，再透過 nginx 去做終端請求的轉發，LVS 就可以串接更多 nginx 藉以提高更高的併發量。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jgIWFou-z2B-GlILrcEsJg.png" /><figcaption>加入 LVS 做 load balance</figcaption></figure><ul><li>F5 ($$$$$)</li></ul><p>俗話說，有錢好辦事。如果真的需要面臨企業級的併發量的話，那就可以考慮 F5 作為負載均衡的第一道防線，不過一台就是幾十萬起跳了…。F5 旗下最大的產品就是 BIG-IP，但說實在概念上跟其他的反向代理有點像，就是透過一個虛擬伺服器來去做轉發的動作，並且也是透過 OSI Layer 4 去做轉發，所以很多人都說就是硬體版的升級 LVS 。</p><p>不過因為 F5 使用了 PVA 芯片去協助處理 LVS 需要透過 CPU 計算的東西，性能上仍安然是遠大於 LVS（不過 F5 也不是說完全不需要 CPU 就是了，只是依賴性低）。</p><p><strong>所以面對高併發且不擔心錢的話，透過 F5 + nginx 去做 load balance 應該是很有機會能夠達到併發目標的。</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1b6b6fcea219" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>