Forem: Pasindu Dewviman

Mastering Fitts’s Law: Designing for Speed and Accuracy

Pasindu Dewviman — Thu, 12 Mar 2026 15:41:49 +0000

In the world of UI/UX design, Fitts’s Law is a fundamental principle used to predict human movement and interaction. Originally proposed by psychologist Paul Fitts in 1954, it describes the relationship between the time it takes to move to a target and the physical characteristics of that target.

For digital designers, this law is the secret to creating interfaces that feel "fast" and "effortless."

The Core Concept

Fitts's Law can be summarized by two main variables:

Distance: The farther away a target is from the user's current pointer (or thumb) position, the longer it takes to reach.

Size: The smaller a target is, the more precision is required, which increases the time and mental effort needed to click or tap it.

In simple terms: Large targets that are close to the user are the easiest to hit.

Practical Applications for Modern Design

To build a high-performing product, you should apply Fitts's Law in the following ways:

Optimize Touch Targets for Mobile
Finger-driven interfaces require larger targets than mouse-driven ones. According to industry standards (like Apple’s Human Interface Guidelines), a touch target should be at least 44x44 pixels. This prevents "fat-finger" errors where a user accidentally taps the wrong button.
Utilize the "Thumb Zone"
Most users navigate mobile devices with one hand. Place high-frequency actions—like "Search," "Add to Cart," or "Next"—within the bottom third of the screen. This area is the most accessible for the thumb, reducing the "travel distance" and making the app feel more responsive.
Group Related Actions
If a user fills out a form, the "Submit" button should be placed immediately following the last input field. Forcing a user to move their cursor or hand to the opposite side of the screen creates unnecessary friction and slows down the workflow.
Leverage "Infinite" Targets
In desktop design, the edges and corners of the screen act as "infinite targets." This is because a user can throw their mouse toward the corner without worrying about overshooting. This is why the Start Menu in Windows or the Apple Menu in macOS are placed in corners—they are the fastest targets to hit.

Key Takeaway

Fitts’s Law isn't about making every button giant. It is about strategic sizing and placement. By making critical actions large and placing them in "high-comfort" zones, you reduce the physical and mental effort required to use your product.

Jakob’s Law in UI/UX Design

Pasindu Dewviman — Wed, 11 Mar 2026 16:21:21 +0000

Jakob’s Law is a very important rule in digital design. It states that users spend most of their time on other websites. Because of this, they expect your website or app to work in the same way as all the other ones they already know.

The Power of Familiarity

When people visit a new website, they bring their past experiences with them. If your design uses standard patterns, users do not have to think hard to understand it. If you try to be too unique with basic features, users will get confused and might leave.

How to Apply Jakob’s Law

You can make your designs much more user-friendly by following these ideas:

Use Standard IconsA magnifying glass means search. A shopping cart means checkout. Do not change these common symbols because users instantly know what they mean.
Place Elements Where ExpectedPeople expect the main menu to be at the top or on the left side. They expect clicking the main logo to take them back to the home page. Keep these basic structures the same.
Do Not Reinvent the WheelIt is good to be creative with your colors, images, and brand message. However, the way a user navigates and interacts with your site should remain standard and familiar.

Summary

Building a familiar interface helps users feel safe and confident. When they do not have to learn how to use your site, they can focus entirely on your content or product.

Understanding Hick’s Law in UI/UX Design

Pasindu Dewviman — Tue, 10 Mar 2026 13:55:15 +0000

Hick’s Law is a psychological principle used in design to improve user experience. It states that the time it takes for a person to make a decision increases with the number and complexity of choices available. In simple terms, more options lead to more confusion and slower action.

The Problem of Choice Overload

When a user visits a website or opens an app, their brain has a limited amount of processing power. This is called cognitive load. If you present them with a long list of menu items or dozens of buttons at once, they might feel overwhelmed. This often results in "analysis paralysis," where the user decides to do nothing and leaves the site.

