HasLab by Lutfi | Blog

Vibe Coding: The Programming Revolution Taking 2025 by Storm

Mon, 23 Jun 2025 15:02:00 GMT

The software development landscape is experiencing a seismic shift in 2025, and it has a name: vibe coding. This revolutionary approach to programming is changing how we think about software development, making it more accessible while sparking intense debates about the future of coding itself.

What Exactly is Vibe Coding?

Section titled “What Exactly is Vibe Coding?”

Vibe coding represents a fundamental departure from traditional programming methodologies. Instead of manually writing lines of code, developers use natural language descriptions to instruct AI agents to generate working software. The term was popularized by computer scientist Andrej Karpathy, co-founder of OpenAI and former AI leader at Tesla, in February 2025.

At its core, vibe coding is about focusing on the creative aspects of app development rather than getting bogged down in technical implementation details. It’s a conversational approach where you describe what you want your software to do, and AI tools transform those descriptions into functional code.

The Vibe Coding Process

Section titled “The Vibe Coding Process”

The methodology typically follows these steps:

Natural Language Description: Explain your desired functionality in plain English
AI Code Generation: Let AI tools create the initial codebase
Iterative Refinement: Work collaboratively with AI to improve and modify the code
Outcome-Focused Development: Concentrate on what the code should accomplish rather than how to write it
Rapid Prototyping: Build functional applications quickly without deep technical expertise

Popular Tools Driving the Movement

Section titled “Popular Tools Driving the Movement”

Several platforms have emerged as leaders in the vibe coding space:

Replit: Web-based coding environment with integrated AI assistance
Cursor: AI-powered code editor designed for natural language programming
GitHub Copilot: Microsoft’s AI pair programmer
Claude and other LLMs: Conversational AI tools for code generation

These tools are particularly popular among Y Combinator startups, enabling rapid development and launch of AI-powered applications.

The Bright Side: Why Vibe Coding is Gaining Traction

Section titled “The Bright Side: Why Vibe Coding is Gaining Traction”

Democratization of Development

Section titled “Democratization of Development”

Vibe coding’s most compelling advantage is its ability to lower the barrier to entry for software development. People with innovative ideas but limited coding experience can now create functional applications by simply describing their vision in natural language.

Speed and Efficiency

Section titled “Speed and Efficiency”

The approach enables unprecedented development speed. What once took weeks of coding can now be accomplished in hours or days. This rapid prototyping capability is particularly valuable for:

MVP development for startups
Quick proof-of-concept builds
Experimental feature testing
Automation script creation

Creative Focus

Section titled “Creative Focus”

By removing the burden of syntax and implementation details, vibe coding allows developers to focus on creative problem-solving and user experience design rather than technical minutiae.

The Dark Side: Limitations and Risks

Section titled “The Dark Side: Limitations and Risks”

Code Quality Concerns

Section titled “Code Quality Concerns”

The most significant criticism of vibe coding centers on code quality. Many vibe-coded projects may appear functional on the surface but harbor serious underlying issues including:

Absent or inadequate error handling
Poor performance optimization
Questionable security practices
Logically fragile code architecture

Technical Debt Accumulation

Section titled “Technical Debt Accumulation”

Vibe coding can create substantial technical debt through:

Inconsistent Coding Patterns: AI generates solutions based on different prompts without unified architectural vision
Patchwork Codebases: Similar problems solved in dissimilar ways throughout the application
Maintenance Challenges: Difficulty in understanding and modifying AI-generated code

Security Vulnerabilities

Section titled “Security Vulnerabilities”

The automated nature of vibe coding introduces new security risks:

AI may inadvertently generate code with security flaws
Difficulty in comprehensive code review
Unknown vulnerabilities in AI-generated solutions
Lack of security-first thinking in the development process

Skill Erosion Risk

Section titled “Skill Erosion Risk”

Perhaps the most concerning long-term implication is the potential impact on developer skills. Over-reliance on AI tools may lead to:

Weakened programming fundamentals
Reduced understanding of system architecture
Diminished debugging and problem-solving abilities
Loss of critical thinking in software design

The Enterprise Reality Check

Section titled “The Enterprise Reality Check”

While vibe coding excels in rapid prototyping and experimentation, it faces significant challenges in enterprise environments where factors like performance, accessibility, security, maintainability, and cost efficiency are paramount. Traditional software engineering practices remain crucial for production systems that require reliability and scalability.

Finding the Balance: The Future of Vibe Coding

Section titled “Finding the Balance: The Future of Vibe Coding”

The most promising path forward involves treating vibe coding as a powerful complement to, rather than replacement for, traditional programming skills. The optimal approach might involve:

Using vibe coding for rapid prototyping and ideation
Applying traditional programming practices for production systems
Maintaining strong foundational programming knowledge
Leveraging AI tools to enhance rather than replace human expertise

