f4him

Currency Converter Chrome Extension – A Deep Dive

2026-07-29T00:00:00+06:00

Currency Converter

Instantly convert prices on any website into your preferred currency.

Introduction

Shopping online has never been simpler, but one problem remains surprisingly common: prices are often displayed in currencies that do not match the shopper’s own expectations. A product listed in US dollars may feel completely different to someone browsing from Bangladesh, the UK, or Japan. For many users, the friction is not in finding the product, but in mentally converting the price into a currency they understand.

That is the problem this extension solves.

The Currency Converter Chrome Extension is a lightweight browser tool designed to make online shopping feel more intuitive. Instead of manually translating every price in your head, the extension detects prices on supported e-commerce pages and overlays a converted value in your preferred currency. The result is a smoother, more familiar browsing experience that helps users compare products without leaving the page.

Because the source repository is private and only the Chrome Web Store listing is meant to be public, this post focuses on the product experience, the architecture behind it, and the technical choices that make it work reliably.

What the Extension Does

At its core, the extension performs three tasks in a seamless loop:

It detects prices visible on a webpage.
It identifies the currency associated with each price.
It displays a converted value in a target currency selected by the user.

This is not a traditional currency calculator that only works when you manually paste in a value. Instead, it acts like a quiet layer over the web page itself. When a user visits an e-commerce site such as Amazon, AliExpress, Walmart, eBay, Temu, or a generic product page, the extension scans the page and recognizes price-related content automatically.

Once a price is found, the extension attaches a small visual annotation—often a tooltip or inline label—showing the converted amount. The user can then quickly see what a product would cost in a currency they know well, such as Bangladeshi Taka (BDT), without interrupting their browsing flow.

Screenshot taken from Amazon.

This makes the extension especially useful for:

Shoppers comparing international products
Users who prefer local currencies for budgeting
People unfamiliar with the original currency format
Customers trying to interpret deals, discounts, and final totals quickly

Why It Matters

The modern web is global, but the shopping experience is still often local in feel. A product page might list a price in USD, EUR, or AUD, but a customer in Bangladesh may prefer BDT. The mismatch is not just aesthetic; it affects decision-making.

For instance, a price like “$29.99” may appear cheap at first glance, but when translated into BDT it could feel very different depending on the current exchange rate. The extension helps bridge that gap by making currency conversion visible and immediate.

Instead of forcing users to open a separate calculator or search engine, it delivers the information directly where they need it: on the page they are already viewing.

How It Works

The extension is built around a simple but effective pipeline.

1. Detecting Price Content

The first step is recognizing prices in the Document Object Model (DOM). The extension scans the page for numeric values accompanied by currency symbols or currency codes. This includes examples such as:

$19.99
€45
£12.50
৳3,200
BDT3200
NZD 80

The detection logic is intentionally flexible. It looks not only for traditional currency symbols but also for shortcodes such as USD, EUR, BDT, and NZD. That makes the converter more robust across different websites and international pricing styles.

2. Identifying the Currency

Once a price-like value is found, the extension maps it to an internal currency definition. This is handled through a currency dictionary that stores metadata about each supported currency, including:

the display symbol
the ISO code
the currency name
the number of decimal places used for formatting

For example, a currency entry may include both the symbol and the short code, allowing the extension to recognize either form. This is important because different websites use different conventions. Some show prices as “$50”, while others use “USD50” or “US$50”.

3. Fetching Exchange Rates

After detecting a price and identifying the currency, the extension needs a current exchange rate. It does this by communicating with a background service worker, which fetches exchange-rate information from the Frankfurter API.

The background layer acts as a central worker for network tasks. Instead of making requests directly from every page context, the extension routes rate-fetching through the background script. That keeps the logic centralized and makes it easier to cache results.

4. Formatting the Converted Value

Once the exchange rate is retrieved, the extension calculates the converted amount and formats it for display. Formatting is important because a converted number should not just be mathematically correct, but also readable.

The extension uses currency-specific formatting rules so that values appear in a natural style for the selected target currency. For example, the number of decimal places, thousands separators, and decimal separators are adjusted based on the currency definition.

5. Injecting a Visual Overlay

The final step is presentation. The extension adds a lightweight annotation near the original price, usually in the form of a tooltip or inline label. This overlay shows the converted value so that the user can understand the price immediately.

The experience is intentionally non-intrusive. The original price remains intact, and the added conversion is supplemental rather than disruptive.

The Architecture Behind the Extension

The extension is organized into a small but well-structured set of files.

Manifest and Background Logic

The manifest file defines the extension’s permissions, content-script behavior, and service-worker configuration. The background script handles tasks such as:

receiving requests from content scripts
fetching exchange rates
storing cached rates locally
responding with the latest values

