<?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 Chonlaphoom Thaiyanto on Medium]]></title>
        <description><![CDATA[Stories by Chonlaphoom Thaiyanto on Medium]]></description>
        <link>https://medium.com/@chonlaphoomth?source=rss-cb2b00eabf3c------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*lbQPjeWTY1K6pePyRr7tww.jpeg</url>
            <title>Stories by Chonlaphoom Thaiyanto on Medium</title>
            <link>https://medium.com/@chonlaphoomth?source=rss-cb2b00eabf3c------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 10:36:34 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@chonlaphoomth/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[Is ‘AI’ Closing or Widening the Developer Gap?]]></title>
            <link>https://medium.com/@chonlaphoomth/is-ai-closing-or-widening-the-developer-gap-6712ca75bc2f?source=rss-cb2b00eabf3c------2</link>
            <guid isPermaLink="false">https://medium.com/p/6712ca75bc2f</guid>
            <dc:creator><![CDATA[Chonlaphoom Thaiyanto]]></dc:creator>
            <pubDate>Tue, 12 Aug 2025 08:41:59 GMT</pubDate>
            <atom:updated>2026-04-19T15:44:22.739Z</atom:updated>
            <content:encoded><![CDATA[<p>Note: When I talk about AI in this article, I’m mostly referring to “vibe coding” and AI Coding Agents. I’m not talking about AI in general.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WGZHUCiI9ql3SoXhgeGI7A.jpeg" /><figcaption>me and ducks</figcaption></figure><p>Recently, I was interviewing a candidate and asked a simple question: “What’s your take on AI?” He said that “AI will close the gap between junior and senior developers.”</p><p>My first thought was that it would do the opposite that “it would make the gap between junior and senior even wider”. I believe you can’t skip the experience. Software development is about at its core, an exercise in continuous decision-making where the developer must own the consequences of those choices. Senior developers have already learned many lessons and know most of the problems that might happen ahead therefore they can use LLM to be even more efficient, while juniors risk missing out on crucial learning.</p><p>So, I disagreed but without much explanation. I thought it was a simple question and I didn’t want to overcomplicate it.</p><p>Later, I revisited the question and came up with a better answer. My question was too broad. My short answer is: it depends on your goals and your starting point. I’ll explain why in this article.</p><h3>It is Not Always A Fire and Forget to Get a Good Result</h3><p>To build software and make money from it, you have to maintain, scale and keep responding to the Market. There are many small decision along the way that you can’t let LLM decide for you. This is very similar to using LLM to create an image but you have to keep improving it until you get the image you want. It’s not a fire and forget process. You have to keep iterating and improving until you get the result you want. The same thing applies to software development. You can use AI to help you get there faster but the you still own the process of adjusting and improving the image until you get the result you want. Same as coding. All I am saying is using LLM still requires skills and experience to get the best result.</p><p>I’ve noticed that the people most excited about Coding Agents are often the high level person who haven’t done the actual implementation for a long time. They are excited about the potential of AI to automate tasks and increase productivity, but they might not fully understand the implications of relying on AI for coding tasks. (This is just an observation, not a generalization.)</p><p>I think there’s a reason for this. With all the hype and advertising, it’s easy to believe that everything will work as expected, regardless of the consequences.</p><p>I agree with the excitement, but what about the consequences for a developer?</p><p><em>The image below refers to when you are using AI within your area of competence. You know what you are doing.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/512/1*ZUQUZzqVeQCzdYcmNkCxdw.png" /><figcaption>1st Illustrate</figcaption></figure><p>AI might help you reach your goal faster, but will you actually learn anything from it? maybe…</p><p><em>The image below refers to when you are using AI out of your area of competence.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/731/1*tnOShzIVZ67jiNZbLzly6Q.png" /><figcaption>2nd Illustrate</figcaption></figure><p>My concern from 2nd illustrate is that AI can create a false sense of competence. <a href="https://en.wikipedia.org/wiki/Dunning%E2%80%93Kruger_effect">The Dunning-Kruger effect</a> might occur faster, where a developer believes they have the ability to achieve the code they want. But as time goes on, you’re more likely to pile disaster upon disaster until the code is impossible or not worth the effort to fix or maintain.</p><h3>More over</h3><p>As I illustrated above, the more competent you are, the better your chances of creating maintainable and scalable software. If you’re at the beginning of your software development career with less experience and knowledge, you’re more likely to fall into the second scenario.</p><h3>How do we expand our area of competence?</h3><p>To do so, you need experience and hard learning. With “vibe coding” alone, I don’t think you’ll gain the most knowledge. This is unless you already have a strong foundation and a very efficient learning method which is very individual. You can use AI to help you learn, but it’s not a substitute for the learning process itself. It’s more of a tool to assist you in that process.</p><h3>How to Learn</h3><p>For instance, when I’m learning a new language, I find it’s best to disable all AI code assistants. When you code by yourself, you tend to think and to understand problems more deeply, including edge cases. You build your thoughts upon your thoughts. This is how you truly learn about a problem and increase your chances of inventing good solutions.</p><h3>Conclusion</h3><p>I agree that AI helps us learn, be more productive, but letting Coding Agents implement things for you entirely is an different matter. In other words currently it provide less accuracy when it comes to bigger picture. It’s crucial to know your goal before using AI. Otherwise, you might miss the opportunity to learn or have fun coding, both of which affect your long-term improvement. **Use it with care**.</p><p>Coding Agents is a very powerful tool for proving an idea, especially if your idea doesn’t require complex prerequisites. It can help you quickly create a Minimum Viable Product (MVP) version of your idea. Increase productivity. Later on, you might throw the entire project away or pick some parts to continue evaluating your idea. This helps you get more and more accurate results toward your goals.</p><h3>Lastly</h3><p>I’m not against AI. I use it every day. My point is that you need to be more aware of the path you’re on. Everyone can cook, but not everyone can be a chef. I don’t know… my take might change in the future since AI improves so rapidly each year. If you have any thoughts, please share them in the comments</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6712ca75bc2f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Unholy Commandments of the -10x Engineer]]></title>
            <link>https://medium.com/@chonlaphoomth/the-unholy-commandments-of-the-10x-engineer-ed945bd5de4e?source=rss-cb2b00eabf3c------2</link>
            <guid isPermaLink="false">https://medium.com/p/ed945bd5de4e</guid>
            <category><![CDATA[programmer]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[newbie-coder]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Chonlaphoom Thaiyanto]]></dc:creator>
            <pubDate>Mon, 28 Jul 2025 09:47:49 GMT</pubDate>
            <atom:updated>2025-08-08T04:41:17.510Z</atom:updated>
            <content:encoded><![CDATA[<p>PS: This article was initially inspired by <a href="https://taylor.town/-10x">taylor.town’s story</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-L2QbhfsCKysNBZl70IRuQ.jpeg" /><figcaption>On the way to the gym.</figcaption></figure><h3>Prologue</h3><p>I’m not sure if the 10x Engineer truly exists. I’ve heard they might, perhaps in the digital realm of ‘AIs’ (just kidding… mostly).</p><p>Short but not clear definition of 10x Engineer is a person who achieves ten times the productivity of their peers.</p><p><em>But what exactly does “productivity” mean ?</em></p><p><em>Is it about raw outputs ? Or outputs that actually matter ?</em></p><p><em>Is it making decision that significantly impact the work (positive impact, of course) ?</em></p><p><em>Solving problem fast and efficient in long run ?</em></p><p>The direct answer is often seen as the measurement of output over input. For a software engineer, this might infer how efficiently tasks are completed, considering factors like time spent, resource utilization, and quality.</p><h3>Here are the 10 unholy commandments to becoming a true -10x engineer.</h3><ul><li><strong>Embrace communication chaos:</strong> Either flush your team with irrelevant information or go completely silent. Either way, they’ll spend precious hours guessing your next move.</li><li><strong>Focus on shiny features not problem solving:</strong> Introduce new problem is a plus. Cultivate an unclear product vision and routinely shift requirements to nullify all prior engineering efforts.</li><li><strong>Champion burnout:</strong> Demand constant overtime. Do not embrace feedback. Master the art of blaming others. Burn out is your primary goal.</li><li><strong>Master the art of misalignment:</strong> Ensure team goals never align. More blockers mean more ‘critical’ cross-team meetings. A perfect excuse to talk without achieving anything. After all, we’re human, we <em>need</em> to communicate… inefficiently.</li><li><strong>Do not learn:</strong> What you know is enough.</li><li><strong>Only do low leverage activities:</strong> Dedicate yourself to reactive tasks, endless busywork, and utterly pointless rituals.</li><li><strong>Adopt multi-responsibility principle:</strong> Architect tightly coupled codebases that introduce a cascade of side effects. This guarantees endless future development and maintenance, securing your job for eternity.</li><li><strong>Keep 10 engineers in a meeting that they don’t actually need to be involve:</strong> Your go-to phrase: ‘We need you here just in case!’”</li><li><strong>Worship complexity:</strong> Simplicity is for amateurs. The more complexity your solutions are, the less likely any ‘AI’ will ever replace you.</li><li><strong>Master context-switching:</strong> Maximize build times to force engineers into constant context switches. Force engineers to have less focus and switch the context regular. You can achieve similar thing with testing or do both.</li></ul><h3>Final Advise</h3><p>If you’ve made it this far, ignore or negate every single piece of advice I’ve offered. Don’t take them serious. Your productivity (and sanity) will thank you.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ed945bd5de4e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Go Slices: More Than Just Dynamic Arrays]]></title>
            <link>https://medium.com/@chonlaphoomth/go-slices-more-than-just-dynamic-arrays-edcfdb9d8d63?source=rss-cb2b00eabf3c------2</link>
            <guid isPermaLink="false">https://medium.com/p/edcfdb9d8d63</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[golang]]></category>
            <dc:creator><![CDATA[Chonlaphoom Thaiyanto]]></dc:creator>
            <pubDate>Tue, 15 Jul 2025 16:39:24 GMT</pubDate>
            <atom:updated>2025-07-20T04:39:49.010Z</atom:updated>
            <content:encoded><![CDATA[<p>what’s up with slices ?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TvwNdzxj9ovaqoACgxMyqg.png" /><figcaption>I used Gemini to create this image</figcaption></figure><p>Slices and arrays are indeed powerful and fundamental variable types in Go when it comes to working with collections or “sets” of data. I will discuss their differences later.</p><p>Last week, I was continuing to write my Go project and encountered this behavior with Go slices. I have a function that is going to make a simple refresh token. The function generates a cryptographically secure, random refresh token as a hexadecimal string.</p><pre>func MakeRefreshToken() string {<br>   byte32 := make([]byte, 32)<br>   rand.Read(byte32)<br>   encoded := hex.EncodeToString(byte32)<br>   return encoded<br>}</pre><ul><li>The first line creates a new byte slice (an array of bytes) named byte32. make([]byte, 32) allocates space for 32 bytes. This means the resulting refresh token will be based on 32 bytes of random data.</li><li>The second line fills byte32 with cryptographically secure random bytes.</li><li>The third line converts the raw byte slice (byte32) into its hexadecimal string representation, then returns it.</li></ul><p>Wait… if you notice, we send byte32 to rand.Read() not &amp;byte32, but why in the third line do we expect byte32 to contain random bytes?</p><p>This is what makes slices different from arrays. A slice is a reference type, not a value type (arrays are value types). They are descriptors that point to an underlying array. When you pass a slice to a function or assign one slice to another, you’re passing a copy of the slice header (which contains a pointer to the underlying array, its length, and its capacity), not a copy of the entire data. This makes them very efficient for large datasets.</p><p>If you look at src/runtime/slice.go, you clearly see what it is under the hood:</p><pre>// src/runtime/slice.go<br>type slice struct {<br>   array unsafe.Pointer<br>   len   int<br>   cap   int<br>}</pre><p>Let’s look at an array example below</p><pre>package main<br><br>import &quot;fmt&quot;<br><br>func main() {<br>   alphas := [...]string{&quot;A&quot;, &quot;B&quot;} // or [2]string{&quot;A&quot;, &quot;B&quot;}<br>   removeA(alphas)<br>   fmt.Println(alphas) // [A B]<br>}<br>func removeA(alphas [2]string) {<br>   for index, a := range alphas {<br>    if a == &quot;A&quot; {<br>     alphas[index] = &quot;&quot;<br>    }<br>   }<br>}</pre><p>You get [A B] instead of [ B]. However, if you make a &quot;slicely&quot; different declaration by giving alphas an address instead of a value, you will get what you expect:</p><pre>package main<br><br>import &quot;fmt&quot;<br><br>func main() {<br>   alphas := [...]string{&quot;A&quot;, &quot;B&quot;}<br>   removeA(&amp;alphas)<br>   fmt.Println(alphas) // [ B]<br>}<br><br>func removeA(alphas *[2]string) {<br>   for index, a := range *alphas {<br>     if a == &quot;A&quot; {<br>       (*alphas)[index] = &quot;&quot;<br>    }<br>  }<br>}</pre><p>In summary:</p><p><strong>Array</strong></p><ul><li><strong>Fixed Size:</strong> An array in Go has a fixed size defined at its declaration.</li><li><strong>Contiguous Memory:</strong> Elements in an array are stored contiguously in memory.</li><li><strong>Value Type:</strong> Arrays are value types. When you pass an array to a function or assign one array to another, a copy of the entire array is made. This can be a consideration for large arrays.</li></ul><p><strong>Slice</strong></p><ul><li><strong>Dynamic Size (Flexible):</strong> Slices provide a flexible view into an underlying array. You don’t need to specify their size at compile time. They can grow or shrink as needed.</li><li><strong>Reference Type (Underlying Array):</strong> Slices are reference types (or more precisely, they are descriptors that point to an underlying array).</li><li><strong>Convenient Operations:</strong> Go provides built-in functions and syntax for working with slices that make common data manipulation tasks easy, such as append and the slicing operator ([low:high]).&quot;</li></ul><p>For more information: <a href="https://go.dev/doc/effective_go#slices">https://go.dev/doc/effective_go#slices</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=edcfdb9d8d63" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Go’s Goroutines: A Practical Guide to Concurrency, Race Conditions, and Synchronization]]></title>
            <link>https://medium.com/@chonlaphoomth/gos-goroutines-a-practical-guide-to-concurrency-race-conditions-and-synchronization-96df8ad41623?source=rss-cb2b00eabf3c------2</link>
            <guid isPermaLink="false">https://medium.com/p/96df8ad41623</guid>
            <category><![CDATA[programming-languages]]></category>
            <category><![CDATA[go]]></category>
            <category><![CDATA[deadlock]]></category>
            <category><![CDATA[golang]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Chonlaphoom Thaiyanto]]></dc:creator>
            <pubDate>Sat, 28 Jun 2025 16:49:34 GMT</pubDate>
            <atom:updated>2025-06-30T12:54:16.085Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/720/0*oCWD2S0ruZBgsgRS.png" /><figcaption><a href="https://georgearisty.dev/posts/golang-deadlocks/">https://georgearisty.dev/posts/golang-deadlocks/</a></figcaption></figure><p><strong>Goroutines</strong> are a standout feature that draws many developers to Go. Essentially, they are the fundamental building blocks for concurrent programming in the language. As the official documentation states, “A goroutine is a lightweight thread managed by the Go runtime.” The benefits of using goroutines are numerous, with a primary advantage being their ability to make your program utilize the CPU more efficiently, depending on the number of available CPU cores and specific settings.</p><p>However, with the power of goroutines come certain considerations and “rules of thumb” you need to be aware of. Issues like <strong>goroutine leaks</strong> (where a goroutine starts but never exits) and <strong>deadlocks</strong> can arise if not handled carefully. As Uncle Ben wisely advised, “With great power comes great responsibility.” While I won’t cover every potential pitfall in this article, I want to focus on a particularly common one that many, including myself, encounter during the initial phases of learning Go: the <strong>race condition</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/538/0*NqGQx-CMQlBqhBSR.jpg" /></figure><p>A <strong>race condition</strong> occurs when multiple goroutines concurrently access shared memory, and at least one of these accesses is a write operation. The final outcome becomes unpredictable because it depends on the non-deterministic interleaving of their operations, often leading to incorrect or inconsistent data.</p><p>Consider the following example, which demonstrates an anti-pattern:</p><pre>package main<br><br>import (<br> &quot;fmt&quot;<br> &quot;sync&quot;<br>)<br><br>var counter int // Shared memory<br><br>func Counter() {<br>   var wg sync.WaitGroup<br>   for i := 0; i &lt; 100; i++ {<br>      wg.Add(1)<br>      go func() {<br>         defer wg.Done()<br>         counter++<br>      }()<br>   }<br>   wg.Wait()<br><br>   fmt.Println(&quot;Final Counter (problematic):&quot;, counter) // Likely not 100<br>}</pre><p>You might expect the final value of counter to be 100, but in reality, it&#39;s highly unlikely to be.</p><p>Let’s break down why. In the loop, you see counter++. This seemingly simple operation is actually a shorthand for three distinct steps:</p><ol><li><strong>Read</strong> the current value of counter.</li><li><strong>Increment</strong> that value by 1.</li><li><strong>Write</strong> the new value back to counter.</li></ol><p>The problem arises because multiple goroutines are attempting to perform these steps concurrently on the same counter variable. Imagine a scenario where Goroutine A reads counter as 50. Before it can increment and write 51 back, Goroutine B also reads counter as 50. Now, both goroutines increment their local copy to 51 and then write 51 back. Instead of the counter reaching 52 (after two increments), it only reaches 51, effectively losing one of the increments. This unpredictable interleaving leads to an incorrect and inconsistent final value.</p><p>As the famous Go proverb states: “Do not communicate by sharing memory; instead, share memory by communicating.” In this context, “sharing memory” refers to directly accessing and modifying the same variables from multiple goroutines without explicit synchronization mechanisms, which is precisely the anti-pattern we’ve just observed.</p><h3>How to Avoid Race Conditions</h3><p>To avoid race conditions, we embrace the second part of the Go proverb: “instead, share memory by communicating.” One common and effective way to achieve this is by using a <strong>Mutex</strong>.</p><p>sync.Mutex in Go is a mutual exclusion lock. It&#39;s a fundamental synchronization primitive used to protect shared resources (like variables, maps, or structs) from being simultaneously accessed and modified by multiple goroutines. When a goroutine acquires a mutex, any other goroutine attempting to acquire the same mutex will be blocked until the first goroutine releases it.</p><p><strong>sync.Mutex is just instance to </strong>manages the locking state</p><ul><li>When one goroutine calls mu.Lock(), it acquires the lock. If another goroutine tries to call mu.Lock()</li><li>while the lock is already held, that second goroutine will <strong>block</strong> (wait) until the first goroutine calls mu.Unlock().</li><li>Once mu.Unlock() is called, the lock is released, and one of the waiting goroutines can then acquire the lock and proceed <strong>so mutex is simple mechanic but yet powerful.</strong></li></ul><p>Let’s fix our problematic Counter example using a Mutex:</p><pre>package main<br><br>import (<br> &quot;fmt&quot;<br> &quot;sync&quot;<br>)<br><br>var counter int<br>var mu sync.Mutex // Our mutex<br><br>func main() {<br>   var wg sync.WaitGroup<br>   for i := 0; i &lt; 100; i++ {<br>      wg.Add(1)<br>      go func() {<br>         defer wg.Done()<br>         mu.Lock() // Acquire the lock<br><br>         counter++<br><br>         mu.Unlock() // Release the lock<br>      }()<br>   }<br>   wg.Wait()<br>   fmt.Println(&quot;Final Counter (safe with mutex):&quot;, counter) // Will be 100<br>}</pre><p>By placing mu.Lock() and mu.Unlock() around the counter++ operation, you ensure that only one goroutine at a time can execute that critical section of code. This effectively &quot;communicates&quot; (through the lock and unlock operations) about the shared memory (counter), preventing concurrent access and guaranteeing correct increments.</p><h3>The Hidden Trap: Deadlocks with Mutexes</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/672/0*bgD6SdYYnAC4r4k0.jpg" /><figcaption><a href="https://www.reddit.com/r/ProgrammerHumor/comments/60pe0k/classic_deadlock/#lightbox">https://www.reddit.com/r/ProgrammerHumor/comments/60pe0k/classic_deadlock/#lightbox</a></figcaption></figure><p>While mutexes are powerful, a common mistake for beginners is unintentionally causing a <a href="https://en.m.wikipedia.org/wiki/Deadlock_(computer_science)"><strong>deadlock</strong></a>. A deadlock emerges when two or more goroutines are blocked indefinitely, each waiting for the other to release a resource that it needs.</p><p>Consider this example of a Cache structure with a reapLoop function designed to periodically clean expired entries:</p><pre>type Cache struct { <br>    mu *sync.Mutex <br>    entries map[string]cacheEntry <br>    interval time.Duration <br>}<br><br>func (c *Cache) reapLoop() { <br>  ticker := time.NewTicker(c.interval)<br>  c.mu.Lock() // ←- PROBLEM HERE! Lock acquired here!<br>  defer c.mu.Unlock() // This defer will only run when the function exits!<br><br>  for range ticker.C {<br>      for key, value := range c.entries {<br>          if time.Since(value.createAt) &gt; c.interval {<br>              delete(c.entries, key)<br>              fmt.Println(&quot;cache delete: &quot;, key)<br>          }<br>      }<br>      // No c.mu.Unlock() inside the loop. The mutex stays locked.<br>  }<br>  // The defer c.mu.Unlock() only runs *after* the loop, which never ends.<br>}</pre><p>This reapLoop function, intended to periodically clear the cache, has a critical flaw that can lead to a deadlock. Here&#39;s why:</p><ol><li><strong>reapLoop acquires </strong><strong>c.mu:</strong> As soon as reapLoop is called, it successfully calls c.mu.Lock() and acquires the mutex.</li><li><strong>reapLoop enters infinite </strong><strong>for range:</strong> It then immediately enters the for range ticker.C loop, which is designed to run indefinitely (unless the ticker is explicitly stopped and its channel closed externally, which isn&#39;t happening within reapLoop&#39;s direct control).</li><li><strong>Mutex remains locked:</strong> Because c.mu.Unlock() is deferred to the very end of the reapLoop function, and the for range loop never terminates, the mutex c.mu remains locked indefinitely.</li><li><strong>Other goroutines block forever:</strong> Any other goroutine in your program that attempts to interact with the Cache (e.g., calling c.Add(), c.Get(), or any other method that uses c.mu.Lock()) will now try to acquire c.mu. Since reapLoop holds the lock permanently, these other goroutines will block indefinitely, waiting for a lock that will never be released. This is a classic deadlock scenario.</li></ol><h3>The Correct Approach to Locking in Loops</h3><p>The solution is to ensure the mutex is only held for the duration of the critical section within the loop, not for the entire lifetime of the reapLoop goroutine.</p><pre>func (c *Cache) reapLoop() { <br>    ticker := time.NewTicker(c.interval) <br><br>    for range ticker.C { <br>      c.mu.Lock() // ←- Lock is acquired inside the loop<br><br>      for key, value := range c.entries {<br>	if time.Since(value.createAt) &gt; c.interval {<br>      	  delete(c.entries, key)<br>      	  fmt.Println(&quot;cache delete: &quot;, key)<br>  	}<br>      }<br><br>      c.mu.Unlock() // Lock is released *inside* the loop<br>    }<br>}</pre><p>In this corrected version:</p><ul><li>The mutex is acquired (c.mu.Lock()) only for the duration of the cache cleanup logic <strong>within each iteration</strong> of the loop.</li><li>Immediately after the cleanup is complete for that iteration, the mutex is released (c.mu.Unlock()).</li><li>The reapLoop goroutine then goes back to waiting on the ticker.C channel <strong>without holding the lock</strong>. This crucial change allows other goroutines to access the cache safely while reapLoop is waiting for the next cleanup interval, thereby preventing deadlocks.</li></ul><h3>Conclusion: Master Go’s Concurrency Wisely</h3><p>Goroutines are an incredibly powerful feature that makes concurrent programming in Go accessible and efficient. However, like any powerful tool, they require a deep understanding and careful application. Always remember to design your concurrent code with clear communication patterns and disciplined resource access to avoid common pitfalls and ensure your programs run smoothly and correctly.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=96df8ad41623" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Mouse to Mastery: My Unexpected Journey with Vim]]></title>
            <link>https://medium.com/@chonlaphoomth/from-mouse-to-mastery-my-unexpected-journey-with-vim-38db4eaa8346?source=rss-cb2b00eabf3c------2</link>
            <guid isPermaLink="false">https://medium.com/p/38db4eaa8346</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[vim]]></category>
            <dc:creator><![CDATA[Chonlaphoom Thaiyanto]]></dc:creator>
            <pubDate>Sun, 22 Jun 2025 16:53:15 GMT</pubDate>
            <atom:updated>2025-08-08T06:01:40.816Z</atom:updated>
            <content:encoded><![CDATA[<h3>My Unexpected Journey with Vim (Later Neovim)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FzAafbTm2QR9L3Nw2yrG6Q.png" /></figure><p>As developers, we’re always seeking that edge whether it’s writing cleaner code, shipping features faster, or simply finding more joy in the daily grind. For me, that quest led me down an unexpected path: the seemingly ancient, often intimidating, world of Vim. What started as a casual observation during a pair programming session has since transformed how I interact with my code, my terminal, and even my understanding of personal learning.</p><h3>The First Glimpse: A Colleague’s Vim Magic</h3><p>My first real encounter with Vim wasn’t in a dusty old terminal, but right there in the familiar glow of VS Code. I was pair programming with a colleague from a previous company, and to my mind surprise, his editor had the Vim extension turned on. I’d dabbled with vi from time to time on servers, mostly out of necessity to make quick configuration changes. My knowledge was limited to the absolute basics: i for insert, esc to exit insert, hjkl for navigation, and of course, the sacred :wq or :q! to quit. Seeing him fly through code without ever touching the mouse, even then, I thought, &quot;That&#39;s cool. Maybe someday.&quot;</p><p>Inspired, I tried the same. I installed the Vim extension in my own VS Code setup. But when the deadlines come and the pressure mounted, old habits emerge. My muscle memory for clicking, dragging, and quick keyboard shortcuts with the mouse was deeply ingrained. I was fast with my comfort method, and the initial awkwardness of Vim motions felt like a roadblock. The motivation wasn’t strong enough, and the extension became something I’d turn on and off, a curious experiment rather than a committed practice.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/583/1*5M66BiBUKY-HMXwbgtB8sw.png" /><figcaption>from <a href="https://www.learntermux.tech/2023/03/vim-text-editor.html">https://www.learntermux.tech/2023/03/vim-text-editor.html</a></figcaption></figure><h3>The Turning Point: Beyond the Mouse, Beyond JavaScript</h3><p>My primary domain has always been frontend development, meaning JavaScript and TypeScript are my bread and butter. While I’ve picked up C, C++, C#, and Java in the past, I never truly mastered them or formed strong opinions on their deeper features, generally sticking to SOLID principles. The desire to broaden my language arsenal was a constant.</p><p>Then came the YouTube deep dives. As I explored new programming languages and frameworks, particularly in the Go community (which seemed to have a strong Vim following), I noticed a recurring theme: almost every seasoned developer on these channels seemed to navigate their code with Vim. They were incredibly fast, seemingly performing magic without ever reaching for the mouse. It wasn’t that my mouse-and-keyboard combo was slow it was efficient for <em>me</em>. But watching them, it felt like an entirely different league of interaction, like truly “talking to the machine” in a way that certainly looked like hacking.</p><p>A seed was planted: Could I do that? Could I learn this once and apply it everywhere? The thought was particularly appealing as I considered diving deeper into backend development, where navigating servers and interacting with text-based environments is far more common.</p><h3>Embracing the Suck: The Path to Muscle Memory</h3><p>The transition wasn’t immediate, and it certainly wasn’t without its frustrations. Initially, even simple edits felt like a wrestling match. My brain screamed for the comfort of the mouse, the familiar Ctrl+C and Ctrl+V. But I persisted, learning to “yank” and “paste” a process that felt a bit like a game in itself. I began forcing myself to use Vim motions for navigation, even if it meant doing things slower at first. To push myself, I decided that during any overtime work, I would <em>only</em> use Vim motions. This way, even while completing tasks, I was doing something for myself, turning a chore into a self-improvement challenge.</p><p>This phase is where the real learning happens. It’s about <strong>embracing the suck long enough to become better at it.</strong> With enough practice, it becomes second nature.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/0*Mq4AHeJQOd-xdcMq.jpg" /><figcaption>from <a href="https://filiphalas.com/from-vscode-to-neovim">https://filiphalas.com/from-vscode-to-neovim</a></figcaption></figure><h3>Beyond Speed: The True Joys of a Vim Workflow</h3><p>Was my primary motivation to be faster? Maybe subconsciously. But honestly, it was more about the “cooler” factor even though nobody care about your editor. And what I discovered was something far more profound than just speed: it was <strong>fun to code</strong> again.</p><p>Not every aspect of being a software engineer is inherently enjoyable, but the act of writing code itself should be. With Vim motions, coding transformed into a kind of mini-game. Each text object, each motion, each operator felt like a new move to master. It was like solving a puzzle, optimizing my movements, and building complex actions from simple primitives. This add an enjoyment into my work, making me eager to learn more and less afraid to experiment. It reinforced a powerful lesson: I <em>can</em> learn challenging new things, and the effort pays off.</p><p>This newfound enjoyment found when I ventured beyond the VS Code extension and into the world of Neovim. Neovim’s extensibility, particularly its use of Lua for configuration, opened up an entirely new dimension of customization. Diving into my init.lua file, tweaking plugins, and building my ideal editing environment was not just a technical exercise; it was a journey of self-discovery. I learned what truly mattered to <em>me</em> in an editor, how I preferred to organize my workspace, and what shortcuts truly enhanced my workflow. It was another piece of evidence in my pocket that I could take a complex tool, understand its inner workings, and mold it into a personal, enjoyable extension of my thought process.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XmPUj3miIrYYtwJupvGs1A.png" /><figcaption>from <a href="https://www.learntermux.tech/2023/03/vim-text-editor.html">https://www.learntermux.tech/2023/03/vim-text-editor.html</a></figcaption></figure><h3>More to Learn, More to Enjoy</h3><p>The journey with Vim (and now Neovim) is ongoing. There’s always a new motion to discover, a new plugin to explore, a new way to optimize. But that’s part of the fun. For me, however, the “fun” isn’t about collecting a vast array of plugins. In fact, I’m quite the opposite; I try to use as few plugins as possible, avoiding the overwhelm of configurations I don’t fully understand. My approach is to stick with the core functionality, and only if I encounter a specific problem or friction point do I then seek out a plugin or configuration snippet that precisely addresses that issue, and nothing more.</p><p>You start to understand what you want from your tools, and you gain the knowledge and power to get it. In a profession where not every task is glamorous, having a set of tools that you genuinely enjoy using, that you can customize and make your own, makes a world of difference. My Vim-powered workflow isn’t just about efficiency; it’s about reclaiming a little piece of joy in the daily act of creation.</p><p>Now I can do “I use Vim, btw.” (And yes, it’s still hard to quit.)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=38db4eaa8346" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why I Stopped Rushing and Started Planning]]></title>
            <link>https://medium.com/@chonlaphoomth/why-i-stopped-rushing-and-started-planning-1795316151a4?source=rss-cb2b00eabf3c------2</link>
            <guid isPermaLink="false">https://medium.com/p/1795316151a4</guid>
            <category><![CDATA[self-improvement]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[self-awareness]]></category>
            <dc:creator><![CDATA[Chonlaphoom Thaiyanto]]></dc:creator>
            <pubDate>Mon, 14 Apr 2025 15:20:06 GMT</pubDate>
            <atom:updated>2025-08-08T13:00:37.513Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="This photo was taken in Na Chom Thian, Chonburi, Thailand." src="https://cdn-images-1.medium.com/max/1024/1*jhNdbji7wdSwybmWXqWfQQ.jpeg" /><figcaption>This photo was taken in Na Chom Thian, Chonburi, Thailand.</figcaption></figure><blockquote>Disclaimer: This article is based on my personal observations and experiences. It may not apply to everyone, but I hope some of you will find it relatable.</blockquote><h3>What kind of rushing am I talking about?</h3><p>First of all, I’ve always been someone who tries to complete whatever task I’m assigned. This mindset started back in high school, not because I was particularly attentive in class, but because I was raised with a strong sense of responsibility. Like many kids raised in middle-class Asian families, I was taught to do whatever teachers told me, regardless of whether it made sense or not.</p><p>Looking back, I realize how naive that was. I didn’t practice critical thinking at the time, I just followed instructions without question. (Of course, I’ve since learned the value of critical thinking and how to properly frame questions.) That behavior, though, made me a pretty ideal entry-level employee.</p><p>After graduating from university, I found that tasks became more complex over time, whether due to your role, responsibilities, or position. You often have multiple things on your plate, all seemingly urgent. Even with prioritization in place, you sometimes feel your progress isn’t fast enough. That’s when the feeling of being “in a rush” kicks in.</p><p>For example, after going through a high-pressure situation once, the next time something similar comes up, you might start rushing from the very beginning. Even if the new situation is different, the fear of running out of time kicks in early. When you make decisions like this repeatedly over the years, that mindset becomes a habit, a default way of thinking and feeling.</p><p>Sometimes, it works out. You finish everything before the deadline and feel productive. But there are trade-offs. There are also times when it backfires you misjudge the time needed, get overwhelmed, and miss the deadline anyway. And even if you learn from the experience, the stress and pressure from constantly rushing can be immense. It’s not healthy, and it’s certainly not something you should consistently sacrifice yourself for, especially not just for the sake of your company.</p><p>As I reflect more, I’ve come to understand the feeling I’m describing: it’s the state of feeling rushed. Don’t confuse this with a sense of urgency. Knowing your priorities and starting promptly is important, but that doesn’t mean you need to feel rushed.</p><h3>The Drawbacks of Rushing</h3><ol><li><strong>Rushing the process increases the risk of mistakes. <br></strong>When you’re in a hurry, your attention narrows. You skip over small details, make assumptions, and react instead of thinking things through. That might work once or twice, but over time, it leads to avoidable errors, ones that could’ve been prevented with just a bit more care or reflection.</li><li><strong>Not everything allows for shortcuts. <br></strong>Some tasks demand full attention, or deep thinking. Trying to “speedrun” them often backfires. You might get to the end quicker, but the quality suffers, or worse, you miss the point entirely.</li><li><strong>You miss out on valuable learning opportunities.</strong><br>When you’re rushing, you’re often in such a hurry to finish that you don’t fully absorb what you’re doing. You complete the task, sure, but you don’t take time to understand the why behind it. Over time, this builds a shallow skill set, where you’ve done many things but mastered few.</li><li><strong>It creates unconscious stress that builds over time.</strong><br>You might not even realize how much pressure you’re putting on yourself. But constantly operating in “rush mode” takes a toll. Eventually, you hit the wall, because no matter how hard you try, you can’t control every variable. when your system depends on everything going fast and perfectly, you’re left anxious and burnt out the moment it doesn’t.</li></ol><h3>A Better Alternative: Thoughtful Planning</h3><p>The mindset shift that helped me was this: I now prefer to invest time in thoughtful planning, breaking tasks down, creating the most concrete plan I can, and then simply sticking to it. I focus on being present, learning what needs to be learned along the way. This approach feels more sustainable and far healthier in the long run. I were told to act fast, because I weren’t mature yet. But doing things quickly is relative. You can move fast and still go in the wrong direction. You can take your time and still finish faster in the end. It’s all about perspective.</p><p>Ultimately, it all comes down to self-management and the ability to regulate one’s thoughts. Even when experiencing a sense of urgency or pressure, it is still possible to develop and execute an efficient plan. The key lies in managing one’s thoughts with intention and awareness. Although I still encounter moments of feeling rushed, I am now more conscious of these experiences compared to the past, which enables me to respond more effectively.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1795316151a4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Antifragile Living: Thriving in an Unpredictable World]]></title>
            <link>https://medium.com/@chonlaphoomth/antifragile-living-thriving-in-an-unpredictable-world-4ac0c316d1a5?source=rss-cb2b00eabf3c------2</link>
            <guid isPermaLink="false">https://medium.com/p/4ac0c316d1a5</guid>
            <category><![CDATA[growth-mindset]]></category>
            <category><![CDATA[books]]></category>
            <category><![CDATA[self-improvement]]></category>
            <category><![CDATA[antifragile]]></category>
            <dc:creator><![CDATA[Chonlaphoom Thaiyanto]]></dc:creator>
            <pubDate>Sun, 08 Sep 2024 15:06:40 GMT</pubDate>
            <atom:updated>2024-09-09T13:55:40.757Z</atom:updated>
            <content:encoded><![CDATA[<p>In 2022, I had the opportunity to meet a new co-worker who worked on the same project as I did. I found him to have an interesting and creative approach to solving complex problems and not rely on habits or routines as solutions. His calm demeanor when facing challenges was remarkable. Although we had not been close, we had an ice-breaking session one day, despite having worked remotely for almost a year (as you know, remote work during the post-COVID era). During this session, he recommended a book that influenced his philosophy: Antifragile by Nassim Nicholas Taleb. He explained that it presents a mindset that benefits from a world full of volatility. That was the first time I had heard of this book, and I have been interested in it ever since.</p><h3><strong>What is Antifragile?</strong></h3><p>I believe you are already familiar with the concept of fragility. Fragile items are those that can be easily broken. I appreciate how the book describes fragility as akin to a parcel that should be labeled ‘Please handle with care,’. Fragile should be at best unharmed. Conversely, if we consider the opposite scenario, it would be labeled ‘Please handle carelessly,’ which does not correspond to robustness or resilience. Robustness means that an item remains at best or at worst unharmed or we can describe that items as neither break nor improve therefor we will not put label on that parcel. The term ‘Antifragile’ is used to describe something that goes beyond being robust or resilient. While robustness resists shocks and remains the same, antifragility actually improves from such disturbances.</p><p>To elaborate, fragile are things that get easily damaged by shocks, randomness, and changes. Robust things can handle these without being affected. Antifragile actually gains and improve from these disturbances. For example, a glass plate is fragile. Any disturbances can break it. The mythical phoenix is robust in the sense that it doesn’t die; it continually regenerates and returns to its original state. Muscles is antifragile system because thrive under pressure (up to a point) and growing stronger when strained.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/571/1*D8mfeJAGi7CzFARMjJ1Alw.png" /><figcaption>Fragile = concave; Antifragile = convex</figcaption></figure><blockquote>Antifragile embodies Friedrich Nietzsche’s quote, “What does not kill us makes us stronger.”</blockquote><h3><strong>Becoming Antifragile</strong></h3><p><strong>Embrace Challenges</strong></p><p>Actively seek volatility and step out of your comfort zone to explore new opportunities rather than clinging to the familiar. Embrace challenges and use them as opportunities for growth. Whenever you feel too comfortable, it might be time to focus on the tasks that are not urgent but important according to the Eisenhower Matrix.</p><p><strong>Diversify</strong></p><p>For example in investment world. Spread your risks and exposures across different areas. This way, when one area is affected negatively, others may benefit or remain unaffected. The book talks about the Barbell Strategy which blends a safe approach with a speculative one, is considered more robust than a single-mode strategy and is often essential for achieving antifragility.</p><p><strong>Continuous Learning</strong></p><p>learning new skills is essential in a rapidly changing world. It helps you stay adaptable, open to new opportunities. Adopt a mindset of lifelong learning and curiosity.</p><p>Adopting an antifragile approach will certainly benefit you in a world characterized by chaos and rapid change. However, each individual has their own capacity to manage risk and safety. It is essential to push yourself to the limit that you can responsibly manage.</p><blockquote>T. S. Eliot aptly stated, “Only those who risk going too far can possibly find out how far one can go.”</blockquote><p>There are numerous additional examples and case studies described in the book. I hope this article sparks your interest.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4ac0c316d1a5" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Are You Really Mature? 4 Key Indicators to Find Out]]></title>
            <link>https://medium.com/@chonlaphoomth/are-you-really-mature-4-key-indicators-to-find-out-edcccaa0fd43?source=rss-cb2b00eabf3c------2</link>
            <guid isPermaLink="false">https://medium.com/p/edcccaa0fd43</guid>
            <category><![CDATA[self-awareness]]></category>
            <category><![CDATA[growing-up]]></category>
            <category><![CDATA[maturity]]></category>
            <category><![CDATA[self-improvement]]></category>
            <category><![CDATA[life]]></category>
            <dc:creator><![CDATA[Chonlaphoom Thaiyanto]]></dc:creator>
            <pubDate>Sun, 18 Aug 2024 17:31:29 GMT</pubDate>
            <atom:updated>2024-08-18T17:40:44.973Z</atom:updated>
            <content:encoded><![CDATA[<p>Maturity is a key part of growing up, but it’s important to note that some individuals may age without truly maturing. I firmly believe that maturity isn’t fully relate to age, especially when considering factors beyond just physical development. You may have encountered situations where someone appears older but lacks maturity, highlighting that age isn’t everything. In other hands, there are those in their 20’s who exude a sense of maturity. Let’s explore four key indicators that can help you determine if you are mature.</p><h4><strong>1. You start to stand up, stop blaming others and start making hard decision</strong></h4><p>It’s evident that maturity often comes hand in hand with a certain degree of leadership. Essentially, it’s about taking the necessary actions. Many people struggle to make sound decisions because they get caught up in blaming others. When you’re focused on blame, you can’t move forward. Life-changing experiences typically arise from making choices and owning the results. This is a significant aspect of being mature.</p><h4><strong>2. You are ready to make sacrifice</strong></h4><p>A clear example of this is parenting. As a child, I had no understanding of the immense sacrifices my parents made to raise me from infancy to adulthood. It takes a lot of time and financial resources to nurture someone into a good member of society, and that’s no small feat. When you have someone relying on you, it often means putting their needs ahead of your own desires. To sum it up, you won’t always receive what you desire. It’s include the ability of forego the sour for sweet.</p><h4><strong>3. You control your own emotions.</strong></h4><p>Emotional maturity means taking a moment to think before you react to things that trigger you, allowing you to respond calmly instead of just reacting impulsively.</p><h4><strong>4. You are comfortable in your own skin</strong></h4><p>I encountered this statement from Dry Creek Wrangler School on YouTube, and I find it to be profoundly insightful, reflecting a level of wisdom associated with maturity. It emphasizes the importance of embracing one’s true self rather than comparisons with others. Understanding your identity, as is the ability to simplify your life. You possess a sense of confidence internally.</p><p>Maturity isn’t just about age. It’s how a person approaches life and circumstance. It includes qualities like self-control, empathy, reliability, and the ability to learn from experiences. Essentially, you grow wiser and has broader view when life goes on. In overall these might not be the ultimate indicators. I hope these indicators will help us observe ourselves. Life is never stagnant; you’re either growing or fading.</p><blockquote>The idea is that flowing water never goes stale, so just keep on flowing. ― Bruce Lee</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=edcccaa0fd43" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[เริ่มต้นจากเป้าหมายสูงสุด (Begin with the end in mind)]]></title>
            <link>https://medium.com/@chonlaphoomth/%E0%B9%80%E0%B8%A3%E0%B8%B4%E0%B9%88%E0%B8%A1%E0%B8%95%E0%B9%89%E0%B8%99%E0%B8%88%E0%B8%B2%E0%B8%81%E0%B9%80%E0%B8%9B%E0%B9%89%E0%B8%B2%E0%B8%AB%E0%B8%A1%E0%B8%B2%E0%B8%A2%E0%B8%AA%E0%B8%B9%E0%B8%87%E0%B8%AA%E0%B8%B8%E0%B8%94-begin-with-the-end-in-mind-1c8b4115cae1?source=rss-cb2b00eabf3c------2</link>
            <guid isPermaLink="false">https://medium.com/p/1c8b4115cae1</guid>
            <category><![CDATA[goal-setting]]></category>
            <category><![CDATA[inspriation]]></category>
            <category><![CDATA[7-habits]]></category>
            <category><![CDATA[self-improvement]]></category>
            <dc:creator><![CDATA[Chonlaphoom Thaiyanto]]></dc:creator>
            <pubDate>Sat, 10 Aug 2024 15:05:01 GMT</pubDate>
            <atom:updated>2024-08-18T14:51:18.198Z</atom:updated>
            <content:encoded><![CDATA[<p>คุณเคยได้ยินประโยคว่า “Begin with the end in mind” ไหมครับ? ผมเจอประโยคนี้ครั้งแรกจากในหนังสือ Seven Habits of Highly Effective People ของ Dr. Stephen R. Covey เป็นหัวข้อที่น่าสนใจ และอยากนำมาแบ่งปันครับ</p><p>ผมเชื่อว่าในการใช้ชีวิตของเรามักมีช่วงที่เรารู้สึกว่าทุกการลงมือทำ กิจกรรมในชีวิตนั้นไม่เติมเต็มภายใน ขาดชีวิตชีวา ต้นเหตุของอาการเหล่านี้อาจมาจากการเป้าในการดำเนินชีวิตที่ชัดเจน การเริ่มต้นจากจุดสุดท้ายหรือการมีเป้าหมายชีวิตที่ชัดเจนจะทำให้เราใช้ชีวิตอย่างมีประสิทธิภาพมากขึ้น เปรียบเสมือนเรือที่มีการบังคับหางเสือ โดย Dr. Stephen R. Covey กล่าวว่า ทุกสิ่งถูกสร้างขึ้นสองครั้ง ครั้งแรกในความคิด ครั้งที่สองในโลกความเป็นจริง กล่าวคือ Begin with the end in mind คือการมองเห็นสิ่งที่เราต้องการสุดท้ายอย่างชัดเจนจนเกิด ‘Strong Why’ เมื่อเรามีคำว่า ‘ทำไม’ ที่แข็งแรง คำว่า ‘อย่างไร’ จะตามมาอย่างอัตโนมัติ (knock and the door will be opened to you.) อีกทั้งยังสร้างแรงจูงใจให้การวิ่งสู่เป้าหมายนั้นให้ความหมายกับชีวิตเราอย่างแท้จริง อีกทั้งยังนำไปสู่การตั้งคำถามเบื้องลึกเกี่ยวกับตัวเราตามมาหรือการรู้จักตนเองมากขึ้นนั่นเอง</p><p>วิธีการคือเริ่มต้นจากการถามตนเองว่าเป้าหมายสูงสุดของสิ่งที่เราต้องการคืออะไร จะเกิดขึ้นเมื่อไหร่ จะทำอย่างไร ยิ่งลงรายละเอียดมาก เป้าหมายของเราก็ยิ่งมีความเป็นไปได้มาก ขั้นตอนมีดังนี้</p><p><strong>1. ตั้งเป้าหมาย</strong><br> จำกัดความสิ่งที่เราต้องการในชีวิตว่าคืออะไรในแต่ละด้าน โดยอาจเริ่มจากมุมต่างๆของชีวิต การเงิน การงาน อารมณ์ ความสัมพันธ์ สุขภาพ Harvard Business School เคยทำงานวิจัยเกี่ยวกับการตั้งเป้าหมายในปี 1979 โดยทำการตั้งคำถามกับนักเรียนที่จบในปีนั้นว่าพวกเขาได้กำหนดเป้าหมายและเขียนเป็นแผนงานหรือไม่ ผลคือ</p><ul><li>84% ไม่มีเป้าหมาย</li><li>13% มีเป้าหมาย แต่ไม่มีแผนการที่ชัดเจน</li><li>3% มีเป้าหมายและมีแผนงานที่ชัดเจน</li></ul><p>ในอีก 10 ปีต่อมา กลุ่มคน 13% ที่มีเป้าหมายแต่ไม่มีแผนที่ชัดเจนทำเงินได้มากกว่า 2 เท่าของกลุ่ม 84% ที่ไม่ได้ตั้งเป้าหมาย และกลุ่มคน 3% ที่มีเป้าหมายกับมีแผนงานที่ชัดเจน ทำเงินได้ถึง 10 เท่าของ 97% ที่เหลือ แน่นอนว่าเรื่องเงินอาจไม่ใช่ปัจจัยเดียวที่บ่งบอกว่าเราประสบความสำเร็จแต่ก็เป็นตัวชี้วัดหนึ่งที่บอกเราได้ว่าการตั้งเป้าหมายนั้นสำคัญ</p><p><strong>2. มองว่าตอนนี้เราอยู่จุดไหนอย่างตรงไปตรงมา</strong><br> การมองว่าเราอยู่จุดไหนของเป้าหมายสำคัญมาก สมมติว่าเรามีแผนที่ที่ละเอียดที่สุดอยู่ในมือ เรามีจุดหมายว่าเราจะไปไหนเว้นแต่เราไม่ทราบว่าเราอยู่ตรงไหนของแผนที่ก็เท่ากับว่าเรายังคงหลงทางอยู่ ในหลายสถาบันภาษาจะใช้วิธีการวัดระดับภาษาก่อนเพื่อให้คอร์สเรียนเบื้องต้นที่เหมาะสม หรือแม้กระทั่งการยอมรับในจุดอ่อนของตนเองและเริ่มแก้ไขอย่างจริงจัง เป็นต้น</p><p><strong>3. วางแผนเส้นทาง</strong><br>ระบุแผนงานออกมาโดยแบ่งออกเป็นเป้าหมายย่อยจากนั้นพิจารณาไปทีละขั้นตอน การทำแบบนี้จะทำให้เรามีการจดจ่อกับสิ่งที่เราเริ่มได้เลย</p><p><strong>4. เขียนทุกอย่างลงกระดาษ </strong><br> การเขียนหรือพิมพ์เป็นลายลักษณ์อักษรจะทำให้เราได้ทบทวนแผนการว่าทำไมเราถึงต้องการมัน ในหนังสือยังพูดถึงการเขียนมันลงเป็น Personal Mission Statement โดยโฟกัสไปที่ 3 สิ่งคือคือตัวตน (Character) เราอยากมีคาแรคเตอร์แบบใด, ผลงาน (Contribution) เราอยากทำอะไร, ความสำเร็จ (Achievements) อะไรคือคุณค่าที่เรายึดถือและจะสอดคล้องกับตัวตน ความสำเร็จของเราอย่างไร ผู้อ่านสามารถอ่านสามารถค้นหารายละเอียดการเขียน Personal Mission Statement เพิ่มเติมได้โดยผมจะยังไม่ลงลึกในส่วนนี้</p><p><strong>5. ตัดสินใจลงมือทำ</strong><br> ข้อนี้คือข้อที่คนมักตกม้าตายกัน สี่ข้อก่อนหน้านี้จะหมดความหมายทันทีหากปราศจากการลงมือทำอย่างต่อเนื่อง ความคิดจะเป็นตัวกำหนดความต้องการ แต่การลงมือทำจะกำหนดสิ่งที่เราได้รับ</p><blockquote><em>“A real decision is measured by the fact that you’ve taken a new action. If there’s no action, you haven’t truly decided.”</em></blockquote><blockquote><em>– Tony Robbins</em></blockquote><p>เราสามารถนำมาปรับใช้ได้กับทุกด้านของชีวิต การงาน การเงิน สุขภาพ ความสัมพันธ์ หรือโปรเจกต์ที่เราอยากทำให้ลุล่วงตัวอย่างเช่น สมมติว่าเป้าหมายท้ายสุดในการวิ่งออกกำลังกายคือ เห็นตนเองวิ่งเข้าเส้นชัยมาราธอนในอีก 10 เดือนข้างหน้า จากนั้นเริ่มลงรายละเอียดถึงตารางการฝึกซ้อมรายเดือน เรามีต้นทุนทางร่างกายเท่าไหร่ จัดสรรเวลาในการวิ่งกี่วันต่อสัปดาห์ แต่ละวันจะฝึกซ้อมอย่างไรบ้าง (อาจจะถามจากคนที่ทำได้แล้ว) ตัวอย่างในเรื่องการงานเช่น เราอยากเพิ่มยอดขายให้กับธุรกิจของเราเป็นสองเท่าภายใน 2 ปี จะทำอย่างไร ธุรกิจของเราอยู่จุดไหน เราจะเพิ่มกลยุทธ์อะไรลงไป จากนั้นเริ่มลงแผนงาน ซอยเป้าหมายออกมาเป็นรายเดือน ไปจนถึงรายวัน มีการวัดผลเป็นระยะๆ เป็นต้น</p><p>นอกจากนี้การสร้าง Begin with the end in mind ยังสามารถใช้เป็นการมองภาพรวมของชีวิตได้อีกด้วยตัวอย่างเช่น การเห็นภาพตนเองในบั้นปลายของชีวิต ผู้เขียนให้เทคนิคคือ จินตนาการว่าหากวันนี้เรายืนอยู่ในงานศพของตนเอง ยืนครุ่นคิด reflect ถึงชีวิตที่ผ่านมา จะมีใครมาร่วมงานบ้าง พวกเขาจะพูดถึงเราอย่างไรในแง่มุมต่างๆ และเราจะฝากอะไรไว้กับโลกนี้ ยิ่งมีรายละเอียดมากยิ่งดี ให้เรามองภาพนั้นเป็นภารกิจของชีวิต</p><p>Begin with the end in mind คือหลักการมองไปถึงจุดหมายสุดท้าย จากนั้นเปลี่ยนเป้าหมายเป็นแผนงาน และยังลงลึกไปถึงเรื่องของการค้นหาคุณค่าของเราในแต่ละด้าน หวังว่าผู้อ่านจะลองนำหลักการ Begin with the end in mind นี้ไปปรับใช้กับชีวิตและประสบความสำเร็จตามที่ต้องการ</p><p>วันนี้คุณมีจุดหมายในใจแล้วหรือยัง?</p><p>References:</p><p>[1] <a href="https://www.wanderlustworker.com/the-harvard-mba-business-school-study-on-goal-setting/?fbclid=IwAR0bqvAenfQIKQkENLnDWTkecK3lwcgAzIvxESFzsJDGJU67Yl0XWJ4cNOw">https://www.wanderlustworker.com/the-harvard-mba-business-school-study-on-goal-setting/?fbclid=IwAR0bqvAenfQIKQkENLnDWTkecK3lwcgAzIvxESFzsJDGJU67Yl0XWJ4cNOw</a></p><p>[2] <a href="https://toggl.com/blog/begin-with-the-end-in-mind?fbclid=IwAR08rLRlIOYP34EKrZy6Lki2EohNNN52vvnjTdzTUXBnlSAqazDLHGrMKUY">https://toggl.com/blog/begin-with-the-end-in-mind?fbclid=IwAR08rLRlIOYP34EKrZy6Lki2EohNNN52vvnjTdzTUXBnlSAqazDLHGrMKUY</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1c8b4115cae1" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>