Conclusion: A Tool, Not a Revolution

Section titled “Conclusion: A Tool, Not a Revolution”

Vibe coding represents an exciting evolution in software development, offering unprecedented accessibility and speed. However, like any powerful tool, it comes with trade-offs that developers and organizations must carefully consider.

The key to success in the vibe coding era isn’t choosing between AI-assisted development and traditional programming—it’s learning to use both approaches strategically. As we navigate this new landscape, the developers who thrive will be those who can harness the power of vibe coding while maintaining the critical thinking and fundamental skills that make great software possible.

The vibe coding trend is here to stay, but it’s not the end of programming as we know it. Instead, it’s the beginning of a new chapter where human creativity and AI capability combine to push the boundaries of what’s possible in software development.

What are your thoughts on vibe coding? Have you experimented with AI-assisted development in your projects? The conversation about the future of programming is just getting started.

Golang and Web Frameworks

Wed, 04 Jun 2025 12:47:00 GMT

In the modern world of web development, choosing the right programming language and framework is crucial for building scalable, efficient, and maintainable applications. Golang (Go) has emerged as a powerful player in this space due to its simplicity, concurrency model, and performance characteristics. When combined with lightweight frameworks like Gin and Fiber, Go becomes an excellent choice for building high-performance web services.

In this blog post, we’ll explore:

Why choose Go for web development
Introduction to popular Go web frameworks: Gin and Fiber
Performance comparison between Gin and Fiber
How Go stacks up against other languages like Node.js, Python, and Java
Use cases where Go excels

Why Choose Golang for Web Development?

Section titled “Why Choose Golang for Web Development?”

Go was developed by Google to solve real-world problems faced by large-scale systems. It’s known for:

Simplicity: Minimalist syntax and small learning curve.
Concurrency: Built-in support via goroutines and channels.
Compilation Speed: Fast compilation into native binaries.
Performance: Near-C speed with garbage collection.
Standard Library: Rich set of packages for networking, HTTP, JSON, etc.

These features make Go particularly well-suited for cloud-native applications, microservices, and APIs.

Popular Go Web Frameworks: Gin and Fiber

Section titled “Popular Go Web Frameworks: Gin and Fiber”

While Go’s standard net/http package is robust enough for many use cases, frameworks like Gin and Fiber offer additional features and productivity enhancements without sacrificing performance.

1. Gin

Section titled “1. Gin”

Gin is one of the most popular Go web frameworks. It’s fast, flexible, and comes with a lot of built-in functionality such as middleware support, routing, and JSON validation.

Key Features:

Section titled “Key Features:”

High performance (often cited as one of the fastest Go routers)
Middleware support (JWT, logging, recovery, etc.)
Built-in rendering (HTML, JSON, XML)
Easy to test and debug

Example:

Section titled “Example:”

package main

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

func main() {
    r := gin.Default()
    r.GET("/hello", func(c *gin.Context) {
        c.JSON(200, gin.H{
            "message": "Hello from Gin!",
        })
    })
    r.Run(":8080")
}

2. Fiber

Section titled “2. Fiber”

Fiber is a relatively newer framework inspired by Express.js. It’s designed specifically for performance and developer experience, especially appealing to developers coming from JavaScript backgrounds.

Fiber runs on top of Fasthttp, which is faster than Go’s default net/http.

Key Features:

Section titled “Key Features:”

Extremely fast thanks to Fasthttp
Express-like API for easy adoption
Lightweight and modular
Built-in WebSocket support
Zero memory allocation in many operations

Example:

Section titled “Example:”

package main

import "github.com/gofiber/fiber/v2"

func main() {
    app := fiber.New()
    app.Get("/hello", func(c *fiber.Ctx) error {
        return c.JSON(fiber.Map{
            "message": "Hello from Fiber!",
        })
    })
    app.Listen(":3000")
}

Performance Comparison: Gin vs Fiber

Section titled “Performance Comparison: Gin vs Fiber”

Both Gin and Fiber are highly performant, but there are subtle differences depending on your use case.

Feature	Gin	Fiber
Base Router	Custom	Fasthttp
Throughput	~60k req/sec	~100k+ req/sec
Memory Usage	Moderate	Very Low
Middleware Support	Yes	Yes
Learning Curve	Slight learning	Familiar to JS devs
Community Size	Large	Growing rapidly

📌 Conclusion: If you need maximum performance and lower memory usage, Fiber might be the better option. For more mature ecosystems and broader community support, Gin is often preferred.

Go vs Other Languages: A Comparative Overview

Section titled “Go vs Other Languages: A Comparative Overview”

Let’s compare Go with some of the most widely used backend languages: Node.js, Python, and Java.