This background layer is crucial because it keeps the extension responsive and avoids repeatedly hitting the exchange-rate service for every price on the page.

Content Scripts

The content script is the brain of the user-facing experience. It is responsible for scanning the page, matching price patterns, identifying currencies, requesting conversion data, and injecting the visual overlay.

In practice, this means the content script performs the page-level analysis while the background script handles the network-heavy work.

Currency Definitions

The currency dictionary stores the metadata needed to recognize and format currencies. Instead of hard-coding each behavior in the main logic, the extension keeps currency information in a dedicated data file. That makes it easier to expand support for additional currencies later.

Site-Specific Adapters

One of the most interesting parts of the extension is its support for site-specific behavior. E-commerce websites often structure their markup differently. A price on Amazon might be nested differently from a price on AliExpress, eBay, or Walmart. Because of that, the extension includes specialized adapters for different sites.

These adapters help the script understand where prices are likely to appear and what DOM patterns should be considered. A generic fallback is also included for websites that do not match one of the known patterns.

This approach makes the extension more reliable because it avoids assuming every page uses the same structure.

Why the Service Worker Design Was Important

One of the key technical decisions in the project was the use of a classic service worker rather than a module-based worker.

A module service worker would have caused issues with one of the extension’s core loading patterns because the background script relies on importScripts() to share the currency dictionary with the worker context. In a module-based worker, that mechanism is not supported, causing runtime errors.

By using a classic service worker, the extension could:

load shared scripts correctly
access the local currency data without complications
register the background worker cleanly
support the extension’s messaging architecture without breaking

This technical fix was not just a minor detail. It was essential to ensuring the extension could load and function reliably in Chrome.

Performance and User Experience

A successful browser extension must be both useful and unobtrusive. This project was designed with that balance in mind.

Caching for Efficiency

Exchange rates do not need to be fetched every single time a user views a page. To reduce unnecessary requests, the extension caches rates in local storage for a short period. That means repeated conversions can be served quickly without making a fresh API request every time.

This improves both speed and reliability. Users get near-instant feedback, and the extension avoids unnecessary network traffic.

Lightweight UI

The popup interface allows the user to choose a target currency, toggle the extension on or off, and view the last update time. The interface is intentionally minimal so it does not distract from the browsing experience.

The extension is designed to feel like a helpful utility rather than a heavy application. It works quietly in the background and only surfaces itself when needed.

How the Extension Handles Real-World Web Pages

The biggest challenge in building a price-conversion extension is not the math. The hard part is dealing with the astonishing variety of web pages that exist.

Some stores place prices inside compact product cards. Others display them inside hover panels. Some use special formatting, hidden text, or repeated price blocks. A single page can contain promotional prices, sale prices, original prices, partner offers, and shipping information, all within the same layout.

That is why the extension includes logic for different site structures. It is not enough to detect a number followed by a currency sign; the script must also avoid misidentifying unrelated content. It needs to focus on the pricing context, not just any numeric value on a page.

This is where the site-specific adapters and generic fallback come into play. They improve the probability that the extension will attach conversion annotations to the right elements without producing noisy or incorrect overlays.

Privacy and Simplicity

The extension is intentionally lightweight and does not require a complex account system or external login.

Its core behavior relies on:

the browser’s local context
the user’s selected target currency
exchange-rate data fetched from an external API

The extension does not need to store sensitive user data in order to function. It mainly uses local storage for caching and browser messaging to coordinate between scripts.

That makes it easier to trust and easier to maintain.

Installation and Usage

For development testing, the extension can be loaded directly in Chrome through the Extensions page by enabling Developer mode and selecting the unpacked project folder.

Once installed, the user can:

Open an e-commerce page
Allow the extension to scan the page
View converted prices inline or via hover annotations
Change the desired target currency from the popup

The behavior is immediate enough to feel native. The user does not need to manually enter values or switch context; the conversion appears as part of the browsing experience.

What Makes the Project Interesting

What makes this extension compelling is not just that it converts currencies, but that it does so in a way that feels integrated into the browser experience.

It combines several pieces of modern web development:

browser extension architecture
content-script manipulation
background service workers
DOM analysis
asynchronous API calls
caching strategies
cross-site compatibility

That combination makes the project more than a simple utility. It is a practical example of how browser extensions can enhance everyday online tasks in subtle but meaningful ways.

Future Possibilities

The current version already provides a useful experience, but there is plenty of room for growth.

Possible future improvements include:

supporting multiple target currencies at once
adding better localization and formatting rules
improving dark-mode compatibility for tooltips
expanding support for more storefronts and markup patterns
adding optional API-key support for higher-rate limits

These ideas would make the extension even more flexible and polished, especially for users who rely on it heavily while shopping internationally.

