Forem: ANDI NUGROHO

Introducing colorific-magic: Enhance Your Console Logs with Stunning Colors

ANDI NUGROHO — Wed, 17 Sep 2025 04:25:02 +0000

🚀 Exciting News! 🚀

I’m thrilled to announce the release of my latest npm package: colorific-magic! 🎨✨

What is colorific-magic?

colorific-magic is a lightweight and versatile Node.js library designed to bring vibrant and customizable colors to your console logs. Perfect for developers who want to make their terminal outputs stand out, colorific-magic offers a range of colorful and stylish log options to brighten up your development workflow.

NPM package : npm i colorific-magic
Link :

Key Features:
Success Messages:

success(msg: string) - Green and bold
successLight(msg: string) - Light green and bold
successBg(msg: string) - Green background with white text
Danger/Error Messages:

danger(msg: string) - Red and bold
dangerBg(msg: string) - Red background with white text
dangerOutline(msg: string) - Red border with text
Info Messages:

info(msg: string) - Black text on yellow background
infoLight(msg: string) - Yellow text on black background
infoBlue(msg: string) - Blue and bold
Warning Messages:

warning(msg: string) - Orange and bold
warningBg(msg: string) - Orange background with white text
warningOutline(msg: string) - Orange border with text
Debugging Messages:

debug(msg: string) - Blueviolet and bold
debugBg(msg: string) - Blueviolet background with white text
debugShadow(msg: string) - Blueviolet with text shadow
Success with Borders:

successWithBorder(msg: string) - Green border with text
successBgWithBorder(msg: string) - Green background with dark green border
Neutral Messages:

neutral(msg: string) - Gray text
neutralBg(msg: string) - Gray background with white text
neutralShadow(msg: string) - Gray text with shadow
Custom Styles:

custom(msg: string, color: string, bgColor: string) - Customizable text and background
bold(msg: string) - Bold black text
italic(msg: string) - Italic blue text
underline(msg: string) - Underlined purple text
strikethrough(msg: string) - Strikethrough red text
Fancy Styles:

gradientText(msg: string) - Gradient text
shadowText(msg: string) - Text with shadow
rainbowText(msg: string) - Rainbow text
darkBg(msg: string) - White text on dark background
lightBg(msg: string) - Black text on light background
blueBg(msg: string) - White text on blue background
Other Fancy Styles:

fancyShadow(msg: string) - Magenta text with shadow
fancyBorder(msg: string) - Purple dashed border
fancyBgWithShadow(msg: string) - Dark blue background with shadow
Why Use colorific-magic?

Enhance Visibility: Make your logs more readable and visually appealing.
Customizable: Tailor your logs with different colors, backgrounds, and styles.
Easy to Use: Simple API for integrating into any Node.js project.
🔗 Check it out and get started today! You can find colorific-magic on npm.

Feel free to reach out with any questions or feedback, and happy coding! 💻✨

Just enough Typescript to build Projects.

ANDI NUGROHO — Tue, 10 Jun 2025 16:13:54 +0000

What is the point of using TypeScript ?

JavaScript is a dynamically typed language meaning type checking is performed at runtime or at the time of execution.

JavaScript allows accessing values which aren't present leading to unexpected bugs.

const person = { name: "Andi Delouise", id: 1 };

console.log(person.email) // <- undefined
person.name.toUppercase() // <- will throw TypeError

TypeScript was created to solve these type of problems by adding static type checking to JavaScript.

Think of JavaScript as a person which doesn't provide feedback until you Beat the s- I mean ask it. The feedback provided however is not much in-depth such as where might the error be until you console log it like above.

TypeScript is a typed superset of JavaScript which provides static type checking (type checking is performed at compile time) to catch potential bugs before runtime. It adds type safety to your JavaScript code.

With TypeScript, The above code will now throw an error in the IDE before runtime.

Typescript is basically a more wiser version of JavaScript which helps you catch a lot of errors including typos, uncalled function (Math.random * 6), etc.

TL;DR

types + Javascript = Typescript.

Basic Types

Before using Typescript we need to know about JavaScript types and some special TypeScript types.

Here are a bunch of them -