How to Apply Hick’s Law

You can make your designs more effective by following these simple steps:

Reduce the Number of Options
Remove unnecessary buttons or links. Only show the most important actions to the user.
Break Down Complex Tasks
If a process is long, like a checkout or a registration form, break it into smaller steps. This makes the task feel less intimidating.
Categorize Information
Use menus and sub-menus. Grouping similar items together helps users find what they need without looking at every single option.
Highlight Recommended Actions
Use color or size to guide the user toward the "next step" you want them to take.

When to Use It
Hick’s Law is most important when users need to act quickly, such as during a checkout process or when navigating a dashboard. However, do not over-simplify to the point where the user cannot find what they need. The goal is to find a balance between providing enough information and keeping the interface clean.

Summary

By minimizing choices, you reduce the mental effort required from your users. This leads to a faster, more enjoyable experience and increases the chances of them completing a task.

GitHub හි පරණ Commit එකක් නැවත ලබාගන්නේ කොහොමද?

Pasindu Dewviman — Sun, 08 Mar 2026 12:25:54 +0000

වැඩ කරගෙන යන අතරතුර අත්වැරදීමකින් වැදගත් Branch එකක් Delete වුණොත් හෝ වැරදි Commit එකක් නිසා කේතය (Code) අවුල් වුණොත් මොකද කරන්නේ? ගොඩක් දෙනෙක් හිතන්නේ ඒ දත්ත සදහටම නැති වුණා කියලා.

නමුත් Git Reflog හරහා ඔබට නැති වූ ඕනෑම දෙයක් නැවත ලබාගන්න පුළුවන්.

මැකුණු Branch එකක් නැවත ලබා ගැනීම ඔබ වැදගත් Branch එකක් Delete කළත්, Git විසින් එහි අවසාන තොරතුරු ටික කාලයකට මතක තබා ගන්නවා. එය නැවත ලබාගන්න මේ පියවර අනුගමනය කරන්න:

✅ මුලින්ම ඔබේ Terminal එකේ git reflog ලෙස Type කරන්න.
එවිට ඔබට ඔබ කළ සියලුම ක්‍රියාකාරකම් වල ලැයිස්තුවක් (History) දැකගන්න ලැබෙයි.

✅ එහි ඔබ Delete කළ Branch එකේ තිබූ අවසාන Commit එකට අදාළ Commit ID (උදා: e3a4f52) එක සොයාගන්න.

✅ දැන් පහත Command එක භාවිතා කර නව Branch එකක් සාදා ගන්න: git checkout -b [new-branch-name] [commit-id]

පරණ Commit එකකට ආපසු යන්නේ කොහොමද? ඔබ කළ අලුත් වෙනස්කම් (Changes) නිසා Project එකේ Errors එනවා නම්, ඔබට ඉතා පහසුවෙන් කලින් තිබූ හොඳ තත්වයකට (Previous Commit) ආපසු යන්න පුළුවන්.

✅ පරීක්ෂා කිරීමට (Temporary Check): ඔබට නිකම්ම ඒ පරණ Code එක බලන්න විතරක් ඕනේ නම්: git checkout [commit-id]

✅ සම්පූර්ණයෙන්ම ආපසු හැරවීමට (Permanent Reset): ඔබට අලුත් වෙනස්කම් සියල්ල මකා දමා පරණ Commit එකටම යන්න ඕනේ නම්: git reset --hard commit-id

කල්පනා කළ යුතු කරුණු:
git reflog මගින් දත්ත පෙන්වන්නේ සීමිත කාලයකට පමණි (සාමාන්‍යයෙන් දින 30-90).

වැදගත් වෙනස්කම් කිරීමට පෙර සැමවිටම වෙනත් Branch එකක් භාවිතා කරන්න.

GitHub #GitTips #SoftwareEngineering #Coding #Sinhala #GitReflog #WebDevelopment