Final Thoughts

The Currency Converter Chrome Extension is a small project with a very practical purpose: making international online shopping easier to understand. It takes a simple idea—currency conversion—and embeds it directly into the browsing experience so the user does not have to leave the page or think about it consciously.

What makes it stand out is the combination of simplicity and technical care. The project is easy to use, but behind the scenes it relies on a thoughtful architecture that handles price detection, currency recognition, exchange-rate fetching, and visual presentation in a coordinated way.

For a browser extension, that balance is exactly what matters most. The goal is not just to add a feature, but to make that feature feel natural, fast, and useful in everyday life.

If you enjoy using the extension, the best compliment is to keep it simple, reliable, and genuinely helpful for the people who need it most.

Explain That Code: From Copy-Pasting Code into ChatGPT to Building My Own Chrome Extension

2026-02-13T00:00:00+06:00

Explain That Code

Instant AI explanation for selected code. This extension is not yet published.

Chrome Extension

Introduction

I got tired of copying code into ChatGPT just to understand it, so I built a Chrome extension that brings AI explanations directly into the current tab.

Every developer has been there.

You’re reading documentation, browsing GitHub, or scrolling through a Stack Overflow answer when you come across a piece of code that doesn’t quite make sense.

My instinct was always the same.

I would highlight the code, copy it, open ChatGPT, paste it, and ask for an explanation.

It worked. But after doing it dozens of times a day (yes, I am so bad, i know…), I realized the process itself was slowing me down. Every explanation required leaving the page, switching tabs, and repeating the same sequence of actions.

One day I caught myself doing it again and thought:

Why am I moving the code to AI? Why can’t AI come to the code?

That simple question became the idea behind Explain That Code.

Instead of interrupting my workflow every time I wanted to understand a snippet, I built a Chrome extension that lets me explain code without ever leaving the page.

Now the process is simply:

Highlight the code.
Right-click.
Click Quick Explain This Code.

The extension handles everything else.

Why I Built It

The goal was not to create another AI chatbot.

There are already many excellent ones.

Instead, I wanted to reduce friction.

Developers already spend most of their time inside the browser:

GitHub
Stack Overflow
Documentation
Tutorials
Blogs

Rather than switching tabs every few minutes, the extension lets developers stay focused while still benefiting from AI assistance.

Features

The extension adds a custom entry to Chrome’s context menu.

Whenever text is selected, users can simply choose:

Quick Explain This Code

No copy-paste.

No additional windows.

No unnecessary clicks.

Multi-Provider AI Support

Instead of locking users into a single AI provider, the extension supports multiple APIs.

Currently supported:

NVIDIA API (Free api available in some countries)
OpenAI (Paid)
DeepSeek (Paid)
OpenRouter (Free api available)

For now, I didn’t want to walk the path of payment and subscriptions. So, I let the users choose whichever provider they prefer.

To be honest, this flexibility makes the extension useful for people with different budgets and preferences.

Choosing Models

Advanced users are not limited to default models. Each provider allows users to specify their own model of choice.

Light-users who would not want to choose any model, can leave it empty and the extension automatically falls back to a sensible default.

Lets be technical

Configuration

The extension stores settings using Chrome Storage Sync.

This includes:

Selected provider
API keys
Preferred model

Because Chrome Sync is used, settings can travel across browsers when the user is signed into Chrome.

Provider Abstraction

One design goal was avoiding provider-specific code throughout the project.

Instead, every provider is described using a configuration object.

{
  (url, defaultModel, apiKeyStorageKey, modelStorageKey, headers, defaults);
}

This approach made adding future providers significantly easier.

How Chrome Handles everything

The extension is built using Manifest V3. It’s been only a few days into building simple chrome extensions and as a javascript developer I am really enjoying it.

Service Worker

The background service worker is like the conductor of an orchestra. It doesn’t play every instrument itself, but it ensures everything happens at the right time and in the right order. It is responsible for:

Creating context menu items
Receiving messages from the user
Reading saved settings
Sending API requests
Returning AI responses to the user

Because Manifest V3 uses service workers, the extension remains lightweight and efficient.

Content Script

The content script is like the little performer working as the service worker tells it to do. It creates DOM elements, processes data and mostly acts as the bridge between webpages and the extension.

Its responsibilities include:

Receiving selected text
Sending requests to the service worker
Displaying explanations inside the page

The separation between the content script and the service worker keeps responsibilities clean and the code organized and maintainable.

Messaging Architecture

The extension relies heavily on Chrome’s messaging system.

The workflow looks like this:

User selects code
        │
        ▼
Context Menu
        │
        ▼
Background Service Worker
        │
        ▼
Content Script
        │
        ▼
AI Provider
        │
        ▼
Background Service Worker
        │
        ▼