string
number (there's no int or float data type in JavaScript)
boolean
Arrays (datatype[] or Array)
object ({})
any (NOTE :- This removes the type safety provided by TS, meaning you will be back to the same old JavaScript for that particular variable)
undefined
void
never
unknown
Union Types (combination of two or more types)
Enum

and more

Type Annotations and Inference

TypeScript allows you to optionally specify the type of variable while declaring it.

let name: string = "andi";
let count: number = 0;
let isEven: boolean = true;
let array: number[] = [1, 2, 3, 4, 5];
let obj: { a : number; b : number; c?: number } = { a : 10, b : 20 
let age: number | string = 20; // union type, age is either a number or string
let alignment: "left" | "centre" | "right"; // Union of literal types
};

These are called Type Annotations.

In the example of object, we use ; separate the properties and declare a property optional by adding ? after its name.

But this is redundant as TypeScript can automatically infer the type of variable based on assigned value.

This is called Type Inference.

Functions in TypeScript

While declaring a function you can add Type Annotations to parameters and return type, so that arguments to that function gets checked.

function add(a: number, b: number): number  {
  return a + b;
}

In the above function, a and b are assigned the type number as well as the return type which comes after the closing parenthesis of parameter list, note that the return type can be inferred by typescript so it is not necessary to write always.

Here are some more examples

function print(name: string): void {
  console.log(`Hello ${name}`);
}

function sum(...numbers: number[]): number {
  return numbers.reduce((acc, curr) => acc + curr);
}

function printLength(item: string | string[]) {
  if (typeof item === "string") {
    console.log("Length:", item.length);
  } else {
    console.log("Lengths:", item.map(str => str.length));
  }
}

The first function, print, simply console logs the string, hence the return type is void.

The second function, sum, uses the Rest parameters syntax, allowing it to accept an indefinite number of arguments so we use array of numbers.
You may want to revisit reduce function.
and in the last function, printlength, item is either a string or an array of string, inside the function we use typeof to check its type. If it is a string, we simply log the length of the string otherwise if it is an array, we iterate over each string in the array and log their lengths. This is called Narrowing.

Type Aliases

It is a name for a type, It is used to create reusable types or if you simply want to separate writing types for convenience.

You may capitalize type aliases name to differentiate them from variables and functions.

type Person = {
  name: string;
  age: number;
};

function greet(p: Person) {
  console.log(`Hi ${p.name}, you are ${p.age} years old`);
}

greet({ name: "John Doe", age: 100 });

// Some more examples
type ID = number; 
type Name = string;
type Age = number | string;
type NaturalNumbers = number[];

type Body = {
  height: number;
  width: number;
  location?: string;
  readonly name: string; // This property cannot be re-assigned.
}

We can use type aliases to create function type expressions.

type func = (a: string) => void; // function type expression

function greets(name: string, callback: func) {
  callback(name);
}

greets("John Doe", function (name) {
 console.log(`Hi ${name}`);
});

The above type func means a function with one parameter of type string and returns nothing.

Interfaces

Interfaces are another way to name an object type. They are similar to Type Aliases but have some distinctions which we'll talk about later.

Syntax

interface Book {
  title: string;
  author: string;
  readonly pageCount?: number;
}

const book: Book = {
  title: "The Great Gatsby",
  author: "F. Scott Fitzgerald",
};

interface AnotherInterface {
  name: string;
  func: (a: string) => void; // describe a function inside interface
  func2(a: string): void; // another way to describe a function
}

// This is function type, functions in JavaScript are objects which can be called, and we can also add properties to our functions.
interface MathOperation {
  (x: number, y: number): number;
}

const add: MathOperation = (x, y) => x + y;
const subtract: MathOperation = (x, y) => x - y;

// Its type aliases equivalent
type MathOperationType = (x: number, y: number) => number;

Some key differences between Types and Interfaces

Types aliases do not support declaration merging while interfaces do.

Declaration merging is adding new properties to an existing interface.

for example,

interface Object {
  a: number;
}

interface Object {
  b: number;
}

function printobj(o: Object) {
  console.log(o.a);
  console.log(o.b);
}

Both Interface and types can be extended but have different syntax.

You can read more about these distinctions here.

You can use whatever you like, I generally use interfaces for objects and types for everything else.

Generics

lets say you wanna create a function that accepts an argument and returns it.

function identity(arg: any) {
  return arg;
};

let num = identity(5);

This works fine but the issue with this is we lose all our type definitions for the return value of the function. If we pass in an argument of type number, the function returns the same argument but with type any.

By using generic this problem can be solved.

function identity<T>(arg: T): T {
  return arg;
}

// Two ways of consuming generic functions
let num0 = <number>identity(5); // explicitly passing the T parameter
let num = identity(5); // let the compiler infer it

The T in the angle bracket is called the Type Variable, you can name it whatever you like.

Generics are used to create reusable components that work with different types of data.

Let's say now we want to pass an array of different types and return it

function identity<T>(arg: T[]) {
  return arg;
}

Notice we don't have to specify the return type as the compiler can infer it.

If we want to have a generic type for types with a length property such as string and arrays. We can use something called a constraint.

function identity<T extends { length: number }>(arg: T){
  return arg.length;
}

In similar way we can create generic interfaces.

interface Box<T> {
  value: T;
};

type NumberBox = Box<number>;
type StringBox = Box<number>;

Tuples

Tuples are array but with a pre-defined length and types for each index.

Syntax

type FirstTuple = [number, string];
type SecondTuple = [number, string, boolean];

const firstTuple: FirstTuple = [1, '2'];
const secondTuple: SecondTuple = [1, '2', true];

FirstTuple is an array of fixed length 2 with index 0 being a number and index 1 being a string. if we try access element past index 1, TypeScript will throw error.

never

Type when function never returns a value, it is similar to void but it is used when function throws an exception or if a function enters an infinite loop.

function throwError(message: string): never {
  throw new Error(message);
}

function infiniteLoop(): never {
  while (true) {
    // ...
  }
}

Non-null Assertion Operator (Postfix !)

It is used to tell the compiler to assume that a value is not null or undefined, even if typescript thinks it could be nullable.

function func(arg?: number) {
  console.log(arg!++);
}

Type Assertions

Type Assertions are way to override the type inference and explicitly set the type.

For Example

const btn = document.getElementById("my_button") as HTMLButtonElement;

TypeScript thinks that getElementById will return some kind of HTMLElement, but you can override this by using the as operator.

Thanks for reading, I tried to condense as much as examples possible and tried cover most frequently used types.

Blockchain Architecture Basics: Components, Structure, Benefits & Creation

ANDI NUGROHO — Sun, 11 May 2025 17:46:27 +0000

Understanding the blockchain architecture and process doesn’t seem like an easy task, does it? The following article will help you learn the different components of blockchain technology effortlessly.

The term blockchain was first described back in 1991. A group of researchers wanted to create a tool to timestamp digital documents so that they could not be backdated or changed. Further, the technique was adapted and reinvented by Satoshi Nakamoto. In 2008, Nakamoto created the first cryptocurrency, the blockchain-based project called Bitcoin.

In general, blockchain technology has the core characteristics of decentralization, accountability, and security. This technique can improve operational efficiency and save costs significantly. The demand and usage of applications built on blockchain architecture will only evolve. Thus, it makes now the right time to get educated on this topic.

Let's learn the key insights to easily understand how blockchain technology works. Maybe this will encourage you to think more about building your own blockchain solution.

What is Blockchain Architecture?

For starters, let's first learn what is blockchain technology. Logically, a blockchain is a chain of blocks which contain specific information (database), but in a secure and genuine way that is grouped together in a network (peer-to-peer). In other words, blockchain is a combination of computers linked to each other instead of a central server, meaning that the whole network is decentralized.

To make it even simpler, the blockchain concept can be compared to work done with Google Docs. You may recall the days of tossing over doc. documents and waiting for other participants to make necessary edits. These days, with the help of Google Docs, it is possible to work on the same document simultaneously.

The blockchain technique allows digital information to be distributed, rather than copied. This distributed ledger provides transparency, trust, and data security.

Blockchain architecture is being used very broadly in the financial industry. However, these days, this technology helps create software development solutions for cryptocurrencies and record keeping, digital notary, and smart contracts.

Database vs. Blockchain Architecture

The traditional architecture of the World Wide Web uses a client-server network. In this case, the server keeps all the required information in one place so that it is easy to update, due to the server being a centralized database controlled by a number of administrators with permissions.

In the case of the distributed network of blockchain architecture, each participant within the network maintains, approves, and updates new entries. The system is controlled not only by separate individuals, but by everyone within the blockchain network. Each member ensures that all records and procedures are in order, which results in data validity and security. Thus, parties that do not necessarily trust each other are able to reach a common consensus.

To summarize things, the blockchain is a decentralized, distributed ledger (public or private) of different kinds of transactions arranged into a P2P network. This network consists of many computers, but in a way that the data cannot be altered without the consensus of the whole network (each separate computer).

The structure of blockchain technology is represented by a list of blocks with transactions in a particular order. These lists can be stored as a flat file (txt. format) or in the form of a simple database. Two vital data structures used in blockchain include:

Pointers - variables that keep information about the location of another variable. Specifically, this is pointing to the position of another variable.
Linked lists - a sequence of blocks where each block has specific data and links to the following block with the help of a pointer.

Logically, the first block does not contain the pointer since this one is the first in a chain. At the same time, there is potentially going to be a final block within the blockchain database that has a pointer with no value.

Basically, the following blockchain sequence diagram is a connected list of records:

Blockchain architecture can serve the following purposes for organizations and enterprises:

Cost reduction - lots of money is spent on sustaining centrally held databases (e.g. banks, governmental institutions) by keeping data current secure from cyber crimes and other corrupt intentions.
History of data - within a blockchain structure, it is possible to check the history of any transaction at any moment in time. This is a ever-growing archive, while a centralized database is more of a snapshot of information at a specific point.
Data validity & security - once entered, the data is hard to tamper with due to the blockchain’s nature. It takes time to proceed with record validation, since the process occurs in each independent network rather than via compound processing power. This means that the system sacrifices performance speed, but instead guarantees high data security and validity.

Types of Blockchain Architecture Explained

All blockchain structures fall into three categories:

Public blockchain architecture
A public blockchain architecture means that the data and access to the system is available to anyone who is willing to participate (e.g. Bitcoin, Ethereum, and Litecoin blockchain systems are public).
Private blockchain architecture
As opposed to public blockchain architecture, the private system is controlled only by users from a specific organization or authorized users who have an invitation for participation.
Consortium blockchain architecture
This blockchain structure can consist of a few organizations. In a consortium, procedures are set up and controlled by the preliminary assigned users.

The following table provides a detailed comparison among these three blockchain systems:

As mentioned, blockchain is a distributed journal where all parties hold a local copy. However, based on the type of blockchain structure and its context, the system can be more centralized or decentralized. This simply refers to the blockchain architecture design and who controls the ledger.

A private blockchain is considered more centralized since it is controlled by a particular group with increased privacy. On the contrary, a public blockchain is open-ended and thus decentralized.

In a public blockchain, all records are visible to the public and anyone could take part in the agreement process. On the other hand, this is less efficient since it takes a considerable amount of time to accept each new record into the blockchain architecture.

In terms of efficiency, the time for each transaction in a public blockchain is less eco-friendly since it requires a huge amount of computation power compared to private blockchain architecture.

Core Components of Blockchain Architecture: How Does It Work

These are the core blockchain architecture components:

Node - user or computer within the blockchain architecture (each has an independent copy of the whole blockchain ledger)
Transaction - smallest building block of a blockchain system (records, information, etc.) that serves as the purpose of blockchain
Block - a data structure used for keeping a set of transactions which is distributed to all nodes in the network
Chain - a sequence of blocks in a specific order
Miners - specific nodes which perform the block verification process before adding anything to the blockchain structure
Consensus (consensus protocol) - a set of rules and arrangements to carry out blockchain operations

Any new record or transaction within the blockchain implies the building of a new block. Each record is then proven and digitally signed to ensure its genuineness. Before this block is added to the network, it should be verified by the majority of nodes in the system.

The following is a blockchain architecture diagram that shows how this actually works in the form of a digital wallet.

Let's have a closer look at what is a block in a blockchain. Each blockchain block consists of:

certain data
the hash of the block
the hash from the previous block

The data stored inside each block depends on the type of blockchain. For instance, in the Bitcoin blockchain structure, the block maintains data about the receiver, sender, and the amount of coins.

A hash is like a fingerprint (long record consisting of some digits and letters). Each block hash is generated with the help of a cryptographic hash algorithm (SHA 256). Consequently, this helps to identify each block in a blockchain structure easily. The moment a block is created, it automatically attaches a hash, while any changes made in a block affect the change of a hash too. Simply stated, hashes help to detect any changes in blocks.

The final element within the block is the hash from a previous block. This creates a chain of blocks and is the main element behind blockchain architecture’s security. As an example, block 45 points to block 46. The very first block in a chain is a bit special - all confirmed and validated blocks are derived from the genesis block.

Any corrupt attempts provoke the blocks to change. All the following blocks then carry incorrect information and render the whole blockchain system invalid.

On the other hand, in theory, it could be possible to adjust all the blocks with the help of strong computer processors. However, there is a solution that eliminates this possibility called proof-of-work. This allows a user to slow down the process of creation of new blocks. In Bitcoin blockchain architecture, it takes around 10 minutes to determine the necessary proof-of-work and add a new block to the chain. This work is done by miners - special nodes within the Bitcoin blockchain structure. Miners get to keep the transaction fees from the block that they verified as a reward.

Each new user (node) joining the peer-to-peer network of blockchain receives a full copy of the system. Once a new block is created, it is sent to each node within the blockchain system. Then, each node verifies the block and checks whether the information stated there is correct. If everything is alright, the block is added to the local blockchain in each node.

All the nodes inside a blockchain architecture create a consensus protocol. A consensus system is a set of network rules, and if everyone abides by them, they become self-enforced inside the blockchain.

For example, the Bitcoin blockchain has a consensus rule stating that a transaction amount must be cut in half after every 200,000 blocks. This means that if a block produces a verification reward of 10 BTC, this value must be halved after every 200,000 blocks.

As well, there can only be 4 million BTC left to be mined, since there is a maximum of 21 million BTC laid down in the Bitcoin blockchain system by the protocol. Once the miners unlock this many, the supply of Bitcoins ends unless the protocol is changed.

To recap, this makes blockchain technology immutable and cryptographically secure by eliminating any third-parties. It is impossible to tamper with the blockchain system; as it would be necessary to tamper with all of its blocks, recalculate the proof-of-work for each block, and also control more than 50% of all the nodes in a peer-to-peer network.

How to Make a Private Blockchain Architecture

A decentralized blockchain application is designed just the same as any other normal software product. Functional specification, UX/UI designs, and an architecture plan are required for its development. It is crucial to identify the app’s functionality, user roles, and think over the system flow and the interaction between users and information.

In order to build your own blockchain architecture, it is necessary to consider:

Blockchain network - refers to the application’s infrastructure placed within a particular environment inside one, or a few, organizations.
Blockchain code - refers to the tasks and goals this blockchain solution has been developed to perform.

There are a few open-source solutions used to build a private blockchain architecture. The most popular among them is Hyperledger by Linux Foundation. This project is also widely used by IBM and other famous tech organizations. Hyperledger Composer provides a set of tools for building blockchain architecture.

Some other solutions to build your own blockchain with are Ethereum and Corda.

Blockchain Network Creation

Once an organization, or a few, decide to implement a blockchain solution, they are already creating a network. The network could be viewed as companies with their personnel or from the perspective of the technical infrastructure within these companies.

To make it more concrete, let's take the example of diamonds. Risks and challenges associated with diamonds exist during every part of the process, from the extraction of diamonds to their final, commercial result. Consumers want to be sure they are purchasing real and ethical diamonds. Government institutions want to keep track of their taxation and exports. Blockchain architecture can be used to eliminate these risks.

The parties involved in this network include:

Diamond Manufacturers
Government Institutions
Diamond Transporters
Diamond Sellers

Blockchain solutions organize all these parties into a peer-to-peer network that helps to remove all the mentioned risks and build a transparent system. Everyone would receive access to the synchronized data of a “shared, immutable ledger” and be able to keep track of the diamond's moving from manufacturing to the final consumer. The blockchain ledger would hold the sequence of all actions occurring like diamond mining, refining, and distribution.

In most cases, each organization within a network holds their own copy synced together with clever protocols and technical layers of blockchain network (called peers). As well, in order to outline a few processes happening at the same time, there is the Ordering Service. This is shared among all parties deciding the transactions within the blockchain structure and their order. In case with multiple users, there is a Membership Services Provider (MSP) that allows access for particular users inside the network.

In the end, all the transactions during this path are kept in a general ledger (e.g data with diamond photos, place of extraction, color, serial number, place where it was cut, purified, sold, etc.). This information is complete and authentic.

Here is a high-level hyperledger architecture diagram to create a blockchain solution.

Blockchain Code Creation

After the blockchain network is set up, the next step is to agree upon the type of business transactions happening inside the blockchain architecture. In reality, these rules are written in legal agreements. Logically, within the blockchain code, this refers to a Smart Contract (also called as Chaincode or Business Network Definition from Hyperledger Composer).

As in the real world, the blockchain contract has participants, assets, and transactions. For each transaction, a Transactional Processor Function is written (reflects JavaScript) and lays out the things that will happen once the transaction has been generated.

Skills Required to Build Blockchain Architecture

To be a blockchain developer is a demanding task that requires a lot of technical skills and a complex background. Generally, in order to work with blockchain architecture, a strong background in Computer Science or Engineering is most desirable. As well, knowledge pertaining to consensus methods, data structures, decentralized ledgers, cryptographies and cryptocurrencies, and data security is also highly sought after.

Recently, the task of developing a blockchain has been simplified with the help of Ethereum and other similar blockchain software. Ethereum is an open source software platform based on blockchain technology allowing for the building and deployment of decentralized applications (DApps).

In terms of the coding skills required to develop a blockchain solution, one should become familiar with a range of programming languages, not one specifically. If the goal is to implement a customizable blockchain system, programming languages such as C++, Python, C, Java, and Ruby help to accomplish this task. As well, web development skills like HTML, CSS, Node JS could become handy.

In case you are interested in writing smart contracts (smart contracts are the programs stored in the blockchain system and used to automatically exchange coins or any other funds based on predefined conditions) using Ethereum, the contract-based programming language Solidity is required.

Aside from hard programming skills, custom software developers need to understand business requirements and operations, as well as possess great cooperation and negotiation skills

Key Characteristics of Blockchain Architecture

Blockchain architecture possesses a lot of benefits for businesses. Here are several embedded characteristics:

Cryptography - blockchain transactions are validated and trustworthy due to the complex computations and cryptographic proof among involved parties
Immutability - any records made in a blockchain cannot be changed or deleted
Provenance - refers to the fact that it is possible to track the origin of every transaction inside the blockchain ledger
Decentralization - each member of the blockchain structure has access to the whole distributed database. As opposed to the central-based system, consensus algorithm allows for control of the network
Anonymity- each blockchain network participant has a generated address, not user identity. This keeps users' anonymity, especially in a public blockchain structure
Transparency - the blockchain system cannot be corrupted. This is very unlikely to happen, as it requires huge computing power to overwrite the blockchain network completely

Create Your Own Blockchain Architecture

To summarize everything, blockchain technology can be viewed from business, legal, and technical perspectives as a great solution. It can help businesses run daily operations more easily within a network of mutually agreeing members. From a legal perspective, any intermediaries are excluded from the blockchain ledger and any connection is made between involved parties only. At the same time, technically, it ensures control, security, and privacy of data inside the system.

Blockchain technology enables organizations & companies in the following ways:

Possibility to complete transactions much more quickly and with trust
Cost reduction for businesses, or cross-enterprise processes while removing intermediaries, inefficiencies, and duplications
Introduction of modern digital interaction
Opportunity to keep detailed control over business processes and transactions without a central control point
Remove cheating, cyber attacks, or other electronic crimes

A blockchain, with its transparent mechanisms and maximum clarity, will ultimately revolutionize the way individuals and societies carry out transactions and deal with one another. Unsurprisingly, many projects already exist using blockchain architecture. For example, TenX helps to spend cryptocurrencies, EOS.IO offers functionality for decentralized apps (DApps), Augur assists with a predictive market analysis for future events, etc.

The future looks bright for blockchain solutions. These are applied in fields like crowdfunding, stock trading, the sharing economy,mobile banking app developmenti, in many aspect of the healthcare industry, etc.

Python + Databases = Unlimited Side Projects!

ANDI NUGROHO — Tue, 18 Mar 2025 07:06:49 +0000

Imagine turning every spark of an idea into a working project with just a few lines of Python code and the power of a database. Whether it's a personal finance tracker to keep your spending in check, an AI-powered chatbot that engages users, or a real-time dashboard that brings data to life, you have the tools to make it happen today.

Why Python and Databases?
Python’s clear, concise syntax makes it accessible for beginners and robust enough for professionals. When paired with a reliable database system—be it SQLite for small projects or PostgreSQL for larger applications—the combination offers versatility, scalability, and a wealth of learning opportunities.

Key Advantages:

Simplicity & Readability: Python’s code is like plain English, making it easy to learn and maintain.
Extensive Libraries: Tools like SQLAlchemy for database management, Flask for web apps, and Pandas for data manipulation save you time and headaches.
Versatility: From web development to data science, Python can be the backbone of your next big side project.
Scalability: Start small with SQLite and transition to more powerful databases as your project grows.

info: "Python's blend of simplicity and power makes it the ideal choice for anyone looking to build real-world applications. Its extensive community support and libraries ensure that help is always just a search away."

Did You Know?

Recent surveys have shown that Python is among the top three most popular programming languages, with over 50% of developers using it daily. This wide adoption means countless tutorials, community forums, and real-world examples are at your disposal.

For those interested in furthering their expertise, explore deep dives into Database fundamentals and API Programming to level up your project-building skills. And if you’re curious about the cutting edge of technology, our AI Engineering course offers practical insights into integrating AI into your projects.

Project Spotlight 1: Personal Finance Tracker
Managing your finances can be challenging. Imagine having a tool that not only logs your transactions but also gives you insights into spending trends, helping you budget more effectively.

What to Build:

Expense Logging: A simple interface to enter income, expenses, categories, and dates.
Data Storage: Use SQLite for a lightweight solution or PostgreSQL for scalability.
Visual Insights: Generate charts with Matplotlib or Plotly to visualize trends over time.

Detailed Explanation with Code Example:
Let’s start by creating a simple SQLite database to store transaction data. The code below sets up a table and inserts sample transactions:

import sqlite3
import random

# Connect to SQLite database (or create it)
conn = sqlite3.connect('chatbot.db')
cursor = conn.cursor()

# Create a table to log conversations
cursor.execute('''
CREATE TABLE IF NOT EXISTS conversations (
    id INTEGER PRIMARY KEY,
    user_input TEXT,
    bot_response TEXT
)
''')
conn.commit()

# Simple chatbot logic
def get_bot_response(user_input):
    responses = {
        "hello": "Hi there! How can I help you today?",
        "help": "Sure, I can help. What do you need assistance with?",
        "bye": "Goodbye! Have a great day!"
    }
    return responses.get(user_input.lower(), "I didn't understand that. Can you rephrase?")

# Simulate a conversation
user_inputs = ["Hello", "Help", "Bye"]
for user_input in user_inputs:
    response = get_bot_response(user_input)
    print(f"User: {user_input}\nBot: {response}\n")
    cursor.execute('INSERT INTO conversations (user_input, bot_response) VALUES (?, ?)', (user_input, response))
conn.commit()
conn.close()

info: "Every interaction is a chance to learn. Logging conversations not only helps improve the bot's responses but also provides insights into user needs and behavior."

Additional Learning:

Enhance your skills with advanced API Programming, ensuring your chatbot integrates seamlessly with other services.
Brush up on Database management for effective data logging.
Explore our AI Engineering course to incorporate more sophisticated AI techniques into your projects.

Project Spotlight 3: Real-Time Dashboards
Real-time dashboards transform raw data into actionable insights by visualizing key metrics as they happen. Whether you're monitoring website traffic or tracking business performance, a dynamic dashboard can make a huge difference.

What to Build:

Data Collection: Gather data from APIs, sensors, or internal systems.
Live Updates: Use Python frameworks like Flask or FastAPI to serve real-time data.
Interactive Visuals: Combine backend data processing with frontend JavaScript for a dynamic experience.

Detailed Explanation with Code Example:
Here’s a basic example using Flask to serve real-time data:

from flask import Flask, jsonify, render_template
import random
import threading
import time

app = Flask(__name__)
data = {"metric": 0}

def update_data():
    while True:
        data["metric"] = random.randint(0, 100)
        time.sleep(2)

@app.route('/data')
def get_data():
    return jsonify(data)

@app.route('/')
def index():
    return render_template('dashboard.html')  # Assume a dashboard.html file exists

if __name__ == '__main__':
    threading.Thread(target=update_data).start()
    app.run(debug=True)

dashboard.html might include a simple JavaScript snippet to poll the /data endpoint every few seconds.

info: "Real-time dashboards provide a window into the pulse of your operations. Even a simple metric can drive smarter decisions when visualized in real time."

Explore More:

Deepen your understanding of Database connections and data flows.
Consider exploring API Programming for dynamic data integration.
Advance your project with insights from our AI Engineering curriculum.

Beyond the Spotlight: More Cool Side Projects
The combination of Python and databases offers an endless playground for creativity. Here are some additional project ideas:

Task and Project Managers: Build an app to organize your to-dos, deadlines, and progress.
Inventory Systems: Create systems to manage stock, whether for a small business or a hobby.
Social Media Analyzers: Develop tools to gather and analyze social media trends.
Event Trackers: Design an application to monitor and manage event logistics.

info: "Every new project is a learning opportunity. Don't hesitate to experiment—each iteration brings you one step closer to mastery."

Further Resources:

Get started with foundational Database techniques.
Expand your skill set with our API Programming course.
Check out our AI Engineering course for innovative project ideas.

Advanced Developer Tutorial on Address Lookup Tables

ANDI NUGROHO — Sun, 09 Mar 2025 07:13:15 +0000

Since the early times when data begun to be used to compute values, there has always been a need to store complex data in such a way that they would always be easy to access. In ancient times this was accomplished with sine tables and a 98-column multiplication, advances in computing technology has impacted the way data is stored and retrieved.
In the early years of computer technology, processing input/output was particularly slow and would consume more resource and time. To solve this problem, it made sense to reduce significantly the process of reading operations and operations data. A very efficient method that was introduced to solve this problem was Caching (which involves storing data so that it can be available for future request at faster speeds due to an earlier computation of the data stored elsewhere).
However, while systemwide Caching tries to automate the process of fetching commonly occurring data items, to enable a much faster mechanism for obtaining data items that possess a sort of immutability, lookup tables were introduced.

What is a Lookup Table

As if defined in computer science, 1

a lookup table(LUT) is an array that replaces runtime computation with a simpler array indexing operation. This process of utilizing array indexing to compute the running phase of a program is also known as direct addressing. It is much faster and less expensive since data is retrieved from memory using indexes as reference compared to the processing input/output approach. The tables may be pre-calculated and stored in static program storage, calculated (or "pre-fetched") as part of a program's initialization phase, or even stored in hardware in application-specific platforms.

A lookup table is more efficient in terms of lookup operation and has a guaranteed O(1) time complexity. However, it is not possible for two entities to have the same lookup key k, and as the size of the datasets grow increasingly larger, in the magnitude of considering all forms of allottable data, it becomes less practical to stored a LUT in memory.

Address Lookup Table (ALTs)

As defined on the Solana documentation, 2

An address Lookup Tables, commonly referred to as "lookup tables" or "ALTs" for short, allow developers to create a collection of related addresses to efficiently load more addresses in a single transaction. Since each transaction on the Solana blockchain requires a listing of every address that is interacted with as part of the transaction; without ALTs, this listing would effectively be capped at 32 addresses per transaction, but with ALTs, it would be effectively raise the addresses per transaction to 256

ALTs are part of additional functionalities that were introduced in the versioned transaction format which is quite similar to the legacy transaction format with just slight differences in libraries used.

How to Create An Address Lookup Table(ALTs)

This tutorial is going to show you how you can implement ALTs on your projects and help you see the benefits and advantages they offer.

What We Will Implement in This Tutorial

In this Tutorial, we will:

Create and execute a Version 0 (V0) Transaction

Create and Populate an Address Lookup Table

Compare the transaction size of two nearly identical transactions where one would implement a lookup table and the other would not

Perquisites:

Node.js

Intermediate Experience with Typescript/JavaScript

ts-node

basic or solid experience in running Solana transactions

all necessary imports including classes from Solana Web3 library

create a wallet and fund it with some devnet SOL

set up API endpoint to connect with the Solana network

Your setup Environment should look similar to this:

Steps to Creating ALTs

Executing Versioned Transaction V(0)

To use Lookup Tables, you must execute a versioned transactions.

We can do this by Let's start by creating a new function, createAndSendV0Tx, that accepts an array of TransactionInstructions, txInstructions:

async function createAndSendV0Tx(txInstructions: TransactionInstruction[]) {
// Step 1 - Fetch Latest Blockhash   
let latestBlockhash =await SOLANA_CONNECTION.getLatestBlockhash('finalized');    console.log("   ✅ - Fetched latest blockhash. Last valid height:", latestBlockhash.lastValidBlockHeight)
;    

// Step 2 - Generate Transaction Message    
const messageV0 = new TransactionMessage({ payerKey: SIGNER_WALLET.publicKey,  recentBlockhash: latestBlockhash.blockhash, instructions: txInstructions    }).compileToV0Message();    console.log("   ✅ - Compiled transaction message");    
const transaction = new VersionedTransaction(messageV0);    
// Step 3 - Sign your transaction with the required `Signers`    transaction.sign([SIGNER_WALLET]);    console.log("   ✅ - Transaction Signed");    // Step 4 - Send our v0 transaction to the cluster    const txid = await SOLANA_CONNECTION.sendTransaction(transaction, { maxRetries: 5 });    console.log("   ✅ - Transaction sent to network");    
// Step 5 - Confirm Transaction     
const confirmation = await SOLANA_CONNECTION.confirmTransaction({signature: txid,        blockhash: latestBlockhash.blockhash, lastValidBlockHeight: latestBlockhash.lastValidBlockHeight    });  if (confirmation.value.err) { throw new Error("   ❌ - Transaction not confirmed.") }    console.log('🎉 Transaction succesfully confirmed!', '\n', `https://explorer.solana.com/tx/${txid}?cluster=devnet`);}

Let's walk through our code:

Step 1: We fetch the latest blockhash from the network. Note: We pass the parameter, 'finalized', to make sure the block does not belong to a dropped fork.
Step 2: Using our txInstructions parameter and the latestBlockhash, we create a new MessageV0 by building a Message and executing the .compileToV0Message() method.
Step 3: We sign the transaction with an array of signers. In this case, it is just our SIGNER_WALLET.
Step 4: We send the transaction to the cluster using sendTransaction, which will return a transaction signature/id.
Step 5: We wait for the cluster to confirm the transaction has succeeded. If it succeeds, we log our explorer URL; otherwise, we throw an error.

Once successful with the above, we now move on to create an ALT

Create an Address Lookup Table

Create a new async function, createLookupTable, that will build our transaction instruction and invoke createAndSendV0Tx:

async function createLookupTable() {
    // Step 1 - Get a lookup table address and create lookup table instruction
    const [lookupTableInst, lookupTableAddress] =
        AddressLookupTableProgram.createLookupTable({
            authority: SIGNER_WALLET.publicKey,
            payer: SIGNER_WALLET.publicKey,
            recentSlot: await SOLANA_CONNECTION.getSlot(),
        });

    // Step 2 - Log Lookup Table Address
    console.log("Lookup Table Address:", lookupTableAddress.toBase58());

    // Step 3 - Generate a transaction and send it to the network
    createAndSendV0Tx([lookupTableInst]);
}

Breaking down our code:

Step 1: We create two variables, lookupTableInst and lookupTableAddress, by destructuring the results of the createLookupTable method. This method returns the public key for the table once created and a TransactionInstruction that can be passed into our createAndSendV0Tx function.
Step 2: We log the table's address
Step 3: Finally, we call createAndSendV0Txby passing lookupTableInst inside of an array to match our type requirements.

Create an empty address table by running:

createLookupTable();

To run the transaction, enter your terminal and execute:

ts-node app.ts

After the transaction has completed, you should receive a URL to the transaction page on Solana Explorer, like in the image below:

The lookup table account address is: 3uBhgRWPTPLfvfqxi4M9eVZC8nS1kDG9XPkdHKgG69nw

Next steps:

Remove the call to createLookupTable()
Add the table lookup address from your console to the PublicKey declaration like so :

const LOOKUP_TABLE_ADDRESS = new PublicKey("YOUR_TABLE_ADDRESS_HERE"); 
// e.g const LOOKUP_TABLE_ADDRESS = new PublicKey("3uBhgRWPTPLfvfqxi4M9eVZC8nS1kDG9XPkdHKgG69nw");

So what's going on with the extendLookupTable method:

We pass our SIGNER_WALLET to pay the transaction fees and any additional rent incurred.
We define our update authority - in our case, we set that as the SIGNER_WALLET in our table creation step above.
We pass in the lookup table account address (which we defined as LOOKUP_TABLE_ADDRESS).
We pass an array of addresses into our lookup table. We will pass in a few random public keys, but you can pass in any public key that you like! The Program's "compression" supports storing up to 256 addresses in a single lookup table!
log a link to our lookup table entries for easy access after the transaction is complete. Finally, we pass TransactionInstruction into createAndSendV0Tx to generate a transaction and send it to the network!

Call the new function:

addAddressesToTable();

Now run the in the terminal using the previous ts-node app.tscommand. Check the returned URL to see your transactions and your lookup table entries on the Solana Explorer. On the lookup table entries, there will be a list of all the stored public keys.

By now perhaps you are asking, why is this better? Well, The power of ALTs in transaction lies is in the efficiency of the transaction! By effectively compressing a 32-byte address to a 1-byte index value
This is great for speed as well as space efficiency as you can push in more transactions without bothering about space. By eliminating the need for long and complex iterations in cases of numerous addresses, which leads to error-resistance as ALTs can be engineered to prevent duplicate addresses.
Also this is cheaper; by reducing the number and size of the instructions in a transaction, thereby making fees required to develop on the blockchain way more cost-effective.
From transaction caching operations, scalability, speed, cost, the advantages of the address lookup table cannot be overemphasized, the benefits are numerous!
of course they are not the best when it comes to dealing with a dataset of unpredictable large number of possible keys, and could exceed the number of keys that are actually stored. For this sort of cases, hash tables are more efficient. Read more about hash tables here

While most use cases of ALTs revolve around transactional caching, decentralized applications employ their power to store multiple address for easy access at O(1) time; within a single transaction, you can load a large number of addresses

A very practical use case for ALTs can be found in asset management dApps where multiple wallets are being monitored; without Solana ALTs, it would be a resource consuming process.

For further reference, You can find another simple example to build on the example we have shown already Github

Conclusion

We have learned the following points in this terse tutorial:

In blockchain transactions, the magnitude of addresses used in multi-level transactions can easily scale in magnitude of millions of addresses; hence requiring an efficient means of retrieving transaction data in an O(1) time
Lookup tables are best for this as they utilize a concept known as "direct addressing" which utilizes array indexing to compute the running phase of a program.
By utilizing Address Lookup Tables, blockchain developers can create a collection of related addresses to efficiently load more addresses in a single transaction; address tables can store up to 256 addresses each. This can however be a limitation in special cases. In addition to stored addresses, address table accounts also tracks various metadata.