Criteria	Go (Gin/Fiber)	Node.js (Express/NestJS)	Python (Flask/Django)	Java (Spring Boot)
Performance	⭐⭐⭐⭐⭐	⭐⭐⭐	⭐⭐	⭐⭐⭐⭐
Concurrency Model	⭐⭐⭐⭐⭐	⭐⭐	⭐	⭐⭐⭐
Ease of Use	⭐⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐⭐	⭐⭐
Compilation Time	⭐⭐⭐⭐⭐	N/A (interpreted)	N/A	⭐
Ecosystem Size	⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐⭐
Scalability	⭐⭐⭐⭐⭐	⭐⭐⭐	⭐⭐	⭐⭐⭐⭐
Ideal For	APIs, Microservices	Real-time apps	Prototyping, ML	Enterprise apps

Why Go Stands Out:

Section titled “Why Go Stands Out:”

Concurrency at scale using goroutines beats Node.js async and Java threads.
Native compilation allows for minimal Docker images and fast startup times.
Low resource usage makes it ideal for edge computing and serverless environments.

Real-World Use Cases

Section titled “Real-World Use Cases”

Here are some scenarios where Go shines:

✅ Microservices Architecture

Section titled “✅ Microservices Architecture”

Go’s low overhead and concurrency model make it perfect for building scalable microservices.

✅ Cloud-Native Applications

Section titled “✅ Cloud-Native Applications”

Used extensively in Kubernetes, Docker, and Terraform — all written in Go.

✅ APIs and REST Services

Section titled “✅ APIs and REST Services”

High throughput and low latency with Gin or Fiber.

✅ CLI Tools

Section titled “✅ CLI Tools”

Go compiles to static binaries, making it ideal for cross-platform command-line tools.

Final Thoughts

Section titled “Final Thoughts”

If you’re looking for a language that balances performance, simplicity, and scalability, Golang is a fantastic choice. With frameworks like Gin and Fiber, building fast and reliable web applications becomes both efficient and enjoyable.

Whether you’re migrating from another language or starting fresh, Go offers a compelling alternative to traditional backend stacks like Python + Django or Java + Spring.

So why not give Go a try? Your next high-performance backend could be just a few lines of code away.

Rich Text Editor for React or NextJS

Thu, 08 May 2025 17:55:00 GMT

I’m thinking of making a mini project, a shared notepad, but I found the default Textarea limited. So I decided to find a Rich Text Editor, with options like CKEditor, Slate Rich Text Editor and Quill Text Editor.

CKEditor is a commercial Rich Text Editor with a free license option, but I changed my mind. I think an open source one would be better, I first tried SlateJS:

import React, { useCallback, useMemo } from 'react'
import isHotkey from 'is-hotkey'
import { Editable, withReact, useSlate, Slate } from 'slate-react'
import {
  Editor,
  Transforms,
  createEditor,
  Descendant,
  Element as SlateElement,
} from 'slate'
import { withHistory } from 'slate-history'

import { Button, Icon, Toolbar } from '../components'

const HOTKEYS = {
  'mod+b': 'bold',
  'mod+i': 'italic',
  'mod+u': 'underline',
  'mod+`': 'code',
}

const LIST_TYPES = ['numbered-list', 'bulleted-list']
const TEXT_ALIGN_TYPES = ['left', 'center', 'right', 'justify']

const RichTextExample = () => {
  const renderElement = useCallback(props => <Element {...props} />, [])
  const renderLeaf = useCallback(props => <Leaf {...props} />, [])
  const editor = useMemo(() => withHistory(withReact(createEditor())), [])

  return (
    <Slate editor={editor} initialValue={initialValue}>
      <Toolbar>
        <MarkButton format="bold" icon="format_bold" />
        <MarkButton format="italic" icon="format_italic" />
        <MarkButton format="underline" icon="format_underlined" />
        <MarkButton format="code" icon="code" />
        <BlockButton format="heading-one" icon="looks_one" />
        <BlockButton format="heading-two" icon="looks_two" />
        <BlockButton format="block-quote" icon="format_quote" />
        <BlockButton format="numbered-list" icon="format_list_numbered" />
        <BlockButton format="bulleted-list" icon="format_list_bulleted" />
        <BlockButton format="left" icon="format_align_left" />
        <BlockButton format="center" icon="format_align_center" />
        <BlockButton format="right" icon="format_align_right" />
        <BlockButton format="justify" icon="format_align_justify" />
      </Toolbar>
      <Editable
        renderElement={renderElement}
        renderLeaf={renderLeaf}
        placeholder="Enter some rich text…"
        spellCheck
        autoFocus
        onKeyDown={event => {
          for (const hotkey in HOTKEYS) {
            if (isHotkey(hotkey, event as any)) {
              event.preventDefault()
              const mark = HOTKEYS[hotkey]
              toggleMark(editor, mark)
            }
          }
        }}
      />
    </Slate>
  )
}

