Forem: Chamal Mallawaarachchi

Pyrefly: A new rust based Language Server for Python from Meta

Chamal Mallawaarachchi — Thu, 20 Nov 2025 07:04:05 +0000

Today, Meta has announced the first public beta of their new in-development open source Language Server for Python called Pyrefly.

According to Meta this was started as an in-house tool for their instagram developers as they were experiencing severe performance issues when navigating their codebases with exisiting Python tooling.

While there are other fast language servers like Ruff which doesn't perform static type checking, Pyrefly is aiming to be both faster and feature complete type cheker and a Language Server.

Key Features in the type checker:

Type Inference: Pyrefly infers types in most locations, apart from function parameters. It can infer types of variables and return types.
Flow Types: Pyrefly can understand your program's control flow to refine static types.
Incrementality: Pyrefly aims for large-scale incrementality at the module level, with optimized checking and parallelism.

Other than these, Pyrefly supports all the other features of Language Server Protocol (LSP) and generally the first thing you'll feel is the lightning fast autocomplete even in the dense codebases.

NOTE: As of the Beta release in November 2025, Pyrefly is over 70% conformant with the Python Typing Specification. So it might not be a good choice for your complex production codebase yet but I would recommend it for small personal projects. Meta also mentioned that many improvements are needed for third party libraries like Django.

A perormance comparison meta showcased

Wanna give it a try?

From browser

Meta has created a sandbox that you can jump in from the browser and test Pyrefly.

Pyrefly Sandbox - https://pyrefly.org/sandbox

By installing

Pyrefly is available in PyPI and can be installable from your favourite python package manager.

Below commands show you how can get started using some famous python package and runtime managers.

# using pip
pip install pyrefly
pyrefly init
pyrefly check --summarize-errors

# using conda
conda install -c conda-forge pyrefly
pyrefly init
pyrefly check --summarize-errors

# using uv
uvx pyrefly init
uvx pyrefly check --summarize-errors

IDE extensions?

Yes, Meta already provides IDE extensions for Pyrefly for all major IDEs.

For VSCode, you can easily get it from their marketplace.

For other code-oss based IDEs like Codium, the extension is available in openvsx.

Openvsx link - https://open-vsx.org/extension/meta/pyrefly

What about GOAT text editors?

Pyrefly is easily installable for Vim/Neovim, Emacs and Helix.

Refer this section - https://pyrefly.org/en/docs/IDE/#other-editors

More information and references

Pyrefly repository - https://github.com/facebook/pyrefly
Pyrefly Documentation - https://pyrefly.org/en/docs

Thank you for reading upto here ❤️.

How to use unsupported macbooks for modern software development

Chamal Mallawaarachchi — Sat, 15 Nov 2025 17:46:55 +0000

If you clicked on this, chances are either you own an old unsupported macbook or willing to buy one to kickstart your development journey.

Hey, that's a great decision in my opinion. If you don't have enough money to jump to a new MacBook, do not go for cheap Windows laptops. Instead consider an old MacBook.

But why?

Coz they have great displays. You will be starring at text for the rest of the journey so why not go for a better display?
Great keyboards (except the 2016-2017 models)
Great webcams, speakers and battery backup.
MacOS is optimized for MacBooks and probability of you getting into OS related bugs are very low compared to a Windows machine.
Looks sleek, well built, good hinge mechanisms, auto brightness for both keyboard and display and many more quality of life things that most cheap Windows laptops skips.
You can even install Windows alongside MacOS if there's something that isn't working for you in MacOS (Only on Intel MacBooks).

A note before going any further

Please do not buy unsupported macbooks for iOS or any apple application development. While you will be able to develop, you won't be able to publish those to appstore.

Here are some models that I recommend

2013-2015 models (super cheap)
2018-2019 models (if you can spend a little more)

Alright, Still in?

Cool, then from here on I'm gonna tell you exactly what you need to do once you get that old mac to set it up to get the best juice out of it.

Get a package manager up and running

For those who don't know, a package manager is a terminal based tool (most of the time) that makes managing software easier than installing with any other way. Most Unix like OSes comes with a one but MacOS doesn't for some reason. But we can install one. Homebrew is the most famous option but it only supports upto 3 latest MacOS versions and if yours aren't in that, every app you install with that will build from source. It's a nightmare. Don't install homebrew if you're even on the supported OS list as it will get unsupported soon and after that you can't go any OS beyond that.

Instead go for MacPorts package manager. It supports versions as old as El Capitan (Even a 2012 model can go beyond that version).

As long as you're on a model later than 2013, you'll have no problem installing modern software development kits like Java 21, Node.js latest, C/C++ 17, Flutter 3.x.x, Python 3.x.x, Dotnet 9 and etc.

Macports -> https://www.macports.org

Keep the OS lightweight

While this things is pretty expected to know by anyone but added this anyways in case some might think that they would be able to run whole bunch of heavy applications. Only keep neccessary applications and do not add anything if that thing is provided by OS itself.

Some things you get from MacOS by default,

A simple screen recorder and screenshot tool
Voice recorder
A color picker (Useful for webd dev and designing)
A camera app
Notes taking app
Music and video players

There's many more that MacOS has built in so definitely Google what you need to see if it already in the OS before going for a third party application.

Switch to CLI apps as much as possible

This is the most impactful trick and this also helps you to become a better software developer as well. Always stick to CLI apps as much as possible. There will be a steep learning curve but it's gonna reward you along the way. Belive me.

Some examples,

Use Git CLI instead of any GIT GUIs
Use terminal for files, and folder navigation.
Use things like grep, sed or awk for searching files
Use a terminal multiplexer to split the terminal instead of openning multiple terminal windows.
Skip code editors like VSCode or any of it's forks. They run on electron which takes a lot of CPU and RAM just to even keep it running without doing anything. Switch to efficient editors that provides native binaries. I'd recommend Emacs if you need a Graphical User Interface or VIM/Neovim if terminal is comfortable.