Guarding the Sinhala Web: Building Suba Bhas with Google Gemini

Pasindu Dewviman — Tue, 03 Mar 2026 05:10:06 +0000

This is a submission for the Built with Google Gemini: Writing Challenge

What I Built with Google Gemini

The Suba Bhas is a browser extension and AI-powered filter designed to make the internet a safer space for Sinhala speakers. It acts as a real-time "shield" that detects offensive language and hate speech on web pages and automatically blurs it out.

The Problem: Online toxicity in local languages like Sinhala often goes undetected by global moderation tools.
The Tech: I built a Flask-based backend to serve a Bi-LSTM model trained on the SOLD (Sinhala Offensive Language Dataset).
Gemini's Role: I used Google Gemini to help architect the system, debug the complex JavaScript for the DOM observer (which scans the text in real-time), and refine the logic for dynamic keyword extraction. Gemini was also instrumental in helping me translate technical concepts between the Python backend and the Chrome extension frontend.

Demo

Github Link - [https://github.com/itspasindu/Suba-Bas-Project]

What I Learned

Building this was a massive learning curve. I improved my skills in:

atural Language Processing (NLP): Handling the unique nuances of the Sinhala script and offensive context.
Full-Stack Integration: Connecting a JavaScript extension to a Python Flask API seamlessly.
Soft Skills: I learned the importance of "ethical AI"—designing tools that protect users without over-censoring helpful content.
Unexpected Lesson: I realized how difficult real-time web scraping can be when you're trying to blur text without slowing down the user's browser.

Google Gemini Feedback

The Good: Gemini was incredibly fast at suggesting fixes for my Flask routes and helped me understand how to handle CORS issues between the extension and the server. It acted like a senior developer sitting right next to me.
The Friction: Sometimes, when I asked about specific Sinhala NLP libraries, Gemini would occasionally suggest generic English-centric models. I had to be very specific in my prompts to ensure the AI understood I was working with a low-resource language like Sinhala.

The burning AWS UAE facility, showing the physical impact of the attack on the "mec1-az2" zone.

Pasindu Dewviman — Tue, 03 Mar 2026 04:54:03 +0000

Amazon Web Services (AWS) is currently racing to restore power to its Middle East infrastructure after "unidentified objects" struck a key data center in the United Arab Emirates on Sunday, sparking a massive fire and knocking critical services offline.

❗The Incident: Direct Hit on 'mec1-az2'
At approximately 4:30 AM local time on March 1, AWS confirmed that its facility in the ME-CENTRAL-1 region (UAE) was impacted by external objects. The strike triggered immediate sparks and a fire within the building.

To ensure the safety of emergency crews, the local fire department ordered a complete shutdown of all electrical systems and backup generators. This effectively "blacked out" Availability Zone mec1-az2, causing an immediate ripple effect across the global digital economy.

While AWS has officially used the neutral term "objects," the incident occurred during a night of heavy military escalation.

❗Retaliatory Strikes: The strike coincided with a barrage of Iranian missiles and drones targeting the UAE and other Gulf states.

❗Wider Disruption: By Monday morning, AWS reported "localized power issues" in its Bahrain region (ME-SOUTH-1) as well, suggesting the conflict is physically straining the backbone of the regional internet.

❗Historic Precedent: Analysts note this may mark the first time a major U.S. "hyperscale" data center has been directly knocked offline by military kinetic action.

❗Global and Local Impact
The outage has paralyzed services for thousands of customers:

❗Banking & Finance: Major regional institutions, including Abu Dhabi Commercial Bank, reported significant disruptions to mobile and online banking apps.

❗AI & Tech: Traffic for global AI platforms like Claude (Anthropic) was rerouted, leading to increased latency and "network spikes" as data was forced through servers in Europe and the US.

❗Service Failures: Core AWS services, including EC2 (virtual servers), S3 (storage), and Lambda, saw high error rates. Launching new instances in the UAE region remains impossible as of Monday afternoon.

AWS engineers are currently awaiting safety clearance to re-energize the facility. The company warned that full restoration will take "at least a day," as cooling, power systems, and physical hardware must be inspected for structural damage before being brought back online.

"This incident highlights that while the cloud feels virtual, it lives in physical buildings that are vulnerable to the realities of war," said one regional tech analyst.

AWS continues to advise all customers to move their workloads to unaffected regions like Europe (Ireland) or US-East until the ME-CENTRAL-1 region is fully stabilized.

aws #awsdown #cluade #galfwar #MiddleEastConflict #UAE #Bahrain #AWSOutage #CloudSecurity #DataCenterFire #Geopolitics

Understanding WebSockets

Pasindu Dewviman — Sun, 01 Feb 2026 15:18:48 +0000

WebSockets are a technology that helps computers talk to each other in real-time. If you have ever used a chat app, watched a live sports score update without refreshing the page, or played a multiplayer game online, you have likely used WebSockets.

They allow a user's web browser and a server to keep a connection open constantly. This lets them send messages back and forth instantly.

How the Standard Web Works (HTTP)

To understand why WebSockets are special, we first need to look at how the web normally works. This is called HTTP.

Think of HTTP like sending a letter.

The client (your browser) sends a request (the letter) to the server asking for information.
The server receives the request, finds the information, and sends a response back.
Once the response is sent, the connection closes.

If you want new information, you have to send another letter. This is safe and reliable, but it is slow for things that need to happen instantly.

The WebSocket Difference

WebSockets work differently. Instead of sending a letter, think of WebSockets like a phone call.

The client calls the server.
The server answers.
Now, both sides can talk and listen at the same time.
The line stays open until one side decides to hang up.

Because the line stays open, the server does not have to wait for the client to ask for updates. If the server has new data (like a new chat message), it can push it to the client immediately.

How the Connection Starts

A WebSocket connection starts with a standard HTTP request. This is often called the "handshake."

The client sends a normal request to the server but adds a special note asking to upgrade the connection to a WebSocket.

If the server agrees, it sends back a confirmation code.

The standard HTTP connection switches over to a WebSocket connection.

From that moment on, the heavy rules of HTTP are dropped. Data flows freely and quickly between the two.

When to Use WebSockets

WebSockets are best for applications where speed is the most important factor.

Chat Applications: Messages need to appear instantly for everyone in the room.
Live Sports Tickers: Scores must update the second a goal is scored.
Multiplayer Games: Players need to see where other players are moving in real-time.
Collaborative Editing: When two people write on the same document (like Google Docs), they need to see each other's typing immediately.

Summary

WebSockets changed the internet from a place where you request information to a place where information flows to you. By keeping a permanent channel open between the user and the server, developers can build fast, interactive experiences that feel immediate.

How Your Computer Actually Reads Code: The Magic of Abstract Syntax Trees

Pasindu Dewviman — Sun, 18 Jan 2026 05:43:23 +0000

When we write code, we see lines of text. We see keywords, brackets, and variable names. But when a computer looks at that same code, it sees something completely different. It does not read top-to-bottom like a human reads a book. Instead, it turns that text into a structure called an Abstract Syntax Tree, or AST.

If you have ever wondered how tools like Prettier format your code automatically, or how compilers turn high-level languages into machine code, the answer usually lies in the AST.

What is an Abstract Syntax Tree?

An AST is a data structure that represents the logic of your code in a tree format.

Think of a sentence in English. You can diagram that sentence by breaking it down into a subject, a verb, and an object. An AST does the same thing for programming languages. It breaks a line of code down into its essential parts.

It is called "Abstract" because it throws away details that do not affect the logic, such as:

Whitespace (spaces and tabs)
Comments
Parentheses (the tree structure itself shows the order of operations)

Visualizing the Tree

Imagine a simple math operation: 5 + 3 * 6

If a computer read this strictly left-to-right, it might calculate 5 + 3 first, which is wrong. We know that multiplication happens before addition.

An AST solves this by creating a hierarchy. The multiplication 3 * 6becomes a branch that sits deeper in the tree than the addition. The computer solves the deeper branches first.

In this tree:

The root node is the Addition (+).
The left child is the number 5.
The right child is another operation, the Multiplication (*).
That multiplication node has two children: 3 and 6.

This structure makes it impossible for the computer to get the order of operations wrong.

From Text to Tree

The process of creating an AST generally happens in two main steps:

Lexical Analysis (Scanning) The compiler reads your raw code string and breaks it into a list of "tokens." A token is a tiny unit of meaning, like a keyword, an operator, or a variable name. It is like taking a sentence and chopping it into individual words.

Syntax Analysis (Parsing) The parser takes that list of tokens and arranges them into the tree structure. It validates that the tokens follow the rules of the language. If you miss a semicolon or use a keyword wrong, this is usually where the "Syntax Error" happens.

Why Should You Care?

You might think ASTs are only for people who build compilers. However, if you are a modern developer, you likely use tools powered by ASTs every single day.

Linters (like ESLint) Linters do not just scan your code for text matches. They turn your code into an AST to understand the logic. This allows them to spot complex errors, like a variable that is defined but never used, or a function that returns the wrong value.

Formatters (like Prettier) Prettier ignores your original style. It takes your code, builds an AST, and then prints the code back out from scratch using its own rules. This is why it can fix your indentation perfectly every time.

Transpilers (like Babel) When you write modern JavaScript but need it to run on old browsers, Babel uses an AST. It parses your modern code into a tree, changes the nodes that old browsers do not understand into nodes they do understand, and then turns that tree back into code.

Summary

The Abstract Syntax Tree is the bridge between human-readable text and machine-executable logic. It is the hidden backbone of modern software development. Understanding it helps you understand how your tools work and how to write better, cleaner code.

Next time you see a syntax error or watch your code auto-format, remember: it is all thanks to the tree.

Why MCP Servers Change Everything

Pasindu Dewviman — Mon, 05 Jan 2026 11:59:09 +0000

We all know that AI models like Claude and ChatGPT are powerful. They can write code, summarize books, and answer complex questions. But they have a big problem.

They are blind to your actual work.

Your AI does not know what is in your database. It cannot see your company’s internal documents. It cannot check your latest code commit on GitHub. Until now, connecting AI to your data required writing complex, custom code for every single tool.

This is where the Model Context Protocol (MCP) comes in. It is being called the "USB-C for AI applications," and it is going to change how we build software.

🤖 The Problem: AI is Isolated
Imagine hiring a brilliant assistant but locking them in an empty room. They have read every book in the world, but they cannot see the files on your desk. If you want them to do a task, you have to describe every detail manually.

This is how most AI works today. It is isolated from your data.

Developers usually fix this by building "pipelines" to feed data into the AI. But this is hard work. You have to build a different pipeline for Google Drive, another for Slack, and another for your SQL database. If you change your AI model, you often have to rebuild everything.

🤖 The Solution: MCP Servers
MCP stands for Model Context Protocol. It is an open standard that lets AI models talk to data sources in a universal language.

Think of it like a universal plug.

Before MCP: You build a specific connector to link Claude to your Postgres database.

With MCP: You install a "Postgres MCP Server." Now, Claude can read the database. But so can any other AI tool that supports MCP.

You build the connection once, and it works everywhere.

🤖 How It Works Simply
The system has three parts working together:

The Host: This is the app you are using, like the Claude Desktop app or an IDE like Cursor.

The Client: This connects the Host to the Server.

The Server: This is the special bridge. It sits on top of your data (like your files or database) and translates it so the AI can understand it safely.

🤖 Why Developers Are Excited
This standard solves the biggest headache in AI development: Context.

Build Once, Use Everywhere If you write an MCP server for your company's internal API, you can use it with different AI agents instantly. You do not need to rewrite the integration when a new, better AI model comes out.

Real-Time Data The AI is not just guessing based on old training data. It is looking at your live data. If you ask, "What is the latest error in the logs?" the MCP server lets the AI look at the actual logs right now.

Better Security You do not have to upload all your data to the AI company's cloud. The MCP server runs locally on your machine or your infrastructure. You control exactly what the AI can and cannot see.

🤖 The Future of "Agentic" AI
We are moving away from AI that just talks to us. We are moving toward "Agents"—AI that can take action.

For an Agent to be useful, it needs tools. It needs to be able to search the web, read a file, or query a database. MCP provides those tools in a standard way.

In the near future, you will not just chat with an AI. You will tell it, "Check the inventory database and email the supplier if we are low on stock."

Because of MCP servers, the AI will actually be able to do it.

Securing React Application

Pasindu Dewviman — Sun, 28 Dec 2025 13:22:42 +0000

React Application එකක් හදනකොට අපි ගොඩක් වෙලාවට Performance සහ UI එක ගැන වද උනාට, Security පැත්ත ගැන හිතනවා මදි නේද? 🤔

React කියන්නේ safe framework එකක් තමයි, ඒත් අපි නොදැනුවත්වම කරන පුංචි වැරදි නිසා මුළු application එකම අනතුරේ වැටෙන්න පුළුවන්. 2025 දී React App එකක් Secure කරගන්න නම් මේ දේවල් අනිවාර්යයෙන්ම බලන්න ඕන. 👇

🔐 1. dangerouslySetInnerHTML පාවිච්චිය සීමා කරන්න React වලින් XSS (Cross-Site Scripting) නවත්වන්න default protection එකක් දෙනවා. හැබැයි ඔයා manual HTML render කරන්න dangerouslySetInnerHTML පාවිච්චි කරනවා නම්, අනිවාර්යයෙන්ම DOMPurify වගේ library එකක් පාවිච්චි කරලා ඒ content එක sanitize කරගන්න. නැත්නම් hacker කෙනෙක්ට ලේසියෙන්ම malicious scripts run කරන්න පුළුවන්.

🛡️ 2. Authentication Tokens පරිස්සම් කරන්න (LocalStorage vs. Cookies) JWT Tokens හෝ Session ID කවදාවත් localStorage එකේ save කරන්න එපා. XSS attack එකකදී attackers ලට ලේසියෙන්ම localStorage access කරන්න පුළුවන්. ඒ වෙනුවට HttpOnly Cookies පාවිච්චි කරන්න. ඒක ගොඩක් ආරක්ෂිතයි.

🔗 3. URL Based Attacks වලින් ප්‍රවේශම් වෙන්න User කෙනෙක් input කරන link එකක් කෙලින්ම a tag එකේ href එකට දානකොට පරිස්සම් වෙන්න. කෙනෙක්ට පුළුවන් javascript:alert('Hacked') වගේ malicious code එකක් ඒ හරහා execute කරන්න. හැමවිටම link එක http හෝ https වලින් පටන් ගන්නවද කියලා validate කරන්න.

📦 4. Dependencies Update කරලා තියාගන්න React වල විතරක් නෙවෙයි, අපි පාවිච්චි කරන third-party libraries වලත් vulnerabilities තියෙන්න පුළුවන්. නිතරම npm audit run කරලා බලන්න. පරණ වෙච්ච packages (outdated dependencies) අප්ඩේට් කරගන්න.

backend එකේ validation නැතුව කවදාවත් client-side validation මත විතරක් යැපෙන්න එපා. Frontend එක කොච්චර secure කරත්, Backend එකේ security එක තමයි වැදගත්ම දේ! 💯

ReactJS #WebSecurity #CyberSecurity #SoftwareEngineering #WebDevelopment #CodingLife #SinhalaTech

Building a REST API in Go (Golang)

Pasindu Dewviman — Wed, 24 Dec 2025 17:30:54 +0000

Go, also known as Golang, is renowned for its simplicity, performance, and built-in concurrency support, making it an excellent choice for building RESTful APIs. Companies like Docker, Kubernetes, and Uber rely on Go for high-performance backend services. In 2025, Go continues to dominate API development due to its efficiency and robust ecosystem.

What is a REST API?

REST (Representational State Transfer) is an architectural style for designing networked applications. It uses standard HTTP methods to perform CRUD operations on resources:

GET: Retrieve a resource
POST: Create a resource
PUT/PATCH: Update a resource
DELETE: Delete a resource

Resources are identified by URLs (e.g., /users/123), and responses are typically in JSON format.

Why Choose Go for REST APIs?

Performance: Compiled to machine code with low latency and high throughput.
Concurrency: Goroutines handle thousands of requests efficiently.
Standard Library: net/http provides everything needed for basic servers.

Options for Building REST APIs in Go

Standard Library (net/http) Ideal for learning or lightweight APIs. Go 1.22+ improved ServeMux with method-specific routing (e.g., HandleFunc("GET /users", handler)). Example basic server:

package main

import (
    "encoding/json"
    "net/http"
)

type User struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
}