const toggleBlock = (editor, format) => {
  const isActive = isBlockActive(
    editor,
    format,
    TEXT_ALIGN_TYPES.includes(format) ? 'align' : 'type'
  )
  const isList = LIST_TYPES.includes(format)

  Transforms.unwrapNodes(editor, {
    match: n =>
      !Editor.isEditor(n) &&
      SlateElement.isElement(n) &&
      LIST_TYPES.includes(n.type) &&
      !TEXT_ALIGN_TYPES.includes(format),
    split: true,
  })
  let newProperties: Partial<SlateElement>
  if (TEXT_ALIGN_TYPES.includes(format)) {
    newProperties = {
      align: isActive ? undefined : format,
    }
  } else {
    newProperties = {
      type: isActive ? 'paragraph' : isList ? 'list-item' : format,
    }
  }
  Transforms.setNodes<SlateElement>(editor, newProperties)

  if (!isActive && isList) {
    const block = { type: format, children: [] }
    Transforms.wrapNodes(editor, block)
  }
}

const toggleMark = (editor, format) => {
  const isActive = isMarkActive(editor, format)

  if (isActive) {
    Editor.removeMark(editor, format)
  } else {
    Editor.addMark(editor, format, true)
  }
}

const isBlockActive = (editor, format, blockType = 'type') => {
  const { selection } = editor
  if (!selection) return false

  const [match] = Array.from(
    Editor.nodes(editor, {
      at: Editor.unhangRange(editor, selection),
      match: n =>
        !Editor.isEditor(n) &&
        SlateElement.isElement(n) &&
        n[blockType] === format,
    })
  )

  return !!match
}

const isMarkActive = (editor, format) => {
  const marks = Editor.marks(editor)
  return marks ? marks[format] === true : false
}

const Element = ({ attributes, children, element }) => {
  const style = { textAlign: element.align }
  switch (element.type) {
    case 'block-quote':
      return (
        <blockquote style={style} {...attributes}>
          {children}
        </blockquote>
      )
    case 'bulleted-list':
      return (
        <ul style={style} {...attributes}>
          {children}
        </ul>
      )
    case 'heading-one':
      return (
        <h1 style={style} {...attributes}>
          {children}
        </h1>
      )
    case 'heading-two':
      return (
        <h2 style={style} {...attributes}>
          {children}
        </h2>
      )
    case 'list-item':
      return (
        <li style={style} {...attributes}>
          {children}
        </li>
      )
    case 'numbered-list':
      return (
        <ol style={style} {...attributes}>
          {children}
        </ol>
      )
    default:
      return (
        <p style={style} {...attributes}>
          {children}
        </p>
      )
  }
}

const Leaf = ({ attributes, children, leaf }) => {
  if (leaf.bold) {
    children = <strong>{children}</strong>
  }

  if (leaf.code) {
    children = <code>{children}</code>
  }

  if (leaf.italic) {
    children = <em>{children}</em>
  }

  if (leaf.underline) {
    children = <u>{children}</u>
  }

  return <span {...attributes}>{children}</span>
}

const BlockButton = ({ format, icon }) => {
  const editor = useSlate()
  return (
    <Button
      active={isBlockActive(
        editor,
        format,
        TEXT_ALIGN_TYPES.includes(format) ? 'align' : 'type'
      )}
      onMouseDown={event => {
        event.preventDefault()
        toggleBlock(editor, format)
      }}
    >
      <Icon>{icon}</Icon>
    </Button>
  )
}

const MarkButton = ({ format, icon }) => {
  const editor = useSlate()
  return (
    <Button
      active={isMarkActive(editor, format)}
      onMouseDown={event => {
        event.preventDefault()
        toggleMark(editor, format)
      }}
    >
      <Icon>{icon}</Icon>
    </Button>
  )
}

const initialValue: Descendant[] = [
  {
    type: 'paragraph',
    children: [
      { text: 'This is editable ' },
      { text: 'rich', bold: true },
      { text: ' text, ' },
      { text: 'much', italic: true },
      { text: ' better than a ' },
      { text: '<textarea>', code: true },
      { text: '!' },
    ],
  },
  {
    type: 'paragraph',
    children: [
      {
        text: "Since it's rich text, you can do things like turn a selection of text ",
      },
      { text: 'bold', bold: true },
      {
        text: ', or add a semantically rendered block quote in the middle of the page, like this:',
      },
    ],
  },
  {
    type: 'block-quote',
    children: [{ text: 'A wise quote.' }],
  },
  {
    type: 'paragraph',
    align: 'center',
    children: [{ text: 'Try it out for yourself!' }],
  },
]

export default RichTextExample

Unlocking the Fast Lane: Accelerate Your Programming Journey

Thu, 08 May 2025 17:54:00 GMT

Welcome to the fast lane of programming mastery! Learning to code doesn’t have to be a slow and tedious process. With the right strategies, you can accelerate your progress and become a proficient programmer in no time.

