<?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 Pasindu Pabasara on Medium]]></title>
        <description><![CDATA[Stories by Pasindu Pabasara on Medium]]></description>
        <link>https://medium.com/@pabasarapasindu365?source=rss-7b5da5b72c5a------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*8KWF-XEqxB9hiMHBt5YSuQ.jpeg</url>
            <title>Stories by Pasindu Pabasara on Medium</title>
            <link>https://medium.com/@pabasarapasindu365?source=rss-7b5da5b72c5a------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 07:33:06 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@pabasarapasindu365/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[Speed Up Your SQL Queries with Indexing]]></title>
            <link>https://medium.com/@pabasarapasindu365/speed-up-your-sql-queries-with-indexing-e0c25d65e771?source=rss-7b5da5b72c5a------2</link>
            <guid isPermaLink="false">https://medium.com/p/e0c25d65e771</guid>
            <category><![CDATA[sql]]></category>
            <category><![CDATA[query-optimization]]></category>
            <category><![CDATA[database-indexing]]></category>
            <dc:creator><![CDATA[Pasindu Pabasara]]></dc:creator>
            <pubDate>Wed, 19 Aug 2026 08:06:39 GMT</pubDate>
            <atom:updated>2026-08-19T08:06:39.477Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="chatgpt generated image" src="https://cdn-images-1.medium.com/max/1024/1*tsbcAZ-hCT4_yVu8XgYyZg.png" /></figure><p>I used to think that SQL queries were fast by default. You write a query, run it, get the result. Done. At least, that’s how it feels when you’re working with a few hundred or a few thousand rows. Then the database grows.Suddenly, the same query that felt instant starts taking seconds. You start wondering:</p><p><strong>“What happened? I didn’t even change the query.”</strong></p><p>The answer, in many cases, is the amount of data. And that’s where I started paying much more attention to <strong>database indexing</strong>.</p><h3>It Started With a Simple Query</h3><p>Imagine we have a users table:</p><pre>SELECT *<br>FROM users<br>WHERE email = &#39;sample@gmail.com&#39;;</pre><p>Nothing complicated. If the table has 100 rows, the database can find the user almost instantly. Now imagine the same table has <strong>10 million rows</strong>.The database needs to find one particular email among millions of records. Without a suitable index, it may have to examine a huge number of rows to find the match.</p><p>It’s basically like being handed a book with 10,000 pages and being told:</p><blockquote><em>“Find every page containing the word ‘database’.”</em></blockquote><p>You could start from page one and check every page.</p><p>Or…</p><p>You could use the indexing.</p><h3>So What Exactly Is an Index?</h3><p>Think about the index at the back of a textbook. If I want to learn about “Normalization”, I don’t read the entire book. I look at the index.</p><p>It might tell me:</p><pre>Normalization → Page 184</pre><p>I jump directly there.</p><p>A database index works on a similar idea. Instead of searching through every row in a table, the database can use an index to locate the relevant data more efficiently.</p><p>For example:</p><pre>CREATE INDEX idx_users_email<br>ON users(email);</pre><p>Now our original query:</p><pre>SELECT *<br>FROM users<br>WHERE email = &#39;sample@gmail.com&#39;;</pre><p>has an index available for the email lookup. That’s a pretty small change in the code. But the performance difference can be significant when the table becomes large.</p><h3>The Part I Didn’t Realize: Indexes Have a Cost</h3><p>At first, indexing sounds like a cheat code. Query slow? Just add an index. Problem solved. But Indexes aren’t free.</p><p>Suppose our table looks like this:</p><pre>users<br> ├── id<br> ├── name<br> ├── email<br> ├── country<br> ├── status<br> └── created_at</pre><p>We could create indexes on everything:</p><pre>CREATE INDEX idx_email ON users(email);<br>CREATE INDEX idx_country ON users(country);<br>CREATE INDEX idx_status ON users(status);<br>CREATE INDEX idx_created_at ON users(created_at);</pre><p>It might make some queries faster. But now every time we insert, update, or delete data, the database may also need to maintain those indexes. So we have traded some write performance and storage for faster reads.</p><p>That’s the first important lesson I learned:</p><blockquote><strong><em>An index is an optimization, not a decoration.</em></strong></blockquote><p>You should have a reason for creating one.</p><h3>When Should You Create an Index?</h3><p>This is where things get interesting. You don’t normally create an index simply because a column exists. Instead, look at how your application actually queries the database.</p><p>For example, suppose your application frequently does this:</p><pre>SELECT *<br>FROM orders<br>WHERE customer_id = 42;</pre><p>If orders contains millions of records, customer_id could be a good candidate for an index:</p><pre>CREATE INDEX idx_orders_customer_id<br>ON orders(customer_id);</pre><p>The same idea applies to columns frequently used in:</p><ul><li>WHERE</li><li>JOIN</li><li>ORDER BY</li><li>Sometimes GROUP BY</li></ul><p>The key word is <strong>frequently</strong>.</p><p>If a column is almost never used for searching, creating an index on it may provide little value.</p><h3>Then I Discovered EXPLAIN</h3><p>One of the biggest improvements in the way I think about SQL performance was learning to stop guessing. Instead of asking:</p><p><strong>“Will this index make my query faster?”</strong></p><p>I can ask the database.</p><p>For example:</p><pre>EXPLAIN<br>SELECT *<br>FROM users<br>WHERE email = &#39;sample@gmail.com&#39;;</pre><p>The exact output depends on the database you’re using, but the execution plan can tell you things such as:</p><ul><li>Whether an index is being used</li><li>How many rows may be examined</li><li>What access method is being used</li><li>How tables are joined</li><li>The optimizer’s estimated cost</li></ul><p>Some database systems also support:</p><pre>EXPLAIN ANALYZE</pre><p>which can provide actual execution information.</p><p>That changed my approach.</p><p>Instead of:</p><pre>Query is slow<br>      ↓<br>Add random index<br>      ↓<br>Hope</pre><p>I started thinking:</p><pre>Query is slow<br>      ↓<br>Inspect the execution plan<br>      ↓<br>Understand the bottleneck<br>      ↓<br>Optimize<br>      ↓<br>Measure again</pre><p>That’s a much better workflow.</p><h3>Composite Indexes Are Where Things Get Interesting</h3><p>Here’s another situation I came across.</p><p>Imagine we’re querying orders like this:</p><pre>SELECT *<br>FROM orders<br>WHERE customer_id = 42<br>AND status = &#39;completed&#39;;</pre><p>We could create an index involving both columns:</p><pre>CREATE INDEX idx_customer_status<br>ON orders(customer_id, status);</pre><p>But there’s an important detail here:</p><p><strong>The order of columns matters.</strong></p><p>These aren’t necessarily interchangeable:</p><pre>(customer_id, status)</pre><p>and:</p><pre>(status, customer_id)</pre><p>Database indexes have ordering characteristics, so the best column order depends on the queries you’re actually running.</p><p>This is one of those things that looks simple when you first learn indexing but becomes much more interesting when you’re dealing with real workloads.</p><h3>More Indexes ≠ Faster Database</h3><p>This is probably the biggest misconception I had.</p><p>It’s tempting to think:</p><pre>More indexes<br>     ↓<br>More optimization<br>     ↓<br>Faster database</pre><p>But real systems aren’t that simple. Every additional index consumes storage and can increase the work required to maintain the database during writes.</p><p>Imagine an application that receives thousands of inserts per second. Having a huge number of indexes can become a serious overhead.</p><p>So instead of asking:</p><blockquote><em>“Which columns can I index?”</em></blockquote><p>Ask:</p><blockquote><em>“Which queries are important enough to optimize?”</em></blockquote><p>That small change in thinking makes a huge difference.</p><h3>What About Primary Keys?</h3><p>If you’ve used relational databases, you’ve probably written something like:</p><pre>CREATE TABLE users (<br>    id INT PRIMARY KEY,<br>    name VARCHAR(100),<br>    email VARCHAR(255)<br>);</pre><p>Primary keys are normally indexed automatically by the database system. That’s why you generally don’t need to create another ordinary index just for the same primary key column.</p><p>The database already needs an efficient way to enforce uniqueness and locate rows by that key.</p><h3>Indexes Are Especially Important as Data Grows</h3><p>This is something that’s easy to overlook during development.</p><p>Your application works perfectly with:</p><pre>100 rows</pre><p>Then:</p><pre>10,000 rows</pre><p>Still fine.</p><p>Then:</p><pre>1,000,000 rows</pre><p>Now things start getting interesting. The code didn’t necessarily become worse. <strong>The workload changed. </strong>A query that was perfectly acceptable at a small scale may become a bottleneck at a larger scale. That’s why database performance shouldn’t only be tested with tiny development datasets. If you’re building something that you expect to grow, think about how your queries behave as the data grows with it.</p><h3>The Real Lesson</h3><p>Indexing isn’t about memorizing:</p><pre>CREATE INDEX ...</pre><p>The syntax is the easy part. The more important skill is understanding <strong>why</strong> a query is slow. When I started looking at SQL performance this way, database optimization became less about randomly adding indexes and more about understanding what the database is actually doing.</p><p>A good workflow is:</p><pre>1. Find a slow query<br>2. Inspect the execution plan<br>3. Understand how the database accesses the data<br>4. Identify the bottleneck<br>5. Add or modify an index if appropriate<br>6. Test again<br>7. Keep only indexes that provide real value</pre><h3>One Thing I’ll Keep in Mind</h3><p>If there’s one thing I’d take away from all of this, it’s this:</p><blockquote><strong><em>Don’t index everything. Index intentionally.</em></strong></blockquote><p>An index can turn an expensive lookup into a much more efficient one. But an index also has a cost. The goal isn’t to have the database filled with indexes. The goal is to make the database <strong>do less unnecessary work</strong>. And honestly, that’s what makes database optimization interesting.</p><p>At first, you’re just writing:</p><pre>SELECT *<br>FROM users<br>WHERE email = &#39;...&#39;;</pre><p>Then you start asking:</p><p><strong>“How does the database actually find this row?”</strong></p><p>That’s when SQL starts getting much more interesting.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e0c25d65e771" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[fcrackzip Cheat Sheet for CTF Players]]></title>
            <link>https://medium.com/linkit-intecs/fcrackzip-cheat-sheet-for-ctf-players-5f5b0a92c3ea?source=rss-7b5da5b72c5a------2</link>
            <guid isPermaLink="false">https://medium.com/p/5f5b0a92c3ea</guid>
            <category><![CDATA[password-cracking]]></category>
            <category><![CDATA[cheatsheet]]></category>
            <category><![CDATA[ctf]]></category>
            <category><![CDATA[zip]]></category>
            <category><![CDATA[fcrackzip]]></category>
            <dc:creator><![CDATA[Pasindu Pabasara]]></dc:creator>
            <pubDate>Wed, 06 May 2026 04:02:36 GMT</pubDate>
            <atom:updated>2026-05-06T04:02:36.848Z</atom:updated>
            <content:encoded><![CDATA[<p><em>A practical guide for cracking ZIP files during competitions</em></p><figure><img alt="Photo by FLY:D on Unsplash" src="https://cdn-images-1.medium.com/max/1024/1*anQNPFQlmPZg7CKkXVqwAw.png" /></figure><h3>Introduction</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/830/1*oU9FPwq0XqOUV43HJPpBqw.png" /></figure><p>A few days ago, my friends and I took part in our first CTF, CryptX 2.0, organized by the Information and Communication Technology Society. We went in without much expectation, just curious to see how things work in a real competition.</p><p>Out of more than 70 teams, our team, Packet Pirates, managed to reach the finals as one of the top 15. That alone felt unreal for a first attempt.</p><p>In the first round, there were several challenges, and a few of them involved cracking ZIP files to retrieve flags. At that point, I was honestly a bit confused. I had seen password-protected ZIP files before, but never in a situation like this where it actually mattered.</p><p>So I did what most beginners do. I searched online to figure out how to crack a ZIP file and started learning on the spot.</p><p>So I did what most beginners do. I searched online, read a few guides, tried things out, and slowly figured it out while the clock was ticking.</p><p>That is when I discovered <strong><em>fcrackzip</em></strong>.</p><h3>What is fcrackzip?</h3><p>fcrackzip is a small and focused tool made for cracking ZIP file passwords. It is fast, simple, and does exactly what you need without unnecessary complexity.</p><p>That is why it shows up so often in CTFs. When you need quick results, tools like this can save a lot of time.</p><h3>When Should You Use It in CTFs?</h3><p>You do not need it for every challenge. But in certain situations, it becomes very useful.</p><p>Use it when you come across password-protected ZIP files and there are no clear hints. It is also helpful when you suspect the password is something simple or commonly used.</p><p>If you just want to test a few possibilities quickly without setting up heavy tools, this is a good starting point.</p><p>Think of it as your first attempt tool before going deeper.</p><h3>How to install it on Ubuntu</h3><ol><li>Update package list</li></ol><pre>sudo apt update</pre><p>2. Install fcrackzip</p><pre>sudo apt install fcrackzip</pre><p>Optional: Install useful wordlists</p><p>For CTF work, wordlists are important. A common one is:</p><pre>sudo apt install wordlists</pre><p>After installing, you can find rockyou.txt here:</p><pre>/usr/share/wordlists/rockyou.txt</pre><h3>Attack Methods Overview</h3><p>Understanding attack types is more important than memorizing syntax.</p><p><strong>1. Dictionary Attack</strong></p><p>This method uses a wordlist of possible passwords.</p><p>Best used when:</p><ul><li>The challenge hints at real words</li><li>You have common password lists</li><li>The flag format may resemble a password</li></ul><p>Common sources for wordlists include:</p><ul><li>rockyou.txt</li><li>Custom lists generated from challenge clues</li></ul><p><strong>2. Brute Force Attack</strong></p><p>This tries every possible combination within a defined pattern.</p><p>Best used when:</p><ul><li>Password length is small</li><li>Characters are limited</li><li>No hints are available</li></ul><p>The key here is limiting the search space. Blind brute force wastes time in CTFs.</p><p><strong>3. Mask-Based Attack (Pattern Guessing)</strong></p><p>A smarter version of brute force where you define structure.</p><p>Example scenarios:</p><ul><li>Password starts with “flag”</li><li>Ends with numbers</li><li>Contains only lowercase letters</li></ul><p>This approach often wins CTF challenges because it combines logic with automation.</p><h3>When fcrackzip is not enough</h3><p>There will be times when it does not work.</p><p>The password might be too complex, or the encryption too strong. Sometimes you simply run out of time.</p><p>That is when you move to more advanced tools like John the Ripper or Hashcat.</p><p>But even then, tools alone will not solve the problem. The real skill is in how you think about the challenge.</p><h3>Conclusion</h3><p>Looking back, cracking that first ZIP file was a small moment, but it changed how I approach CTFs.</p><p>It is not about knowing every tool in advance. It is about staying calm, learning quickly, and making smart decisions under pressure.</p><p>fcrackzip is just one tool, but in the right situation, it can make a big difference.</p><p><em>Start simple, think carefully, and build from there. <br></em>That is how you grow from a beginner to someone who can actually compete.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5f5b0a92c3ea" width="1" height="1" alt=""><hr><p><a href="https://medium.com/linkit-intecs/fcrackzip-cheat-sheet-for-ctf-players-5f5b0a92c3ea">fcrackzip Cheat Sheet for CTF Players</a> was originally published in <a href="https://medium.com/linkit-intecs">LinkIT</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Getting Started with Go: History , Installation and Setup]]></title>
            <link>https://medium.com/@pabasarapasindu365/getting-started-with-go-history-installation-and-setup-7062ba8c1e57?source=rss-7b5da5b72c5a------2</link>
            <guid isPermaLink="false">https://medium.com/p/7062ba8c1e57</guid>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[installation]]></category>
            <category><![CDATA[golang]]></category>
            <category><![CDATA[setup]]></category>
            <category><![CDATA[cloud-native-development]]></category>
            <dc:creator><![CDATA[Pasindu Pabasara]]></dc:creator>
            <pubDate>Mon, 06 Apr 2026 06:23:02 GMT</pubDate>
            <atom:updated>2026-04-06T06:23:02.404Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*bHcvnTA3fLi8V8g-.png" /></figure><p>Hi everyone,</p><p>This is my new article series about the Go programming language. I’m actually a beginner myself, so I’ll be writing these articles while learning. In this article, I’ll talk about getting started with Go, what it is and how to install it on your computer. In my next post, I’ll cover the basics of Go and show how to write a simple “Hello World” program.</p><p>If you are a beginner in Go, this will be very helpful for you. So, are you ready to dive into the world of Go?</p><h3>1. What is Go?</h3><figure><img alt="Credits go to “www.mitrais.com”" src="https://cdn-images-1.medium.com/max/1024/0*2L157LVPdEvQzrlx.png" /></figure><p>A few months ago I heard about Go when I was learning cloud native development and DevOps. At that time I thought Python was the only programming language mostly used in cloud computing and DevOps. But I saw a video on a YouTube channel about Go. First I thought it was just another backend language. But in the thumbnail I saw the Golang logo. It was very cute and attractive. Only because of that I clicked the video and watched it. It was published by the Admoic YouTube channel, and he explained Golang simply and clearly (credit to <a href="https://www.youtube.com/@adomicarts">Admoic</a> YouTube channel-you can watch the video here: <a href="https://youtu.be/VJ-hLA_BMPA?si=_fbn-7C_xdn_qzvd">https://youtu.be/VJ-hLA_BMPA?si=_fbn-7C_xdn_qzvd</a>).</p><p>This is a simple introduction to Golang. Go (Golang) is an open source programming language developed by Google. It was designed to build fast, reliable, and scalable software. Go is widely used in cloud computing and DevOps because of its simplicity, strong performance, and built in support for concurrency. Many popular cloud native and DevOps tools such as Docker, Kubernetes, and Terraform are written in Go. Because of this, learning Go can be very useful for engineers who work with cloud infrastructure, automation, and distributed systems.</p><p>Go is popular in DevOps because it is fast, simple to deploy, and handles concurrent tasks very well. Unlike Python, Go programs can be compiled into a single binary file, so you can just copy and run them without installing many dependencies. This makes it very practical for servers, containers, and automation tools. Go is also used to build many real infrastructure tools, so learning it can be very useful for engineers who work with cloud platforms, CI/CD pipelines, and system automation.</p><h3>2. History of Go</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nJoXKUP4WDEqgZqRjIW8UA.jpeg" /></figure><p>Before we get into the technical stuff, let me introduce the real star of Go, the <strong>Go Gopher</strong>. This little guy is tiny, round, and ridiculously cute. It’s the official mascot of Go and honestly, it made me smile the first time I saw it. The Gopher isn’t just decoration. It’s like the friendly face of a language that could otherwise feel serious and complicated. There’s even an official guide for how it should look, from its big eyes to its tiny paws. Only Go would do that, right?</p><p>Now, about the language itself. Golang, was created at <strong>Google in 2007</strong> by <strong>Robert Griesemer, Rob Pike, and Ken Thompson</strong>. I read somewhere that they were frustrated with the long compile times of C++ and the complexity of Java. Scripting languages were easier but too slow for big systems. Go was their answer, a way to make writing software faster, simpler, and more reliable. Rob Pike even joked that if compiling C++ didn’t take 45 minutes back then, Go might never have happened.</p><p>Go went public as an <strong>open-source language in 2009</strong>, and version 1 came out in 2012. That version brought backward compatibility and a strong standard library, covering everything from HTTP servers to text formatting. Go was built to handle modern challenges like multi-core CPUs and distributed systems. It’s simple, fast, and great at running multiple tasks at the same time, which makes it perfect for cloud native development and DevOps work.</p><p>The language got really popular when tools like <strong>Docker, Kubernetes, and Terraform</strong> were written in Go. Later, they even made the compiler in Go itself and added generics, which made it even more powerful.</p><p>And through it all, the Gopher has been quietly cheering everyone on, reminding us that programming can be serious but still fun. If a little cartoon critter can handle cloud infrastructure, so can we.</p><h3>3. Install Go on Linux</h3><p>There are already plenty of articles explaining how to install Go on Windows or macOS, so I thought it would be more useful to show <strong>how to install Go on Linux</strong>. If you are a Windows or Mac user, you can find installation instructions in this [link].</p><p>On Linux, there are several ways to install Go. You <strong>can</strong> use your package manager, for example on Ubuntu:</p><pre>sudo apt install golang</pre><p>But honestly, this is <strong>not the recommended way</strong>. Package managers often don’t provide the latest Go version, and you might run into compatibility issues with newer libraries or tools.</p><p>Instead, I’ll show you the recommended method.</p><p><strong>Step 1: Download Go</strong></p><p>Go to the official Go download page <a href="https://golang.org/dl/">https://golang.org/dl/</a> and download the latest <strong>Linux tarball</strong>. For example, it might look like go1.21.2.linux-amd64.tar.gz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mdP4880ZlMAu50T0dyDKzg.png" /></figure><p><strong>Step 2: Extract the Archive</strong></p><p>Open your terminal and navigate to the folder where you downloaded the tarball. Then run:</p><pre>sudo tar -xzf go1.26.1.linux-amd64.tar.gz -C /usr/local</pre><p><strong>Step 3: Set Up Environment Variables</strong></p><p>After this, you’ll want to add Go to your PATH. For example, add this to ~/.profile or ~/.bashrc:</p><pre>export PATH=$PATH:/usr/local/go/bin</pre><p>Then apply the changes:</p><pre>source ~/.profile</pre><p><strong>Step 4: Verify the Installation</strong></p><pre>go version</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/815/1*mhqc33u_QbGONohky8cIKg.png" /></figure><h3>4. Setting Up Your First Go Workspace</h3><p>Even though modern Go uses modules, it’s a good idea to create a dedicated project folder for your code. This keeps your projects organized and makes it easier to manage dependencies.</p><p>Open your terminal and run</p><pre>mkdir ~/go-projects<br>cd ~/go-projects<br>go mod init myproject</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/815/1*MAlKatvYLK12PNEaE2Hk9g.png" /></figure><p>This creates a new folder called go-projects and initializes a Go module named myproject. Now you’re ready to start coding in Go on Linux. In the next article, we’ll write our first <strong>Hello World</strong> program and explore the basics of the language.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7062ba8c1e57" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Beginning My Automation Engineering Journey with Python and Selenium]]></title>
            <link>https://medium.com/linkit-intecs/beginning-my-automation-engineering-journey-with-python-and-selenium-e6826e2ca51d?source=rss-7b5da5b72c5a------2</link>
            <guid isPermaLink="false">https://medium.com/p/e6826e2ca51d</guid>
            <category><![CDATA[automation]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[selenium]]></category>
            <category><![CDATA[web-scraping]]></category>
            <dc:creator><![CDATA[Pasindu Pabasara]]></dc:creator>
            <pubDate>Fri, 03 Apr 2026 03:33:03 GMT</pubDate>
            <atom:updated>2026-04-03T03:33:03.857Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Created using chatgpt" src="https://cdn-images-1.medium.com/max/1024/1*gvSZzbPLjKPQW1jWubOEFA.png" /></figure><p>Hi guys, After a long time, I finally had some time to write an article on Medium because I’ve been busy with academics, club activities, and my internship. Yes, I started an internship in my first year, I’ll tell you more about it later. Today, I want to talk about a fascinating and interesting technology called automation.</p><p>I had heard about it a long time ago but never had a chance to try it. After starting my internship, I needed to create automation scripts using Python because my company primarily works with RPA (Robotic Process Automation). This meant I had to learn advanced Python and start writing small scripts as learning projects during my first month of the internship (and I’m currently in my first month!).</p><p>Actually, I don’t have a complete understanding of RPA and automation yet. But I do have a clear idea about my first automation project, what I learned from it, and some best practices for automating websites or web applications.</p><p>When you want to automate a website, it helps to have a clear understanding of Python and OOP concepts. You also need to use certain libraries and modules in your script. For my project, I had to install <strong>Selenium</strong>, <strong>Requests</strong>, <strong>BeautifulSoup (bs4)</strong>, <strong>Pandas</strong>, and <strong>python-dotenv</strong>. I won’t cover all of them in detail here, so you’ll need to explore and learn each one on your own.</p><p>Run this command on your terminal</p><pre>pip install selenium webdriver-manager beautifulsoup4 pandas python-dotenv</pre><p>Once installed, you can import these libraries in your script. I’m not sharing the code here because my focus is on <strong>explaining how to approach automation logically</strong> rather than showing exact code. You can follow this guide to understand the process and then create your first script on your own. This way, you’ll learn more effectively by doing it yourself.</p><p>First, you need to register on the website manually and store your login credentials in a .env file. Avoid hardcoding credentials inside your script because it is not a secure practice.</p><p>To automate login, you can use either <strong>Selenium</strong> or <strong>Requests</strong>.</p><p>With Selenium, the script opens a real browser, enters credentials, and clicks the login button just like a normal user. This approach works well even if the website uses JavaScript or complex authentication flows.</p><p>With Requests, you send HTTP requests directly to the login endpoint. This method is faster but requires understanding how the website handles authentication, including cookies, sessions, CSRF tokens, and request headers. These details can usually be found using the browser Network tab.</p><p>Since login is typically performed once per session in most automation workflows, Selenium is often the easier choice for beginners because it does not require reverse engineering the authentication process.</p><p>After logging into the website, the bot can perform actions similar to a normal user. For example, in my project I needed to search for books and extract the data into a Python dictionary.</p><p>For data extraction, there are two main approaches. You can either use Selenium or use BeautifulSoup together with Requests.<br>Selenium can extract data directly from the page, but it is usually slower because it loads the full browser, executes JavaScript, and renders the UI. This makes it useful for interaction but not always ideal for large-scale data extraction.</p><p>BeautifulSoup, on the other hand, is faster because it only parses HTML content. When combined with Requests, you can directly fetch the page source and extract the required data without rendering the browser interface.</p><p>For example, if you need to extract data for 1000 books across 50 pages, using Selenium alone could take a long time because it must load each page fully. Using Requests and BeautifulSoup can be much faster because you only download and parse the HTML. So Always try to use python Requests and BeautifulSoup rather than Selenium.</p><p>At this stage, about half of the project was complete. The next part was more complex. The main challenge was automating the <strong>add to cart</strong> process and the <strong>checkout workflow</strong> (up to the payment stage).</p><p>This part was more difficult because, unlike searching or data extraction, cart and checkout processes usually involve multiple steps, session handling, button actions, and sometimes dynamic page updates. If you have enough time to work on this task, you can automate this part completely without using Selenium, but it is not mandatory. Like the login process, this is also usually a one-time process, so you can use Selenium to complete it easily.</p><p>I did not describe exactly how to do it because the workflow is simple. You can find the add-to-cart API, take the books from the book dictionary (which was created in the previous stage), and send requests to that API. After that, you can navigate to the checkout page and take a screenshot of the product summary.</p><p>If you use Selenium, you can do this easily by clicking the add-to-cart buttons, navigating to the checkout page, and taking a screenshot. However, my recommendation is to always try to complete the task without using Selenium when possible.</p><p>This was my first serious automation project, and I learned several important practical lessons that are not obvious when you first start learning automation.</p><h3>1. Always understand the workflow before writing code</h3><p>At the beginning, I tried to start coding immediately. Later I realized the better approach is to first understand the full workflow manually. This includes login flow, search behavior, API calls, cart updates, and checkout steps.</p><p>When you clearly understand the process, writing the automation becomes much easier and cleaner.</p><h3>2. Do not depend only on Selenium</h3><p>At first, Selenium looked like the easiest solution for everything. But later I understood that Selenium is not always the best tool for every task.</p><p>Good practice is:</p><ul><li>Use Selenium for interaction</li><li>Use Requests for API communication</li><li>Use BeautifulSoup for parsing data</li></ul><p>This makes automation faster and more efficient.</p><h3>3. Always use proper waits instead of sleep</h3><p>One mistake beginners make is using time.sleep() everywhere. This makes scripts slow and unreliable. I also made this mistake at the beginning, and my mentor advised me to reduce unnecessary sleep statements.</p><p>A better approach is using explicit waits because they wait only until the element is ready instead of waiting a fixed time.</p><p>This makes scripts:</p><ul><li>Faster</li><li>More stable</li><li>More professional</li></ul><h3>4. Keep credentials secure</h3><p>Never hardcode usernames and passwords inside scripts. Using .env files is a simple but important best practice. This is something used in real industry projects.</p><h3>5. Websites change, automation breaks</h3><p>One important lesson I learned is that automation is not “write once and forget”. Even small UI changes can break scripts. Because of this, writing maintainable and flexible code is important.</p><h3>6. Think like an engineer, not just a coder</h3><p>The biggest lesson I learned was that automation is not just about writing scripts. It is about understanding systems, workflows, and designing efficient solutions.</p><p>This project marks the beginning of my automation engineering journey. It helped me move from just learning Python syntax to actually solving practical problems.</p><p>There is still a lot for me to learn about RPA, workflow automation, and large scale automation systems, but this project gave me a strong starting point.</p><p>My next goal is to improve these skills by building more automation projects, learning better design practices, and understanding how automation is used in real production environments.</p><p>If you are also starting automation, “start with a small real problem, try to solve it step by step, and focus on understanding the logic rather than just copying code”. Also, do not think you have to learn all the concepts before doing a project. <strong>Learn while doing the project.</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e6826e2ca51d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/linkit-intecs/beginning-my-automation-engineering-journey-with-python-and-selenium-e6826e2ca51d">Beginning My Automation Engineering Journey with Python and Selenium</a> was originally published in <a href="https://medium.com/linkit-intecs">LinkIT</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Dispatcher-Performer Architecture for Designing Scalable Automation Systems]]></title>
            <link>https://medium.com/@pabasarapasindu365/dispatcher-performer-architecture-for-designing-scalable-automation-systems-aabdbc1a9769?source=rss-7b5da5b72c5a------2</link>
            <guid isPermaLink="false">https://medium.com/p/aabdbc1a9769</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[automation]]></category>
            <category><![CDATA[web-scraping]]></category>
            <category><![CDATA[selenium]]></category>
            <category><![CDATA[dispatcher-performer]]></category>
            <dc:creator><![CDATA[Pasindu Pabasara]]></dc:creator>
            <pubDate>Sun, 29 Mar 2026 06:52:00 GMT</pubDate>
            <atom:updated>2026-03-29T06:52:00.990Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/626/0*agewIRmDe4M1H_KT" /></figure><p>Hi all, welcome to my new article series on Robotic Process Automation. In this series, I will explore key concepts, design patterns, and practical approaches that help automation engineers build scalable and reliable systems. In this first article, I’m focusing on <strong>Dispatcher–Performer Architecture</strong>, a design pattern that separates task planning from task execution. To make it easier to understand, I’ll also walk you through a real-world scenario that shows how this architecture works in practice and why it matters for handling large-scale automation tasks efficiently.</p><h3>1. What is Dispatcher–Performer Architecture</h3><figure><img alt="Image from uipath — https://www.uipath.com/" src="https://cdn-images-1.medium.com/max/1024/0*kTYMhNdmEi8AwpT4.png" /></figure><p><strong>Dispatcher–Performer Architecture</strong> is a system design pattern used to handle large numbers of tasks in an organized and scalable way. It separates the responsibility of <strong>managing work</strong> from <strong>executing work</strong>. One part of the system decides what needs to be done, while the other part actually performs the work.</p><p>In simple terms, the Dispatcher assigns tasks, and the Performers carry them out efficiently, making the system easier to scale, maintain, and monitor.</p><h3>2. Why This Architecture Works for Large Scale Automation</h3><ul><li>Scalability: multiple performers can handle many tasks simultaneously.</li><li>Reliability: failures in one performer don’t crash the system.</li><li>Observability: easier to monitor task progress and system health.</li><li>Flexibility: system can evolve without rewriting everything.</li></ul><h3>3. Real world scenario</h3><p>For better understanding, I will simply explain this architecture using a real-world scenario. Imagine you are an Automation Engineer, and your Tech Lead gives you a task to write a script to fetch all the item details from Kapruka.com and generate a separate PDF (containing item details) for each item. You know that Kapruka has a large number of items, and the data is updated automatically as well.</p><p>You decide to write a simple Python script in a single .py file to handle the task. You run it and… wait. And wait. The script takes forever to finish. Frustrated, you ask your Tech Lead what’s going wrong. He smiles and says, “Ah, this is exactly why you should use Dispatcher–Performer Architecture.”</p><p>He explains that with Dispatcher–Performer Architecture, this task can be done much more efficiently by dividing it into stages. First, the Dispatcher collects all the item details from Kapruka.com, organizes them, and creates a list of tasks. Each task is for one item and includes everything needed to generate its PDF. Then the Performers take these tasks and process them independently, generating the PDFs in parallel. By separating the work into stages like preparing tasks and executing tasks, the system becomes faster, more reliable, and easier to manage, even when dealing with thousands of items.</p><h3>4. Conclution</h3><p>Using Dispatcher–Performer Architecture makes it clear why large scale tasks can be handled efficiently without overloading a single script. By separating task planning from execution, the system becomes faster, more reliable, and easier to manage. This approach allows multiple performers to work in parallel, reduces the impact of failures, and makes monitoring much simpler. Once you start thinking in stages like this, automation stops being just about writing scripts and becomes about designing systems that can scale, adapt, and handle real world workloads effectively.</p><p>In the next article, I’ll dive deeper into implementing Dispatcher–Performer in Python and show how to handle thousands of tasks efficiently. It will be even more interesting than this conceptual part. But before jumping into the technical details, this overview will help you understand the architecture and why it works.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=aabdbc1a9769" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Setting Up a Linux Playground on Azure: A Step-by-Step VM Guide for Beginners.]]></title>
            <link>https://medium.com/@pabasarapasindu365/setting-up-a-linux-playground-on-azure-a-step-by-step-vm-guide-for-beginners-e3d541ac2e9a?source=rss-7b5da5b72c5a------2</link>
            <guid isPermaLink="false">https://medium.com/p/e3d541ac2e9a</guid>
            <dc:creator><![CDATA[Pasindu Pabasara]]></dc:creator>
            <pubDate>Mon, 24 Nov 2025 15:51:37 GMT</pubDate>
            <atom:updated>2025-11-24T15:51:37.104Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MjYhpT92smD6fD-sbIh8rQ.png" /></figure><p>If you want to learn Linux, it is worth starting with a cloud instance. A cloud server gives you a real environment where you can practice commands, manage files, and work through mistakes without changing anything on your main computer. You avoid the trouble of installing VirtualBox or setting up a dual boot. You only need a stable internet connection to log in through SSH and begin working.</p><p>For IT students who hope to enter DevOps or cloud engineering, learning on real servers is important. You will work with platforms like AWS, Azure, and Google Cloud in the future, so getting used to their environments early is helpful.</p><p>You can still install VirtualBox and learn Linux locally, but it requires enough RAM to run smoothly. A cloud instance removes that limit and gives you a clean, reliable space to learn.</p><h3>Why Azure is a good option for beginners</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*tiTXmzPPvmWTt4Nr.png" /></figure><p>Azure offers a steady learning experience for anyone starting with Linux. The portal is simple to navigate, and most settings come with helpful defaults. This means you can create a working Linux server without dealing with complex configurations. Azure also provides detailed monitoring, so you can see how your server uses CPU, memory, and storage. This gives beginners a better understanding of how systems behave under different workloads.</p><p>Another advantage is the support for many Linux distributions. You can choose Ubuntu, Debian, CentOS, or others, and switch between them whenever you want to try something new. Azure keeps these images updated, which makes the setup reliable and secure. The platform also includes free credits for new users, allowing students and beginners to practice without a financial burden.</p><p>Most important is the real-world experience you gain. Modern DevOps and cloud teams work with virtual machines every day. Learning on Azure gives you a feel for resource groups, networks, firewalls, and server management in a professional environment. This makes your transition from student practice to industry work much smoother.</p><h3>Creating a Free Account and Understanding Credits</h3><p>Before you start practicing Linux on Azure, you need to create a free account. Microsoft gives new users <strong>$200 in credits</strong> for the first 30 days, which is more than enough to spin up a few virtual machines and experiment freely. Even after the $200 runs out, there are <strong>always-free services</strong>, like small Linux VMs and storage, so you can keep learning without paying a thing.</p><p>Signing up is simple, you just need a Microsoft account and a payment method for verification. Don’t worry, Microsoft won’t charge you automatically when your credits run out like AWS. The dashboard clearly shows your <strong>remaining credits, usage, and estimated costs</strong>, making it easy to track how much you’ve used.</p><h3>How to Create a Virtual Machine</h3><p>After your Azure account ready you can see a Azure Home page.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Kdif-jKc1z8qRqvZPysDIw.png" /></figure><p>Just Search virtual machines on the Search bar and click it. Now you are in the Azure vritual machines section.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gSbDfX-gCsjWLykR_olvcA.png" /></figure><p>Next, click <strong>“Create”</strong> and choose <strong>“Virtual Machine”</strong>. You will be asked to fill in some details:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GnenHytJ0MVtMWLEYSyVOA.png" /></figure><ul><li><strong>Subscription and Resource Group:</strong> If you don’t have a resource group yet, create a new one. This keeps all related resources organized.</li><li><strong>Virtual Machine Name:</strong> Give your VM a name you can recognize, like linux-playground.</li><li><strong>Region:</strong> Choose a location near you for better performance.</li><li><strong>Image:</strong> Pick a Linux distribution. For beginners, <strong>Ubuntu LTS</strong> is a great choice.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/547/1*Dkvw6-_DWrtWNOMM7jtk9g.png" /></figure><ul><li><strong>Size:</strong> Start with a small instance - it’s enough for practicing commands and installing software without using too many credits.</li><li><strong>Authentication:</strong> Set a strong password or SSH key to log in safely.</li><li><strong>Networking:</strong> Make sure <strong>SSH (port 22)</strong> is allowed so you can connect from your computer.</li></ul><p>Finally, review your choices and click <strong>“Create”</strong>. In a few moments, your Linux virtual machine will be ready, and you can start logging in to practice Linux commands and explore your new server.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TsIP7ScG3oEiTnZTnEjXgQ.png" /></figure><h3>Connecting to Your Linux VM via SSH</h3><p>Once your virtual machine is created, you can connect to it using <a href="https://medium.com/@aqeelabbas3972/introduction-to-ssh-secure-shell-0d07e18d3149"><strong>SSH</strong></a>, which lets you access the server from your own computer.</p><ol><li>Go to your VM in the Azure portal and copy the <strong>public IP address</strong>.</li><li>You don’t need to worry about which operating system you use. <strong>Termius</strong> and <strong>MobaXterm</strong> work on Windows, Linux, and macOS. Open one of these apps, create a new connection, enter your VM’s public IP, username, and password (or SSH key), and you’re ready to connect.</li></ol><h3>Using Termius to Connect to Your Linux VM</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*TATXN3Mc-zg61YaV.png" /></figure><p>When learning Linux on Azure, <a href="https://termius.com/download/"><strong>Termius</strong></a> is one of the easiest ways to connect to your virtual machine. It works on <strong>Linux,Winodws and macOS</strong>, so you don’t need to worry about your operating system. Termius also makes managing multiple servers simple with a clean interface and saved connections.</p><p>For Students, Termius <strong>Pro</strong> is included in the <strong>GitHub Developer Pack</strong>, giving access to extra features like snippets, SFTP, and advanced host management, which can make learning and managing servers even smoother.</p><h3>Steps to Connect with Termius</h3><p><strong>Install Termius</strong> — Download and install it from <a href="https://www.termius.com/">Termius.com</a>. It’s free for basic use, which is enough for learning Linux.</p><p><strong>Create a New Host</strong> — Open Termius, click <strong>New Host</strong>, and enter:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*R2hMO6O9qSKFiG2kc5pKcQ.png" /></figure><ul><li><strong>Label:</strong> Any name for your VM (like Linux Playground)</li><li><strong>Hostname / IP:</strong> Your VM’s public IP address from Azure</li><li><strong>Username:</strong> The Linux username you created when setting up the VM</li><li><strong>Authentication:</strong> Either a password or SSH key</li></ul><p><strong>Connect</strong> — Save the host and click <strong>Connect</strong>. The first time, Termius will ask you to accept the server fingerprint.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kMdJOW3ec9bUxH0dJQPPyA.png" /></figure><p><strong>Start Exploring</strong> — Once connected, you can run Linux commands, install software, and practice safely. Termius also lets you organize multiple servers, create snippets for common commands, and even use SFTP to transfer files.</p><h3>Why Termius is Great for Beginners</h3><ul><li>Cross-platform support (Windows, macOS, Linux)</li><li>Easy to manage multiple servers</li><li>Saves credentials securely</li><li>Supports SSH keys and passwords</li><li>Built-in SFTP for file transfers</li></ul><p>Using Termius, you can focus entirely on learning Linux without worrying about OS compatibility or complex SSH setup. It’s a beginner-friendly gateway to real-world Linux servers on Azure.</p><p>This article was also published on the <a href="http://blog.rotaractmora.org/setting-up-a-linux-playground-on-azure-a-step-by-step-vm-guide-for-beginners/">Rotaract Mora blog</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e3d541ac2e9a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Windows to Linux: A Simple Guide for New Users.]]></title>
            <link>https://medium.com/@pabasarapasindu365/from-windows-to-linux-a-simple-guide-for-new-users-b96c98506d53?source=rss-7b5da5b72c5a------2</link>
            <guid isPermaLink="false">https://medium.com/p/b96c98506d53</guid>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[linux]]></category>
            <dc:creator><![CDATA[Pasindu Pabasara]]></dc:creator>
            <pubDate>Tue, 18 Nov 2025 05:49:26 GMT</pubDate>
            <atom:updated>2025-11-18T05:49:26.475Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fYsogPC1QWvkTutYJRc9uw.png" /></figure><p>As a first-year IT undergraduate, I needed an operating system for development and daily tasks. I chose Windows because it’s user-friendly and I was already comfortable using it. Later, I learned about an operating system called Linux, and to me, it felt like a whole new world of possibilities.</p><p>Unlike Windows, Linux gave me full control over my system. It allowed me to explore programming tools freely and encouraged me to understand how computers really work. At first, it was a little challenging with commands, terminals, and unfamiliar file structures. The more I used it, the more I realized how powerful and flexible it is. For students, developers, or anyone curious about technology, Linux opens doors that are hard to find elsewhere.</p><h3>What is Linux</h3><p>Technically, Linux is not a complete operating system. It is a kernel. You can think of it as the engine of a car. It interacts with the hardware and runs programs. On top of this engine, people build complete systems called <strong>distributions</strong>. These include the desktop environment, applications, and all the tools you need.</p><p>When we say “Linux,” we usually mean a full system like <strong>Ubuntu</strong>, <strong>Fedora</strong>, or <strong>Linux Mint</strong> that is ready to use for development, learning, or daily computing.</p><h3>Getting started with linux</h3><p>If you want to switch to Linux, there are several ways to do it. Linux is not as user-friendly as Windows, and it relies on the terminal for many tasks. Therefore, the first step is to learn how to use the terminal. The good news is that you do not need to install Linux on your personal computer to start practicing. In fact, installing it directly on your main system can be a little risky. Here are some safe ways to try Linux, in my recommended order:</p><ol><li><strong>Use a cloud instance</strong> — <a href="https://medium.com/@sahdevgrover02/understanding-amazon-ec2-cb702b53c9ca">AWS EC2 </a>or <a href="https://medium.com/@veerababu.narni232/how-to-create-a-first-azure-virtual-machine-498a88a06443">Azure virtual machines</a> with free tiers allow you to access a Linux environment online without touching your local system. You can use tools like <strong>Termius</strong> or <strong>MobaXterm</strong> to log in and work comfortably.</li><li><strong>Use a virtual machine</strong> — Tools like <a href="https://www.virtualbox.org/">Oracle VirtualBox </a>or <a href="https://www.vmware.com/">VMware</a> let you run Linux safely inside your current operating system.</li><li><strong>Dual boot</strong> — Install Linux alongside Windows on your computer, giving you the option to choose which OS to start. <a href="https://youtu.be/H7BW--lhfyA?si=VNUIKp29d0vQtP-G">Watch this video to learn how to setup dual boot</a>.</li><li><strong>Install Linux on a portable hard disk</strong> — This allows you to run Linux from an external drive without affecting your main system. <a href="https://youtu.be/lz8TDYSKXu8?si=qMzXC_q2RTDeNlbk">Watch this video to learn how to setup portable hard disk.</a></li></ol><h3>Choosing a Linux Distribution</h3><p>Once you have decided how to try Linux, the next step is choosing a distribution, or “distro.” For beginners, I recommend <strong>Ubuntu</strong> or <strong>Linux Mint</strong>. They are stable, user-friendly, and have large communities, which makes finding help online easy. If you are more curious about experimenting, <strong>Fedora</strong> or <strong>Pop!_OS</strong> are also great choices. If you enjoy playing video games, <strong>Pop!_OS</strong> is especially designed with gaming in mind, offering good driver support and performance out of the box, though it may still have some limitations with certain game titles compared to Windows.</p><p>To help you understand Linux better, here is an overview of the main Linux families:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1pwkv_lmkP3DW_S98UIISA.png" /></figure><p>Debian-based distributions are usually the best choice for beginners because of their simplicity and large support communities. Red Hat-based distros are more enterprise-focused, Arch-based distros suit users who want complete control, and independent distros offer unique experiences for those looking to explore something different.</p><h3>Basic Linux Commands</h3><p>After choosing your distribution, the next step is getting comfortable with the <strong>terminal</strong>, which is the heart of Linux. At first, it may feel strange compared to the familiar clicks and menus of Windows, but learning a few basic commands will help you navigate and manage your system confidently. Here are the essentials:</p><ul><li>ls – Lists all files and folders in the current directory</li><li>cd – Changes the current directory</li><li>pwd – Shows the path of the current directory</li><li>mkdir – Creates a new folder</li><li>rm – Deletes files or folders (be careful when using this command)</li><li>sudo – Runs commands with administrative privileges</li><li>man – Opens the manual for any command</li></ul><p>Using these commands regularly will make your Linux experience much smoother. You don’t need to memorize everything at once. Start small, experiment, and try to solve simple tasks in the terminal. It’s the best way to learn.</p><h3>Using Linux in Daily Life</h3><p>Linux can be used for both development and everyday tasks. You can browse the internet, watch videos, write documents, and even play games, depending on your distro. Software installation is usually handled through <strong>package managers</strong>, which make it simple to add or update applications. For example, on <strong>Ubuntu</strong>, you can install a program using:</p><pre>sudo apt install program-name</pre><p>If you want to update your system, you can do it just as easily:</p><pre>sudo apt update &amp;&amp; sudo apt upgrade -y</pre><p>This is one of the features I find most exciting. Other distributions use similar commands, depending on the package manager they include.</p><p>Linux also encourages customization. You can change the desktop environment, themes, and shortcuts to match your workflow, giving you a personalized computing experience.</p><h3>Conclusion</h3><p>Switching to Linux may feel challenging at first, especially if you are used to Windows. However, with a little practice, it becomes a powerful tool for both learning and daily tasks. Linux gives you full control over your system, encourages exploration, and opens up endless possibilities for development and customization. Start small, experiment safely, and enjoy the freedom and flexibility that Linux offers.</p><p>This article was also published on the <a href="https://blog.rotaractmora.org/p/46310492-70e9-4507-907a-2f7513f36d31/">Rotaract Mora blog</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b96c98506d53" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[FirmUp: Simplifying OTA Firmware Updates for ESP32 Devices]]></title>
            <link>https://medium.com/linkit-intecs/firmup-simplifying-ota-firmware-updates-for-esp32-devices-1b65ebd2af0e?source=rss-7b5da5b72c5a------2</link>
            <guid isPermaLink="false">https://medium.com/p/1b65ebd2af0e</guid>
            <category><![CDATA[iot]]></category>
            <dc:creator><![CDATA[Pasindu Pabasara]]></dc:creator>
            <pubDate>Wed, 12 Nov 2025 05:59:01 GMT</pubDate>
            <atom:updated>2025-11-30T04:43:39.666Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Image By Author" src="https://cdn-images-1.medium.com/max/1024/1*EIvi8hCDcEQHK4ayydKdBA.png" /><figcaption>Cover Image by Author</figcaption></figure><p>As a first-year IT undergraduate at the University of Moratuwa, we have to complete four projects over four years. In the first year, we are required to do a microcontroller-based hardware project. It’s a team project, and each team can have a maximum of five members. So, I joined some of my friends and started working on a hardware project. For this project, we chose the ESP32 as our microcontroller because it has a built-in Wi-Fi module, a Bluetooth module, and is very small. For the first part of our project, we created an RC Car (just for testing) using the ESP32 and other components.</p><figure><img alt="Image By Author" src="https://cdn-images-1.medium.com/max/747/1*zNNevPfGdkunx7oux8tU8Q.jpeg" /><figcaption>RC Car Image by Author</figcaption></figure><p>We built the car and the remote controller, and my part was programming them to work together. I used ESP-NOW to control the car with the remote controller, which meant coding for two ESP32 devices simultaneously. At first, I didn’t know much about Arduino code, so I copied and pasted snippets from ChatGPT. However, when we tested the car, it didn’t work properly. On top of that, every small change required me to reconnect the USB cables, flash the firmware, and test again, over and over. It quickly became tedious. To solve this, I went back to the basics and learned Arduino fundamentals. Since we had studied C in our first-semester programming module, picking up the syntax was easier. I started modifying the code manually, testing each adjustment, and gradually got the car working reliably.</p><h3>OTA (Over-the-Air)</h3><p>After spending hours reconnecting USB cables and flashing the ESP32 again and again, I realized there had to be a better way. That’s when I learned about OTA, or <strong>Over-The-Air updates</strong>. OTA means updating the device firmware wirelessly over Wi-Fi, without needing to connect it to a computer each time.</p><p>At first, it sounded almost too good to be true. I set it up for our RC Car project, and suddenly, I could push code changes from my computer while the devices were already running in the field. No more opening the car, plugging in cables, or worrying about loose connections. It felt like a weight lifted off my shoulders.</p><p>With OTA, I could focus on writing and testing the code itself rather than spending hours on the repetitive flashing process. This small change made developing and refining the RC Car so much faster, and it taught me the importance of using the right tools to simplify hardware projects.</p><h3>Implementing OTA</h3><p>After understanding OTA, I decided to set it up for my project. I found several existing libraries for ESP32, such as <strong>ArduinoOTA</strong>, <strong>ESP32HTTPUpdate</strong>, and <strong>AsyncElegantOTA</strong>. I tried implementing one of them to handle updates for the RC Car and remote controller.</p><p>At first, it seemed promising, but I quickly ran into a few issues. Some libraries required a lot of boilerplate code, others didn’t provide proper version tracking, and a few lacked clear mechanisms for verifying firmware integrity. Handling errors or interruptions during updates was also tricky, which made the process less predictable.</p><p>These limitations made me realize there was room for a simpler, safer solution. That’s why I decided to build <strong>FirmUp</strong>, a lightweight OTA library designed to make updates automatic, secure, and easy to manage. With FirmUp, I could implement SHA-256 verification, version tracking, and automatic update checks with minimal setup, solving the exact problems I faced with the other libraries.</p><h3>How to Implement FirmUp</h3><p>Once I had built FirmUp, the next step was to actually integrate it into a project. Implementation was straightforward, which was one of the goals of the library. First, I added FirmUp as a dependency in PlatformIO:</p><pre>lib_deps =<br> rootcypher/FirmUp@¹.0.0</pre><p>Then, in my Arduino code, I created a simple instance of the FirmUp class, pointing it to the HTTP server where the firmware was hosted. With just a few lines, both the RC Car and the remote controller could check for updates, verify the firmware using SHA-256, and install it automatically.</p><pre>#include &lt;FirmUp.h&gt;<br><br>FirmUp updater(&quot;http://my-server.com/firmware.bin&quot;, &quot;1.0.0&quot;);<br><br>void setup() {<br>  Serial.begin(115200);<br>  updater.begin();<br>}<br><br>void loop() {<br>  updater.checkForUpdate();<br>}</pre><p>The first test was exciting. I made a small change in the firmware, uploaded it to the server, and within moments, both ESP32 devices downloaded the update and restarted automatically. No USB cables, no repetitive flashing, just seamless OTA updates.</p><p>Developing FirmUp started from a simple problem: manually updating ESP32 devices is slow, repetitive, and prone to errors. Existing libraries like <strong>ArduinoOTA</strong>, <strong>ESP32HTTPUpdate</strong>, and <strong>AsyncElegantOTA</strong> solved parts of the problem but had limitations - complex setup, no version tracking, or weak error handling.</p><p>FirmUp was my solution: a lightweight, easy-to-use OTA library that provides automatic update checks, SHA-256 verification, version tracking, and works with any HTTP-based firmware server. It streamlines firmware delivery, making updates predictable and safe for embedded projects.</p><p>Whether you’re building an IoT device, experimenting with microcontrollers, or just want a reliable OTA workflow, <strong>FirmUp</strong> aims to simplify the process so developers can focus on building features instead of worrying about updates.</p><p><strong>Thanks for reading this blog!!</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1b65ebd2af0e" width="1" height="1" alt=""><hr><p><a href="https://medium.com/linkit-intecs/firmup-simplifying-ota-firmware-updates-for-esp32-devices-1b65ebd2af0e">FirmUp: Simplifying OTA Firmware Updates for ESP32 Devices</a> was originally published in <a href="https://medium.com/linkit-intecs">LinkIT</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why Installing Software on Ubuntu Feels Hard at First: A Beginner’s Guide to Package Managers]]></title>
            <link>https://medium.com/@pabasarapasindu365/why-installing-software-on-ubuntu-feels-hard-at-first-a-beginners-guide-to-package-managers-7da57e26ce5f?source=rss-7b5da5b72c5a------2</link>
            <guid isPermaLink="false">https://medium.com/p/7da57e26ce5f</guid>
            <dc:creator><![CDATA[Pasindu Pabasara]]></dc:creator>
            <pubDate>Sun, 09 Nov 2025 05:48:57 GMT</pubDate>
            <atom:updated>2025-11-09T05:48:57.016Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*YZurPkYXXidyMGHK.jpg" /></figure><p>When students move to Ubuntu for development or DevOps labs, they expect a clean and fast system. I felt the same when I switched for the first time. Everything looked sharp and simple, until I tried to install my first program.</p><p>On Windows life had always been easy. I would download an installer, double click, and watch a setup window appear. It was so familiar that I never thought about how it worked. Ubuntu greeted me with a different world. There were no .exe files to run. No friendly wizard guiding each step. Instead, the system wanted commands and repositories. It talked about package managers as if everyone already knew what they were.</p><p>At that moment Linux felt a little intimidating. It looked harder than it actually was. Later I learned that Ubuntu was not being complex on purpose. Its method of installing software is simply different. Once you understand that method, the system becomes steady, predictable, and much easier to maintain than the old installer-based approach.</p><h3>Understanding Package Managers</h3><p>Ubuntu does not rely on standalone installers like Windows. Instead, it uses <strong>package managers</strong> to fetch, install, and maintain software. The main tools are:</p><ul><li><strong>APT - </strong>the standard package manager for most system software.</li><li><strong>Snap -</strong> universal, sandboxed packages maintained by developers.</li><li><strong>Flatpak -</strong> cross-distribution apps for desktop software outside Ubuntu repositories.</li></ul><p>Package managers track dependencies, ensure updates are safe, and allow easy removal of software. Unlike Windows, Ubuntu keeps your system clean and organized.</p><h3>Installing Software with APT</h3><p>APT is the backbone of Ubuntu software management. It connects to official repositories and installs programs along with their dependencies.</p><p>Example:</p><pre>sudo apt update<br>sudo apt install vlc</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sPLyAqaSDywdPjx9C8YErA.png" /></figure><ul><li>update refreshes the list of available software.</li><li>install downloads the program and its required libraries.</li></ul><p>APT makes installation reliable, but beginners may feel confused by the Terminal or package names that differ from their Windows equivalents.</p><h3>Using Snap and Flatpak</h3><p>Not all software is available via APT. Developers often distribute apps through <strong>Snap</strong> or <strong>Flatpak</strong>. These formats bundle all required dependencies inside a single package, which avoids conflicts with the system. Because of this bundling, Snap and Flatpak packages are generally <strong>larger and heavier</strong> than APT packages, which can result in longer installation times and slightly slower startup.</p><p>Example:</p><pre>sudo snap install postman<br>flatpak install flathub com.spotify.Client</pre><p>Despite being heavier, Snap and Flatpak give access to <strong>newer software versions</strong> and <strong>cross-distribution compatibility</strong>, making them valuable for applications not included in the standard Ubuntu repositories.</p><h3>Why Ubuntu Feels Hard Initially</h3><p>Several factors contribute to the initial difficulty:</p><ol><li><strong>No GUI:</strong> Installation happens via commands, which feels unfamiliar.</li><li><strong>Different software names:</strong> The app you want may have a different package name in the repository.</li><li><strong>Dependency management:</strong> Ubuntu installs shared libraries separately, which can overwhelm beginners.</li><li><strong>Multiple package systems:</strong> APT, Snap, and Flatpak can confuse new users.</li></ol><p>Once you understand the logic behind these systems, Ubuntu becomes easier to navigate than Windows.</p><h3>Conclusion</h3><p>Installing software on Ubuntu can feel intimidating at first, especially if you’re used to Windows. But once you understand how package managers work, it all starts to make sense. APT, Snap, and Flatpak aren’t just technical tools, they’re ways to keep your system organized, secure, and easy to maintain.</p><p>With a little practice, you’ll find that installing, updating, and managing software on Ubuntu becomes straightforward and even satisfying. What once felt confusing will turn into a skill that makes your work faster, cleaner, and more reliable.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7da57e26ce5f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Prometheus and Grafana 101: The First Dashboard.]]></title>
            <link>https://medium.com/@pabasarapasindu365/prometheus-and-grafana-101-the-first-dashboard-6d4dca3f5540?source=rss-7b5da5b72c5a------2</link>
            <guid isPermaLink="false">https://medium.com/p/6d4dca3f5540</guid>
            <dc:creator><![CDATA[Pasindu Pabasara]]></dc:creator>
            <pubDate>Thu, 16 Oct 2025 12:55:15 GMT</pubDate>
            <atom:updated>2025-10-16T12:55:15.199Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/500/1*ctqC_ftJ-gDzcOmYyQ-FQg.png" /></figure><h3>Introduction: The Fire of Prometheus</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/850/1*0EyzGAYa0i5fncz3YMDXWw.jpeg" /></figure><p>You’ve probably heard of <em>Prometheus</em>, the movie, or maybe the myth that inspired it.In Greek mythology, Prometheus was the Titan who stole fire from the gods and gave it to humanity.That single act changed everything. Fire brought light, warmth, and the spark of discovery.</p><p>In the world of technology, Prometheus does something similar.It steals the hidden “fire” of data from our systems and brings it to us in a form we can understand.When paired with Grafana, that fire becomes vision.Grafana transforms streams of raw data into vibrant dashboards, allowing us to see our systems come alive.</p><p>I still remember the first time a Grafana graph moved in real time.t felt almost magical, watching data turn into color and numbers come alive on the screen.Just hours earlier, I had been lost in a sea of raw metrics from Prometheus, unsure what any of them truly meant.But the moment that line on the dashboard began to pulse, something clicked.For the first time, I could actually see what was happening inside my system.</p><p>That experience taught me something important.Monitoring isn’t just about numbers or alerts.It’s about understanding your system’s behavior, its health, and its rhythm.And that understanding starts with two powerful open-source tools: <strong>Prometheus and Grafana</strong>.</p><h3>What is Prometheus</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/707/1*cadXnypzGS9sgovduyxP8A.png" /></figure><p>Prometheus is an open-source monitoring and alerting toolkit that was originally developed at SoundCloud in 2012 (Prometheus Authors, 2024).<br>It has since become one of the most widely used monitoring tools in the DevOps and cloud-native world, now governed by the <strong>Cloud Native Computing Foundation (CNCF)</strong>.At its core, Prometheus is designed to collect metrics, numerical data about your systems and store them as time series.</p><p>Unlike many other monitoring systems, Prometheus uses a <strong>pull-based model</strong>.Instead of waiting for applications to send data, Prometheus actively scrapes metrics from endpoints at regular intervals.Each metric it collects is labeled and timestamped, allowing you to filter, query, and analyze data precisely.This design makes Prometheus efficient, flexible, and easy to scale.</p><p>One of Prometheus’s most powerful features is <strong>PromQL</strong>, a dedicated query language for time-series data. With PromQL, you can ask detailed questions like, “What is the average CPU usage over the last five minutes?” or “Which service is consuming the most memory?”These queries become the foundation of visualizations and alerts.</p><p>Prometheus also includes an <strong>Alertmanager</strong>, which processes alert rules you define.It can send notifications to email, Slack, or other channels when something goes wrong.In a modern DevOps environment, this kind of proactive alerting can save hours of debugging.</p><h3>What is Grafana</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oj7a4EXjr7AOqfWd6Vrc1A.png" /></figure><p>While Prometheus is excellent at collecting and storing data, Grafana brings that data to life.Grafana is an open-source visualization and analytics platform created by Torkel Ödegaard in 2014.It connects to multiple data sources, including Prometheus, InfluxDB, Elasticsearch, MySQL, and many more.</p><p>With Grafana, you can build <strong>interactive dashboards</strong> that transform numbers into visual stories.Graphs, gauges, heatmaps, and panels help you see trends, spot anomalies, and understand how your systems behave over time.You can set up thresholds that change colors when performance drops or panels that show real-time updates every few seconds.</p><p>Grafana is also built for collaboration.You can share dashboards with teammates, embed panels in reports, and even set up alert notifications directly from the interface.t turns monitoring into something visual, accessible, and almost artistic.</p><h3>Why Prometheus and Grafana Work So Well Together</h3><p>Prometheus and Grafana complement each other perfectly.Prometheus focuses on <strong>data collection and alerting</strong>, while Grafana focuses on <strong>visualization and analysis</strong>.When you connect them, you get a complete monitoring stack.</p><p>Here is how it works in practice:</p><ol><li>Prometheus scrapes metrics from your systems and stores them as time series.</li><li>Grafana connects to Prometheus as a data source.</li><li>Dashboards in Grafana query Prometheus in real time to display updated graphs and panels.</li></ol><p>Together, they help you understand your systems holistically.You can see how CPU usage, memory, and network traffic evolve, all from a single dashboard.When performance drops, you can trace the issue quickly using historical data.</p><h3>Conclusion: Seeing the System Breathe</h3><p>When I built my first Prometheus and Grafana dashboard, it felt like watching my system take its first breath.Every curve, every color, every metric told a part of the story that had been invisible before.Since then, I’ve learned that monitoring isn’t just a technical task.It’s a way of understanding how our digital creations live and respond to the world.</p><p>Prometheus and Grafana together make that possible.They turn complexity into clarity, chaos into calm. And for anyone building systems today, that clarity is the first step toward true observability.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6d4dca3f5540" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>