Content Script
        │
        ▼
Explanation shown to user

Error Handling

One area I spent considerable time improving was error handling.

The extension gracefully handles situations such as:

Missing API keys
Invalid providers
Empty selections
API failures
Unexpected provider responses

Instead of failing silently, users receive meaningful feedback explaining what went wrong.

Good software isn’t just about successful requests, it should also fail gracefully.

Code Quality

As the project evolved, I began refactoring it to make it easier to maintain.

Instead of scattering provider-specific logic throughout the codebase, almost everything is driven by configuration.

For example:

Provider URLs
Default models
Placeholder text
Custom headers
Request defaults

This significantly reduces duplication and keeps the code in content script easy to understand and maintain.

When adding another provider in the future, very little application logic needs to change.

Current Limitations

Like every project, this extension still has room to grow.

Some planned improvements include:

Streaming AI responses
Conversation history
Better syntax highlighting
Follow-up questions
Additional AI providers
More customizable prompts

Streaming is especially exciting because explanations would begin appearing immediately instead of waiting for the complete response. But I think, without the chatting functionality it’s not needed that much at the moment.

Who Can Benefit?

This extension is useful for many different groups.

Students

Learning a new programming language often means reading unfamiliar code.

Instant explanations for simple snippets without leaving your current tab might reduce frustration and accelerate learning.

Self-Taught Developers

Self-learning is full of small moments where you think, “Wait… what does this line actually do?” Rather than breaking your concentration to ask an AI assistant in another tab, you can get an explanation exactly where you’re learning.

Professional Developers

Even experienced developers regularly encounter unfamiliar frameworks or libraries.

Quick explanations save time and reduce context switching.

Technical Writers

Understanding code snippets becomes much easier when AI can explain their purpose and structure directly within the browser.

Lessons Learned

Building this extension reinforced several important software engineering principles.

Configuration Beats Conditionals

Rather than writing:

if (provider === "openrouter") { ... }

if (provider === "nvidia") { ... }

if (provider === "openai") { ... }

a configuration-driven design keeps the code cleaner and far easier to extend.

Separation of Responsibilities

The project naturally divided into independent components:

Options page
Background service worker
Content script
Provider configuration

Each part has a single responsibility.

This makes debugging and future development significantly easier.

Good Error Messages Matter

Users don’t want mysterious failures.

They want clear explanations.

Investing time in descriptive error handling greatly improves the overall user experience.

Future Plans

I loved working with this extension and considering how much I use it, it feels more like a super personal tool rather than a webstore-published publicly available extension. So, I will definitely maintain it and add more features to make my own development experience smooth.

Some features I’d like to add include:

Adding a theory mode for students and a technical mode for developers
Support for additional providers such as Anthropic and Groq
Option to pin the dom element that shows the explanation
Saving history as well as a temporary mode
Response streaming
Keyboard shortcuts
Dark mode improvements
Prompt customization
Better markdown rendering
AI conversation mode

I have designed the architecture with these future additions in mind.

Final Thoughts

Explain That Code was built to solve a small but frequent annoyance in a developer’s workflow.

Instead of forcing developers to leave the page they’re reading, the extension brings AI assistance directly to where they’re already working.

Hopefully, it makes learning, reading, and understanding code just a little bit easier for everyone.

HackerNews discord bot

2021-09-05T00:00:00+06:00

I am too lazy to write about this bot.

Visit this link to know more about it.

If the bot is offline its because I am poor.

A roadmap for learning PHP

2021-08-30T00:00:00+06:00

If You are are new in programming and don’t know what php is, this will be a quick help for you. 🥹

So, when I wanted to learn php, it was not because I want to learn php rather it was because I had to learn laravel as a job requirement. I knew It was crazy to think about learning a framework without any prior knowledge in the language it was based upon. But as I already worked with django framework, I was pretty much desperate. So, I went through a lot of things like google, reddit, stackoverflow and what not to have the best suggestion from people who are already proficient in php. And yes, I found a lot of paths and roadmaps. So, I wanted to list them all in a single place to find them easily when needed.

After all my research and hours of internet surfing, what I learnt is if you don’t have at least some understanding of the basics, learning a framework as a first step is a bit of overkill. But if you are coming from another language or you are an experienced developer, it might not be that hard. It’s hard to appreciate what a good framework does for you if you don’t have a fair understanding of how things are often done without one.

Whenever I am learning a new thing (except for a game of course XD), I like to go through the documentation first. So, as a starter to know what php is and how php works, documentation is all you need.

If You are not a complete newbie in coding and you already know how things work in OOP this will be a quick help for you.

But if you are quite new or you want to have an in-depth knowledge in php syntaxes, functions and other built in features of php, The following free tutorials from youtube will surely help:

Tutorial 1

Tutorial 2

After you have mastered raw php, you can try to do some beginners project in php.

Remember, you need basic knowledge in HTML, CSS and javascript to understand and build these projects. You will also need a basic understanding of databases. Learning MySQL will be enough to start.

After you are done with learning basic php you can move on to learning a framework like Laravel, Symfony, CodeIgniter, CakePHP etc.

I am currently learning laravel. To learn laravel I can suggest 3 things of which 2 are free.

Laravel documentation The official laravel documentation is a great tool in learning laravel. But following the documentation only might not feel straight and smooth. There’s a ton of things you might get confused about. So, I would suggest to follow one tutorial at least. The next two options are actually two tutorials of which one is free and another is paid.
A free tutorial on Youtube
A tutorial on Udemy

It’s paid but it goes on sale often.

Regarding this tutorial, I think I should give a little review as it’s a paid one. In my opinion, the instructor, Edwin Diaz is one of the finest instructor on Udemy. He teaches in a way that you won’t be able to move your attention from him. You wont feel bored and overall, the tutorial is good.

Here, I have offered a pathway to learn laravel explicitely since I am learning laravel currently. May be in another post I will write about Why I chose laravel at the first place. Also, if I find more good resources which helped or might help me in my php journey I will append those in this post.

Useful Resources:

Mojipo.com A beautiful guide for becoming a php professional. Felt a bit newbie unfriendly to me.
Detailed roadmap on github For someone with zero knowledge in computers, coding and how things work on zeroes and ones as well as someone with any level of prior knowledge in coding. You can start from any section based on your current skill level.

SteamPy breakdown : Part 1

2021-05-21T00:00:00+06:00

In this post I am going to write about SteamPy, an SCM investment profit tracker for CS:GO items. Well, for now it can track only CS:GO items. I might add support for other games later.

If you want to know what does it do you should go through the documentation. Here I will be describing the ‘how does it do’ part only.

So, there are four files that run the program: main.py, get_price.py, operation.py and our beloved investment.ini file which just act as a config file.

This program is so small it could have been done within a single python file but I did use multiple files to better understand the concepts like importing, modulesm packages etc.

main.py file breakdown:

In the main.py file we have the import section at the top which holds all the necessary modules and packages.

from operation import *
import os
import configparser
import argparse

For the simplicity of understanding I will go to the main() function first and then we will go through the other functions as they are needed during the lifetime of our program.

So, in the main() function we have:

def main():
    option = get_arguments()
    operations(option)

Here, we are calling get_arguments() function to understand what arguments the user has given us. If we look into the function get_arguments() we can see we have two flags -s or --short and -l or --long for two different types of functionality. ArgumentParser() can store command line input string as objects and this information can be used by calling parse_args().

def get_arguments():
    parser = argparse.ArgumentParser(description="A python script to track your SCM investment profits easily.To make this programm give an efficient output, be as accurate as you can when filling up the investment.ini file. It is recommended that you put the name exactly as they are on SCM.",
    epilog="N.B. profit/loss is calculated after deducting the 15% steam tax.")
    parser.add_argument("-s", "--short",action='store_true', help="generate a short report: name and net profit/loss")
    parser.add_argument("-l","--long",action='store_true', help="generate a full detailed report of your investments")
    return parser.parse_args()

To get into more details about parsing arguments in python check out this.

After the user choice is received we pass it to the function operation() as a parameter. Now lets look at operation().

def operations(choice):
    if choice.long and choice.short:
        print("Use either -s or -l to generate a report, not both.")
    elif choice.long:
        details()
    elif choice.short:
        shortlist()
    else:
        print("Please use -s or -l with the command to generate a report. For more help, use -h")

Here, the code is a simple if else block which is checking the validity of the received argument. If it is not valid, the program shows some help texts, otherwise for option -l or --long, it calls details() and for -s or --short, it calls the function shortlist().

With this, breakdown of our main.py ends here.

Click here to continue to the next part.

CS:GO key binding and scripting on linux

2020-07-12T00:00:00+06:00

Buying weapons takes time in CS:GO and every second counts.

Before a round start we usually get a few seconds to buy things. Here, ‘things’ includes arms, different types of explosives and kits. Imagine you hit a keyboard key and items are bought instantly. No need to open the buy menu to buy items and waste time before every round starts.

I know that you already know about key binding in CS:GO.

For those who didn’t know, binding means to set a keyboard key to do some events like purchasing weapons, sending in-game messages or may be decrease your mouse sensitivity. Normally, you have to manually do these events in the particular interfaces. But if you bind keys to these events, they can be done only by a single key stroke.