Here are some tips to supercharge your learning:

1. Set Clear Goals

Section titled “1. Set Clear Goals”

Define what you want to achieve with programming. Whether it’s building a website, creating a mobile app, or diving into data science, having clear goals will give your learning a sense of purpose.

# Example Goal: Build a Personal Portfolio Website
goal = "Build a personal portfolio website showcasing my projects and skills."

2. Break it Down

Section titled “2. Break it Down”

Programming can be overwhelming, especially for beginners. Break down your goals into smaller, manageable tasks. Tackling one piece at a time will make the learning process more digestible.

// Example Task: Learn HTML and CSS
const tasks = [
    'Learn HTML basics',
    'Master CSS styling',
    'Build a simple webpage',
];

3. Hands-On Coding

Section titled “3. Hands-On Coding”

Theory is essential, but hands-on coding is where the real learning happens. Code every day, even if it’s just for a short period. Practice makes perfect, and it solidifies your understanding.

# Example Daily Practice
def daily_coding_practice
  puts "Code for at least 30 minutes every day!"
end

daily_coding_practice

4. Build Real Projects

Section titled “4. Build Real Projects”

Apply your knowledge by working on real projects. Building something tangible not only reinforces what you’ve learned but also provides a portfolio to showcase your skills to potential employers.

// Example Project: Task Manager App
public class TaskManager {
  // Your project code goes here
}

5. Seek Feedback and Collaboration

Section titled “5. Seek Feedback and Collaboration”

Don’t code in isolation. Share your code with others, seek feedback, and collaborate on projects. Learning from experienced programmers and receiving constructive criticism will catapult your skills.

Terminal window

# Example Collaboration
git clone https://github.com/your-username/awesome-project.git

6. Utilize Online Resources

Section titled “6. Utilize Online Resources”

Take advantage of the vast array of online resources. Platforms like Codecademy, freeCodeCamp, and Khan Academy offer interactive lessons. Leverage documentation and forums when you encounter challenges.

# Example Learning Platform
learning_platform = "freeCodeCamp"

7. Stay Curious and Keep Learning

Section titled “7. Stay Curious and Keep Learning”

Programming is a dynamic field, so staying curious is crucial. Embrace the joy of discovery, explore new technologies, and stay updated on industry trends.

// Example Curiosity
const stayCurious = () => {
    console.log('Keep exploring and learning!');
};

stayCurious();

Embark on your programming journey with determination, curiosity, and a willingness to embrace challenges. Remember, the key to learning faster is consistency and a passion for the craft. Happy coding!

Build Smart Contract REST API

Thu, 08 May 2025 17:50:00 GMT

Blockchain and smart contracts are two of the most innovative technologies of the 21st century, and have the potential to revolutionize a wide range of industries, from finance and healthcare to supply chain management and real estate.

Blockchain is a decentralized digital ledger that records transactions across a network of computers. It uses cryptography to secure and verify transactions and control the creation of new units of a particular cryptocurrency.

Smart contracts are self-executing contracts with the terms of the agreement written directly into the code. They run on a blockchain network and enable secure, transparent and tamper-proof contract execution without the need for intermediaries.

Together, blockchain and smart contracts have the potential to increase efficiency, reduce costs, and improve transparency and security across multiple industries. For example, in the financial industry, blockchain can be used to streamline cross-border payments and reduce the risk of fraud, while smart contracts can automate the execution of financial agreements.

In this blog post, we will learn to build simple Smart Contract API using truffle and Tomochain.

Setup Truffle

Section titled “Setup Truffle”

Before we continue, i hoped that you already have a metamask account, if not, you can see how to create it here create-new-wallet then add the tomochain testnet network add-tomochain-to-metamask and finally get the fund faucet, of the many networks, I think tomochain is the best in this case, on other networks it will usually give a little ethereum, 0.5 to 1 eth only. On tomochain we will get 15 TOMO. Get tomo fund here tomo-faucet

to get truffle, first we have to install it with npm or yarn globally

Terminal window

# npm
npm i -g truffle
# yarn
yarn global add truffle

there are two way to get started with truffle, truffle init or truffle unbox

Terminal window

truffle init
# or
truffle unbox

next is to install package truffle-hdwallet-provider

Terminal window

npm i truffle-hdwallet-provider
# or
yarn add truffle-hdwallet-provider

In this practice, we will use tomochain as a network blockchain, so we must add a network chain to the truffle configuration.

'use strict';
var HDWalletProvider = require('truffle-hdwallet-provider');
require('dotenv').config();

var mnemonic = process.env.MNEMONIC;