var users = []User{{ID: 1, Name: "Alice"}}

func getUsers(w http.ResponseWriter, r *http.Request) {
    if r.Method != http.MethodGet {
        http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
        return
    }
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(users)
}

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("GET /users", getUsers)
    http.ListenAndServe(":8080", mux)
}

Building a Simple REST API with Gin

Let's create a basic user management API.

Setup:Bashgo mod init rest-api-example go get github.com/gin-gonic/gin

Code (main.go):

package main

import (
    "net/http"

    "github.com/gin-gonic/gin"
)

type User struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
}

var users = []User{{ID: 1, Name: "Alice"}}

func main() {
    r := gin.Default()

    r.GET("/users", getUsers)
    r.GET("/users/:id", getUser)
    r.POST("/users", createUser)

    r.Run(":8080")
}

func getUsers(c *gin.Context) {
    c.JSON(http.StatusOK, users)
}

func getUser(c *gin.Context) {
    id := c.Param("id")
    // Parse and find user...
    c.JSON(http.StatusOK, gin.H{"id": id})
}

func createUser(c *gin.Context) {
    var newUser User
    if err := c.BindJSON(&newUser); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
        return
    }
    users = append(users, newUser)
    c.JSON(http.StatusCreated, newUser)
}

Golang Concurrency සරලව - Buffered Channels