I play CS:GO on my manjaro linux. So, when I searched the internet over tutorials and howtos on key binding, I found a lot. But all of them were for windows platform. I was at a loss what to do or which file to edit for linux. So, after doing a lot of file searching, some guessing I found the way to permanently bind CS:GO commands to keyboard keys.

Here is how you can do it too.

Finding the config.cfg file:

Basically to bind the commands you have to go to the following location on your file system:

/home/your_user_name/.local/share/Steam/userdata/1025583974/730/local/cfg/config.cfg

If you have multiple accounts registered in your steam cleint, you will find multiple directories inside the userdata directory. Inside the user directory you will look for a directory named 730 as it is the game code of CS:GO.

Before you start playing with the config file, I will highly recommend you to keep a backup of the file. To back up fire up the terminal in the directory containg the config file and give the following command

cp config.cfg config_backup.cfg

Binding a single command:

Now to bind commands to a key, you have to follow the following format:

bind “key_code” “command [arg]”

‘bind‘ is a keyword here, ‘key_code‘, ‘command‘ and ‘arg‘ (if there is) must be exchanged with actual key codes, command and the command’s argument respectively.

For example:

bind “p” “buy defuser”

Here, ‘p’ is the key code, ‘buy‘ is the command and ‘defuser‘ is the argument. Binding multiple commands:

You can also bind multiple commands to a single key, you have to follow the following format:

bind “key_code” “command1 [arg1]; command2 [arg2]”

For example: bind “l” “use weapon_c4;drop;say_team dropping bomb” Now, pressing ‘L’ will immediatly drop the c4 no matter which slot you are equipped with and a team message “dropping bomb” will be sent.

You have to append these commands in the config file each on a newline.

There is also another method to bind keys on the developer console. After binding, there you have to export the binds to a file. Then the contents of the files have to be pasted in the config file. That method is effective for newbies who has to check the functionality of the scripts by playing at the same time. But if you know what you are doing then I suggest you to directly append the bindings to the config file.

As I have experienced, on linux, this config.cfg file is executed automatically everytime your game launches. So, unlike windows, you won’t have to put any launch options to auto execute your config file everytime the game launches.

Here’s an example of some standard bindings.

// buy binds
bind “kp_home” “buy ak47; buy m4a1;”
bind “kp_uparrow” “buy awp;”
bind “kp_pgup” “buy negev;”
bind “kp_leftarrow” “buy flashbang;”
bind “kp_5” “buy smokegrenade;”
bind “kp_rightarrow” “buy molotov; buy incgrenade;”
bind “kp_end” “buy vesthelm;”bind “kp_downarrow” “buy defuser;”
bind “kp_pgdn” “buy p250;”
bind “kp_del” “buy vest;”
bind “kp_slash” “buy ump45;”
bind “kp_multiply” “buy p90;”

Once you’ve set your binds, your next step is to practice them and become adjusted to their functionality. This will inevitably take time to get used to, but the more you practice, the better you become. Eventually, the buy menu will be a breeze, giving you time to focus on strategy and get your head in the game.

You should also check the functionality of the ‘alias‘ command in CS:GO scripts to make your scripts simpler and more manageable.

Here is a tool to help you with generating buy binds.

Fix poor download speed in terminal when updating or installing new packages on manjaro

2020-07-03T00:00:00+06:00

I remember, like every other day I fired up my potato and may be an hour later when i finally logged in, I opened up terminal and wrote the divine mantra to make my device new.

sudo pacman -Syu

Then I saw the download speed was around a few kbps even though my internet speed was a decent one.

So, I surfed the internet and found out about pacman-mirrors. Pacman-mirrors is a Manjaro specific utility for generating and maintaining the system mirror-list.

Manjaro uses pacman as package manager for maintainence, updates, installations and removal of packages.

For pacman to function, a list of servers, or more commonly known as mirrors, with Manjaro software packages is required. As Manjaro has many mirrors all over the world it is feasible to use the mirrors closest to our location and preferably also up-to-date.

Here is how you can use pacman-mirrors to select the closest server so you get the best possible download speed.

To list available countries in the default mirror pool execute this command on your terminal:

pacman-mirrors --country-list

To list available countries in custom mirror pool execute this:

pacman-mirrors --country-config

To check what branch you are on:

pacman-mirrors --get-branch

Here was the main problem I was facing. I didn’t know that Bangladesh has an official manjaro mirror. It is hosted in Xeonbd’s Bangladesh Data Center since 2018. So, I configured my pacman-mirrors for a custom mirror pool (In this case it was Bangladesh, obviously) and my problem was solved.

To Update mirror-list with the fastest mirrors you can invoke this command:

sudo pacman-mirrors --fasttrack

Remember, after changing the mirror-list you have to synchronize pacman with the newly configured mirror-list.

You can synchronize pacman by this command:

sudo pacman -Syyu