Do not customize your terminal too much

I have seen that customizing the terminal too much also affects older macs to get slow even inside the terminal.

Notable performance culprits I have noticed,

Do not use Starship to customize your prompt. Use powerlevel10k. They are similar in customization but starship takes a lot of CPU power which makes your terminal emulator laggy.

Use an efficient terminal emulator that supports true color

There's many. Choose something that fit's your liking. I recommend Alacritty or Kitty.

Alacritty -> https://alacritty.org
Kitty -> https://sw.kovidgoyal.net/kitty

Use Turbo Boost Switcher

A third party free software that use can use to turn off turbo boost when doing normal work. (I only enable turbo boost when compiling fairly large software)

Turbo Boost Switcher -> https://tbswitcher.rugarciap.com

Finally, Some etc tips!

If this MacBook is your first computer, it's better you understand how Unix works a little bit as well because it will help you to setup the computer, fix bugs and save from many other pifalls many new MacOS users face as developers.

Some things that I think you might needed,

[XDG Base Directory Specification]

(https://specifications.freedesktop.org/basedir/latest/)
While MacOS itself doesn't respect this, many applications that will use as a developer in MacOS will respect this spec. So give it a read so you won't be hammering ChatGPT or google search asking "where the heck is my config for X app or Y app" and end up with delusional answers utltimately breaking other apps.

[How manage environment variables]

(https://support.apple.com/en-is/guide/terminal/apd382cc5fa-4f58-4449-b20a-41c53c006f8f/2.12/mac/11.0)

[File System Hierachy Standard]

(https://en.wikipedia.org/wiki/Filesystem_Hierarchy_Standard)
You won't find all of the directories in this standard in MacOS as apple has done some modifications to this like /Library for an example. Nevertheless, you might find this useful. Just read it, try doing ls for each of those directories so you can know what you have, which you'll be able to use when you need them.

When you first try to see if git is available or a compiler is available, you'll be prompted to install xcode-commandline-tools which will install many other programs behind your back. (i.e. Python3, Git, Clang(MacOS C-compiler), curl, grep, rsync and few others). Why I'm telling this is that, while it is good that they get installed automatically but they're not the most upto date versions. So I recommend you to install upto date tools using a package manager like macports set it has the default using the environment variables.
Many kids start with web dev. So you might getinto trouble with npm failed to install packages when you try to install them globally.

New users eat their hair trying to fix this. The most simplest and easiest solution that I can suggest is creating a directory for npm global packages in the /home directory and assign it to npm using environment variables.

Let me leave it here in case you want to fix it quickly

$ pwd # make sure you're in home directory
/Users/<your-username>

$ mkdir .npm-global # create a directory

$ npm config set prefix '~/.npm-global' # Set the prefix config variable

$ vim .zshrc # open .zshrc file with a text-editor (i use vim here)

Paste the below line to it. Save and exit.

export PATH="$HOME/.npm-global/bin:$PATH"

source ~/.zshrc # reload zshell config

Now your npm global package installs will work!

That's it!

If you can bear with those things, I think you'll have a great overall experience.

Thank you for reading upto here ❤️.

Meet Asgardeo: Your last stop for IaaS

Chamal Mallawaarachchi — Fri, 14 Nov 2025 18:06:36 +0000

Are you using multiple services for manging authentication for your business/personal projects that accumilates several payment plans?
Are you frustrated on complex configurations for branding and workflow management?
And still get stuck when it comes to extensiblity?

What if I say there's a product that checks all these under one bill.

Enter Asgardeo

Asgardeo is an IaaS (Identity as a Service) provided by WSO2 for the modern AI blended era. It is a hosted and first party supported version of their own open source Identity Server.

Yeah you heard it right. It is open source if you want and have time to set it up yourself on your own infrastructure.

So what's special about Asgardeo?

It can deliver the same functionalities you orchestrated using bunch of services at your favourite cloud infrastructure provider as a single product.

Some of the highlighting features includes,

1. A visual editor to customize your auth flow and how it looks.

2. Multiple ways for user onboarding including self-sign-up invitation and social account linking.

3. Define your branding and login flow with AI.

4. Plethora of authentication methods including passwordless login.

5. Bulit-in logging and monitoring.

6. supports webhooks to bring notifications to wherever you want.

7. SDKs for all widely used frameworks and technologies with joyful developer experience.

Checkout this video where I integrate Asgardeo authentication to Next.Js under 10 mins:

This is just the surface

I am just touching the surface of this product and it has many powerful features that might feel like a godsend for your specific workflows. So definetely give this product a go. It has a free tier that doesn't require any payment method so you can go for a spin without wasting a cent.

Sign up for Asgardeo -> https://asgardeo.io
Learn more about Asgardeo -> https://wso2.com/asgardeo/docs
Identity Server Source Code -> https://github.com/wso2/product-is

Thanks for reading up to here ❤️. Give this a share if you think helpful.

How to use curl

Chamal Mallawaarachchi — Sat, 03 May 2025 15:47:52 +0000

What is curl?

curl (connect URL) is a command line tool and a library for transferring data with URLs.

Why you should learn curl?

Test any REST/ GraphQL/ API
Test anything else related to http/https requests and responses.
Test xml/ json RPC protocols
Upload/ download files
Perform Monitoring and deployments with the help of scripts

If you're an engineer of just a pc enthusiast who works with urls, you should learn curl coz it's gonna make your life easier.

Useful curl Flags:

-X <method>: Specifies the HTTP method (e.g., GET, POST, PUT, DELETE).
-H "<header>": Adds a header to the request.
-d "<data>": Sends data with a POST request (useful for sending JSON).
-I: Fetches only the HTTP headers.
-O: Saves the response to a file.
-L: Follows redirects.
-u <username>:<password>: For basic authentication.
-F "<form-field=@file>": Used to upload files.
-v: Enables verbose output to see request/response details.
-H "Authorization: Bearer <token>": Adds a Bearer token for authentication.

Examples of Using curl

REST API Example

To make a GET request to a REST API endpoint:

curl -X GET https://api.example.com/users

To send data with a POST request:

curl -X POST https://api.example.com/login \
-H "Content-Type: application/json" \
-d '{"username": "user", "password": "pass"}'

GraphQL API Example

To send a query to a GraphQL API:

curl -X POST https://api.example.com/graphql \
-H "Content-Type: application/json" \
-d '{"query": "{ users { id name } }"}'

To use variables in the query:

curl -X POST https://api.example.com/graphql \
-H "Content-Type: application/json" \
-d '{"query": "query($id: ID!) { user(id: $id) { name } }", "variables": {"id": "123"}}'

JSON-RPC Example

To call a method in a JSON-RPC API:

curl -X POST https://example.com/api \
-H "Content-Type: application/json" \
-d '{
  "jsonrpc": "2.0",
  "method": "getUser",
  "params": {"id": 1},
  "id": 1
}'

File Upload Example

To upload a file using curl:

curl -X POST https://example.com/upload \
-F "file=@path/to/file.jpg"

File Download Example

To download a file and save it locally:

curl -O https://example.com/file.zip

Testing API with Authentication

For a REST API with Bearer token authentication:

curl -X GET https://api.example.com/protected-resource \
-H "Authorization: Bearer <your-token>"

Testing API with Basic Authentication

For a REST API with Basic authentication:

curl -u "username:password" https://api.example.com/protected-resource

Follow Redirects

To make a request and follow any redirects:

curl -L https://example.com

Get Only HTTP Headers

To retrieve only the HTTP headers of a response:

curl -I https://example.com


This should be all in one block, ready for you to use. Let me know if you need any more adjustments!

Curl is more than you think

Believe me when I say this, I cannot cover all of the curl's functionalities from one article.

If I did, it would be book. Infact, there is one if you're curious.

Go ahead and read if you want to know -> Everything about curl

Cron Jobs for absolute beginners

Chamal Mallawaarachchi — Fri, 02 May 2025 08:30:05 +0000

What the heck is Cron?

Cron was originally existed as a preinstalled utility in old Unix systems. It was created to run scheduled jobs or in other words to execute something in a predefined time in future.

Since GNU/Linux also created as a Unix like system, this functionality has been offered using multiple open source applications.

Cron runs jobs repetitively, if you want to just run a command once there's another Unix utility called at which will not be explained here.

Fun fact!

The name Cron originated from the Greek word Chronos which means Time.

Don't get confused!!

There are multiple implementations of Cron for Linux. Some of the most used ones are:

Cronie - Default Cron implementation on RHEL (Red Hat Enterprise Linux) and RHEL based distros.
Dcron - A lightweight implementation for distro's like Alpine and embedded systems.
fcron - One with support for non 24/7 systems.
Vixie-cron - One of the earliest implementations.

Despite these multiple applications, they all invokes using the same commands/flags and use the same file formats and share the same basic structure while some of them having additional features.

SO, SIMPLY YOU DON'T NEED TO WORRY AS LONG AS YOU HAVE ONE OF THE ABOVE INSTALLED.

Don't jump ahead and Install yet!

Most of the GNU/Linux distro's comes with a cron application pre-installed. If it isn't, chances are it is available through their official package repositories.

Ubuntu, Ubuntu based, RHEL and RHEL based distro's are usually come with cron pre-installed.

For a system like Arch or Alpine linux, you need to install one from their package repositories and in that case choose one that is available and fit's for your needs.

You can check if a cron application is available using the following command:

sudo systemctl status cron
# this will only work on distro's with Systemd init system

Most modern GNU/Linux distro's use systemd but if yours not, refer distro's documentation for the init system and how to check the services status.

Service is not running!

Dont't worry just start it:

sudo systemctl start cron

For distro's with no cron (examples are for arch and RHEL based)

Don't worry, just,

Install it using your default package manager:

sudo pacman -S cronie # for arch based
sudo yum install cronie # RHEL based

Enable the service:

sudo systemctl enable cronie.service # for arch and RHEL based

Start the service:

sudo systemctl start cronie.service # for arch and RHEL based

How to use

There are two basic terms you need be familiar first:

Cron Job - is single job (a command or a set of commands) that is scheduled to run for a particular time in future.
Crontab - is a file containing one or more Cron Jobs (Crontab is a short term for Cron tables).

Now, let's see how to create a cron job!

First, understand the format for writing a cron job:

* * * * * command_to_run
│ │ │ │ │
│ │ │ │ └─ Day of the week (0–7) → 0 or 7 = Sunday
│ │ │ └──── Month (1–12)
│ │ └─────── Day of the month (1–31)
│ └────────── Hour (0–23)
└──────────── Minute (0–59)

The first 5 fields are use to denote the time to the script.
In an all asterisk case, the command will run infinitely for every minute.

Example 1

5 * * * * echo "hi from cron job"

This will run the echo command on the 5th minute of every hour infinitely.

Example 2

Let's narrow it down further,

5 1 2 * * echo "hi from cron job"

This job will run on the 5th minute of 1st hour of 2nd of every month infinitely.

Example 3

Let's narrow further,

5 1 2 7 * echo "hi from cron job"

This job will run at 1.05 AM on 2nd of July in every year inifintely.

I hope you got the format now. You can run any command, any script, any program using a cron job in a Unix like systems.

How to actually set this up

With the format sinked in, now let's actually create a cron job.

Configure your default editor:

export EDITOR = nvim # I use neovim, you can put anything you want.

export EDITOR = nano # if you have no idea, use this one.

Execute the following command and crontab will be opened in your default editor:

crontab -e

NOTE: If unconfigured, it will open vi.

Now write one or more cron jobs inside the opened file.

5 * * * * yay -S neofetch # I'm installing a package
# Put a command that you can verify later

NOTE: If you look for the location of the crontab file, you might see that it is in a temp directory. That's because once you save the file, it will move it your users default crontab.

3.Verify the status of the command manually. In my case I can see if the package has been installed.

So there's no logs?

Cron does print logs to system log file, but it only contains cron start, stop times and errors encountered by cron. You won't be able to capture all the details you need.

grep CRON /var/log/syslog # You can grep CRON logs from sys log like this

But here's a solution that I use to get a more verbose log!

mkdir logs && touch cronlogs.log # I create a logifle in my home directory
5 * * * * yay -S neofetch >> /home/<username>/logs/cronlogs.log 2>&1
# Then append the stdout and stderr of the run command to that logfile.

One more thing about Crontabs

There are some crontabs that comes built in with cron.

User Crontab This is the crontab we just used above to run our cronjob. When we execute crontab -e and write our cron job and save, it will automatically be moved to the current logged user's crontab.

Those Cron Jobs will only run for that user.

Sytem Crontab If you're the root user or have root access, you can write to the system Crontab as well. These will allow you to specify for which user, a perticular job should run.

You open it using your preffered editor:

sudo nvim /etc/crontab

The format is the same with the addition of the username:

minute hour day month weekday **user** command

NOTE: One Cron Job only can have one user

Don't leave without reading this

Cron used to be the defacto for scheduling tasks for DevOps, but it does have many problems. Some notable ones are,

No proper error handling to retry on failuires.
Seperate verbose logs needs manual setup.
No job dependancy support.
Cannot handle missed jobs. (Though some implementaions can)

Systemd Timers are the future

This is the modern take on Cron Jobs without it's drawbacks and now widely used as a replacement to it.

it is a bit complex to setup but in turn provides more control over the jobs and have a better intergration with the system.

I will explain how to use Systemd Timers to take full advantage of it in a future article.

Setup Haskell for Neovim on Linux

Chamal Mallawaarachchi — Tue, 29 Apr 2025 13:49:39 +0000

This is a distro agnostic simple guide on how to setup haskell on modern linux using GHCup.

Requirements

Make sure you're equipped with all the neccesary packages to run GHCup properly. I'm not gonna list all of them here (if you're a dev already, chances are you're).

So just go here and check -> https://www.haskell.org/ghcup/install/#system-requirements

For an example,

if you're on Arch Linux, you just need the linux-devel and curl packages and rest will be automatically downloaded installed by the GHCup installer.

Setting up

1. Paste the following command and run:

curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | sh

This script will download and install the following binaries:

ghcup - The Haskell toolchain installer
ghc - The Glasgow Haskell Compiler
cabal - The Cabal build tool for managing Haskell software
stack - A cross-platform program for developing Haskell projects (similar to cabal)
hls - (optional) A language server for developers to integrate with their editor/IDE

Note that HLS (Haskell Language Server) is optional here. Make sure you install that when the installer prompts you if you want to use code actions, suggestions, goto definitions, and etc in Neovim (There are other LSPs but I highly recommend this for a beginner).

2. When installer prompts asking to write environment variables to your shell configuation, let it do that.

It will add something simillar to following your shell configuration.

[ -f "/home/<your-username>/.ghcup/env" ] && . "/home/<your-username>/.ghcup/env" # ghcup-env

3. After the installer finishes up, reload your shell configuation, close and reopen your terminal.

source .zshrc # for zsh
source .bashrc # for bash
source ~/.config/fish/config.fish # for Fish

# If you're using a different shell refer it's manual

4. Make sure everyting is correctly installed:

$ ghc --version

Should print The Glorious Glasgow Haskell Compilation System, version 9.6.7

$ which haskell-language-server-wrapper

Should print /home/<your-username>/.ghcup/bin/haskell-language-server-wrapper

5. You can manage what has installed or install new tools using the below command:

ghcup tui

Make sure ticks are like in the below image in the ghcup tui:

Double tick means installed and set as default. If hsl is not set, set it with s.

Configuring neovim

1. If you're new to Neovim ( which I highly doubt) start with something like kickstarter neovim config by TJ.

Following steps assume that you have a lazy.nvim and nvim-lspconfig plugins installed and configured to the way you like.

2. Setup treesitter for syntax highlighting:

{
  "nvim-treesitter/nvim-treesitter",
  lazy = false, 
  build = ":TSUpdate",
  config = function()
    -- treesitter configs
    local config = require("nvim-treesitter.configs")
    config.setup({
      auto_install = true, -- Auto install treesitter parsers when a new file type detects
      highlight = {
        enable = true,
      },
      indent = { enable = true },
    })
  end,
}

3. There are multiple ways to start lsp servers using nvim.lspconfig. I will show the one I use here (which extentable later for other langs easily):


{
  "neovim/nvim-lspconfig",
  opts = {
    servers = {
      hls = {}, -- Pass Haskell Language Server to the opts table
      -- your other language servers can be listed here
    },
  },
  config = function(_, opts)
    -- config function using opts.servers

    -- Loop over the servers in opts.servers and enable each
    for server, config in pairs(opts.servers) do
        lspconfig[server].setup(config)
    end
  end,
}

4. Check if the Tree-sitter parsers and LSPs are attaching to the buffer.

Open up a new haskell file:

nvim hello.hs

Give some time for nvim treesitter to download the haskell parser

Check Treesitter:

Type the below command in your neovim cmdline in command mode and it will show avaiable active parsers.

:TsModulInfo

Type following command in the neovim command mode to verify if the LSP is attached to your buffer.

:LspInfo

Another good way to verify is to type some Haskell syntax. If your editor shows like below, you're good to go:

That's it!

Enjoy your functional programming :)

Get to Know MCP

Chamal Mallawaarachchi — Wed, 16 Apr 2025 10:26:23 +0000

The Model Context Protocol (MCP) is released by Anthrophic is becoming the de facto for combining AI models to everything that it cannot directly access.

So let me break it to you with the most simplest ways based on my understandings.

What is the problem?

As you may already know, an AI model struggles when they need to access any information or tools out of their pre-trained datasets. So developers have to write custom code for each API, tool or data source to give them that fine grained access. This made AI bridging to any custom tool or data source a bitter task to any dev.

Anthrophic's solution

Anthropic stepped in and introduced MCP aka the Model Context Protocol. It's a tool, resource and model agnostic protocol to establish connections between AI Models and any other tool or resource.

They introduced this as an open standard which uses JSON-RPC 2.0 which is already used by many standard protocols like Language Server Protocol (LSP) and Etherium network.

The most simplest explanation

Think of it as a REST API for an AI to call and access information and tools it needs. Though they use completely different invoke and expose methods.

Abstracted architecture of an MCP

An Example

Imagine you have your favorite spreadsheet application that you use regularly. You'd love to be able to tell an AI chatbot things like "create a budget spreadsheet" or "calculate the average of my quarterly sales" and have it actually do these tasks in your spreadsheet application.

Here's how you could make this happen:
Let's assume that this spreadsheet application has an API to control it's actions like insert data into cells, insert formulae and etc.
Next, you can write a simple script using a programming language that sends commands to it's API.

Now we need to connect our script to the AI, so it can send commands for the API for us. Instead of us writing a formula and sending, AI can read the spreadsheet, create a formula and write it to the spreadsheet.

This is where MCP comes in!. We just need wrap our scripts into a the MCP supported function. That is called an MCP server.

That has become fairly easy now due to the already available libraries for many programming languages.

This is how you write an MCP server using official python SDK:

from mcp.server.fastmcp import FastMCP

# Create an MCP server
mcp = FastMCP("my-spreadsheet-mcp-server")


# Add a tool
@mcp.tool()
def writeToSpreadSheet(userString : str) -> str:
    """
    Your logic or the script that 
    access the spreatsheet API
    """
    return "you can return what happened back to AI"


# Add a resource
@mcp.resource("://{name}")
def accessSpreadSheets(name: str) -> str:
    """
    Your logic or the script that 
    access the spreatsheet API
    """
    return "you can return what happened back to AI"

here tools decorator tells the AI model that function access tool (like the spreadsheet program) and resource tells that it access a data source (like an actual spreadsheet file directly).

After writing your mcp server. You can load it to an MCP client ( like claude desktop) to let an LLM access your MCP and do what you asks using the new capabilities of your MCP server.

Using this method, you can give access to any data source, database, REST/RPC APIs or any other software to your choice of AI model.

Wait, don't go and write another MCP server now!!

There might be already an MCP server for your task that someone has written, so give it a try first.

Here's list of MCP servers people have written as of now,

https://github.com/punkpeye/awesome-mcp-servers

References

MCP official introduction by Anthropic - https://www.anthropic.com/news/model-context-protocol
Python SDK for MCP -https://github.com/modelcontextprotocol/python-sdk
JSON-RPC 2.0 spec - https://www.jsonrpc.org/specification

Flutter Development for Low end PCs

Chamal Mallawaarachchi — Sun, 12 Jan 2025 12:18:04 +0000

This is a dead simple and minimal dev workflow setup for flutter development.

Aight first up, let's see the memory footprint

These screenshots are taken from my Hyprland setup which is a very minimal Desktop Setup.

You can see that neovim is taking only 41mb of RAM while scrcpy is taking 181mb of RAM. These two apps replaces the VsCode and Android emulator which results in like 90% memory freeing.

With Hyprland, my complete setup when running the emulator and code editor is still under 4GB of RAM.

And with everything configured, this is how the setup looks;

Ingredients:

A package manager - to install stuff easily
Neovim - for code editing
Android studio - for managing the android sdk
Flutter sdk - duh.!
Scrcpy - android screen mirroring tool
Your android phone - for the emulation (assuming it is above android version 5)

Steps:

Setup package manager.

Linux:
you already have a package manager built in!

macOS:
```
# skip the first command if you already have  homebrew installed.
/bin/bash -c "$(curl -fssl https://raw.githubusercontent.com/homebrew/install/head/install.sh)"
```
Windows:
- Follow this guide to setup chocolatey if you haven't: https://chocolatey.org/install
Install neovim (skip if deciding to use VsCode).

Install neovim and configure it work with flutter. if you aren't familier with vim motions, you can swap this step with vscode but it will increase the memory footprint when running everything. But it will still be better than running the emulator with VsCode.

Linux:
```
sudo pacman -s neovim # if you're on arch linux, for other distros, google it up
```
macOS:
```
brew install neovim
```
Windows:
```
choco install neovim
```

Install android studio.

Linux:

yay -s android-studio # if you're on arch linux, for other distros, google it up

macOS:

brew install --cask android-studio

Windows:

choco install androidstudio

Install flutter sdk.

Linux:

yay -s flutter-bin # This is arch linux syntax

macOS:

brew install --cask flutter

Windows:

choco install flutter

Flutter Setup (skip if you're VsCode and Install dart and flutter extensions instead):
Follow this guide to setup flutter tools with neovim (yeah it is lengthy but it's worth for the profit) - https://www.etiennetheodore.com/building-flutter-application-with-neovim/.

Install scrcpy.

Linux:

yay -s scrcpy # This is arch linux syntax

macOS:

brew install scrcpy

Windows:

choco install scrcpy

Enable usb debugging in your android device.

a. Tap build number 7 times and enable developer. options
b. Go to it and enable usb debugging.
Authorize your phone with adb.

a. Connect your phone via a usb cable to your pc/mac.
b. Type adb devices.
c. A prompt will come in your phone to authorize the device.
d. After that just plug out and re-plug your device to computer.
Now create a new flutter project or open and existing one with neovim.

a. cd into your flutter project folder and type nvim ..
b. Then press : symbol and type flutterRun in neovim. this is a command provided by flutter-tools neovim plugin. you can learn all the commands it offers through their GitHub repo.
Mirror the screen using scrcpy.
```
scrcpy --turn-screen-off
```
that's it!
You now have a very fast flutter emulator just beside your code editor. this can also setup to connect wirelessly. more on that in a future article.

Thank You for reading. Share if you think this is useful.

Hassle free flutter Development in Hyprland with Neovim

Chamal Mallawaarachchi — Thu, 09 Jan 2025 20:59:54 +0000

I am writing this article to help anyone surfing through the internet for a proper guide to setup a smooth flutter dev work low for their Hyprland setups.

1. Install flutter through your package manager. If you're on Arch linux you can try following command.

yay -S flutter-bin # This will install dart and flutter from AUR

2. Install android-studio using your package manager. Again if on Arch, use below command.

yay -S android-studio # This will install android studio from AUR

3. Install flutter-tools neovim plugin to setup the LSP.

I assume you already know how to setup neovim plugins. Also this plugin will setup dart-ls automatically so don't install it through your lspconfig. flutter tools will give all of the functionalities Vs-code flutter extensions plus some additional stuff.

You can follow the repo's README to set this up accroding to your neovim setup.

flutter-tools - https://github.com/nvim-flutter/flutter-tools.nvim

4. Now open android studio and create an emulator of your choice.

I recommend something above android 12 (S) as others will be x86 by default. Flutter will soon drop support for x86-based emulators or devices.

5. Once that done, next usual step is to run the emulator,

But android studio's emulator does not support native wayland as of now according to my findings.

MY WORKAROUND TO GET IT RUNNING:

You can use following command to force the current session of the emulator to run through Xwayland.

env QT_QPA_PLATFORM=xcb flutter emulators --launch <your-emulator-name>

If you're using fractional scaling or any scaling in Hyprland, the emulator will launch in a blurred window. To fix that add the following code to your hyprland.conf

xwayland {
  force_zero_scaling = true
}

6. That's it!

You should be able to connect to the emulator using :FlutterRun inside neovim. Other commands to control and access the flutter utilities can be found in the flutter-tools GitHub repo's README.

If you want a quick neovim setup or an entire hyprland setup with everything configured, you can use my neovim config in my dotfiles.

My dotfiles - https://github.com/Chamal1120/dotfiles-linux-hyprland

Thank You chief for reading up to here

Feel free to ask me if anything is doubtful or let me know if there are better ways to do what I am doing right now. Comments are always welcome.

# How to write good commit messages

Chamal Mallawaarachchi — Fri, 13 Dec 2024 15:05:48 +0000

If you are here, chances are you have already used git and probably thinking "Am I writing my commit messages in a good standard?".

If yes, then you must read this before you go and do your next big project.

So what is a good commit message?

Well, there's actually multiple standards when it comes to git commit messages. But they all should,

Be written in imperative mood if it is a simple commit (means a one liner).
Have a title in imperative mood if it is a detailed commit.
Write logically, each addressing a single concern.
Reference issues or tasks explicitly (if there is any).

Let's look at an example

Simple Commit:

Fix typo in README

Detailed Commit:

Add caching mechanism to improve performance

Implemented a caching layer to reduce redundant database calls,
which improves page load times by approximately 30%.

Fixes #42.

This is written following the Git flow style commits standard.

So what are the other standards then?

Since there's many, I won't be writing all of them here. Below standards will be the ones you'll most probably should be using and encounter as a software developer. Some further references will be linked at the end of the article for curious people.

1. GitHub Flow-Style Commits:

Popular for open-source projects in GitHub. Often references related issues or pull requests (e.g., "Closes #123").

Add pagination to the blog list view

Pagination improves performance for blogs with a large number 
of posts. Closes #42.

2. Conventional commits:

Probably the most widely used standard. Have a type at the beginning followed by a semi-colon and then a scope, description, body and a footer.

The commonly used types are,

feat: A new feature.
fix: A bug fix.
docs: Documentation updates.
style: Code style changes (e.g., formatting, no logic changes).
refactor: Code restructuring without changing behavior.
perf: Performance improvements.
test: Adding or updating tests.
build: Changes to build tools or dependencies.
ci: Continuous integration updates.
chore: Miscellaneous tasks (e.g., updating dependencies).
revert: Reverts a previous commit.

Scope (Optional):

The part of the codebase affected (e.g., auth, api, ui).

Description:

A short summary of the change in the imperative mood.

Body - for detailed commits(optional):

Detailed explanation of the change.

Footer - for detailed commits(optional):

Breaking changes (BREAKING CHANGE: ...) or issue references (Fixes #123).

2. Tim Pope's Guidelines:

Tim Pope, a Git expert, suggests:

Limit subject line to 50 characters.
Capitalize the first word of the subject.
Do not end the subject with a period.
Use the imperative mood.
Separate the body with a blank line.

Refactor user authentication module

Simplified the code by removing redundant checks and aligning
with the latest OAuth2 library changes.

3. Angular Commit Guidelines:

The foundation for Conventional Commits.
Adds a specific format with types, scopes, and more.

feat(user): add user profile page

This page includes basic details about the user and their recent
activity. Also adds lazy loading for the profile module.

4. Semantic Commit Messages:

Focuses on using keywords to make commits machine-readable.
Often integrated with tools like semantic-release.
Similar to Conventional Commits but may include specific metadata.

feature(login): implement Google OAuth login

6. Subject-Prefix Standards:

Uses a prefix to indicate the change type.
Less formal than Conventional Commits.

[Bugfix] Resolve incorrect total calculation
[Enhancement] Improve search performance

For further references

Conventional Commits - https://www.conventionalcommits.org/en/v1.0.0/
Tim Pope's blog post on commit messages - https://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html
Senamtic Versioning - https://semver.org/
Angular git commit guideline - https://github.com/angular/angular/blob/main/CONTRIBUTING.md#commit

Thank You

Load of thanks for reading up to here. comments are welcome. Point out if I have missed any details or stated anything erroneously. Let's learn together and grow to become better developers.

zoxide - A faster alternative to boring cd command

Chamal Mallawaarachchi — Sun, 19 May 2024 04:08:55 +0000

Why zoxide is a better replacement??

Best way to start explaining is to show how we normally navigate using the good old cd command.

Now you might think that "hey, can't we just use up arrow key or an autocomplete plugin?".

Well, those might perform very well when working with simple folder structures, but imagine having to press up arrow key thousands of times to get to your previously used directory that wanted to navigate to.

And also in the case of auto-complete plugin, it will also leave a very unreadable number of lines in the terminal that might confuse you when you referring back the previous lines of your terminal for reviewing something.

That's where zoxide excels!

Both of those problems can be easily be eliminated just by installing zoxide to your terminal.

Now let's see how we do the same operation using Zoxide.

Pretty easy right?

Well if you have multiple folders with the same name in different directories there are two ways you can use zoxide to get to the exact one you want.

Method 1 - If you are on a compatible shell version of bash,zsh or fish you will be automatically prompted with the available directories for that folder name as follows.

Method 2 - If for some reason you don't get the above feature, you can use another famous tool called fzf (aka fuzzy finder). With the power of fzf you can use the below command to show all the directories saved with that particular folder name. You can even take a peak at the content inside that folder.

Not only that there are many other ways you can customize the commands. You'll find a very detailed instruction set in their official repo which I have linked at the end of this article.

Actually zoxide isn't the first program that provided these facilities. There were earlier programs which are still up-to-date named z, autojump and fasd. While autojump and fasd are way more advanced than zoxide, they also have a more steep learning curve.

In terms of simplicity and lightweightness, zoxide is the best option out of all. On top of that, zoxide is built on Rust which makes it blazing fast.

Believe me you won't even notice that you're using a third party tool.

Okay now we'll see how to install this into your favorite terminal.

zoxide will work with any Linux terminal including Windows and MacOS. Infact it is available through almost any package manager you have heard, used or seen.

For Linux/MacOS

Although the official documentation of zoxide recommends using package installers or managers, I would highly suggest you to use curl to get the install script and install.

curl -sS https://raw.githubusercontent.com/ajeetdsouza/zoxide/main/install.sh | bash

For Windows

zoxide works really well with Powershell in Windows.

Use winget package manager to install zoxide.

winget install ajeetdsouza.zoxide

Post install steps (only for Linux/MacOS)

Open your configuration file related your terminal using a code editor.

# Assuming you are on zsh and using nano as the code editor
nano .zshrc

Add the following line to the end of the file to initialize zoxide with your terminal.

eval "$(zoxide init zsh)"

(skip this step if it is already in the file)

Now add following line to add the zoxide install directory to the PATH which helps you to use the z command in every directory of your terminal.

export PATH="/Users/chamalrandika/.local/bin:$PATH"

Source the configuration file to invoke the changes.

source .zshrc

Install fzf (if multiple directory handling didn't work with the default z syntax)

clone the official repo to get the install script.

git clone --depth 1 https://github.com/junegunn/fzf.git ~/.fzf

Install

~/.fzf/install

Add this line to configuration file as explained in previous steps to reduce the width of the suggestions window (default is 100%)

export FZF_DEFAULT_OPTS='--height 40%'

Source the configuration file.

More information

You can refer the official documentation if you are an advanced user or just curious to know more about the projects.

zoxide official GitHub repo - https://github.com/ajeetdsouza/zoxide
fzf official GitHub repo - https://github.com/junegunn/fzf

That's it!

Happy CLI life devs. ✌️

Understanding the pointers in C

Chamal Mallawaarachchi — Sun, 03 Mar 2024 20:18:25 +0000

Hello coding pals 👋

Today I'm going to give you a comprehensive yet simple guide to pointers in C.

Before proceeding, make sure you are alt-east familiar with some basic c syntaxes like printf, scanf, main and user defined functions.

Understanding this will help you to deal with pointers in other languages as well. 😌

Aright then!, let's begin shall we?

First of all, what's a pointer?

Our computer programs are usually using the main memory(RAM) when they are executing.

The variables we assign in programs are stored in the main memory.

So, when a variable is stored in the main memory, there is an address for that memory location where the variable is located in our main memory.

That address is what we use to access the value which stored in that variable.

A pointer's job is to provide a point to that exact address so we can access the value in that variable.

image credit: geeksforgeeks.org

The above image shows the difference between a pointer variable and a normal variable that pointer points to.

NOTE: A pointer variable also occupies system memory, which gives it a memory address too. so we can even create another pointer variable to an already specified pointer variable as well.

So simple terms, a pointer is a variable that stores a memory address.

Enough theory, now let's jump into practical examples to better understand how pointers works in a programming environment.

We're going to use C as our programming language since it's one of the few languages that offers direct memory manipulation where proper use of pointers are needed.

#include <stdio.h>

int main()
{
    int b = 42;

    int *a;

    return 0;
}

Study the above code.

Inside our main function, I have created a int type variable named b which stores the value 42.

after that, I have created another int type variable named *a.

You'll notice few differences in the declaration syntax.

* means make it a pointer, So *a means make a a pointer. And int means a is going to point to int values.

With the above code nothing will happen actually. Bcuz we're just telling a is an int pointer. We haven't tell it to where it should point to.

Let's see how we do that now.

#include <stdio.h>

int main()
{
    int b = 42;

    int *a = &b;

    return 0;
}

Now in the above code you'll notice I have added another thing to the end of the pointer variable declaration.

This & operator is used to get a memory address of a certain variable.

So &b means we are telling to get the memory address of b.

So, the complete line int *a = &b; means to create a pointer variable named a that points to an int value and assign the memory address of b to it.

Theoretically, now *a should have the exact memory address of b.

We can verify this by printing the both b's memory address and *a's memory address.

#include <stdio.h>

int main()
{
    int b = 42;

    int *a = &b;

    printf("b: %d\n", b); // prints the value of b
    printf("&b: %p\n", &b); // prints the memory address of b
    printf("a: %p\n", a); // prints the value of a

    return 0;
}

If compile and run the above code, You'll get the following output. (your memory addresses may be vary)

b: 42
&b: 0x7ff7b3c403c8
a: 0x7ff7b3c403c8

You can see that both value of &b and value of a are equal.

This what happens when we create a pointer variable and point it to another variable.

There's another thing you need to know.

We can de-reference a pointer

De-referencing a pointer means accessing the value stored at the memory address pointed to by that pointer

by doing that, we can refer back a pointer and modify the contents of the variable that it points.

#include <stdio.h>

int main()
{
    int b = 42;

    int *a = &b;

    printf("b: %d\n", b); 
    printf("&b: %p\n", &b);
    printf("a: %p\n", a);

    *a = 50;

    printf("b: %d\n", b); 
    printf("&b: %p\n", &b);
    printf("a: %p\n", a);

    return 0;
}

In the above code, I have added a few changes from the previous code.

The *a here is not telling to change value of a. Instead this tells to go get what a is pointing to and use that.

And with the rest of the code in that line, *a = 50; tells the program to go get what a is pointing to and change the value of it to 50.

Output of above code will look like follows,

b: 42
&b: 0x7ff7b76443c8
a: 0x7ff7b76443c8
b: 50
&b: 0x7ff7b76443c8
a: 0x7ff7b76443c8

You'll see that only the value of b has changed. The memory addresses stay the same.

This is how de-referencing is done using a pointer.

But what's the purpose of this huh?

The scanf function

Scanf is a built in function in C that use the advantage of pointers to read values from an input.

Let's see an implementation of it

#include <stdio.h>

int main()
{
    int a, b, c;
    a = b = c = 0;

    printf("Enter 3 numbers:");
    scanf("%d %d %d", &a, &b, &c);
    printf("Result: %d\n", a + b + c);

    return 0;
}

In the above code, What scanf does is, it's accepting 3 inputs from the user %d %d %d(integers) and store them into a, b and c.

You'll notice that we have assigned 0 to all a, b and c.

But if you run this code you'll see that scanf somehow modified the variables and provide the output as the addition of all three numbers.

Enter 3 numbers:2 5 3
Result: 10

So how does scanf is able modify the a, b and c?

What scanf function does is, it gets the values of &a, &b, &c instead of a, b, c.

If you provide a, b, c you just giving the values of those variables which are 3 zeros.

By providing the variables as &a, &b, &c to the scanf, it can point to the addresses of the variables and modify them with the user assigned values.

This is known as a pass by reference.

Since this is built in function we don't see what's happening inside the scanf.

To get a clear idea, we'll create our own simple pass by reference function.

#include <stdio.h>

void swap(int *a, int *b);

int main(void)
{
    int x, y;
    x = 5;
    y = 10;

    printf("x: %d, y: %d\n", x, y); //before the sawp
    swap(&x, &y);
    printf("x: %d, y: %d\n", x, y); //after the swap

    return 0;
}

void swap(int *a, int *b)
{
    int temp = 0;
    temp = *a;
    *a = *b;
    *b = temp;
}

In the above code, we have created a swap function which accepts addresses of variables as int pointers.

Simply said, when we pass the &x and &y to swap function following thing happens first,

int *a = &x

int *b = &y

Familiar that?

That's what we did before de-referencing in the code where I explained the de-referencing.

After that, inside the swap function, whatever we do with *a and *b will happen using the values of the variables x and y.

temp = *a; will assign 5 to the variable temp

*a = *b; will assign 10 to *a.

*b = temp; will assign 5 to *b.

So the final result of the code will display as follows,

x: 5, y: 10
x: 10, y: 5

First line prints the values before swap and the next line prints the values after swap.

If want to see how memory addresses are de-referred, you can add two more print statements as below in the code.

#include <stdio.h>

void swap(int *a, int *b);

int main(void)
{
    int x, y;
    x = 5;
    y = 10;

    printf("x: %d, y: %d\n", x, y); //before the sawp
    printf("&x: %p\n&y: %p\n", &x, &y); // addresses of x and y
    swap(&x, &y);
    printf("x: %d, y: %d\n", x, y); //after the swap

    return 0;
}

void swap(int *a, int *b)
{
    printf("a: %p\nb: %p\n", a, b); // addresses of x and y
    int temp = 0;
    temp = *a;
    *a = *b;
    *b = temp;
}

Newly added print inside the main function prints the memory addresses of x and y.

Newly added print inside the swap function prints the memory addresses of pointed by *a and *b.

Output will be shown as below.

x: 5, y: 10
&x: 0x7ff7bf5af3c8
&y: 0x7ff7bf5af3c4
a: 0x7ff7bf5af3c8
b: 0x7ff7bf5af3c4
x: 10, y: 5

You can see now memory addresses of x and y matches the memory addresses of *a and *b.

That means *a and *b are pointing to x and y.

So, by using *a and *b, you can manipulates the values of x and y inside the swap function without affecting the memory addresses.

This is how a pass by reference works.

There are many cool stuff you can do with pointers in C.

But, I don't want to make this article very lengthy.😊

So, let's see how pointers help the dynamic memory allocation in a future article.☝️😌

Till then, ✌️