<?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 Deepa J on Medium]]></title>
        <description><![CDATA[Stories by Deepa J on Medium]]></description>
        <link>https://medium.com/@deepa-j?source=rss-0419a5b6a9c5------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*EtCIIKAyAgoDQmbr</url>
            <title>Stories by Deepa J on Medium</title>
            <link>https://medium.com/@deepa-j?source=rss-0419a5b6a9c5------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 12:36:53 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@deepa-j/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[Deploying a Flask App with systemd: My Notes from the First Time]]></title>
            <link>https://medium.com/codetodeploy/deploying-a-flask-app-with-systemd-my-notes-from-the-first-time-2ad2a687e7c0?source=rss-0419a5b6a9c5------2</link>
            <guid isPermaLink="false">https://medium.com/p/2ad2a687e7c0</guid>
            <category><![CDATA[deployment]]></category>
            <category><![CDATA[systemd]]></category>
            <category><![CDATA[systemd-service]]></category>
            <category><![CDATA[flask]]></category>
            <dc:creator><![CDATA[Deepa J]]></dc:creator>
            <pubDate>Mon, 03 Aug 2026 13:11:17 GMT</pubDate>
            <atom:updated>2026-08-03T13:33:24.740Z</atom:updated>
            <content:encoded><![CDATA[<p>While learning how to deploy a Flask application on Ubuntu, I also learned how to set it up as a <strong>systemd </strong>service. I kept notes along the way because it was my first time working with <strong>systemd</strong>.</p><p>I thought I’d clean those notes up and turn them into a short article, and hopefully you’ll find it useful too. I would, however, like to mention that this isn’t an in-depth guide to <strong>systemd</strong>. It’s just enough if you wanna know why you’re running each command instead of just copying and pasting it.</p><blockquote><strong><em>💥 Master Any Skills in 3 Months</em></strong><br><em> </em>📚 Up to <strong>50% OFF</strong> Premium Courses<br> ⏰ Limited-Time Offer<br><a href="https://trk.udemy.com/zz4NBO"><em>👉 </em><strong><em>Enroll Now &amp; Start Learning</em></strong></a></blockquote><h3>Step 1: Connect to your server</h3><p>The first thing you’ll need is access to your Linux server. If you’re using an AWS EC2 instance, you’ll usually connect to it over SSH.</p><pre>ssh -i &lt;your-key.pem&gt; ubuntu@&lt;your-server-ip&gt;</pre><p>Replace &lt;your-key.pem&gt; with your private key and &lt;your-server-ip&gt; with your server&#39;s public IP. Once you’re in, every command from here onwards runs directly on the server.</p><h3>Step 2: Get your application onto the server</h3><p>Now you’ll need your project on the machine.</p><p>Clone your repository. This downloads your application into a new folder.</p><pre>git clone &lt;your-repository-url&gt;</pre><p>Move into the project folder.</p><pre>cd &lt;your-project-folder&gt;</pre><p>If you’re deploying from a specific branch, switch to it.</p><pre>git checkout &lt;branch-name&gt;</pre><p>You should now be in your project’s root directory, where files like app.py, requirements.txt, and .env usually live.</p><h3>Step 3: Create a virtual environment</h3><p>If you’ve worked with Python before, you’ve probably used virtual environments already.</p><p>A virtual environment simply keeps your project’s dependencies separate from the rest of the system. That way, installing packages for one project doesn’t accidentally affect another.</p><p>Create one:</p><pre>python3 -m venv env</pre><p>Then activate it.</p><pre>source env/bin/activate</pre><p>If you see (env) appear before your terminal prompt, you&#39;re good to go.</p><h3>Step 4: Install the project dependencies</h3><p>Most Python projects come with a requirements.txt file that lists everything the application needs.</p><p>Install them using:</p><pre>pip install -r requirements.txt</pre><p>Once this finishes, your environment should have everything required to run the application.</p><h3>Step 5: Configure the environment variables</h3><p>Add the required environment variables to your .env file. This assumes your application loads the .env file itself (for example, using python-dotenv).</p><pre>nano .env</pre><h3>Step 6: Make sure the application actually runs</h3><p>A quick manual test here can save you a lot of debugging later.</p><p><strong>Development</strong></p><p>If you’re using Flask’s built-in development server:</p><pre>python app.py</pre><p><strong>Production</strong></p><p>If you’re deploying with Gunicorn:</p><pre>gunicorn --bind 0.0.0.0:8000 &lt;module&gt;:&lt;app_instance&gt;</pre><p><em>Replace </em><em>&lt;module&gt; with your Python file and </em><em>&lt;app_instance&gt; with your Flask application object.</em></p><p>If you have a health endpoint, verify it as well.</p><pre>curl http://127.0.0.1:&lt;port_number&gt;/&lt;health-endpoint&gt;</pre><p>Once you’ve confirmed it’s working, stop the application using Ctrl + C. This way, if anything goes wrong later, you’ll know the issue isn’t with the application itself.</p><h3>Step 7: Turn it into a systemd service</h3><p>Until now, we’ve only made sure the application runs correctly. The next step is to configure <strong>systemd</strong> so Linux knows how to start and manage it automatically.</p><p>Create a service file.</p><pre>sudo nano /etc/systemd/system/flask-app.service</pre><p><strong>Development:</strong></p><p>Add the following configuration.</p><pre>[Unit]<br>Description=Flask Backend Application<br>After=network.target<br><br>[Service]<br>User=&lt;username&gt;<br>WorkingDirectory=/home/&lt;username&gt;/&lt;project-folder&gt;<br>Environment=&quot;PATH=/home/&lt;username&gt;/&lt;project-folder&gt;/env/bin&quot;<br>ExecStart=/home/&lt;username&gt;/&lt;project-folder&gt;/env/bin/python app.py<br>Restart=always<br>[Install]<br>WantedBy=multi-user.target</pre><p><em>If you’re testing or learning, this setup is perfectly fine.</em></p><p><strong>For production, replace only the </strong><strong>ExecStart line with:</strong></p><pre>ExecStart=/home/&lt;username&gt;/&lt;project-folder&gt;/env/bin/gunicorn --bind 0.0.0.0:8000 app:app</pre><p><em>The rest of the service file remains exactly the same.</em></p><p>Replace:</p><ul><li>&lt;username&gt; with your Linux username.</li><li>&lt;project-folder&gt; with the folder where your application is located.</li></ul><p>Let’s quickly go over what each field means.</p><p><strong>Description: </strong>Just a name for your service.</p><p><strong>User: </strong>The Linux user that will run the application.</p><p><strong>WorkingDirectory: </strong>This tells systemd where your project lives.</p><p><strong>Environment: </strong>Points systemd to the Python executable inside your virtual environment.</p><p><strong>ExecStart: </strong>The command systemd uses to start your application. During development, this can be python app.py. For production deployments, you&#39;ll typically use Gunicorn instead.</p><p><strong>Restart=always: </strong>If your application crashes, systemd will automatically start it again.</p><p><strong>WantedBy=multi-user.target: </strong>This makes sure your application starts automatically whenever the server boots.</p><p>Once you understand these fields, creating another service file later becomes much easier.</p><h3>Step 8: Enable and Start the Service</h3><p>Reload systemd to register the new service. This only needs to be done when you create or modify a service file.</p><pre>sudo systemctl daemon-reload</pre><p>Enable it so it starts automatically after a reboot.</p><pre>sudo systemctl enable flask-app.service</pre><p>Finally, start the service.</p><pre>sudo systemctl start flask-app.service</pre><h3>Step 9: Verify the Service</h3><p>Check the status of your service using:</p><pre>systemctl status flask-app.service</pre><p>If everything is set up correctly, you should see the service in the <strong>active (running)</strong> state.</p><p>If it isn’t, check the logs first.</p><pre>journalctl -u flask-app.service -f</pre><p>This streams the application logs in real time and usually tells you exactly why the service failed to start.</p><h3>What if you make changes later?</h3><p>Say you’ve updated your application code. Just pull the latest changes and restart the service.</p><pre>git pull<br>sudo systemctl restart flask-app.service</pre><p>If you edit the <strong>systemd service file</strong> itself, there’s one extra step.</p><p>Reload systemd so it picks up the updated configuration.</p><pre>sudo systemctl daemon-reload<br>sudo systemctl restart flask-app.service</pre><p>Once you’ve done that, you’re good to go.</p><p>That’s pretty much it. Once you’ve gone through this process once, deploying another Flask application with systemd becomes much more straightforward.</p><p>Happy building!</p><h3>Thank you for being a part of the community</h3><p><em>Before you go:</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*d9QTaaaxboQP_gKSLedW_w.png" /></figure><p>👉 Be sure to <strong>clap</strong> and <strong>follow</strong> the writer ️👏<strong>️️</strong></p><p>👉 Follow us: <a href="https://www.linkedin.com/in/bhuwan-kc-583505319/?isSelfProfile=true"><strong>Linkedin</strong></a>| <a href="https://medium.com/codetodeploy"><strong>Medium</strong></a></p><p>👉 CodeToDeploy Tech Community is live on Discord — <a href="https://discord.gg/ZpwhHq6D"><strong>Join now!</strong></a></p><p><strong>Disclosure:</strong> This post includes affiliate and partnership links.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2ad2a687e7c0" width="1" height="1" alt=""><hr><p><a href="https://medium.com/codetodeploy/deploying-a-flask-app-with-systemd-my-notes-from-the-first-time-2ad2a687e7c0">Deploying a Flask App with systemd: My Notes from the First Time</a> was originally published in <a href="https://medium.com/codetodeploy">CodeToDeploy</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Design Better REST APIs with Google’s Resource-Oriented Design (ROD): A Concise, Practical Summary]]></title>
            <link>https://towardsdev.com/design-better-rest-apis-with-googles-resource-oriented-design-rod-a-concise-practical-summary-40e464961ca0?source=rss-0419a5b6a9c5------2</link>
            <guid isPermaLink="false">https://medium.com/p/40e464961ca0</guid>
            <category><![CDATA[api]]></category>
            <category><![CDATA[rest-api]]></category>
            <category><![CDATA[api-design]]></category>
            <category><![CDATA[research-oriented-design]]></category>
            <category><![CDATA[google]]></category>
            <dc:creator><![CDATA[Deepa J]]></dc:creator>
            <pubDate>Fri, 18 Jul 2025 11:56:18 GMT</pubDate>
            <atom:updated>2026-08-05T09:26:42.061Z</atom:updated>
            <content:encoded><![CDATA[<p>When my mentor recommended Google’s Resource-Oriented Design (ROD), I thought it was just another way to structure REST APIs. I had designed REST APIs before, so I assumed I had a solid grasp of how it’s done - define some endpoints, structure the data, and you’re good to go. But once I dug into ROD, I realized it addressed something deeper, that is, the long-term consistency and clarity that most REST APIs quietly lack.</p><p>This blog is a concise, practical summary of ROD based on <a href="https://google.aip.dev/121">Google’s official guidelines</a>. It is structured to help you actually apply these ideas. You’ll find examples, clear naming conventions, and explanations that’ll actually make things click by the time you’re done reading. If you’ve ever paused wondering what to name an endpoint or weren’t sure whether a custom action made sense, this guide will help you get it right.</p><h3>What Is ROD?</h3><p>ROD is Google’s way of designing RESTful APIs and it works by focusing on:</p><ul><li><strong>Resources</strong> as nouns (e.g., songs,albums,playlists)</li><li><strong>HTTP methods</strong> as verbs (GET,POST,PUT,PATCH,DELETE)</li><li>JSON as the default data format</li><li>Stateless, REST-aligned API behavior</li></ul><p>The core idea here is, your APIs should expose <em>things</em>, not <em>actions</em>. Once that sinks in, the rest of the design starts to fall into place naturally.</p><h3>Naming Resources in ROD</h3><p>Here’s how naming typically works across different parts of a ROD-compliant API, so everything stays predictable and easy to follow.</p><p>1.<strong> URLs</strong> should use lowercase-with-hyphens. For example:</p><ul><li>/v1/songs</li><li>/v1/playlists/456</li><li>/v1/albums/map-of-the-soul-persona/songs</li></ul><p>2.<strong> JSON field names</strong> should use lowerCamelCase. For instance:</p><ul><li>songTitle</li><li>artistName</li><li>albumName</li></ul><p>3.<strong> Service names</strong> should use UpperCamelCase. You might name your service MusicService if you&#39;re building an API under the domain music.googleapis.co.</p><ul><li>Naming might feel like a small detail, but doing it right makes your API feel intuitive and easier to work with, both for you and everyone else. So these naming conventions aren’t just cosmetic.</li></ul><h3>HTTP Methods in ROD: The Standard Verbs</h3><p>Each HTTP method has a clear and non-negotiable role:</p><ul><li>GET: Retrieve a resource<br> <em>Example</em>: GET /v1/songs/2013 returns details of a specific song like “Spring Day”</li><li>POST: Create a new resource<br> <em>Example</em>: POST /v1/albums with body: { &quot;albumName&quot;: &quot;Proof&quot;, &quot;releaseYear&quot;: 2022 }</li><li>PUT or PATCH: Update an existing resource<br> <em>Example</em>: PUT /v1/songs/123 to update metadata for &quot;Epiphany&quot;</li><li>DELETE: Remove a resource<br> <em>Example</em>: DELETE /v1/playlists/456 to delete a playlist named “Bangtan Sonyeondan’s English Songs”</li></ul><p>These operations have always been part of REST, ROD just makes sure we don’t overlook them.</p><h3>Custom Methods: When CRUD Isn’t Enough</h3><p>Some actions cannot be captured with just CRUD operations. Say you want to shuffle a playlist, that’s not really a create, read, update, or delete operation. This is where <strong>custom methods</strong> come in.</p><p>ROD allows you to handle these kinds of actions by using a special type of POST endpoint with a colon at the end, like this:</p><p>POST /v1/playlists/93:shuffle</p><p>It means: “Shuffle the playlist with ID 93.”</p><p>Here are a few more examples:</p><ul><li>POST /v1/albums/proof:archive → MusicService.ArchiveAlbum</li><li>POST /v1/users/789:verifyEmail → UserService.VerifyEmail</li></ul><p>These custom methods, however, should be used <strong>only when</strong> the action doesn’t really fit into the usual CRUD pattern.</p><h3>Versioning: Always Start with /v1/</h3><p>One of the easiest and most useful things you can do in ROD is to <strong>add a version number to your APIs from day one.</strong></p><p>Always use a <strong>path prefix</strong> like /v1/, not something like ?version=1 in the query.</p><p><em>Example: </em>GET /v1/albums</p><p>This avoids breaking clients when you later release /v2/.</p><h3>Resource Hierarchies: Design for Clarity</h3><p>ROD encourages designing URLs that reflect how things are actually organized in your system.<strong> </strong>For example: GET /playlists/3012/songs</p><p>This gets all songs in the playlist with ID 3012. These feel natural and make it easy to guess what an API does, even without looking at the docs.</p><h3>Back-end Naming: Follow Language Conventions</h3><p>ROD doesn’t tell you how to name things inside your back-end code. You just follow whatever naming style your language uses. For example, in Python, you’d stick to PEP 8 — so your function names would be in snake_case like create_song, shuffle_playlist, etc.</p><p>These don’t need to match the API’s external naming (createSong or MusicService.ShufflePlaylist).</p><h3>Quick Tips Recap</h3><p>Before we wrap up, here’s a quick summary of the key points, exactly as they appear in Google’s guide:</p><ul><li>Define resources as nouns; use HTTP verbs for actions.</li><li>Use standard methods (GET, POST, PUT, DELETE) for CRUD operations.</li><li>Reserve custom actions like :shuffle for rare, meaningful cases.</li><li>Format URLs using lowercase-with-hyphens.</li><li>Use lowerCamelCase for JSON field names.</li><li>Use UpperCamelCase for service names.</li><li>Prefix all routes with versioning (e.g., /v1/).</li><li>Reflect natural hierarchies in your URL structure when appropriate.</li><li>Follow idiomatic style for your backend language (e.g., PEP 8 for Python).</li></ul><h3>Final Thoughts</h3><p>Once you get the hang of Resource-Oriented Design, API design becomes a lot more predictable. ROD doesn’t slow you down; rather, it ensures you scale cleanly as your system grows.</p><p>Whether you’re building public APIs or internal tools, ROD gives you a structure that’s both practical and proven. Google uses it, and teams that care about long-term maintainability rely on it too.</p><p>Once you adopt it, you start to see why it works so well. Happy building!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=40e464961ca0" width="1" height="1" alt=""><hr><p><a href="https://towardsdev.com/design-better-rest-apis-with-googles-resource-oriented-design-rod-a-concise-practical-summary-40e464961ca0">Design Better REST APIs with Google’s Resource-Oriented Design (ROD): A Concise, Practical Summary</a> was originally published in <a href="https://towardsdev.com/">Towards Dev</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[ClickHouse Essentials: A Beginner’s Guide to ClickHouse’s Architecture and Performance]]></title>
            <link>https://towardsdev.com/clickhouse-essentials-a-beginners-guide-to-clickhouse-s-architecture-and-performance-1966446eb10b?source=rss-0419a5b6a9c5------2</link>
            <guid isPermaLink="false">https://medium.com/p/1966446eb10b</guid>
            <category><![CDATA[columnar-databases]]></category>
            <category><![CDATA[data-warehousing]]></category>
            <category><![CDATA[clickhouse]]></category>
            <category><![CDATA[clickhousedb]]></category>
            <category><![CDATA[database]]></category>
            <dc:creator><![CDATA[Deepa J]]></dc:creator>
            <pubDate>Mon, 07 Jul 2025 10:04:30 GMT</pubDate>
            <atom:updated>2025-07-28T16:25:35.430Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oU6Wv7f4UTtje3-TRK5HiA.png" /></figure><h3>Introduction</h3><p>As a newbie to databases, ClickHouse’s ability to handle massive datasets super-fast had me impressed. What makes it so powerful? In this blog, I will break down ClickHouse’s architecture into its core layers sharing a little about what I’ve learned from various sources. Let’s dive into the Lego pieces that make ClickHouse a great choice for massive data processing!</p><h3>What is ClickHouse?</h3><p>ClickHouse is an open-source database designed for Online Analytical Processing (OLAP), built to analyze large datasets in seconds. Its an open-source columnar database developed by Yandex.Metrica.</p><p>Think processing millions of rows like its no big deal while running SQL queries directly, taking full advantage of hardwarethat’s ClickHouse. Its architecture is made up of layers that makes ClickHouse perform so incredibly, being able to deliver fast queries for big data analytics.</p><h3>Key Components of ClickHouse’s Architecture</h3><p>ClickHouse’s architecture is well designed, with each layer optimized for speed. The three layers are:</p><p>1. Storage Layer</p><p>2. Query Execution Layer and</p><p>3. Connectivity and Integration Layer</p><figure><img alt="An illustration of the layers of ClickHouse Architecture." src="https://cdn-images-1.medium.com/max/1000/1*N4hId1fqCaLqebX4fCkc-w.png" /><figcaption>ClickHouse Architecture Breakdown. (Source: <a href="https://www.chaosgenius.io/blog/clickhouse-architecture/#">chaosgenius.io</a>)</figcaption></figure><p>Below, I’ll explain each in detail in simple jargon to make it clear how they work together to make ClickHouse so cool.</p><h3>1. Storage Layer: Columnar Data Efficiency</h3><p>Unlike most databases that store data in rows, like a table with all details like customer names, total sales and dates in one go all bundled together, ClickHouse uses columnar storage by organizing data by columns. You can think of it like sorting a library by putting all the book titles in one box, all authors in another and genres in the third.</p><p>Let’s say we’re trying to query total sales. ClickHouse reads only that particular column and skips every other column that is irrelevant. This is what drastically cuts down processing time. Another feature of this layer would be data compression. This is achieved using various compression algorithms from general purpose codecs (Compression Decompression Algorithms) to specialized codecs for specific data types. Typically LZ4 is used for fast decompression, which also is the default codec or ZSTD for higher compression ratios. This shrinks data to save disk space and speeds up disk I/O. Also this makes queries faster and storage less expensive as it might take up just half the space as the original uncompressed data. Its surprising how a simple shift in storage design can make such a huge difference.</p><h3>2. Query Execution Layer: The Brain Behind Speed</h3><p>The query execution layer is ClickHouse’s brain responsible for running queries as fast as possible. Basically a query sent is not immediately executed but is made to go through a series of optimization processes designed better performance. The query is analyzed and the most efficient execution plan is picked, similar to GPS mapping the quickest route through an area.</p><p>ClickHouse uses indexes such as sparse primary indexes and skip indexes to locate data quickly. What I mean by these two terms is</p><ul><li>Clickhouse indexes every nth row and each block is called a granule and the technique is called sparse indexing.</li><li>Data is sorted by primary key. Therefore ClickHouse can quickly identify and filter relevant granules from disk, skipping large irrelevant blocks.</li></ul><h3>3. Connectivity and Integration Layer: Connecting the Data World</h3><p>ClickHouse’s Connectivity and Integration layer is the bridge linking it to other systems for smooth data exchange. No external tools needed to push data because ClickHouse uses a pull-based approach, directly fetching data from sources. It supports over 50 table functions and engines, connecting to systems like:</p><ul><li><strong>Relational Databases</strong></li><li><strong>Object Storage</strong></li><li><strong>Streaming Systems</strong></li><li><strong>NoSQL Systems</strong></li><li><strong>Data Lakes</strong></li></ul><p>ClickHouse also handles well versatile data formats like CSV, JSON, Parquet, Avro, ORC, Arrow, and Protobuf. For example, you can query a Parquet file from S3 without converting it. Its MySQL and PostgreSQL compatible wired protocol interfaces let tools designed for those databases work with ClickHouse seamlessly as well.</p><h3>Wrap-Up</h3><p>ClickHouse’s architecture is a powerhouse because of its layers. Columnar storage with compression, optimized query execution with indexes, distributed processing with sharding and replication, and efficient data aggregation, all work in sync to achieve ClickHouse’s purpose. The storage layer keeps the data compact, the query layer plans, optimizes queries and executes them efficiently, the connection and the connectivity layer integrates seamlessly. Its interesting how these layers combine to make ClickHouse a speed machine for big data analytics.</p><h3>Getting Started with ClickHouse</h3><p>Wanna try ClickHouse? I installed it locally on Ubuntu using these commands:</p><pre>sudo apt update<br>sudo apt install -y clickhouse-server clickhouse-client<br>sudo service clickhouse-server start</pre><p>Then, I connected using clickhouse-client on the command line and ran basic queries. <a href="https://www.chaosgenius.io/blog/clickhouse-architecture/"><em>The Beginner’s guide to ClickHouse</em></a> was of great help for understanding these concepts and trying out different queries. It’s a simple way to experience ClickHouse’s speed firsthand!</p><h3>Conclusion</h3><p>ClickHouse’s architecture with its columnar storage, smart query execution, distributed processing, and efficient data aggregation makes it a preferred and reliable choice for analyzing big data. As a newbie, I found these layers surprisingly easy to understand once broken down. Install ClickHouse locally and try some queries to see its power for yourself. It’s straightforward to set up, and the speed will blow you away. Happy learning!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1966446eb10b" width="1" height="1" alt=""><hr><p><a href="https://towardsdev.com/clickhouse-essentials-a-beginners-guide-to-clickhouse-s-architecture-and-performance-1966446eb10b">ClickHouse Essentials: A Beginner’s Guide to ClickHouse’s Architecture and Performance</a> was originally published in <a href="https://towardsdev.com/">Towards Dev</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>