module.exports = {
    compilers: {
        solc: {
            version: '^0.8.0',
        },
    },
    networks: {
        development: {
            provider: () =>
                new HDWalletProvider(mnemonic, 'http://127.0.0.1:8545'),
            host: '127.0.0.1',
            port: '8545',
            network_id: '*', // Match any network id
        },
        tomotestnet: {
            provider: () =>
                new HDWalletProvider(
                    mnemonic,
                    'https://rpc.testnet.tomochain.com',
                    0,
                    true,
                    "m/44'/889'/0'/0/"
                ),
            network_id: '89',
            gas: 2000000,
            gasPrice: 10000000000,
        },
        tomomainnet: {
            provider: () =>
                new HDWalletProvider(
                    mnemonic,
                    'https://rpc.tomochain.com',
                    0,
                    true,
                    "m/44'/889'/0'/0/"
                ),
            network_id: '88',
            gas: 2000000,
            gasPrice: 10000000000000,
        },
    },
};

change MNEMONIC env with your mnemonic wallet, more info here link

Create Smart Contract

Section titled “Create Smart Contract”

We will create a smart contract inside folder contract with name JsonArray.sol. The contract has functions such as storeData() to adding Array data, getAllData() to getting all data, getData() to getting data by Id and also getArrayLength() to getting data length.

// SPDX-License-Identifier: MIT
pragma solidity >=0.4.22 <0.9.0;

contract JsonArray{
    string[] public jsonDataArray;

    function storeData(string memory _jsonData) public {
       jsonDataArray.push(_jsonData);
    }

    function getAllData() public view returns (string[] memory) {
        return jsonDataArray;
    }

    function getData(uint256 index) public view returns (string memory) {
        return jsonDataArray[index];
    }

    function getArrayLength() public view returns (uint256) {
        return jsonDataArray.length;
    }
}

Until here, to check we have to compile it. by running the following command:

Terminal window

truffle compile

it will compile all Smart Contract inside folder contract.

next we will deploy the smart contract by creating a file in the migrations folder with the name 1_migration.js

const JsonArray = artifacts.require('JsonArray');

module.exports = function (deployer) {
    deployer.deploy(JsonArray);
};

To deploy smart contracts on the tomochain testnet network, run the following command

Terminal window

truffle migrate --network tomotestnet

and then you will get the transactions receipt

Terminal window

$ truffle migrate --network tomotestnet

Compiling your contracts...
===========================
> Compiling .\contracts\Count.sol solc-bin. Attempt #1
> Compiling .\contracts\JsonArray.sol
> Compiling .\contracts\JsonString.sol
> Artifacts written to D:\Software-Development\blockchain\build\contracts
> Compiled successfully using:
   - solc: 0.8.17+commit.8df45f5f.Emscripten.clang
⠦ Fetching solc version list from solc-bin. Attempt #1
⠏ Fetching solc version list from solc-bin. Attempt #1
Starting migrations...
======================
> Network name:    'tomotestnet'
> Network id:      89
> Block gas limit: 420000000 (0x1908b100)


1_migration.js
==============
⠴ Fetching solc version list from solc-bin. Attempt #1
   Deploying 'JsonArray'
   ---------------------
   > transaction hash:    0x7bbc9f3f5326ddef7756a796234d1b92c394197232ebe55c32650e3b1b61185e
   > Blocks: 0            Seconds: 0lc-bin. Attempt #1
   > contract address:    0x6f3c30D1151216BCEA768c0a35c99d9775d576bF
   > block number:        34187627
   > block timestamp:     1675181656
   > account:             0x82aAb6bc1b906dbE7F4053aE86469318b958a139
   > balance:             66.9123990505
   > gas used:            784391 (0xbf807)
   > gas price:           10 gwei
   > value sent:          0 ETH
   > total cost:          0.00784391 ETH

   > Saving artifacts
   -------------------------------------
   > Total cost:          0.00784391 ETH

Summary
=======
> Total deployments:   1
> Final cost:          0.00784391 ETH


Done in 17.87s.

Since tomochain uses the forked ethereum network, 1 TOMO = 1 ETH but has a different value, i.e. 1 ETH = $1,587.44 but 1 TOMO = $0.381312. In the above transaction, the amount of gas fee we need to pay is 0.00784391 TOMO or $0.00299. Very cheap, right?

Calling Smart Contract function

Section titled “Calling Smart Contract function”

To test your smart contract directly, you can use the online remix idea Remix-Eth-IDE. This time we will use web3.js, just create an api folder, and add the index.js file

const Web3 = require('web3');
require('dotenv').config();
const provider = new Web3.providers.HttpProvider(
    'https://rpc.testnet.tomochain.com'
);
const web3 = new Web3(provider);

