<?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 Peter Moskovits on Medium]]></title>
        <description><![CDATA[Stories by Peter Moskovits on Medium]]></description>
        <link>https://medium.com/@peter.moskovits?source=rss-386f721bfa65------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*8_myJZPq3esn_LmHInAauQ.jpeg</url>
            <title>Stories by Peter Moskovits on Medium</title>
            <link>https://medium.com/@peter.moskovits?source=rss-386f721bfa65------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 03:39:32 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@peter.moskovits/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[Unlocking Fine-grained Encryption for Apache Kafka: Client-side Field-level Encryption]]></title>
            <link>https://medium.com/@peter.moskovits/unlocking-fine-grained-encryption-for-apache-kafka-client-side-field-level-encryption-9731429f3ba1?source=rss-386f721bfa65------2</link>
            <guid isPermaLink="false">https://medium.com/p/9731429f3ba1</guid>
            <dc:creator><![CDATA[Peter Moskovits]]></dc:creator>
            <pubDate>Mon, 30 Jun 2025 22:46:54 GMT</pubDate>
            <atom:updated>2025-06-30T22:46:54.559Z</atom:updated>
            <content:encoded><![CDATA[<p>Recently, I’ve been exploring the world of encrypting specific fields within Kafka messages. Encryption is never a simple topic, but as someone with a limited security background, I’ve aimed to break it down into straightforward terms. My goal is to demystify it for others who may find encryption intimidating.</p><p>To help with that, I created a three-part video series — a mini-course on Client-side Field-level Encryption (CSFLE):</p><ul><li><a href="https://www.youtube.com/watch?v=_SzeO8j7yx4"><strong>Introduction to Client-side Field-level Encryption</strong></a></li><li><a href="https://www.youtube.com/watch?v=J-Pq9Ox0JUw"><strong>Envelope Encryption</strong></a></li><li><a href="https://www.youtube.com/watch?v=EOmTJCql5q4"><strong>End-to-end Walk-through of Configuring CSFLE in Confluent Cloud</strong></a></li></ul><p>Data privacy is more than a compliance checkbox; it’s about building trust. Consumers are increasingly wary about how their data is used. A transparent and secure data protection approach can make a big difference in fostering that trust.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*d0pjXfcW2tMvllt0v-5X8g.png" /></figure><p>Client-side Field-level Encryption is a capability that’s available to both Confluent Cloud and Confluent Platform users and gives you precise control over what records should be encrypted and which shouldn’t. For example, personally identifiable information (PII), such as name, date of birth, social security number should always be encrypted, while non-PII, such as hobbies, or favorite content typ</p><h3>Understanding Envelope Encryption</h3><p>Client-side Field-level Encryption uses a secure and efficient encryption method called <strong>Envelope Encryption</strong>. This widely adopted technique combines two encryption approaches: <strong>symmetric key encryption</strong> and <strong>public key cryptography</strong>.</p><ul><li><strong>Symmetric Key Encryption</strong> is fast and effective for encrypting large data volumes but requires securely sharing the same key between systems.</li><li><strong>Public Key Cryptography</strong> uses a key pair (public for encryption and private for decryption) to provide enhanced security but is computationally intensive.</li></ul><p>Envelope Encryption combines the strengths of both approaches, ensuring both security and performance.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*p7DfajgBVH0tfF0djfKFAA.png" /></figure><p>To better understand this concept, check out my 5-minute video explaining Envelope Encryption. You’ll get familiar with essential terms like <strong>Data Encryption Key (DEK)</strong> and <strong>Key Encryption Key (KEK)</strong>, which will be useful when setting up CSFLE.</p><h3>Configuring CSFLE for Fully Managed Connectors in Confluent Cloud</h3><p>CSFLE is flexible and can be implemented in various ways, which I explore in my introduction video. For this blog, I’ll walk through a practical example using Confluent Cloud’s UI to configure CSFLE for a simple scenario.</p><p>Here’s a high-level overview of the setup:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iS0tHNkNGi2SNBV22TD2fA.png" /></figure><ol><li><strong>Data Source</strong>: A REST service (HTTP endpoint) that returns JSON objects representing credit card transactions.</li><li><strong>HTTP Source V2 Connector</strong>: Fully managed in Confluent Cloud, it retrieves this data.</li><li><strong>Encryption</strong>: Specific fields (like the credit card number and CVC) are encrypted using CSFLE.</li><li><strong>Data in Transit</strong>: The encrypted data travels securely through Confluent Cloud.</li><li><strong>HTTP Sink V2 Connector</strong>: Another fully managed connector decrypts the data and sends it to an HTTP service that stores it in Airtable.</li></ol><p>I built the HTTP endpoint services for this demo, but you can follow the same steps to implement CSFLE for your connectors.</p><p>The setup involves registering your Key Encryption Key (KEK) with Confluent Cloud, tagging specific fields selected for encryption, and defining encryption rules. While it may seem complex, it’s manageable with a clear process.</p><p>In my end-to-end walk-through video, I detail each step, making it easy to follow along. And as a little bonus, I also created a <a href="https://assets.confluent.io/l/32fc0e714f8019b0/">cheat sheet</a> that walks you through the steps you need to take to make CSFLE work.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/804/1*Msuoz7V6WmPfUVDa-j0v1Q.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9731429f3ba1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to Expose Multiple Local Endpoints Using Ngrok and Nginx]]></title>
            <link>https://medium.com/@peter.moskovits/how-to-expose-multiple-local-endpoints-using-ngrok-and-nginx-f9216d83735f?source=rss-386f721bfa65------2</link>
            <guid isPermaLink="false">https://medium.com/p/f9216d83735f</guid>
            <dc:creator><![CDATA[Peter Moskovits]]></dc:creator>
            <pubDate>Fri, 20 Dec 2024 00:02:21 GMT</pubDate>
            <atom:updated>2024-12-20T00:02:21.267Z</atom:updated>
            <content:encoded><![CDATA[<p>When you’re developing applications with multiple API endpoints locally, sharing them over the internet for testing or integration can be tricky, especially if you want to avoid paying for multiple ngrok instances. Using nginx as a reverse proxy, you can combine multiple endpoints into a single ngrok tunnel. In this tutorial, we’ll walk through how to expose two local API endpoints via nginx and ngrok.</p><h3>Prerequisites</h3><ol><li><strong>Ngrok:</strong> Install <a href="https://ngrok.com/download">ngrok</a>.</li><li><strong>Nginx:</strong> Install nginx on your system.</li><li><strong>Two API endpoints:</strong> Ensure you have two endpoints running locally. For this tutorial, we’ll use:</li></ol><ul><li><strong>Producer API</strong>: http://localhost:3000 (GET requests)</li><li><strong>Consumer API</strong>: http://localhost:3030 (POST requests)</li></ul><h3>Step 1: Install and Configure Nginx</h3><ol><li><strong>Install nginx:</strong></li></ol><ul><li>On Ubuntu/Debian:</li></ul><pre>sudo apt update &amp;&amp; sudo apt install nginx -y</pre><ul><li>On macOS (using Homebrew):</li></ul><pre>brew install nginx</pre><p><strong>2. Edit the nginx configuration file:</strong></p><ul><li>Edit the configuration file, <em>nginx.conf</em>. Frequent locations:</li><li>nano /etc/nginx/nginx.conf # Linux</li><li>/usr/local/etc/nginx/nginx.conf # macOS</li><li>/opt/homebrew/nginx/nginx.conf # macOS</li><li>Add a reverse proxy configuration:</li></ul><pre>http {<br>     server {<br>         listen 8080;<br>          location /source {<br>             proxy_pass <a href="http://localhost:3000;">http://localhost:3000;</a><br>         }<br>          location /sink {<br>             proxy_pass <a href="http://localhost:3030;">http://localhost:3030;</a><br>         }<br>     }<br> }</pre><p><strong>3. Test the configuration:</strong></p><pre>sudo nginx -t</pre><p>If the test is successful, restart nginx:</p><pre>sudo systemctl restart nginx  # Linux <br>sudo nginx -s reload          # macOS</pre><h3>Step 2: Start Ngrok with Nginx</h3><ol><li><strong>Run ngrok to expose nginx:</strong></li></ol><pre>ngrok http 8080</pre><ul><li>Note the public URL provided by ngrok, such as <a href="https://abc123.ngrok.io./">https://abc123.ngrok.io.</a></li></ul><p><strong>2. Verify your setup:</strong></p><p>Open your browser and test the endpoints:</p><p>https://abc123.ngrok.io/source should proxy to your producer API at <a href="http://localhost:3000.">http://localhost:3000.</a></p><p>https://abc123.ngrok.io/sink should proxy to your consumer API at <a href="http://localhost:3030.">http://localhost:3030.</a></p><h3>Step 4: Debugging and Logs</h3><p><strong>Ngrok logs:</strong> Run ngrok with the -log option to view logs:</p><pre>ngrok http 8080 -log=stdout</pre><ul><li><strong>Nginx logs:</strong> Check nginx logs for troubleshooting:</li></ul><pre>sudo tail -f /var/log/nginx/access.log /var/log/nginx/error.log  # Linux <br>tail -f /usr/local/var/log/nginx/access.log /usr/local/var/log/nginx/error.log  # macOS</pre><h3>Conclusion</h3><p>With nginx as a reverse proxy, you can efficiently expose multiple local API endpoints through a single ngrok tunnel. This setup is simple, easy to manage, and helps create a seamless development workflow.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f9216d83735f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building a Kafka HTTP Source v2 Connector with Node]]></title>
            <link>https://medium.com/@peter.moskovits/building-a-kafka-http-source-v2-connector-with-node-c5bb4c50e4bd?source=rss-386f721bfa65------2</link>
            <guid isPermaLink="false">https://medium.com/p/c5bb4c50e4bd</guid>
            <category><![CDATA[kafka]]></category>
            <category><![CDATA[nodejs]]></category>
            <category><![CDATA[rest]]></category>
            <dc:creator><![CDATA[Peter Moskovits]]></dc:creator>
            <pubDate>Sun, 17 Nov 2024 04:51:14 GMT</pubDate>
            <atom:updated>2024-11-17T04:51:14.493Z</atom:updated>
            <content:encoded><![CDATA[<p>One of the most efficient ways to integrate data into your data-streaming applications is by using the <a href="https://docs.confluent.io/cloud/current/connectors/cc-http-source-v2.html">Kafka HTTP Source v2 Connector</a>. This connector is designed to interact with any HTTP-based API, making it incredibly versatile for sourcing data from external services or even from custom APIs you set up. The connector will send an HTTP request to a specified API endpoint and automatically stream the response to a Kafka topic.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-CXoM1HjpDBb8WcYQg_KSQ.png" /><figcaption>HTTP Source v2 Connector interacting with Node.js back-end</figcaption></figure><p>For this example, I’m going to walk through the process of generating fake credit card transaction data. The goal here is to demonstrate how the HTTP Source v2 Connector can be used with simple, dynamic data sources, and for this, I built a Node.js application that generates random data for our Kafka topic. To simulate real-world transaction records, I used the <a href="https://github.com/faker-js/faker">Faker library</a>, which allows us to randomize various fields such as names, credit card numbers, transaction amounts, and more.</p><p>The data I’m simulating consists of seven fields: firstName, lastName, creditCardNumber, cvc, zipCode, amount, and timestamp. Let’s dive into the specifics of how this application works.</p><h4>Setting Up the Node.js App</h4><p>To generate the fake transaction data, I wrote a simple app.js file in Node.js. The application uses the Express.js framework to expose an endpoint that serves the randomly generated data. Each time you hit the endpoint, it will return 1-5 fake credit card transactions in JSON format.</p><p>Here’s the contents of the app.js file (all source files available on <a href="https://github.com/pmoskovi/KafkaHTTPv2SourceConnectorNode">GitHub</a>):</p><pre>const express = require(&#39;express&#39;);<br>const faker = require(&#39;faker&#39;);<br><br>const app = express();<br>const port = 3000;<br><br>// Generate a new credit card transaction<br>function generateTransaction() {<br>    return {<br>        firstName: faker.name.firstName(),<br>        lastName: faker.name.lastName(),<br>        creditCardNumber: faker.finance.creditCardNumber(),<br>        expirationDate: faker.date.future().toLocaleDateString(&#39;en-US&#39;, { month: &#39;2-digit&#39;, year: &#39;2-digit&#39; }), // MM/YY format<br>        cvc: faker.finance.creditCardCVV(),<br>        zipCode: faker.address.zipCode(),<br>        amount: Number((1 + Math.random() * 999).toFixed(2)),<br>        timestamp: new Date().toISOString()<br>    };<br>}<br>app.get(&#39;/transactions&#39;, (req, res) =&gt; {<br>    const numberOfRecords = Math.floor(Math.random() * 5) + 1; // Random between 1 and 5<br>    const transactions = Array.from({ length: numberOfRecords }, generateTransaction);<br>    res.json(transactions);<br>});<br>app.listen(port, () =&gt; {<br>    console.log(`Credit card transaction API running on port ${port}`);<br>});</pre><p>This application uses the faker library to create random names, credit card numbers, expiration dates, CVC codes, zip codes, amounts, and timestamps. Each time the /transactions endpoint is hit, the app returns an array with 1-5 randomly generated transactions.</p><h4>Exposing the API with OpenAPI Specification (OAS 3.0)</h4><p>To enable Kafka to source data from this API, we need to define the API’s structure using the OpenAPI Specification (OAS). This step is necessary because the HTTP Source v2 Connector requires an OAS definition to understand how to interact with the endpoint. Here’s the httpsrc.yaml file that defines the API:</p><pre>openapi: 3.0.3<br>info:<br>  title: Credit Card Transactions API<br>  description: This API provides 1-5 randomly generated credit card transaction records.<br>  version: 1.0.0<br>servers:<br>  - url: https://23d1-23-93-164-232.ngrok-free.app<br>    description: Local server<br><br>paths:<br>  /transactions:<br>    get:<br>      summary: Get random credit card transactions<br>      description: Returns between 1 to 5 randomly generated credit card transaction records.<br>      responses:<br>        &#39;200&#39;:<br>          description: A JSON array of credit card transactions<br>          content:<br>            application/json:<br>              schema:<br>                type: array<br>                items:<br>                  type: object<br>                  properties:<br>                    firstName:<br>                      type: string<br>                      example: John<br>                      description: First name of the cardholder.<br>                    lastName:<br>                      type: string<br>                      example: Doe<br>                      description: Last name of the cardholder.<br>                    creditCardNumber:<br>                      type: string<br>                      example: &#39;1234-5678-9876-5432&#39;<br>                      description: Simulated credit card number.<br>                    expirationDate:<br>                      type: string<br>                      format: date<br>                      example: &#39;2026-03-15&#39;<br>                      description: Expiration date in YYYY-MM-DD format.<br>                    cvc:<br>                      type: string<br>                      example: &#39;123&#39;<br>                      description: CVC code.<br>                    zipCode:<br>                      type: string<br>                      example: &#39;12345&#39;<br>                      description: Zip code for the billing address.<br>                    amount:<br>                      type: number<br>                      format: double<br>                      description: Transaction amount in dollars<br>                      example: 245.67<br>                    timestamp:<br>                      type: string<br>                      format: date-time<br>                      description: Transaction timestamp in ISO format<br>                      example: &quot;2024-03-20T15:30:45.123Z&quot;<br>components:<br>  schemas:<br>    Transaction:<br>      type: object<br>      properties:<br>        firstName:<br>          type: string<br>          example: John<br>          description: First name of the cardholder.<br>        lastName:<br>          type: string<br>          example: Doe<br>          description: Last name of the cardholder.<br>        creditCardNumber:<br>          type: string<br>          example: &#39;1234-5678-9876-5432&#39;<br>          description: Simulated credit card number.<br>        expirationDate:<br>          type: string<br>          format: date<br>          example: &#39;2026-03-15&#39;<br>          description: Expiration date in YYYY-MM-DD format.<br>        cvc:<br>          type: string<br>          example: &#39;123&#39;<br>          description: CVC code.<br>        zipCode:<br>          type: string<br>          example: &#39;12345&#39;<br>          description: Zip code for the billing address.<br>        amount:<br>          type: number<br>          format: double<br>          description: Transaction amount in dollars<br>          example: 245.67<br>        timestamp:<br>          type: string<br>          format: date-time<br>          description: Transaction timestamp in ISO format<br>          example: &quot;2024-03-20T15:30:45.123Z&quot;<br>      required:<br>        - firstName<br>        - lastName<br>        - creditCardNumber<br>        - expirationDate<br>        - cvc<br>        - zipCode<br>        - amount<br>        - timestamp</pre><p>In this YAML file, we define the API’s /transactions endpoint and the structure of the JSON data that it returns. Be sure to replace the url field under servers with the actual URL of your running Node.js app, which we will expose using ngrok.</p><h4>Exposing the Local Node.js App Using ngrok</h4><p>To make the local app accessible to Confluent Cloud, I used <a href="https://ngrok.com/">ngrok</a>, a powerful tool that creates a secure tunnel to your localhost, allowing you to expose a local web server to the public internet.</p><p>Here’s how to run ngrok:</p><pre>$&gt; ngrok http 3000</pre><p>This will generate a public URL (e.g., https://23d1-23-93-164-232.ngrok-free.app) that forwards to your local app. This is the URL you will use in the OpenAPI spec for the url under servers.</p><h4>Configuring the HTTP Source v2 Connector in Confluent Cloud</h4><p>Now that we have our API exposed, it’s time to set up the Kafka HTTP Source v2 Connector in Confluent Cloud:</p><ol><li>Log in to your Confluent Cloud account.</li><li>Create a new environment and cluster.</li><li>Navigate to <strong>Connect</strong> and select <strong>Add connector</strong>.</li><li>Choose the <strong>HTTP Source v2 Connector</strong> from the list.</li><li>Under the <strong>Details</strong> tab, provide a name for your connector.</li><li>On the <strong>OpenAPI Specification</strong> section, select the <strong>Add a file</strong> option and upload the httpsrc.yaml file you created.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*S11XB426J5CIb6v6oy7TEg.png" /></figure><p>7. Generate an API key or use an existing one, then click <strong>Continue</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WFTeG10DMWejHvmwnlZYOw.png" /></figure><p>8. On the <strong>Paths</strong> tab, check the box next to /transactions to select the endpoint.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6o3yDaw08AlnCIEv-CloFg.png" /></figure><p>9. Specify a Kafka topic (e.g., cc-topic) where the data will be published.</p><p>10. Leave the default settings for the other options and click <strong>Launch Connector</strong>.</p><h4>Useful Connector Configuration Options</h4><ul><li><strong>Request Interval</strong>: By default, the HTTP Source v2 Connector makes requests every minute (60000 milliseconds). You can adjust this by modifying the “Request Interval” in the connector’s settings.</li><li><strong>Client-Side Field-Level Encryption (CSFLE)</strong>: If you want to encrypt sensitive data like credit card numbers or CVCs, Confluent Cloud supports CSFLE. Learn more about encrypting fields in Kafka here.</li></ul><h4>Conclusion</h4><p>In this tutorial, we’ve walked through setting up an HTTP Source v2 Connector to stream randomly generated credit card transactions into Kafka. This example demonstrates how easy it is to integrate data from any HTTP-based API into your Kafka ecosystem, whether it’s from a third-party service or custom applications. The flexibility of the HTTP Source v2 Connector opens up endless possibilities for enriching your data streaming applications with dynamic, real-time data.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c5bb4c50e4bd" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A Comprehensive VS Code Extension for Kafka Developers]]></title>
            <link>https://medium.com/@peter.moskovits/a-comprehensive-vs-code-extension-for-kafka-developers-10abc0b2a7bb?source=rss-386f721bfa65------2</link>
            <guid isPermaLink="false">https://medium.com/p/10abc0b2a7bb</guid>
            <dc:creator><![CDATA[Peter Moskovits]]></dc:creator>
            <pubDate>Fri, 20 Sep 2024 17:41:04 GMT</pubDate>
            <atom:updated>2024-09-20T17:41:04.886Z</atom:updated>
            <content:encoded><![CDATA[<p>If you missed Current 2024 in Austin, Confluent’s conference on data streaming and processing, you may have overlooked an exciting announcement — Confluent’s new <strong>VS Code extension</strong> for Kafka developers! This extension was showcased in the <strong>Developer Keynote</strong> and at the <strong>DevRel demo pod</strong> as a powerful tool designed to enhance productivity and streamline Kafka development workflows.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nFzUDgiBTvHtBJKtzMkwrA.png" /></figure><p>Currently available on the VS Code Marketplace in <strong>Preview</strong>, this feature-packed extension is a must-try for VS Code users working with Kafka. Whether you’re using on-prem/local deployment or<strong> </strong>Confluent Cloud, it’s built to simplify your interactions with Kafka resources.</p><h3>Getting Started</h3><p>To install or upgrade the extension, open your <strong>Extensions</strong> tab in VS Code and search for “Confluent.”</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0g5aHzlPcAnFrj03Idphiw.png" /></figure><h3>Authentication</h3><p>Before you can connect to your Kafka clusters, you’ll need to authenticate. The extension supports both local clusters and Confluent Cloud. If you’re working with Confluent Cloud, simply go to <strong>Accounts</strong> and select <strong>Sign in with Confluent Cloud</strong>.</p><p>You’ll be redirected between <strong>VS Code</strong> and your browser to complete the sign-in process.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/838/1*rzeaP3iFMZCzGPdePxMlBw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kkFmcvGGpzb3Q-kOJql63w.png" /></figure><h3>Exploring Kafka Topics, Schemas, and Messages</h3><p>Once signed in, click on the <strong>Confluent logo</strong> in the left-hand toolbar of VS Code. You’ll be able to browse your clusters, topics, and schemas directly from the <strong>Resources</strong> and <strong>Topics</strong> panels.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yhY7Uam96xjlNKlZ7aMMCg.png" /></figure><p>The <strong>message viewer</strong> is a particularly powerful tool that allows you to monitor messages in real-time. Not only can you browse messages, but you can also filter, search, and even <strong>diff</strong> messages to spot differences — a game-changer for debugging.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FiUG77o4W-5rWSoIjf6wsg.png" /></figure><p>In addition to message diffing, you can also <strong>compare schemas</strong>, making it easier to track changes across environments.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6KGs204J9nyxf40820OQ6A.png" /></figure><h3>Kickstart New Projects with Templates</h3><p>If you’re starting a new project, the extension can help you generate boilerplate code. Simply go to the <strong>Support</strong> pane and select <strong>Generate Project from Template</strong>. You’ll have a variety of starter templates to choose from, such as:</p><ul><li>Flink Table API Java Example</li><li>Go Consumer Application</li><li>Java Consumer Application</li><li>Java Sink Connector</li><li>Java Source Connector</li><li>Kafka Streams Application</li><li>Python Consumer Application</li><li>Simple Source Connector</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qhRt34oU5bT-hzAj-POqzA.png" /></figure><h3>Your Feedback Matters</h3><p>Since this is a <strong>Preview</strong> release, your feedback is critical. Help improve the extension by sharing your experience. You can easily <a href="https://github.com/confluentinc/vscode/issues">create an issue</a>, <a href="https://github.com/confluentinc/vscode/discussions">start a discussion</a>, or even contribute directly by submitting a PR to the <a href="https://github.com/confluentinc/vscode">open-source GitHub repo</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=10abc0b2a7bb" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Current 2024: The Data Streaming Conference — Breakout Session Roundup]]></title>
            <link>https://medium.com/@peter.moskovits/current-2024-the-data-streaming-conference-breakout-session-roundup-a029edf09800?source=rss-386f721bfa65------2</link>
            <guid isPermaLink="false">https://medium.com/p/a029edf09800</guid>
            <dc:creator><![CDATA[Peter Moskovits]]></dc:creator>
            <pubDate>Thu, 19 Sep 2024 03:19:35 GMT</pubDate>
            <atom:updated>2024-09-19T16:14:12.099Z</atom:updated>
            <content:encoded><![CDATA[<h3>Current 2024: The Data Streaming Conference — Breakout Session Roundup</h3><p>One of the best parts about attending industry conferences like Current is the opportunity to sit in on talks and hear firsthand about the latest innovations in data streaming and processing. At Current, as with other conferences, there’s a long-standing tradition: each room has a dedicated host to introduce the speakers, manage the Q&amp;A sessions, and encourage feedback from the audience.</p><p>This year, I had the chance to serve as a room host. While this role doesn’t let you pick the sessions you attend, it does offer the unique benefit of exposure to topics you might not have chosen yourself. Sometimes, that turns out to be a positive surprise, opening up new perspectives and insights you hadn’t expected.</p><p>Over the course of the event, I hosted six sessions. Below, I’ve summarized my key takeaways from four of them.</p><h3><strong>Empowering Teams: Learning Strategies That Fuel Kafka Adoption</strong></h3><p>Presenters: <a href="https://www.linkedin.com/in/cheriaugustine/">Cheri Augustine</a>, <a href="https://www.linkedin.com/in/chad-layne/">Chad Layne</a>, <a href="https://www.cardinalhealth.com/">Cardinal Health</a></p><p>Cardinal Health, a Fortune 14 company, has undergone a significant transformation: 50% of its internal applications now leverage the company’s event-driven architecture (EDA) infrastructure, powered by Confluent Cloud and Apache Kafka.</p><p>As the authors put it in their abstract, they discussed</p><blockquote>how Cardinal Health devised their enablement strategy and proceeded to build an ecosystem of information and learning support to entice leaders, architects, and developers to get on the EDA-with-Confluent-Cloud-Kafka bandwagon.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tjPD1W5JlPAjynEBNF006g.png" /></figure><p>Cheri and Chad shared how they cataloged existing Kafka learning resources, including both Confluent’s official training and the free courses on <a href="https://developer.confluent.io/courses">Confluent Developer</a> (a highlight for me, personally). But what really stood out was their emphasis on internal technical community-building: they organized live events and brought in external experts, which created a groundswell of interest.</p><p>With a distribution list of 1,800 people, they consistently saw over 200 attendees per event, alongside thousands of views on their internal social network. The key to this success? Strategic promotion and sustained engagement. They didn’t just focus on technical content — they built a culture of learning that was accessible and exciting for their teams.</p><p>Below are a few key slides from their journey.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hD5iELjN_4xSgRUQtw2FYg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IUjYRm261ac3PtA_aJSuXQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Gx-fTHc54_ObZ9TTFqJVAA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5Jok_PEH6CCsIdo0ZFLLcA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*y3WPp2qbeb69dsZWX5K7OA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1MB6KA4nLz_-tNSe-hFijQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QE_Bphjr7KhJjEz4-JH2eA.png" /></figure><h3><strong>Breaking the Bottleneck: Decentralizing Data to Power Library</strong> <strong>Innovation</strong></h3><p>Presenters: <a href="https://www.linkedin.com/in/mihiragochiya/">Mihir Agochiya</a>, Ram Surabi, <a href="https://www.hoopladigital.com/">Hoopla</a></p><p>Hoopla is an impressive digital streaming service that library members can take advantage of.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ErIvJrXlB2nDnI-wug8iPQ.png" /></figure><p>Hoopla lets you instantly borrow eBooks, audiobooks, comics, music, movies and TV. They have 1.5M titles available on their platform, have 13M registered users of which 2.5–3M are active monthly. They are growing at a 25% annual rate. Their delivery platforms include mobile, set-top box, and web.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7duWCR4FV6r0Fct9_EwILQ.png" /></figure><p>As you can imagine, complex services at this scale require some serious back-end. During their talk, Mihir and Ram outlined a handful of use cases. Clickstream and playback position stood out to me. Clickstream at Hoopla scale generates 36 million events each day. Playback position tracks between devices what page the reader is on, or at what time the video was stopped.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DasyI1ZpmC2D1AJfdoLtpA.png" /></figure><p>Then they went on to outline the back-end changes they have implemented across the board — as shown in the slides below.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Er0GigTeMFbM8EsCqBhcPg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jpA0fpKLjKM8kjzKVssXVQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9AeNhrmN5Hw3LsZyuAoJ9g.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*K0wDs1l79-JQbTJOD4czmQ.png" /></figure><h3>Optimizing Apache Kafka with GraalVM: Faster, Leaner, and Performant</h3><p>Presenters: <a href="https://www.linkedin.com/in/krishna-agarwal-06/">Krishna Agarwal</a> and <a href="https://www.linkedin.com/in/vedarth-sharma/">Vedarth Sharma</a>, <a href="https://confluent.io/">Confluent</a></p><p>In this session, Krishna Agarwal and Vedarth Sharma, engineers from Confluent, took us through the creation of the native Apache Kafka Docker image, explaining both its advantages and limitations. This new image, introduced through KIP-974, was designed with the goal of providing a lightweight, fast, and agile solution for local development and testing.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WH-iGzoIESuNooxbhWGd3g.png" /></figure><p>What makes this Kafka image stand out is that it doesn’t require a traditional JVM to run. Instead, it’s compiled ahead of time using GraalVM, which eliminates much of the runtime overhead traditionally caused by the JVM. The result? Faster startup times and a more efficient use of resources.</p><p>First released in July 2024, the native Kafka image has already gained significant traction, with daily pulls exceeding 3,000.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*z3texZmZ2HarjS8eeI_AoA.png" /></figure><p>Its appeal lies in key technical improvements:</p><ul><li><strong>Image size</strong>: just 47 MB</li><li><strong>Startup speed</strong>: around 300 ms</li><li><strong>Memory footprint</strong>: approximately 180 MB</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NmXmJVmnxYsRw5qRIyAJFg.png" /></figure><p>These gains are largely thanks to its ahead-of-time (AOT) compilation, which means the image is precompiled and doesn’t require the JVM’s memory or dynamic class loading.</p><p>However, Krishna and Vedarth also pointed out some limitations:</p><ol><li>The native image only includes the “reachable” elements from the application’s entry point, making it difficult to predict dynamic features.</li><li>Accessing external JAR files from the native VM is more complex — though not entirely impossible.</li></ol><p>In summary, this native Kafka Docker image is a game-changer for developers, whether new or experienced with Kafka, who need a small, fast, and efficient image for local development. While there are a few trade-offs, the performance improvements make it an exciting option for Kafka users looking for speed and efficiency. This image is not recommended for production use.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KwYoPCY30yISruzCB0tlHw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MRQ2C8ly3HTQEgXH9w3Crg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fChxfxWsw1CGcnXuX7pgyA.png" /></figure><h3>Apache Kafka’s Common Pitfalls &amp; Intricacies: A Customer Support Perspective</h3><p><a href="https://www.linkedin.com/in/aurelie-marcuzzo/">Aurelie Marcuzzo</a>, <a href="https://www.linkedin.com/in/christophschubert/">Christoph Schubert</a>, <a href="https://conduktor.io/">Conduktor</a></p><p>Conduktor’s deep Kafka expertise has long been recognized in the community, and Aurelie and Christoph’s talk at Current 2024 didn’t just reinforce that — it did so in an engaging and entertaining way.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FmNQDfyeQ6XT066E9hQ_6g.png" /></figure><p>They guided the audience through a scenario involving an imaginary bank called <em>KafBank</em>, which aimed to build a Kafka data streaming infrastructure. The use case featured two key personas:</p><ul><li><strong>Jack</strong>, a junior Kafka developer tasked with creating a data workflow that handled sensitive information and making this data accessible to other parts of the company.</li><li><strong>Lea</strong>, a DevOps engineer responsible for building and maintaining the Kafka back-end that Jack relies on. Her responsibilities also included upgrades, maintenance, and ensuring the security of the environment.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5mvbHUygs1BzWk02V2QYCA.png" /></figure><p>Through a dynamic and playful role-play, Christoph took on the role of Jack, while Aurelie played Lea. Their dialogue highlighted the typical challenges and interaction between development and operations teams when working with Kafka, providing practical solutions to these common issues.</p><p>Here’s a sample of their conversation, illustrating the interaction between Jack and Lea and how they worked together to overcome the challenges of securely sharing sensitive data.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rHpVjroOzb31c_SNm8cAZA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tyGFM2-3iUabg9XBhbaxMA.png" /></figure><p>I’ve also included a few key slides from their presentation below.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ho-tmAICSLPc-i803jdbBw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CepjC9xJhHjYJDe5HHVe1A.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a029edf09800" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Lessons Learned from Building a Kafka App From Scratch Using WebSocket & NodeJS with ChatGPT-4o]]></title>
            <link>https://medium.com/@peter.moskovits/lessons-learned-from-building-a-kafka-app-from-scratch-using-websocket-nodejs-with-chatgpt-4o-cc9b45885f99?source=rss-386f721bfa65------2</link>
            <guid isPermaLink="false">https://medium.com/p/cc9b45885f99</guid>
            <category><![CDATA[kafka]]></category>
            <category><![CDATA[chatgpt]]></category>
            <category><![CDATA[websocket]]></category>
            <category><![CDATA[nodejs]]></category>
            <category><![CDATA[html]]></category>
            <dc:creator><![CDATA[Peter Moskovits]]></dc:creator>
            <pubDate>Thu, 13 Jun 2024 01:28:48 GMT</pubDate>
            <atom:updated>2024-06-13T01:28:48.130Z</atom:updated>
            <content:encoded><![CDATA[<p>Many moons ago, my job was to build HTML5 apps showcasing the power of the newly ratified WebSocket standard. A common challenge with data streaming demos and tutorials is sourcing the data. The data should be plentiful (temperature data from my balcony is slow-changing and thus quite boring) and verifiable (random data cannot be visualized). Using human-generated and relatable data is often a good solution. One of the apps I built in the past to address this issue was a multi-user drawing app that mirrored the interactions of a user on another user’s screen.</p><p>Ever since I started working with Apache Kafka, I wanted to build this simple demo app with a Kafka back-end. I had been putting it off because I always thought it would take several days, and I never felt I had the time.</p><h3>About the Demo App</h3><p>My high-level goal is to connect Kafka to Node.js and have Node.js talk to the browser via WebSocket. I want to have two separate web apps: a producer app that we use for drawing and a consumer app that mirrors the drawing from another device. For the Kafka back-end, I wanted to use <a href="https://confluent.cloud/">Confluent Cloud</a>, not only because I work for Confluent but also because a simple, polished cloud environment is an easy choice for an experiment like this.</p><p>I finally decided to give it a try, but with a twist: I wanted to see how helpful the recently released ChatGPT-4o would be as an assistant. This post gives you a glimpse into my interaction and journey with ChatGPT, the errors we ran into, and how we resolved them (got to love how I’m already treating this model as a person).</p><h3>Architecture Overview</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NnliwIDCV6RakTXrOc9Mpg.png" /><figcaption>Figure 1: Architecture overview of the drawing app</figcaption></figure><p>A Kafka cluster, running in Confluent Cloud, is at the center of our app. Messages are published to and consumed from the drawing_topic. The heavy lifting of the Kafka interaction is done by the producer (left) and consumer (right) Node.js apps. Lastly, the data that needs to be published (drawing coordinates and some drawing-related meta-data) is generated (left) and rendered (right) by the HTML5 app running in the browsers, respectively.</p><h3>How Helpful Was ChatGPT?</h3><p>As for how ChatGPT performed (<a href="https://github.com/pmoskovi/WebSocket-KafkaApp-ChatGPT4o">source on github</a>): I was genuinely impressed every step of the way and ended up with a simple but functioning app on the first try! I was in the driver’s seat and broke down the problem into bite-sized tasks and testable steps. ChatGPT made two errors that it easily corrected when I pointed them out. As part of this exercise, I’m sharing all the prompts, responses, and code snippets verbatim, thinking that it will also serve as a glimpse or a snapshot into our incredibly fast-changing world.</p><p>I’m thoroughly impressed and concerned at the same time, hoping that this brave new world of ours will turn out not to be a disastrous one</p><h3>App in Action</h3><p>Here’s an animated GIF that shows how the app works. I’m drawing using my mouse in the left-hand browser. Underneath, in the teel terminal window, the Node.js application is publishing messages to the Kafka topic, with messages scrolling. On the right, you can see the other browser consuming the messages. Below my drawing surface, the Chrome Developer Tool Console shows the messages arriving at the consumer app.</p><p>It’s important to note that while the two browsers are local (both running on my computer), the Kafka cluster that the messages are going through is sitting in the cloud. The application gives a pretty good idea about the out-of-the-box latency you can expect from a system like this.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6mgRUEq_ou44GxWiaU7FPg.gif" /><figcaption>Figure 2: Interacting with the drawing app</figcaption></figure><h3>Table of Contents — Sort of</h3><p>To give you an idea of where we’re heading, here you can read all the prompts I provided to ChatGPT. You can think of it as our poor man’s Table of Contents for the post. You can head over to the <a href="https://github.com/pmoskovi/WebSocket-KafkaApp-ChatGPT4o">GitHub repo</a> right away, or follow along the prompts below.</p><p>Here we go…</p><p><strong>Prompt 1</strong></p><blockquote>I’d like to connect my HTML5 app (running JavaScript in the browser) with my Node.js app using websocket. Can you help?</blockquote><p><a href="https://github.com/pmoskovi/WebSocket-KafkaApp-ChatGPT4o/tree/main/Step%2001">Click</a> forChatGPT’s answer and all the source code.</p><p><strong>Prompt 2</strong></p><blockquote>Now, I’d like to take this to the next level. I’d like to use the demo application from here as inspiration: <a href="https://codepen.io/javascriptacademy-stash/pen/porpeoJ.">https://codepen.io/javascriptacademy-stash/pen/porpeoJ.</a> This will be the HTML5 application running in the browser. I want every drawing event to be sent over websocket to the server. Can you do this?</blockquote><p><a href="https://github.com/pmoskovi/WebSocket-KafkaApp-ChatGPT4o/tree/main/Step%2002">Click</a> forChatGPT’s answer and all the source code.</p><p><strong>Prompt 3</strong></p><blockquote>Now let’s create another client that is listening to these messages, and draws on a similar canvas, thus replicating (or mirroring) the drawing from the first HTML5 app.</blockquote><p><a href="https://github.com/pmoskovi/WebSocket-KafkaApp-ChatGPT4o/tree/main/Step%2003">Click</a> forChatGPT’s answer and all the source code.</p><p><strong>Prompt 4</strong></p><blockquote>The Mirror HTML5 application doesn’t draw. On the console it displays the following error message: <br>Uncaught SyntaxError: Unexpected token ‘o’, “[object Blob]” is not valid JSON at JSON.parse (&lt;anonymous&gt;) at ws.onmessage (indexConsumer.html:30:33)</blockquote><blockquote>Before this error message, it shows:<br>Received from server: Blob</blockquote><blockquote>Can you try to fix this?</blockquote><p><a href="https://github.com/pmoskovi/WebSocket-KafkaApp-ChatGPT4o/tree/main/Step%2004">Click</a> forChatGPT’s answer and all the source code.</p><p><strong>Prompt 5</strong></p><blockquote>This is great, it works flawlessly! Now, instead of sending the messages from the Node.js server to the Mirror HTML5 app, I want to publish these messages to my Confluent Cloud Kafka broker. How would I do that? This means, the Mirror app would not render anything.</blockquote><p><a href="https://github.com/pmoskovi/WebSocket-KafkaApp-ChatGPT4o/tree/main/Step%2005">Click</a> forChatGPT’s answer and all the source code.</p><p><strong>Prompt 6</strong></p><blockquote>Can you create another node.js app that subscribes to the same topic? As the messages arrive from Kafka, I want it to send the messages to the Mirror HTML5 app.</blockquote><blockquote>By the end of this, we’ll have an HTML5 app where I draw. It connects to a Node.js websocket server, which publishes the messages to Kafka.</blockquote><blockquote>We’ll have another Node.js websocket app subscribing to the same Kafka topic, consuming those messages, and sending them to the Mirror HTML5 app.</blockquote><p><a href="https://github.com/pmoskovi/WebSocket-KafkaApp-ChatGPT4o/tree/main/Step%2006">Click</a> forChatGPT’s answer and all the source code.</p><p><strong>Prompt 7</strong></p><blockquote>The Mirroring app shows the following error in the console:</blockquote><blockquote>indexConsumer.html:37 Uncaught TypeError: Failed to execute ‘readAsText’ on ‘FileReader’: parameter 1 is not of type ‘Blob’. at ws.onmessage (indexConsumer.html:37:14)</blockquote><blockquote>Can you help?</blockquote><p><a href="https://github.com/pmoskovi/WebSocket-KafkaApp-ChatGPT4o/tree/main/Step%2007">Click</a> forChatGPT’s answer and all the source code.</p><p><strong>Prompt 8</strong></p><blockquote>The mirroring app has one more minor problem. The problem occurs when I lift my mouse (don’t press the mouse button, that is I am not drawing). It connects the last point from the previous drawing with the first point of the new line that I’m drawing. It connects them with a straight line. Can you help me by not drawing a line between these points?</blockquote><p><a href="https://github.com/pmoskovi/WebSocket-KafkaApp-ChatGPT4o/tree/main/Step%2008">Click</a> forChatGPT’s answer and all the source code.</p><p><strong>Prompt 9</strong></p><blockquote>My two Node.js files contain secrets that I want to externalize. They use the same secrets: bootstrap server, cloud API key (username), cloud API secret (password), and topic name. The two Node.js files use the same secrets, so this would make my life a lot easier.</blockquote><p><a href="https://github.com/pmoskovi/WebSocket-KafkaApp-ChatGPT4o/tree/main/Step%2009">Click</a> forChatGPT’s answer and all the source code.</p><p><strong>Prompt 10</strong></p><blockquote>I’d like to add a RESET button to the producer HTML5 app (the one that I’m drawing on). The button should clear the drawing both on the producer and the consumer canvases.</blockquote><p><a href="https://github.com/pmoskovi/WebSocket-KafkaApp-ChatGPT4o/tree/main/Step%2010">Click</a> forChatGPT’s answer and all the source code.</p><p><strong>Prompt 11</strong></p><blockquote>While the reset message arrives to the Mirror app, the drawing is not cleared.</blockquote><p><a href="https://github.com/pmoskovi/WebSocket-KafkaApp-ChatGPT4o/tree/main/Step%2011">Click</a> forChatGPT’s answer and all the source code.</p><h3>Next Steps</h3><p>I wanted to keep the app simple for this post, but I have a few ideas to further evolve it:</p><ol><li>Improve the UI, beautify the app with CSS: Take a screenshot of the current UI and ask the model to suggest CSS improvements to enhance the look and feel. Add features, such as colors, line width, erase, undo, and many more.</li><li>Add natural language features, including voice commands that would do the drawing on your behalf.</li><li>Merge the consumer and producer HTML5 apps: Combine them into a single app to provide a full collaborative experience. This would allow any client to draw and see the drawings of all other clients, similar to Google Docs but for drawing.</li><li>Simplify the back-end architecture: Merge the two Node.js apps into a single one to streamline the code and make the app easier to manage.</li><li>Taking advantage of Kafka and the persistent message log, you can also play back the messages, that is re-draw the picture again. Using timestamps associated with each message, you can also speed up or slow down the drawing.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tCFpBNwufHL1JkiVs6d66Q.png" /><figcaption>Figure 3: Simplified Architecture</figcaption></figure><h3>Conclusions</h3><p>With the model’s assistance, I ended up with a fully functioning prototype app in about an hour. While it’s far from production-ready, it’s an incredible way to learn about technology without most of the usual frustrations and technical challenges.</p><p>I approached this exercise with a clear idea of my goal. I knew how to solve my problem in an event-driven fashion, what technologies I wanted to use on the client and server sides, and how they’d communicate with each other. Additionally, I had an example of a drawing app to guide the model.</p><p>On two occasions, the solution provided wasn’t quite right (Prompts 4 and 7). You might wonder why the model produced code with issues. This is an area I expect significant improvements over time. My prompts might have been somewhat vague, or the model might not have had a perfect understanding of my goals.</p><p>Despite not focusing on writing any code in this exercise, I effectively used the model’s assistance by providing clear symptoms and error messages when I encountered issues. No need for Googling, browsing StackOverflow, or reading documentation — just simple English prompts.</p><p>As someone passionate about sharing and transferring knowledge, I’ve always viewed YouTube as the best tool for democratizing knowledge. This exercise shows that Large Language Models are taking this to the next level, challenging many of our previous assumptions.</p><p>We live in a fundamentally different world than just a couple of years ago, and it fills me with excitement — and at the same time gives me some chills, too.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cc9b45885f99" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>