So it’s better to execute the command like this:

sudo pacman-mirrors --fasttrack && sudo pacman -syyu

To use your current location as a mirror, you can invoke this command:

sudo pacman-mirrors --geoip && sudo pacman -Syyu

Note: Not all countries have mirrors, if geoip returns a country not in the pool all mirrors will be used.

Customize mirror pool by specific countries:

If you have checked the mirror-list and you are certain about using a custom mirror pool by some specific countries, you can use this command to do so:

sudo pacman-mirrors --country Germany,France,Austria && sudo pacman -Syyu

Customize mirror pool by interactive selection:

If you are not so comfortable supplying all arguments in commands, you can do this by an interactive selection too. This command will do it:

sudo pacman-mirrors --interactive --default && sudo pacman -Syyu

Here, using the --default flag will list all available mirrors and procotols in a gui windows allowing to sort the columns and interactively select according to your preferences. If you don’t use --default flag all the mirrors from current list (wheather default or not) will be listed.

When you save your selection, a custom mirror pool is created and will serve as your current mirror pool.

Don’t limit the mirror list in a custom pool too much. pacman will always use the up-to-date mirrors and ignore the other mirrors. So, keep in mind what you are doing.

The customized pool is saved as /var/lib/pacman-mirrors/custom-mirrors.json

If you think you have gone too far and dont know where you are and what to do, you can always reset everything. To apply pacman-mirrors defaults:

sudo pacman-mirrors --country all --api --protocol all -set-branch stable && sudo pacman -Syyu

The system will now throw messages about newer packages on the system. These messages can safely be ignored and they dissappear when the installed package(s) equals the system branch.

Hope this helped you solving your terminal download speed issue.

For more info on pacman-mirrors you can always head to our friend man:

man pacman-mirrors

To get help on usage:

$ pacman-mirrors --help

To check Version:

$ pacman-mirrors --version

I am glad if this piece of writing did help you in any way. All the informations here was taken from manjaro-wiki.

Installing Avro and fixing up Bangla font problem on Debian based Linux

2020-06-23T00:00:00+06:00

If you have installed a fresh debian based linux distro (Kali, Ubuntu, Deepin etc) and you need to work with Bangla font, you will need to install Avro and also some Bangla fonts.

Installing avro will let you type in Bangla where installing the fonts will fix the preview of joint letters (Jukta borno).

If you do not know what is avro, it’s a system which supports most modern English to Bangla phonetic typing method. For example, write anywhere “ami banglay gan gai” and it will be automatically typed as “আমি বাংলায় গান গাই”.

If you cant see the above bangla text or it appears as broken boxes in your bowser, installing the fonts will fix this issue.

In linux, you can install avro through ibus-avro. This software works as an Engine (plugin) of IBus and let users type in English and on-the-fly transliterate them phonetically to Bangla.

Features of ibus-avro:

100% compatible with the current Avro Phonetic scheme.
A preview window lets you see the originally typed text right under the cursor.
Enabling dictionary can predict and suggest phonetically similar words with correct spelling on the fly.
Commonly used English words are transliterated to Bangla (like, Facebook, download etc.) even with their original English spelling.
All the preferences are customizable.

Installing ibus-avro:

Step 1 – Installing dependencies:

You need to install the following packages. Use the command as shown below for debian based distros:

apt-get install git ibus libibus-1.0-dev automake autoconf gjs gir1.2-ibus-1.0 ibus-1.0

Step 2 – Installing ibus-avro:

Once the dependencies are installed, copy the git repository for ibus-avro through the following command:

git clone git://github.com/sarim/ibus-avro.git

After the completion of cloning, go inside the git directory, compile, configure and install ibus-avro by giving the following commands step by step:

cd ibus-avro
aclocal && autoconf && automake --add-missing 

If for some reasons, this command doesn’t work for you, just give the commands one by one, without using the && like shown below: aclocal autoconf automake –add-missing

after the successful completion of these 3 commands add the --prefix=/usr flag to configuration.

./configure --prefix=/usr 
sudo make install

Done.

Setting up Bangla as an input method:

Run IBus (Applications->System Tools->IBus)
Open IBus Preferences right-clicking the panel icon
Go to Input method
Select an input method -> Bengali -> Avro
Now Click Add button to add Avro to the list
Now restart IBus from the top panel icon (Right Click -> Restart)
Now Press Ctrl+Space to toggle between English and Avro (Bengali)
Enjoy Avro Phonetic!

Installing Bangla fonts:

Now that avro is installed, you can type in Bangla without any problem. There might be one more issue though. You are most likely to see certain joint letters not showing up properly (like: স্থান, শাস্ত্র, পঞ্চাশ etc).

If this is the case then you have to install some bangla fonts.