Pasindu Dewviman — Tue, 23 Dec 2025 14:14:57 +0000

අද අපි බලමු වැදගත් කොටසක් වන Buffered Channels ගැන. මේකත් අපි අපේ සුපුරුදු "කුස්සියේ උදාහරණයෙන්" (Kitchen Analogy) තේරුම් ගනිමු.

සාමාන්‍ය Channel එකේ ගැටලුව (Unbuffered Channels)
අපි කලින් ඉගෙන ගත්ත සාමාන්‍ය Channel එකක් හරියට අතින් අතට බඩු මාරු කරනවා වගේ වැඩක්.

Chef (Sender): පීසා එකක් හැදුවොත්, වේටර් (Receiver) ඇවිත් ඒක අතට ගන්නකම් Chef ට ඒක අතේ තියාගෙන බලන් ඉන්න වෙනවා (Block වෙනවා).

වේටර් ආවේ නැත්නම්, Chef ට ඊළඟ පීසා එක හදන්න බැහැ. කුස්සිය හිරවෙනවා.

විසඳුම: Buffered Channels (බෆර්ඩ් චැනල්ස්) 📦
Buffered Channel එකක් කියන්නේ හරියට කුස්සියේ තියෙන කෑම මේසයක් වගේ. වේටර් එනකම් බලන් ඉන්නේ නැතුව, Chef ට පුළුවන් හදපු කෑම පිඟන් ටික මේසෙ උඩින් තියලා දිගටම උයන්න.