const contractAddress = '0x6f3c30D1151216BCEA768c0a35c99d9775d576bF';
const abi = [
    {
        inputs: [
            {
                internalType: 'uint256',
                name: '',
                type: 'uint256',
            },
        ],
        name: 'jsonDataArray',
        outputs: [
            {
                internalType: 'string',
                name: '',
                type: 'string',
            },
        ],
        stateMutability: 'view',
        type: 'function',
        constant: true,
    },
    {
        inputs: [
            {
                internalType: 'string',
                name: '_jsonData',
                type: 'string',
            },
        ],
        name: 'storeData',
        outputs: [],
        stateMutability: 'nonpayable',
        type: 'function',
    },
    {
        inputs: [],
        name: 'getAllData',
        outputs: [
            {
                internalType: 'string[]',
                name: '',
                type: 'string[]',
            },
        ],
        stateMutability: 'view',
        type: 'function',
        constant: true,
    },
    {
        inputs: [
            {
                internalType: 'uint256',
                name: 'index',
                type: 'uint256',
            },
        ],
        name: 'getData',
        outputs: [
            {
                internalType: 'string',
                name: '',
                type: 'string',
            },
        ],
        stateMutability: 'view',
        type: 'function',
        constant: true,
    },
    {
        inputs: [],
        name: 'getArrayLength',
        outputs: [
            {
                internalType: 'uint256',
                name: '',
                type: 'uint256',
            },
        ],
        stateMutability: 'view',
        type: 'function',
        constant: true,
    },
];

const privateKey = process.env.WALLET_PRIVATE_KEY;
// Unlock wallet by private key
const account = web3.eth.accounts.privateKeyToAccount(privateKey);
let coinbase = account.address;
web3.eth.accounts.wallet.add(privateKey);
web3.eth.defaultAccount = coinbase;
console.log(coinbase);

HttpProvider is the rpc network url of the chain to be used. contractAddress is the contract address obtained during deployment, see above. abi is json data from solidity compile, can be seen in the build/contracts/{smart contract name}.json folder. Private key can be seen in the metamask account, can read here Export-private-key coinbase is the address of our account (public key)

next is call function getAllData() and storeData() with dummy data using self execution function (()=>{})() :D

const contract = new web3.eth.Contract(abi, contractAddress);
(async () => {
    // Calling function getAllData()
    await contract.methods
        .getAllData()
        .call()
        .then((v) => {
            const parsedData = v.map((jsonString) => JSON.parse(jsonString));
            console.log(parsedData);
        });

    // Add data storeData()
    const dataDummy = {
        name: 'John Doe',
        age: 30,
    };

    const gasAmount = await contract.methods
        .storeData(JSON.stringify(dataDummy))
        .estimateGas({ from: coinbase });

    const tx = {
        from: coinbase,
        to: contractAddress,
        gas: Number(gasAmount),
        data: contract.methods.storeData(JSON.stringify(dataDummy)).encodeABI(),
    };

    const signature = await web3.eth.accounts.signTransaction(tx, privateKey);
    await web3.eth
        .sendSignedTransaction(signature.rawTransaction)
        .on('receipt', (receipt) => {
            // Data after sign storeData()
            contract.methods
                .getAllData()
                .call()
                .then((v) => {
                    console.log({ message: v, receipt });
                });
        });
})();

you will get response with receipt and state data before & after

Terminal window

$ node api/index.js
0x82aAb6bc1b906dbE7F4053aE86469318b958a139
[ { name: 'John Doe', age: 30 }, { name: 'John Doe', age: 30 } ]
{
  message: [
    '{"name":"John Doe","age":30}',
    '{"name":"John Doe","age":30}',
    '{"name":"John Doe","age":30}'
  ],
  receipt: {
    blockHash: '0xdcf2c86d0bdba12e086876402ad6855cc80a782e9c06a55942a0b11e0371e6e8',
    blockNumber: 34188640,
    contractAddress: null,
    cumulativeGasUsed: 51923,
    from: '0x82aab6bc1b906dbe7f4053ae86469318b958a139',
    gasUsed: 51923,
    logs: [],
    logsBloom: '0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000',
    status: true,
    to: '0x6f3c30d1151216bcea768c0a35c99d9775d576bf',
    transactionHash: '0x320656767171ea4e2fb222c289afafc477cb87f2a710c59860c35d2d2ab94209',
    transactionIndex: 1
  }
}

Next is to create an API with ExpressJS. install express with the following command

Terminal window

npm install express --save
npm install body-parser
# or
yarn add express
yarn add body-parser

here is minimal express API

const express = require('express');
const app = express();
const port = 3001;

app.get('/', (req, res) => {
    res.send('Hello World!');
});

app.listen(port, () => {
    console.log(`Example app listening on port ${port}`);
});

here is the full code for the rest API

const Web3 = require('web3');
const express = require('express');
var bodyParser = require('body-parser');
require('dotenv').config();
const app = express();
const port = 3001;

app.use(bodyParser.json());

const provider = new Web3.providers.HttpProvider(
    'https://rpc.testnet.tomochain.com'
);
const web3 = new Web3(provider);

