<?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 Wattanit Hotrakool on Medium]]></title>
        <description><![CDATA[Stories by Wattanit Hotrakool on Medium]]></description>
        <link>https://medium.com/@wattanit?source=rss-b7f5aee88fc8------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*rYp7fewJYQPCg3XMtT51sg.jpeg</url>
            <title>Stories by Wattanit Hotrakool on Medium</title>
            <link>https://medium.com/@wattanit?source=rss-b7f5aee88fc8------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 06:06:25 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@wattanit/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[Building Software with Hybrid Intelligence: The Story of Veil]]></title>
            <link>https://medium.com/@wattanit/building-software-with-hybrid-intelligence-the-story-of-veil-f3bc2efb89e7?source=rss-b7f5aee88fc8------2</link>
            <guid isPermaLink="false">https://medium.com/p/f3bc2efb89e7</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[future-of-work]]></category>
            <category><![CDATA[softw]]></category>
            <dc:creator><![CDATA[Wattanit Hotrakool]]></dc:creator>
            <pubDate>Sun, 09 Feb 2025 11:58:18 GMT</pubDate>
            <atom:updated>2025-02-09T11:58:18.187Z</atom:updated>
            <content:encoded><![CDATA[<p>Software development has changed dramatically with the rise of AI assistance, yet some fundamental challenges remain unchanged — particularly the challenge of creating sustainable software. The solution might lie in <em>hybrid intelligence</em>: a new paradigm where human expertise and AI capabilities work together as equal partners, each handling the aspects they do best. This goes beyond simple AI assistance — it’s a complete rethinking of how software is developed. This post shares my experience creating Veil, a command-line encryption tool, using this hybrid approach that turned what could have been weeks of work into a 12-hour project.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*a0aidDyo06-geRvGB8xcGA.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/@lazycreekimages?utm_content=creditCopyText&amp;utm_medium=referral&amp;utm_source=unsplash">Michael Dziedzic</a> on <a href="https://unsplash.com/photos/blue-and-black-ball-on-blue-and-white-checkered-textile-qDG7XKJLKbs?utm_content=creditCopyText&amp;utm_medium=referral&amp;utm_source=unsplash">Unsplash</a></figcaption></figure><h3><strong>Part 1: Why Create Another Encryption Tool?</strong></h3><h4><strong>The Problem</strong></h4><p>Looking for a reliable encryption tool, I found myself facing a common situation: choose between proprietary software that might disappear when the company does, or open-source alternatives that haven’t seen meaningful updates in years. Neither option felt future-proof.</p><p>The solution? Create my own. The reasoning was simple: if I’m going to rely on software that might not last, I might as well make one that I can rebuild myself when needed.</p><h4><strong>Veil’s Approach</strong></h4><p>Veil isn’t trying to revolutionize encryption. Instead, it aims to be straightforward and adaptable across different use cases, even if that means making some compromises in advanced security features. The focus is on being transparent and maintainable rather than having the most sophisticated features.</p><h4><strong>Technical Overview</strong></h4><p>Veil works as a command-line interface (CLI) tool that handles file encryption and decryption. Its design prioritizes clarity and ease of use — you provide an input file, and it handles the encryption or decryption based on straightforward commands. While this might sound basic, the underlying implementation deals with complex low-level programming to ensure reliable encryption operations.</p><h3><strong>Part 2: Development Through Hybrid Intelligence</strong></h3><h4><strong>A Different Way to Build Software</strong></h4><p>Traditional software development typically follows a pattern: programmers design the structure, plan the implementation, and write code line by line. Even with modern AI coding assistants like GitHub Copilot, developers still need to think through each step of the implementation, using AI mainly to help with syntax and boilerplate code.</p><p>Hybrid intelligence takes a different approach. Instead of focusing on how to write the code, the emphasis shifts to what we want the software to do. This might sound subtle, but it fundamentally changes the development process.</p><h4><strong>The Two-Phase Development Process</strong></h4><p><strong>Phase 1: Requirements making</strong></p><p>The first phase involves no coding at all. Instead, it’s a collaborative brainstorming process between human expertise and multiple AI agents. The goal is to create a clear, detailed specification of the desired outcome. Unlike traditional requirements that often focus on implementation details, these requirements focus heavily on describing the end result we want to achieve.</p><p>This phase resulted in a concise but comprehensive document that laid out exactly what Veil needed to do, without getting bogged down in how to do it. The document became our source of truth, something both human and AI could refer to throughout the development process.</p><p><strong>Phase 2: Implementation</strong></p><p>With clear requirements in hand, the actual coding phase began. Here, AI took the lead in writing code while human oversight ensured everything aligned with the requirements. This is where an interesting challenge emerged: AI tends to follow common programming practices, which sometimes conflicted with our specific requirements.</p><p>For example, several bugs occurred when the AI automatically followed common encryption implementation patterns instead of our specified approach. The human role became crucial in spotting these discrepancies — places where the code followed general best practices rather than our specific requirements.</p><h4><strong>Real-World Example: Debugging with Hybrid Intelligence</strong></h4><p>One particular challenge highlighted the strength of this approach. During development, we encountered bugs where the AI had implemented parts of the encryption logic following common industry practices rather than our specified requirements. While these practices were generally good, they didn’t align with our goal of simplicity and maintainability.</p><p>A human developer working alone might have spent hours tracking down these inconsistencies. With hybrid intelligence, the process was different. The human’s role was to spot patterns of inconsistency — places where the code didn’t match our requirements document — while the AI could quickly propose and implement fixes once the discrepancy was identified.</p><h4><strong>Time and Effort Breakdown</strong></h4><p>The numbers tell an interesting story:</p><p>- Initial requirements and design: 2–3 hours</p><p>- Core development: 5–6 hours</p><p>- Bug fixing and verification: ~4 hours</p><p>- Total time: 12 hours</p><p>- Traditional development estimate: 1–2 weeks</p><p>What’s notable isn’t just the time saved, but how the time was spent. Instead of writing code, the human effort focused on two key activities: clearly defining what we wanted the software to do, and verifying that the implementation matched those requirements. This is a fundamental shift from traditional development, where programmers spend most of their time figuring out how to implement features.</p><h3><strong>Conclusion: The Future of Software Development</strong></h3><p>Building Veil taught me something important about software development in the age of AI. <strong>The key to effective hybrid intelligence isn’t just having access to AI tools — it’s changing how we think about development entirely.</strong> Our role is evolving from writing code to becoming specialists in defining clear requirements and ensuring quality outcomes.</p><p>This shift might be exactly what we need to create more sustainable software. When we focus on clearly describing what we want rather than how to build it, we create software that’s easier to understand, maintain, and if necessary, rebuild.</p><p>Veil is available on GitHub (<a href="https://github.com/wattanit/veil">https://github.com/wattanit/veil</a>), not just as an encryption tool, but as an example of what’s possible with hybrid intelligence development. Whether you’re interested in the tool itself or the development approach behind it, I encourage you to take a look and consider how this might change your own development practices.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f3bc2efb89e7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Does AI Think Like Humans, and Does It Matter?]]></title>
            <link>https://medium.com/@wattanit/does-ai-think-like-humans-and-does-it-matter-4eee402153ac?source=rss-b7f5aee88fc8------2</link>
            <guid isPermaLink="false">https://medium.com/p/4eee402153ac</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[thinking]]></category>
            <category><![CDATA[philosophy]]></category>
            <dc:creator><![CDATA[Wattanit Hotrakool]]></dc:creator>
            <pubDate>Fri, 28 Jun 2024 12:01:08 GMT</pubDate>
            <atom:updated>2024-06-28T12:01:36.106Z</atom:updated>
            <content:encoded><![CDATA[<p>Whether AI Thinking Like Humans May Not Matter to Most People</p><h4>Introduction</h4><p>As artificial intelligence (AI) becomes a bigger part of our lives, I often hear people say, “AI will never replace us because it can’t think like a human.” This question, while interesting, might not be as relevant as we think. It’s more useful to understand the context and level of AI discussions. In this article, let’s explore how AI is talked about at different levels, how language acts as a common interface, and why the way AI thinks might not matter much for most practical purposes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Xi7uZGBrC0-kB9WE" /><figcaption>Photo by <a href="https://unsplash.com/@growtika?utm_source=medium&amp;utm_medium=referral">Growtika</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h4>How AI Thinks Differently</h4><p>AI processes information and generates responses based on algorithms, data patterns, and what it has learned from vast amounts of data. This is very different from human thinking, which involves consciousness, emotions, and subjective experiences. Humans use a mix of logical reasoning, emotional intuition, and subconscious influences, and they have self-awareness and the ability to reflect on their thoughts and experiences.</p><p>AI, on the other hand, works purely on data input and computational logic. It doesn’t have consciousness or genuine emotions. This raises many philosophical questions about what thought and intelligence really mean.</p><p>John Searle’s Chinese Room Argument is a famous thought experiment that highlights this difference. Imagine a person who doesn’t understand Chinese sitting in a room with a set of rules for manipulating Chinese symbols. They receive Chinese characters, use the rules to produce appropriate responses, and send them back out. To an external observer, it looks like the person understands Chinese, but they are just following rules without comprehension. This is similar to how AI processes information and generates responses without understanding.</p><h4>The Interface of Language</h4><p>Despite these differences, AI and humans share a powerful interface: language. Language allows for meaningful interaction and communication, no matter how different the underlying mechanisms might be. This is similar to how API specifications let different software systems communicate seamlessly, even if they use different technologies.</p><p>Just as APIs enable various software systems to work together, language lets humans and AI collaborate and achieve common goals. This shared interface means AI can assist, augment, and enhance human activities without needing to understand our inner workings deeply.</p><p>By focusing on this interface, we can see how AI can fit into human workflows, using language to cooperate and achieve beneficial outcomes. This shifts the emphasis from whether AI thinks like humans to how effectively AI can communicate and collaborate with us to solve real-world problems.</p><h4>Relevance of How AI Thinks</h4><p>I discussions happen at different levels, each with its own focus. At a high level, the emphasis is on practical applications and benefits, like how AI can solve real-world problems and improve efficiency. This is where business leaders, policymakers, and end-users are involved. At a mid-level, the conversation centers on the technical performance and implementation details of AI systems, engaging developers, engineers, and data scientists. At a low level, the focus shifts to the theoretical foundations and ethical implications of AI, attracting researchers, academics, and ethicists.</p><p>It’s important to recognize that trying to “upsell” or “trash-talk” AI or human intelligence using points from a different level of discussion is counterproductive. Each level has its own context and relevance, and mixing them can lead to misunderstandings. For meaningful conversations about AI, it’s crucial to stay within the appropriate level and focus on the relevant aspects.</p><p>From a high-level perspective, the question of whether AI thinks like humans can be seen as irrelevant. What’s more important is how effective and useful AI is in performing tasks and facilitating communication. Just as the underlying technologies of different software systems become less relevant when considering their ability to interact and achieve goals, the practical implications of AI matter more than whether its cognitive processes resemble human thinking.</p><p>However, it’s essential to emphasize that discussions about the understanding and thinking processes of AI are extremely important. These discussions help us understand limitations, ethical considerations, and areas for improvement. They just aren’t as relevant to the everyday concerns of most users, who care more about what AI can do for them practically. Like any other machine, whether AI thinks like humans or not doesn’t matter as long as they share a common interface — language — and can help us achieve our goals effectively.</p><h4>Conclusions</h4><p>In conclusion, defining the level of discussion is crucial when talking about AI. Whether focusing on practical applications, technical performance, or theoretical foundations, understanding the context helps align expectations and communicate more effectively. While the nature of AI’s thinking process may intrigue some, its practical capabilities and impact on society are of greater significance for most users.</p><p>In the near future, AI might model artificial understanding and logical reasoning, potentially changing the answer to “Does AI think like humans?” However, the interface would remain the same as long as humans continue to work with AI. This shared language interface will continue to facilitate meaningful interactions and collaborations between humans and AI.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4eee402153ac" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Python Package Management with Pipenv]]></title>
            <link>https://medium.com/analytics-vidhya/python-package-management-with-pipenv-63a2bab99300?source=rss-b7f5aee88fc8------2</link>
            <guid isPermaLink="false">https://medium.com/p/63a2bab99300</guid>
            <category><![CDATA[package-management]]></category>
            <category><![CDATA[pipenv]]></category>
            <category><![CDATA[python]]></category>
            <dc:creator><![CDATA[Wattanit Hotrakool]]></dc:creator>
            <pubDate>Tue, 29 Sep 2020 00:00:00 GMT</pubDate>
            <atom:updated>2020-10-14T12:58:21.168Z</atom:updated>
            <content:encoded><![CDATA[<p><a href="https://pipenv.pypa.io/">Pipenv</a> is a modern package manager that brings the best package managing practices found in other languages to Python. To understand the benefits of Pipenv, let’s start with the reason why we should use a package manager.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*3AZBuLDQQsS8OMMc" /><figcaption>Photo by <a href="https://unsplash.com/@stefyaich?utm_source=medium&amp;utm_medium=referral">Stephane YAICH</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Why do package management?</h3><p>It is trivial to work with Python in a few small projects that consist of just one or two programmers. However, as the size of the team and project grows, problems start to arise.</p><p>Imagine a group of people working in a single Python project. Alan started the project successfully then transferred it to Bob. Bob checked out the project on his machine and found out it couldn’t run on his because Alan used the newer versions of some packages. Bob tried to update those packages to the same versions used by Alan, but then he found out that the updates broke another part of the project he worked with Carthy. At this point, Bob’s choices were either to fix the dependency issues in Alan’s code or Carthy’s, neither was easy and without risk of breaking another thing down the line.</p><p>Solving this sort of problem is the task of a package manager.</p><p>Modern package management consists of 2 main concepts:</p><ol><li>dependency management</li><li>environment isolation</li></ol><p>Dependency management declares what packages are used by the project, what other packages those packages depend on, and what versions exactly are they using. It allows everyone working on the same project to use the same version of everything, eliminating the compatibility and functional issues within the code.</p><p>Environment isolation is a mechanism that keeps the dependencies for each project completely isolated. It lets one project to use one set of dependencies while another project uses another set of dependencies which could be different versions.</p><h3>Python’s way of doing package management</h3><p>One of the main shortcomings of Python is the lack of a built-in package management system. Unlike other modern languages such as <em>NodeJS</em> or <em>Go</em>, Python was not designed with a package management mechanism. By default, every package is installed manually by a user into what referred to as “Base Environment”, where the installed package is seen and used across the whole system. This behaviour is precisely the reason for the problems mentioned previously. The use of Base Environment, also known as Global Environment, makes it impossible for projects to independently manage their dependencies.</p><p>Python programmers work around this limitation by creating a practice that acts as a “make-shift” package management using virtualenv package together with pip, Python&#39;s default package installer.</p><p>The virtualenv package allows a project to achieve environment isolation by creating a virtual environment that shadows the Base Environment. In the virtual environment, all code behaves as if packages are installed in the Base Environment, even though they are installed in the project itself.</p><p>To achieve dependency management, Python programmers use the so-called requirements.txt file as a dependency declaration. This file is created using pip, and consumed by pip when recreating the project.</p><h3>Standard package management practice</h3><p>The first programmer creates a new project by:</p><ol><li>create a new virtual environment for the project using virtualenv</li><li>install all dependencies using pip install</li><li>create the requirements file using pip freeze &gt; requirements.txt command.</li></ol><p>Another programmer can recreate the environment by</p><ol><li>create a new virtual environment for the project using virtualenv</li><li>install all dependencies using pip install -r requirements.txt</li></ol><h3>Problems with the current solution</h3><p>Whilst the standard practice allows Python programmers to achieve the same capabilities given by the package managers in other languages, it contains two major flaws:</p><ol><li>Virtual environment and dependency management are separated</li><li>Requirements file is not a real dependency management</li></ol><h4>1. Virtual environment and dependency management are separated</h4><p>It’s all too easy for a Python programmer to be in a wrong environment. When a programmer created the requirements file, they could mistakenly be in the Base Environment instead of the virtual environment. The requirement file they created thus listed the packages in their Base environments instead which could be very different from the ones used in the project. Worse still, when a programmer installed the dependencies from the requirements file, they too could be in Base Environment instead of the intended one. The packages listed got installed system-wide and the impacts were left to the worst of their imagination.</p><p>The fact that Python virtual environment is not easy to activate does not help the case. One could easily forget to source venv/bin/activate before the pip install -r requirements.txt and see their work machine got corrupt in front of their eyes.</p><h4>2. Requirements file is not a real dependency management</h4><p>What exactly does the pip freeze &gt; requirements.txt do? The job of pip freeze command is to print the list of all installed packages, along with their version numbers, to the screen. The&gt; requirements.txt is a little command line trick called <em>redirection</em>. It means to write those printed texts into the requirements.txt file instead. Thus, the content of the requirements file is the list of all installed packages in the environment along with their version numbers.</p><p>Compared it to the dependency management files of other package managers such as <em>npm</em> or <em>cargo</em> and the differences are clear.</p><p><strong>1. What project does this requirements.txt belong to?</strong></p><p>Dependency file should contain the name of the project, with a version number, so that it is impossible to mix up the dependencies between projects/versions.</p><p><strong>2. No dependency hierarchy</strong></p><p>A programmer installed one package they need. They then created a requirements.txt file and found out there were a dozen of packages listed. Most of the packages listed in the requirements.txt are dependencies of other packages in the list. There is no distinction between the packages depended by the project, installed by the programmer, and the packages depended by those <em>top-level</em> packages.</p><p>This is the main point why using requirements.txt as a dependency file is a bad idea. When there are conflicting package problems, most of the time the conflicting packages are those dependent packages and not the top-level ones. Because the programmers themselves usually have no idea what packages the one they install depend on, it is not possible to avoid the conflict manually.</p><p>Modern package managers usually split the dependencies into these two groups. The “real” dependencies, manually installed by the programmer, are stored in the main dependency file. The dependencies of dependencies are resolved during the installation and stored in a separate file, commonly referred to as a <em>lock file</em>.</p><p><strong>3. Package versions as a requirement.</strong></p><p>Version numbers in requirements.txt are exact. When it says numpy==1.19.1, only version 1.19.1 can be installed. Version numbers in the dependency file should be conditional. For example, it should say whether the project requires exactly version 1.19.1, or include any newer version (&gt;=1.19.1), or any version at all (*). This allows the resolver to find a version that fits the project best. The actual version used will be recorded in the lock file.</p><p>Most package managers also separate the main dependencies-packages needed by the program logic-and the development dependencies which are used for the development purposes such as testing and debugging. With this setup, only the relevant packages will be packaged and distributed to the end-users.</p><h3>Introducing Pipenv</h3><p><a href="https://pipenv.pypa.io/">Pipenv</a> is a Python package manager which aims to bring into Python a good modern package manager. From the official Pipenv documentation:</p><blockquote><em>Pipenv is a production-ready tool that aims to bring the best of all packaging worlds to the Python world.</em></blockquote><p>Pipenv is a wrapper on the virtualenv and pip. It enables the dependency management and the environment isolation in Python that conforms to the practices followed by package managers of other languages. Using pipenv solves all the aforementioned issues without the need for any manual process.</p><h3>How to use pipenv</h3><h4>Installation</h4><p>To install pipenv, follow the instruction on <a href="https://pypi.org/project/pipenv/">https://pypi.org/project/pipenv</a></p><h4>Create new project and install new package</h4><p>To create a new project, simply install a package by</p><pre>pipenv install &lt;package name&gt;</pre><p>Pipenv will create the new Pipfile-which is the dependency file-if one does not yet exist. Otherwise, it will update the Pipfile to add the new package.</p><p>Pipenv will then resolve for the dependency list and create the lock file (Pipfile.lock).</p><h4>Activate the virtual environment</h4><p>To activate and use the virtual environment, simply run</p><pre>pipenv shell</pre><p>to enter a new shell which runs inside the virtual environment. All the installed packages are visible to any programs running within this shell.</p><p>Another option is to start the program in the virtual environment directly without entering the shell. Run</p><pre>pipenv run &lt;program name&gt;</pre><p>This command is convenient in many common Python use cases, such as when using Jupyter Notebook. One can simply</p><pre>pipenv run jupyter notebook</pre><p>to start a new notebook inside the virtual environment.</p><h4>Deactivate the virtual environment</h4><p>To deactivate the virtual environment, simply type exit in the shell.</p><h3>Conclusions</h3><p>Even though Python traditionally lacks a good package manager, Pipenv finally brings the best features of modern package management to the language such that it is now possible for Python programmers to work efficiently and safely across multiple projects.</p><p><em>Originally published at </em><a href="https://wattanit.com/2020/09/python-package-management-with-pipenv/"><em>https://wattanit.com</em></a><em> on September 29, 2020.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=63a2bab99300" width="1" height="1" alt=""><hr><p><a href="https://medium.com/analytics-vidhya/python-package-management-with-pipenv-63a2bab99300">Python Package Management with Pipenv</a> was originally published in <a href="https://medium.com/analytics-vidhya">Analytics Vidhya</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>