Go වලදී අපි මේකට "Buffer Capacity" (ධාරිතාව) කියලා කියනවා.

Code Example:

package main

import "fmt"

func main() {
    // අපි මේසයක් හදනවා පීසා 3ක් තියන්න පුළුවන් (Capacity = 3)
    // දැන් Chef ට වේටර් නැති වුනත් පීසා 3ක් මේකේ තියන්න පුළුවන්.
    kitchenTable := make(chan string, 3)

    // පීසා මේසෙට යවනවා (Send)
    kitchenTable <- "Pizza 1"
    kitchenTable <- "Pizza 2"
    kitchenTable <- "Pizza 3"

    fmt.Println("Chef: මම පීසා 3ම හැදුවා. වේටර් තාම නෑ, ඒත් මම හිරවෙලා නෑ!")

    // 4 වෙනි එකක් දාන්න ගියොත් විතරක් Chef හිරවෙනවා (මොකද මේසෙ ඉඩ ඉවරයි).
}

මේ නිසා අපේ ප්‍රෝග්‍රෑම් එක වඩාත් කාර්යක්ෂම වෙනවා. මොකද යවන කෙනාට (Sender) ගන්න කෙනා (Receiver) එනකම් හැම වෙලාවෙම බලන් ඉන්න ඕනේ නැහැ.