const contractAddress = '0x6f3c30D1151216BCEA768c0a35c99d9775d576bF';
const abi = [
    {
        inputs: [
            {
                internalType: 'uint256',
                name: '',
                type: 'uint256',
            },
        ],
        name: 'jsonDataArray',
        outputs: [
            {
                internalType: 'string',
                name: '',
                type: 'string',
            },
        ],
        stateMutability: 'view',
        type: 'function',
        constant: true,
    },
    {
        inputs: [
            {
                internalType: 'string',
                name: '_jsonData',
                type: 'string',
            },
        ],
        name: 'storeData',
        outputs: [],
        stateMutability: 'nonpayable',
        type: 'function',
    },
    {
        inputs: [],
        name: 'getAllData',
        outputs: [
            {
                internalType: 'string[]',
                name: '',
                type: 'string[]',
            },
        ],
        stateMutability: 'view',
        type: 'function',
        constant: true,
    },
    {
        inputs: [
            {
                internalType: 'uint256',
                name: 'index',
                type: 'uint256',
            },
        ],
        name: 'getData',
        outputs: [
            {
                internalType: 'string',
                name: '',
                type: 'string',
            },
        ],
        stateMutability: 'view',
        type: 'function',
        constant: true,
    },
    {
        inputs: [],
        name: 'getArrayLength',
        outputs: [
            {
                internalType: 'uint256',
                name: '',
                type: 'uint256',
            },
        ],
        stateMutability: 'view',
        type: 'function',
        constant: true,
    },
];

const privateKey = process.env.WALLET_PRIVATE_KEY;
// Unlock wallet by private key
const account = web3.eth.accounts.privateKeyToAccount(privateKey);
let coinbase = account.address;
web3.eth.accounts.wallet.add(privateKey);
web3.eth.defaultAccount = coinbase;
console.log(coinbase);

const contract = new web3.eth.Contract(abi, contractAddress);

// call getAllData()
app.get('/', async (req, res) => {
    await contract.methods
        .getAllData()
        .call()
        .then((v) => {
            const parsedData = v.map((jsonString) => JSON.parse(jsonString));

            return res.json({ message: parsedData });
        });
});

// call getData()
app.get('/:id', async (req, res) => {
    await contract.methods
        .getData(req.params.id)
        .call()
        .then((v) => {
            return res.json({ message: JSON.parse(v) });
        });
});

app.post('/', async (req, res) => {
    const { ...data } = req.body;
    const gasAmount = await contract.methods
        .storeData(JSON.stringify(data))
        .estimateGas({ from: coinbase });

    const tx = {
        from: coinbase,
        to: contractAddress,
        gas: Number(gasAmount),
        data: contract.methods.storeData(JSON.stringify(data)).encodeABI(),
    };

    const signature = await web3.eth.accounts.signTransaction(tx, privateKey);
    await web3.eth
        .sendSignedTransaction(signature.rawTransaction)
        .on('receipt', (receipt) => {
            contract.methods
                .getAllData()
                .call()
                .then((v) => {
                    return res.json({ message: v, receipt });
                });
        });
});

app.listen(port, () => {
    console.log(`Example app listening on port ${port}`);
});

run the server with

Terminal window

node api/index.js

call getAllData()

call getData(id)

call storeData()

Hopefully my writing can help, Thank you
Section titled “Hopefully my writing can help, Thank you”

HasLab by Lutfi | Blog

Vibe Coding: The Programming Revolution Taking 2025 by Storm

What Exactly is Vibe Coding?

The Vibe Coding Process

Popular Tools Driving the Movement

The Bright Side: Why Vibe Coding is Gaining Traction

Democratization of Development

Speed and Efficiency

Creative Focus

The Dark Side: Limitations and Risks

Code Quality Concerns

Technical Debt Accumulation

Security Vulnerabilities

Skill Erosion Risk

The Enterprise Reality Check

Finding the Balance: The Future of Vibe Coding

Conclusion: A Tool, Not a Revolution

Golang and Web Frameworks

Why Choose Golang for Web Development?

Popular Go Web Frameworks: Gin and Fiber

1. Gin

Key Features:

Example:

2. Fiber

Key Features:

Example:

Performance Comparison: Gin vs Fiber

Go vs Other Languages: A Comparative Overview

Why Go Stands Out:

Real-World Use Cases

✅ Microservices Architecture

✅ Cloud-Native Applications

✅ APIs and REST Services

✅ CLI Tools

Final Thoughts

Further Reading

Rich Text Editor for React or NextJS

Unlocking the Fast Lane: Accelerate Your Programming Journey

1. Set Clear Goals

2. Break it Down

3. Hands-On Coding

4. Build Real Projects

5. Seek Feedback and Collaboration

6. Utilize Online Resources

7. Stay Curious and Keep Learning

Build Smart Contract REST API

Setup Truffle

Create Smart Contract

Calling Smart Contract function

Hopefully my writing can help, Thank you