To install Bangla fonts:

Download some Bangla fonts from here.
Go to your home directory.
Turn show hidden files on, Create a directory named .fonts (if it’s not already there)
In that directory create a folder bangla_fonts and paste all the downloaded fonts there.
Open terminal, type this command fc-cache -fv and hit Return.
All the fonts should be loaded now.

Restart applications you were using in the running session and you will see everything is showing up correctly and no letters are broken or anything.

Reference for all texts

2019-08-31T00:00:00+06:00

h1

h2

h3

h4

h5

Lorem ipsum dolor amet tousled viral art party blue bottle single-origin coffee cardigan, selvage man braid helvetica. Banh mi taxidermy meditation microdosing. Selvage cornhole YOLO, small batch vexillologist raclette VHS prism sustainable 8-bit ugh semiotics letterpress disrupt pop-up. Celiac shabby chic ugh, jianbing whatever kitsch tattooed edison bulb kogi irony etsy.

Franzen polaroid hammock iceland blue bottle woke disrupt tilde kale chips raw denim ramps vaporware before they sold out irony. Narwhal vaporware offal shaman celiac kinfolk activated charcoal salvia lomo irony readymade normcore. Yr activated charcoal kombucha, man braid whatever biodiesel hella crucifix adaptogen bicycle rights small batch skateboard mixtape. Hot chicken sustainable green juice 90’s. Ennui kickstarter hella pug, meggings man bun shaman messenger bag. Chambray adaptogen kombucha pug affogato, kogi green juice distillery ugh banh mi.

VHS roof party waistcoat cold-pressed, snippet.CodeExample(); master cleanse affogato franzen. Shaman iceland pour-over intelligentsia typewriter tilde, pitchfork copper mug. Wayfarers kickstarter adaptogen vinyl beard kombucha. Organic pinterest master cleanse, mixtape fam gentrify lo-fi kogi.

var foo = function (bar) {
  return bar++;
};

console.log(foo(5));

java

fun main(args: Array<String>) {
    println("Hello, World!")
}

Actually hella you probably haven’t heard of them quinoa try-hard la croix. Street art schlitz actually hell of pour-over air plant. Post-ironic franzen brunch mumblecore readymade. Food truck photo booth polaroid, gochujang vegan street art yr before they sold out man bun. Tilde selfies chia pitchfork everyday carry post-ironic mumblecore sartorial VHS master cleanse activated charcoal biodiesel williamsburg cronut jean shorts. Poutine helvetica keffiyeh butcher pop-up.

Photo by K. Mitch Hodge on Unsplash

f4him

Currency Converter Chrome Extension – A Deep Dive

Currency Converter

Introduction

What the Extension Does

Why It Matters

How It Works

1. Detecting Price Content

2. Identifying the Currency

3. Fetching Exchange Rates

4. Formatting the Converted Value

5. Injecting a Visual Overlay

The Architecture Behind the Extension

Manifest and Background Logic

Content Scripts

Currency Definitions

Site-Specific Adapters

Why the Service Worker Design Was Important

Performance and User Experience

Caching for Efficiency

Lightweight UI

How the Extension Handles Real-World Web Pages

Privacy and Simplicity

Installation and Usage

What Makes the Project Interesting

Future Possibilities

Final Thoughts

Explain That Code: From Copy-Pasting Code into ChatGPT to Building My Own Chrome Extension

Explain That Code

Introduction

Why I Built It

Features

Right-Click Context Menu

Multi-Provider AI Support

Choosing Models

Lets be technical

Configuration

Provider Abstraction

How Chrome Handles everything

Service Worker

Content Script

Messaging Architecture

Error Handling

Code Quality

Current Limitations

Who Can Benefit?

Students

Self-Taught Developers

Professional Developers

Technical Writers

Lessons Learned

Configuration Beats Conditionals

Separation of Responsibilities

Good Error Messages Matter

Future Plans

Final Thoughts

HackerNews discord bot

A roadmap for learning PHP

SteamPy breakdown : Part 1

main.py file breakdown:

CS:GO key binding and scripting on linux

Finding the config.cfg file:

Binding a single command:

Fix poor download speed in terminal when updating or installing new packages on manjaro

To list available countries in the default mirror pool execute this command on your terminal:

To list available countries in custom mirror pool execute this:

To check what branch you are on:

To Update mirror-list with the fastest mirrors you can invoke this command:

You can synchronize pacman by this command:

To use your current location as a mirror, you can invoke this command:

Customize mirror pool by specific countries:

Customize mirror pool by interactive selection:

Installing Avro and fixing up Bangla font problem on Debian based Linux

Installing ibus-avro:

Setting up Bangla as an input method:

Installing Bangla fonts:

Reference for all texts

h1

h2

h3