Channel එක වසා දැමීම (Closing Channels) 🚪
කුස්සියේ වැඩ ඉවර වුනාම Chef අනිවාර්යයෙන්ම කියන්න ඕනේ "අදට වැඩ ඉවරයි, කුස්සිය වහනවා" කියලා. නැත්නම් වේටර්ලා (Receivers) රෑ එළි වෙනකම් හිස් කුස්සිය දිහා බලාගෙන ඉඳීවි (Deadlock).

Go වලදී අපි මේකට close() function එක පාවිච්චි කරනවා.

වැදගත්ම දේ: අපි Channel එකක් close කළාම, ගන්න කෙනාට (Receiver) දැනගන්න පුළුවන් "ආහ්! තව දත්ත එන්නේ නෑ" කියලා.

මේ සඳහා අපිට Range Loop එකක් පාවිච්චි කරන්න පුළුවන්.

Code Example:

package main

import "fmt"

func main() {
    orderQueue := make(chan string, 2)
    // Chef වෙනම වැඩ පටන් ගන්නවා (Goroutine)
    go func() {
        orderQueue <- "Burger"
        orderQueue <- "Fries"

        // වැඩ ඉවරයි! කුස්සිය වහනවා.
        close(orderQueue) 
        fmt.Println("Chef: කුස්සිය වැහුවා (Channel Closed)")
    }()

    // වේටර්: Channel එක close වෙනකම් එන හැම දේම ගන්නවා
    for order := range orderQueue {
        fmt.Println("Received:", order)
    }
    fmt.Println("Waiter: හරි, වැඩ ඉවරයි. මම ගෙදර යනවා.")
}

Output:

Received: Burger Received: Fries Chef: කුස්සිය වැහුවා (Channel Closed) Waiter: හරි, වැඩ ඉවරයි. මම ගෙදර යනවා.

වැදගත් කරුණු (Summary)

Buffered Channels (make(chan type, capacity)): දත්ත කිහිපයක් ගබඩා කර තැබිය හැකි Channels වේ. මෙය Sender සහ Receiver අතර තදබදය අඩු කරයි.
Closing Channels (close(ch)): දත්ත යවා අවසන් බව Receiver ට දැනුම් දීමට භාවිතා කරයි.
Range Loop (for msg := range ch): Channel එක close වන තුරු දිගටම දත්ත ලබා ගැනීමට මෙය භාවිතා කරයි.