DEV Community: OdaloV

Building on the Blockchain: A Developer's Guide to Solidity & Smart Contracts

OdaloV — Mon, 01 Jun 2026 17:48:28 +0000

"Code is law — and on Ethereum, it runs forever."

What Is a Smart Contract?

A smart contract is a self-executing program stored on a blockchain. It runs automatically when predefined conditions are met. No middlemen, no downtime, no censorship.

Immutable (once deployed, the logic doesn't change)
Transparent (anyone can read the code)
Trustless (no central authority needed)
Global (accessible from anywhere on Earth)

Solidity

Solidity is the primary language for writing smart contracts on Ethereum and EVM-compatible chains like Polygon, BNB Chain, Avalanche, Base and others.

It's a statically-typed, contract-oriented language with syntax that feels familiar if you've used JavaScript, C++, or Java.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract HelloBlockchain {
    string public message = "gm, world";

    function setMessage(string calldata _msg) external {
        message = _msg;
    }
}

Core Concepts

1. State Variables & Storage

Everything stored on-chain costs gas. Be deliberate.

contract Bank {
    mapping(address => uint256) public balances; // stored on-chain
    uint256 public totalDeposits;
}

2. Functions & Visibility

Modifier	Who Can Call
`public`	Anyone (internal + external)
`external`	Only from outside the contract
`internal`	Only this contract + children
`private`	Only this contract

3. Payable Functions — Receiving ETH

function deposit() external payable {
    balances[msg.sender] += msg.value;
    totalDeposits += msg.value;
}

msg.sender = the caller's address

msg.value = ETH sent with the call (in wei)

4. Events — Your On-Chain Logs

Events are cheap to emit and essential for off-chain apps to track activity.

event Deposited(address indexed user, uint256 amount);

function deposit() external payable {
    balances[msg.sender] += msg.value;
    emit Deposited(msg.sender, msg.value);
}

5. Modifiers — Reusable Guards

modifier onlyOwner() {
    require(msg.sender == owner, "Not the owner");
    _;
}

function withdraw(uint256 amount) external onlyOwner {
    payable(owner).transfer(amount);
}

A Real Example: Simple Token

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract SimpleToken {
    string public name = "DevToken";
    string public symbol = "DEV";
    uint8 public decimals = 18;
    uint256 public totalSupply;

    mapping(address => uint256) public balanceOf;

    event Transfer(address indexed from, address indexed to, uint256 value);

    constructor(uint256 _initialSupply) {
        totalSupply = _initialSupply * 10 ** decimals;
        balanceOf[msg.sender] = totalSupply;
    }

    function transfer(address to, uint256 amount) external returns (bool) {
        require(balanceOf[msg.sender] >= amount, "Insufficient balance");
        balanceOf[msg.sender] -= amount;
        balanceOf[to] += amount;
        emit Transfer(msg.sender, to, amount);
        return true;
    }
}

This is the essence of an ERC-20 token. The real standard adds approve, transferFrom, and allowance but this gives you the foundation.

Security: The Non-Negotiables

Smart contract bugs are permanent and public. The stakes are high.

Reentrancy Attack

The infamous bug behind the $60M DAO hack (2016).

// VULNERABLE 
function withdraw() external {
    uint256 amount = balances[msg.sender];
    (bool success,) = msg.sender.call{value: amount}(""); // external call BEFORE state update
    balances[msg.sender] = 0; // too late
}

// SAFE 
function withdraw() external {
    uint256 amount = balances[msg.sender];
    balances[msg.sender] = 0;           // 1. Update state
    (bool success,) = msg.sender.call{value: amount}(""); // 2. Then interact
    require(success, "Transfer failed");
}

Rule: Always update state before making external calls.

Other Common Pitfalls

Integer overflow/underflow — Solidity 0.8+ handles this automatically with built-in checks
tx.origin vs msg.sender — Never use tx.origin for authorization
Unchecked return values — Always check the return value of call()
Timestamp dependence — block.timestamp can be manipulated slightly by miners

The Developer Toolchain

Tool	Purpose
Hardhat	Local dev environment, testing, deployment
Foundry	Blazing-fast testing in Solidity itself
Remix IDE	Browser-based IDE, great for prototyping
OpenZeppelin	Battle-tested contract libraries
Ethers.js / Viem	JavaScript libraries to interact with contracts
Alchemy / Infura	Node providers for mainnet/testnet access

Quick Start with Hardhat

mkdir my-contract && cd my-contract
npm init -y
npm install --save-dev hardhat
npx hardhat init

Deploy a Contract

// scripts/deploy.js
const { ethers } = require("hardhat");

async function main() {
  const Token = await ethers.getContractFactory("SimpleToken");
  const token = await Token.deploy(1_000_000);
  await token.waitForDeployment();
  console.log("Deployed to:", await token.getAddress());
}

main().catch(console.error);

npx hardhat run scripts/deploy.js --network sepolia

Gas Optimization Tips

Gas efficiency = lower costs for your users = competitive advantage.

//  Expensive: reading from storage in a loop
for (uint i = 0; i < users.length; i++) {
    total += balances[users[i]];
}

//  Cheaper: cache storage reads in memory
uint256 len = users.length;
for (uint i = 0; i < len; i++) {
    total += balances[users[i]];
}

Other wins:

Use uint256 over smaller types ,the EVM works in 32-byte slots.
Mark functions view or pure when they don't modify state
Use calldata instead of memory for external function parameters
Pack struct variables to fit in fewer storage slots
Emit events instead of storing data you only need off-chain

Contract Standards Worth Knowing

Standard	What It Is
ERC-20	Fungible tokens (USDC, DAI, UNI)
ERC-721	Non-fungible tokens / NFTs
ERC-1155	Multi-token standard (games, etc.)
ERC-4626	Tokenized vaults (DeFi yield)
EIP-2612	Gasless approvals via signatures

OpenZeppelin has production-ready implementations of all of these:

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract MyToken is ERC20 {
    constructor() ERC20("MyToken", "MTK") {
        _mint(msg.sender, 1_000_000 * 10 ** decimals());
    }
}

Testing

// test/Token.test.js (Hardhat + Ethers)
const { expect } = require("chai");
const { ethers } = require("hardhat");

describe("SimpleToken", function () {
  it("should assign total supply to deployer", async function () {
    const [owner] = await ethers.getSigners();
    const Token = await ethers.getContractFactory("SimpleToken");
    const token = await Token.deploy(1000);

    const balance = await token.balanceOf(owner.address);
    expect(balance).to.equal(await token.totalSupply());
  });

  it("should transfer tokens correctly", async function () {
    const [owner, recipient] = await ethers.getSigners();
    const Token = await ethers.getContractFactory("SimpleToken");
    const token = await Token.deploy(1000);

    await token.transfer(recipient.address, ethers.parseUnits("100", 18));
    const recipientBalance = await token.balanceOf(recipient.address);
    expect(recipientBalance).to.equal(ethers.parseUnits("100", 18));
  });
});

Final Thoughts

Smart contract development is one of the most high-stakes disciplines in software. A bug that slips through in a web app might annoy users. A bug in a smart contract holding $10M can be catastrophic and irreversible.

The upside? You're building programmable money, unstoppable applications, and trustless infrastructure that can outlive any company or server.

Middleware in Go

OdaloV — Thu, 14 May 2026 16:26:13 +0000

If you've built any web application in Go, you've probably heard about middlewares. But what exactly are they?

A middleware is just a function that sits between your HTTP server and your route handlers. It can inspect, modify, or even stop a request before it reaches your main application logic.

Think of it as a pipeline.Every request passes through each middleware in order before hitting your handler, and the response travels back through them on the way out.

Example

A middleware accepts a handler and returns a new one:

func MyMiddleware(next HandlerFunc) HandlerFunc {
    return func(c Context) error {
        // runs before your handler
        err := c.Next(next)
        // runs after your handler
        return err
    }
}

c.Next()

When you register multiple middlewares, your framework doesn't run them independently. It builds a chain. Each middleware wraps the next one, like nested functions. c.Next() is the call that says ,pass control to whatever comes next in that chain.

Without it, the chain stops dead. Your route handler never runs, and the client gets no response.

This also means you can intentionally skip it to reject a request early:

func RequireAuth(next HandlerFunc) HandlerFunc {
    return func(c Context) error {
        if c.Request().Header.Get("Authorization") == "" {
            return c.String(http.StatusUnauthorized, "unauthorized")
        }
        return c.Next(next) // only reach here if auth passes
    }
}

Registering middleware

Most frameworks let you attach middleware at three levels.

Global middleware runs on every single request your app receives ,logger and panic recovery belong here:

app.Use(Logger)
app.Use(Recover)

Group middleware applies only to a subset of routes. This is the right place for auth ,you probably don't want to guard your /health endpoint the same way you guard /api/users:

api := app.Group("/api")
api.Use(RequireAuth)

Route-level middleware is for one-off logic that doesn't belong anywhere else:

app.GET("/admin", adminHandler, RequireAdmin)

If a middleware needs to run everywhere, make it global. If it only makes sense for a set of routes, scope it to a group. Route-level is a last resort.

Kenya's proposed AI Bill 2026

OdaloV — Mon, 11 May 2026 08:30:49 +0000

Kenya has the highest AI adoption rate globally – 97.5% of internet users engage with AI monthly (Digital 2026). 68% of Kenyan firms aim for full AI adoption by end of 2026 (KPMG).

But the proposed AI Bill, 2026 has issues:
1. Prison time for locals. Violations carry fines up to $38,000 and three years in jail. Directors must prove their innocence, reversing Kenya's constitutional burden of proof.

2. A loophole for Big Tech. OpenAI's clinical AI runs in 16 Nairobi clinics. A Dutch TB screener processes thousands of X-rays. Google is testing maternal ultrasound. None are explicitly covered. A local dev faces prison. OpenAI faces nothing.

3. No evidence of harm. The Bill was drafted without consulting health, agriculture, or finance sectors about what AI harms they actually experience. It defaults to maximum deterrence (prison) by reflex, not data.

The fix: Remove criminal penalties, close the foreign loophole, and follow the EU model of administrative fines.

Kenya's developers deserve precision.

[Boost]

OdaloV — Mon, 11 May 2026 08:23:33 +0000

Digital Hoarding

OdaloV — Sat, 11 Apr 2026 15:52:47 +0000

A personal journey through 4GB of laptop clutter and over 800 phone screenshots I'll never look at again

The discovery

During some late-night reading, I stumbled across a 2025 paper by Liu & Liu in Frontiers in Psychology on something called digital hoarding.
I'd never heard the term before.
But as I kept reading, I felt Called out.

They defined it as: "The compulsive accumulation of digital files to the point of distress and disorganization."
And I thought to myself ,that's not only a research subject. that's my laptop,and probably my phone too.

On my laptop:

~/Downloads – 47 PDFs, 12 driver installers, 3 tutorials I never finished. Oldest: 2019
~/Desktop – Screenshots of error messages I Googled and fixed. Oldest: 2021
~/code/experiments – 23 half-built projects, 18 with broken dependencies. Oldest: 2020
~/Documents/old-work – Repos from two jobs ago. Two jobs ago! Oldest: 2018

On my phone:

Screenshots folder – 1,112 images. Error messages, tweets, "read later" articles, memes.
Photos (duplicates) – The same picture saved 3-4 times.
Old app caches – 2.1 GB from apps I haven't opened in months.
Voice notes – 47 recordings. "Reminder to self" from 2022 to 2026.
WhatsApp images – From groups I left in 2023.

I was a digital hoarder with a terminal and a smartphone addiction.

What Liu & Liu taught me

The paper described digital hoarding as a "double-edged sword."
On one edge: It feels responsible. "I might need this someday." "Better to save it than lose it."
On the other edge: It's actively hurting me — on every device I own.
They listed consequences that hit too close to home:

Cognitive load – Every extra file is a tiny decision I don't make
Decision fatigue – Which of these 14 project folders is the real one?
Anxiety – "What if I delete something important?"
Battery drain – Your phone constantly indexing thousands of unused files

And the part that really got me: "A protective behavior that eventually becomes a burden."

The hidden cost never measured

Before cleanup:

Storage used: 10 GB
Boot time: 48 seconds
Search time: 6-8 seconds
Battery life: ~6 hours
Backup time: 45 minutes

After deleting 500+ old files and 2,000+ screenshots:

Storage used: 8 GB (down 2 GB)
Boot time: 31 seconds (down 35%)
Search time: 1-2 seconds (down 75%)
Battery life: ~8 hours (up 33%)
Backup time: 12 minutes (down 73%)

No hardware upgrade. No factory reset. Just… deleting things.

The developer-specific hoarding patterns

Liu & Liu didn't study developers specifically. But I noticed patterns unique to our craft — and how they spill onto our phones.

1: The tutorial graveyard

We start a tutorial. Clone the repo. Follow along for 30 minutes. Get distracted. Never finish.
But we keep the folder. Just in case.
My count: 23 unfinished tutorial projects. 18 using packages that are now deprecated.

2: The error screenshot museum

Something breaks. We screenshot the error on our laptop. Then we Google it. Fix it. Feel proud.
But we never delete some of the screenshots.
My count: 110 laptop screenshots + 1,110 phone screenshots. I will never look at 99% of them again.

3: I'll refactor this someday

Old projects. Old code. Old mistakes. We keep them like trophies.
My count: 4GB of code I haven't touched in over two years.

4: The screenshot spiral

See something interesting? Screenshot. Want to remember a tweet? Screenshot. Need to save a receipt? Screenshot.
Then never organize them. Never look at them. Never delete them.
My count: 1,112 screenshots. I remember taking maybe 200 of them.

5: The "I'll clean this later" cache (phone)

Apps cache images, videos, and files. We ignore it. It grows. We run out of storage.
My count: 2 GB of "System Data" — a black hole of forgotten files.

Liu & Liu ended their paper with a question:

"How do we design systems that support selective retention rather than indiscriminate accumulation?"
I don't have an answer. But for me,I'll start small. One old file. One screenshot. One deleted folder at a time.

Progressive Web Apps (PWAs): The Best of Both Worlds

OdaloV — Sun, 01 Mar 2026 12:38:02 +0000

What is PWA?

Progressive Web Apps are regular websites built with standard web technologies such as HTML, CSS and JavaScript, that progressively enhance to deliver an app-like experience. They work in any browser but can be installed on your device like a native app. Think of them as websites that put on an app costume.

Core Technologies

HTTPS - Secure connection required for all modern web capabilities.
Web App Manifest - A JSON file defining your app's name, icons, colors, and launch behavior.
Service Workers - Background scripts that enable offline functionality, caching, and push notifications.

Why PWAs Matter

For Users

Install with one click - No app stores, no approvals, no fees.
Works offline - Access content even without internet.
Lightweight
Cross-platform - Same app works on any device with a browser.

For Developers

Single codebase - One app for all platforms instead of separate iOS/Android builds.
Lower costs - PWA development ranges from $15,000-$150,000 versus $50,000+ per native platform.
No app store gatekeepers - Deploy updates instantly without waiting for approval.
SEO-friendly - PWAs are indexable by search engines unlike native apps.

Real-World Example

Microsoft:

Microsoft took a data-driven approach to PWAs, automatically identifying 1.5 million progressive web apps for inclusion in the Windows Store. This discovery opened up a massive ecosystem of applications that could run natively on Windows without any additional development work.

The impact was twofold:

Users gained access to millions of apps without waiting for developers to build Windows-specific versions
Developers saw their apps appear in the Windows Store automatically—no extra effort required

Microsoft's embrace of PWAs validated that the technology wasn't just for small projects—it was a legitimate distribution channel for the world's largest operating system.

When to Choose PWA

PWAs are ideal for :

E-commerce - Higher conversions, better mobile experience.

Content-driven apps - News, blogs, media.

Businesses with limited budget - One app for all platforms.

Emerging markets - Works on slow connections.

The web is evolving, and PWAs are leading the charge toward a future where the line between websites and apps disappears entirely.

Agentic-AI :Simple tools to autonomous partners

OdaloV — Mon, 02 Feb 2026 09:26:32 +0000

If you have been following AI development,then you've seen the shift, from ChatGPT answering questions to Devin writing entire codebases. From simple chatbots to systems that plan, execute, and adapt.

What Makes an AI Agentic?

Agentic AI is about ,agency,the capacity to act independently toward goals. While a traditional AI model generates text based on patterns, an AI agent:

Sets and pursues goals
Breaks problems into steps
Uses tools to interact with the world
Learns from feedback
Adapts its approach when stuck

It's like moving from a calculator;executes commands, to a mathematician;solves problems using tools and reasoning.

The Fundamental Loop: Perception → Reasoning → Action

The simplest theoretical model of an AI agent is the Perception-Reasoning-Action cycle:
In practice with LLMs, this becomes the ReAct pattern (Reason + Act):

    python

    # How an AI agent thinks and acts
    def agent_loop(objective, tools, memory):
    while not objective.achieved():
    # 1. PERCEPTION: Look around
    observation = perceive_environment()

    # 2. REASONING: Think about next step
    thought = llm_reason(objective, observation, memory)

    # 3. ACTION: Do something with tools
    action = choose_action(thought, tools)
    result = execute_action(action)

    # 4. UPDATE: Learn and continue
    memory.update(thought, action, result)

return "Task completed"

Breaking It Down with Fast Food

Let's say you're craving KFC and tell an AI agent: "Get me KFC for dinner"

Old-School AI (Traditional Chatbot)

Would give you instructions:

Go to the KFC website or use Glovo

Agentic AI (Autonomous Assistant)

Actually does it for you. Here's how it thinks:

Agent's Thought Process:

PERCEIVES:

Checks your current location

Remembers you ordered KFC last Tuesday

Notes you usually ask for extra ketchup
REASONS :

They want KFC. Let me check where they are

Found 3 KFCs nearby. Which one has the shortest wait time?

They like the Zinger Burger based on last order.

Should check for any discounts or offers
ACTS :

Searches for nearby KFC locations

Checks opening hours and current wait times

Compares prices and specials

Places the order via API

Tracks the delivery in real-time
UPDATES :

Noted: they want extra ketchup. Remember for next time.

The bottom line: The agent doesn't just talk about KFC ,it gets you the actual chicken.

Why This Matters
Agentic AI represents a fundamental shift:

You give goals, not step-by-step instructions

AI handles complex multi-step processes

Systems improve through experience

One agent replaces what used to take multiple tools