Forem: Henry Dioniz

🛡️ A Swahili SMS Scam Dataset and a Machine Learning Tool to Use It

Henry Dioniz — Sun, 15 Jun 2025 20:28:44 +0000

In Tanzania 🇹🇿, scammers are getting smarter. They often pretend to be someone you know or trust a relative, a friend, a landlord, or even a job recruiter. Their goal? To trick you into sending them money.

You’ve probably seen texts like:

“Ni tumie kwa namba hii Jina litakuja SALOME KALUNGA, hiyo ni namba yangu mpya ya Halotel”

“Utanitumia kwenye ii 0615810764 airtel jina MARIAM NDUGAI namba yangu inadeni usiitumie”

“MZEE LUKA KIMBANGU tiba asili biashala kazi masomo utajili kesi kuludisha mke&mume piga (0787-406-889)(0787-406-889)”

“666,KARIBU FREEMASON UTIMIZE NDOTO KATIKA BIASHARA, KILIMO,UFUGAJI,MACHI MBO,MICHEZO N.K KWAMHITAJI KUJIUNGA PG: 0786543210 AU 0786543210”

These messages are dangerous, deceptive, and sadly, very common.

As a Tanzanian tech enthusiast and developer, I wanted to do something about it.
So I created Bongoscam dataset an open dataset of over 1,500 Swahili SMS scam examples, and a basic machine learning model to help detect them.

📊 The Dataset: Swahili SMS Detection

I collected and labeled 1,508 real Swahili messages, split into two categories:

scam: Suspicious, misleading, or fraudulent messages.
trust: Legitimate or safe messages.

Example entries:

category	sms
scam	"IYO PESA ITUME KWENYE NAMBA HII 0657538690 JINA ITALETA Magomba Maila"
trust	"Nashukuru kwa kupokea simu yangu. Tutalifanyia kazi."

➡️ Download the dataset on Kaggle:
📥 swahili-sms-detection

🧠 The Model: Simple but Effective

To demonstrate what’s possible, I built a lightweight machine learning model using:

🧹 CountVectorizer for converting text to numeric features
🤖 Multinomial Naive Bayes classifier
📈 98.7% accuracy on test data

The model is wrapped in a Flask API and deployed as a simple website for public use.

You can test it live here:
👉 bongoscam.vercel.app

📦 Project Structure

You can explore or contribute via GitHub:

🔗 GitHub: BongoScamDetection

# Clone the repo
git clone https://github.com/Henryle-hd/BongoScamDetection
cd bongoscam

# Install frontend
cd frontend
npm install

# Install backend
cd backend
pip install -r requirements.txt

# Run backend
python main.py

# Run frontend
npm run dev

🔌 API Example

Endpoint: POST /api/predict
Request:

{
  "sms": "Iyo ela tuma humu kwenye vodacom 0655251448 Jina lije ALLY ISSA"
}

Response:

{
  "prediction": "scam",
  "sms": "Iyo ela tuma humu kwenye vodacom 0655251448 Jina lije ALLY ISSA"
}

🔄 Why This Matters

This project isn’t just about coding. It’s about digital safety.
Millions of people in East Africa rely on SMS for communication.
Without strong tools or education, they’re vulnerable.

By:

Open-sourcing the data
Making the model public
Supporting Swahili language

...I'm hoping this becomes a starting point for more localized ML solutions — in Swahili, for Africa, by Africans.

✍️ Final Thoughts

BongoScam dataset is a small step toward fighting digital fraud in Tanzania, but I believe it can grow with your input.
If you're a:

Developer 🧑‍💻
Linguist 🌍
Security researcher 🔐
Student 📚

…there’s something in this project for you.

👉 Test the tool at bongoscam.vercel.app
👉 Explore the dataset on Kaggle
👉 Contribute code via GitHub

💬 Got feedback or want to collaborate? Drop a comment or find me on LinkedIn or GitHub.

Let’s build AI that speaks Swahili and protects people, not just data.

Vibe Study With AI: Flashcards, Tests & Chat — All in Your Terminal

Henry Dioniz — Sat, 07 Jun 2025 09:55:46 +0000

A while back, I was struggling with studying.

I had tons of videos saved, links bookmarked, PDF notes everywhere… but I felt overwhelmed. I would start watching a lecture and forget it the next day. I kept thinking — "There must be a better way to study, something smarter."

That’s when the idea hit me:

What if I could build a tool that takes all these materials — YouTube, web pages, files — and helps me study them using AI?

And that’s how MTABE was born. A command-line tool that became my study assistant, tutor, and even exam prep coach — all in one.

💡 Why I Created MTABE

I needed a simple tool that:

Helps me create flashcards from any topic
Generates custom tests to quiz myself
Allows me to chat with AI about what I’m learning
Works with YouTube, web content, PDFs, and more
Runs right from my terminal (no need for heavy apps)

And that’s exactly what MTABE does.

I’ve been using it quietly for months during my study sessions. It helped me vibe with learning in a way that felt fun and natural. So now, I’m finally ready to share it with all of you.

🚀 What MTABE Can Do

✅ Add Your Notes

You can load notes from different sources:

mtabe add mynotes -t                     # Type or paste notes
mtabe add lecture -y "https://youtube.com/..."  # From YouTube
mtabe add article -w "https://example.com"      # From website
mtabe add book-notes -l "D:\chapter1.pptx"      # From local path

🧠 Make Flashcards With AI

mtabe flash -f mynotes
mtabe flash -l "D:\myfile.pdf" #local path
mtabe flash -w "https://example.com"
mtabe flash -y "https://youtube.com/watch?v=xxxxx"

When requesting flashcards, specify the number you want or any more instructions (e.g., "Give me 10 cards")

Question

Answer

End Summary

🧪 Generate Practice Tests

mtabe test -f mynotes
mtabe test -l "lecture-notes.pdf"
mtabe test -w "https://example.com"
mtabe test -y "https://youtube.com/watch?v=xxxxx"

You can specify question types:

Multiple choice

True/false

Essay

Fill in the blank

Short explanation

Short answer

Mix of different types

Example Multiple choice test

Test Results

💬 Chat With Your Study Materials

mtabe chat -f mynotes
mtabe chat -l "unit2.pdf"
mtabe chat -w "https://example.com"
mtabe chat -y "https://youtube.com/watch?v=xxxxx"

Chat Examples:

“Explain this topic like I’m 10 years old.”

“Give me 3 examples of supply and demand.”

“Summarize the notes in 5 bullet points.”

“Quiz me on what I just uploaded.”

🛠 Setup Guide

python -m venv venv
source venv/bin/activate  # Windows: venv\Scripts\activate
pip install mtabe

First time you use MTABE, it will ask for:

Your Groq API key (you can get one from for free console.groq.com)
Your name, study level, and area of focus

This helps it personalize your study experience!

📁 Supported Formats

PDF, Word, Excel, CSV, PPTX
Text files
YouTube videos
Web articles

🔥 Why You’ll Love It

No need to open 10 tabs — study everything in one place
Easy to use, even if you're not a tech expert
You can create your own quizzes and flashcards instantly
It's open source — improve it if you want
It’s made by a learner… for learners 💛

✨ Ready to Try It?

🔗 GitHub: https://github.com/Henryle-hd/mtabe
📦 PyPI: https://pypi.org/project/mtabe/

If MTABE helps you, share it with a friend. If you want to suggest features or contribute, I'm always open to collab. Let's keep building tools that make learning fun and easy.

Thanks for reading!

NPM vs NPX: What's the Difference?

Henry Dioniz — Sun, 04 Aug 2024 11:05:44 +0000

If you're new to the JavaScript ecosystem, you've probably encountered the terms NPM and NPX. While they sound similar, they serve different purposes. Let's break down what each one does and when to use them.

NPM: Node Package Manager

NPM (Node Package Manager) is the default package manager for Node.js. It allows you to install and manage JavaScript packages for your projects.

What NPM does:

Installs packages
Manages dependencies
Runs scripts defined in package.json

Example of using NPM:

# Install a package
npm install lodash
# Run a script defined in package.json
npm run start

NPX: Node Package Execute

NPX is a package runner tool that comes bundled with NPM (version 5.2+). It allows you to execute Node.js packages without installing them globally or locally.

What NPX does:

Executes packages without installation
Runs one-off commands
Avoids global package conflicts

# Run create-react-app without installing it globally
npx create-react-app my-new-app

# Run a specific version of a package
npx cowsay@1.4.0 "Hello, NPX!"

Key Differences

Installation: NPM installs packages, while NPX executes packages without installing them.
Usage: NPM is for managing project dependencies, while NPX is for running one-off commands or trying out packages.
Scope: NPM operates on your project's node_modules, while NPX can run packages that aren't in your project at all.

When to Use Each

Use NPM when:
- You need to install packages for your project
- You want to manage your project's dependencies
- You're running scripts defined in your package.json
Use NPX when:
- You want to run a package without installing it
- You need to execute a one-time command
- You want to try out a package without adding it to your project

Conclusion

NPM is your go-to for managing packages, while NPX is perfect for quick executions and trying out new tools without cluttering your system.

Understanding Package, Dependency, and Module in JavaScript

Henry Dioniz — Sun, 28 Jul 2024 15:40:14 +0000

I've noticed some confusion around the terms "package," "dependency," and "module." Let's clarify these concepts to help you use them correctly in your projects.

Package

A package is a collection of files bundled together to provide a specific functionality. In the JavaScript ecosystem, packages are typically distributed via npm (Node Package Manager). A package usually contains:

One or more JavaScript files
A package.json file describing the package and its dependencies
Documentation and other related files

Examples of popular packages:

React
Express
Lodash

Dependency

A dependency is a package that your project relies on to function correctly. Dependencies are listed in your project's package.json file and are installed using npm or yarn. There are two types of dependencies:

Production dependencies: Required for your application to run in production

Examples:

express (Web application framework)
react (UI library)
mongoose (MongoDB object modeling tool)
axios (HTTP client)
moment (Date manipulation library)

Development dependencies: Used only during development

Examples:

jest (Testing framework)
webpack (Module bundler)
eslint (Linting utility)
babel (JavaScript compiler)
nodemon (Development server with auto-restart)

{
  "dependencies": {
    "express": "^4.17.1",
    "react": "^17.0.2",
    "mongoose": "^6.0.12"
  },
  "devDependencies": {
    "jest": "^27.3.1",
    "webpack": "^5.60.0",
    "eslint": "^8.1.0"
  }
}

Module

A module is a self-contained unit of code that encapsulates related functionality. In JavaScript, modules can be:

CommonJS modules (used in Node.js)
ES6 modules (supported in modern browsers and Node.js)

Examples of built-in Node.js modules:

fs (File System operations)
http (HTTP server and client)
path (File path manipulations)
crypto (Cryptographic functionality)

Examples of custom modules you might create in a project:

userAuthentication.js
databaseConnector.js
utilities.js
apiRoutes.js

Modules help organize code, prevent naming conflicts, and allow for better code reuse.

Conclusion

Understanding these terms is crucial for effective JavaScript development:

Packages are distributed bundles of code
Dependencies are packages your project relies on, either for production or development
Modules are units of code organization within your project or packages

Understanding the Difference Between Websites and Web Apps

Henry Dioniz — Tue, 30 Apr 2024 20:39:31 +0000

Introduction:
In the vast expanse of the digital world, two primary entities stand out: websites and web apps. Understanding their distinctions is crucial for navigating the online landscape effectively. Let's explore the disparities between these platforms and illustrate their unique characteristics through practical examples.

1. Traditional Websites: A Gateway to Information and Branding

Objective: Traditional websites serve as gateways for marketing, branding, and information dissemination.
Example: Consider the official website of Apple, showcasing their products through visually captivating designs and compelling narratives.
Key Features: Emphasis on design creativity, engaging content, and user-friendly navigation.

2. Dynamic Web Apps: Tailored Experiences and Functionality

Objective: Web apps are designed to offer tailored experiences and specific functionalities to users.
Example: Explore YouTube, a dynamic web app that dynamically fetches content from its database, offering personalized recommendations and interactive features.
Key Features: Focus on user interaction, intuitive design, and efficient task execution.

3. Research and Development: Crafting User-Centric Experiences

Approach: Building web apps requires extensive research, user experience considerations, and validation of ideas.
Example: Compare the development process of Wikipedia (a traditional website) with that of Google (a dynamic web app) to understand the depth of research and user-centric design involved.
Key Elements: Understanding target audience, competition analysis, and performance optimization.

4. Design Philosophy: Balancing Creativity and Functionality

Approach: Designing a web app emphasizes simplicity, functionality, and mobile responsiveness.
Example: Analyze the clean and intuitive design of Google's search interface, optimized for quick access and seamless user interaction.
Key Aspects: Streamlined layouts, intuitive navigation, and mobile-friendly interfaces.

5. Implementation Challenges: From Concept to Deployment

Process: Developing web apps involves complex coding, iterative testing, and ongoing maintenance.
Example: Contrast the development timeline of a standard website with that of a dynamic web app like YouTube, highlighting the extended timeframe and continuous updates required.
Key Considerations: Technical requirements, scalability, and post-deployment management.

Conclusion:
In the digital realm, traditional websites and dynamic web apps serve distinct purposes, each catering to diverse user needs and objectives. By understanding their disparities and examining real-world examples, we can navigate the digital landscape with clarity and purpose, leveraging the strengths of each platform to achieve our goals effectively.

Understanding SQL vs. NoSQL Databases: A Beginner's Guide

Henry Dioniz — Tue, 09 Apr 2024 13:29:28 +0000

In the world of databases, there are two main types: SQL and NoSQL. But what's the difference between them, and how do you choose the right one for your needs? Let's find out!

What are SQL and NoSQL Databases?

SQL (Structured Query Language) databases are relational databases. They organize data into tables with rows and columns, and they use SQL for querying and managing data. Examples include MySQL, PostgreSQL, and SQLite.

On the other hand, NoSQL databases are non-relational databases. They store data in flexible, JSON-like documents, key-value pairs, or wide-column stores. Examples include MongoDB, Couchbase, and Cassandra.

Comparing Strengths and Weaknesses

Scalability:
SQL databases are typically vertically scalable, meaning you can increase capacity by upgrading hardware. NoSQL databases, however, are horizontally scalable, allowing you to handle large volumes of traffic by adding more servers to your database cluster.

Consistency:
SQL databases provide strong consistency, ensuring that all clients see the same data at the same time. NoSQL databases often sacrifice strong consistency for scalability and performance, offering eventual consistency where data may not be immediately consistent across all nodes.

Data Structure:
SQL databases are rigid in structure, requiring a predefined schema before data insertion. NoSQL databases, on the other hand, are schema-less or schema-flexible, allowing you to store unstructured or semi-structured data without a predefined schema.

Choosing the Right Solution

Use SQL databases when:

You have a structured data model with clear relationships between entities.
Your application requires ACID (Atomicity, Consistency, Isolation, Durability) transactions.
You need complex queries involving joins and aggregations.

Use NoSQL databases when:

Your data is unstructured or semi-structured, such as JSON documents.
You need to scale horizontally to handle large volumes of data or traffic.
You prioritize flexibility and agility over strict consistency.

Free video resources:

SQL: freeCodeCamp.org
MySQL: Bro Code
NoSQL: freeCodeCamp.org
MongoDB: Bro Code

In summary, the choice between SQL and NoSQL databases depends on your specific requirements. SQL databases offer strong consistency and are ideal for structured data with complex relationships, while NoSQL databases provide scalability and flexibility for handling unstructured or semi-structured data at scale. Understanding the strengths and weaknesses of each type will help you make an informed decision based on your project's needs.

Understanding the Difference Between Type and Interface in TypeScript

Henry Dioniz — Tue, 02 Apr 2024 18:31:49 +0000

As a JavaScript or TypeScript developer, you might have come across the terms type and interface when working with complex data structures or defining custom types. While both serve similar purposes, they have distinct characteristics that influence when to use them. In this blog post, we'll delve into the differences between types and interfaces in TypeScript, providing examples to aid your understanding.

Interfaces

Interfaces in TypeScript allow you to define the structure of an object. They provide a way to define contracts within your codebase, specifying the properties and methods an object must have. Interfaces are often used for object shapes and are particularly useful for ensuring consistency across different parts of your codebase.

Here's an example of defining an interface in TypeScript:

interface Person {
  name: string;
  age: number;
  greet: () => void;
}

const john: Person = {
  name: "John",
  age: 30,
  greet() {
    console.log(`Hello, my name is ${this.name}.`);
  }
};

Above, we define an interface called Person with properties name and age, as well as a method greet. Then, we create an object john that adheres to this interface.

Types

Types in TypeScript, on the other hand, offer a more flexible approach to defining shapes of data. They allow you to create aliases for primitive types, union types, tuples, and more complex structures. Types are not limited to object shapes and can be used to represent a wide range of data.

Here's an example of defining a type alias in TypeScript:

type Point = {
  x: number;
  y: number;
};

const point: Point = {
  x: 10,
  y: 20
};

Above, we create a type alias Point representing an object with x and y numeric properties. Then, we create an object point using this type.

When to Use Type or Interface

According to the TypeScript documentation, the choice between using a type or an interface depends on the specific scenario and personal preference. However, there are some general guidelines:

Use Interfaces:
- When defining shapes of objects with specific properties and methods.
- When you want to enforce a contract that objects must adhere to.
- When working with object-oriented patterns like implementing classes.
Use Types:
- When creating aliases for primitive types, union types, tuples, or any other complex data structure.
- When you need to use computed properties or mapped types.
- When you want to compose types together using intersection or union operators.

Conclusion

Understanding the difference between type and interface in TypeScript is crucial for writing clear and maintainable code. While interfaces are great for defining object shapes and enforcing contracts, types offer flexibility and versatility in defining various data structures. By choosing the right tool for the job, you can improve the readability and robustness of your TypeScript codebase.

Question: When would you prefer using an interface over a type in TypeScript?

Reference: TypeScript example

Is React a Framework or a Library?

Henry Dioniz — Fri, 29 Mar 2024 20:36:46 +0000

Ever dabbled in web development? If so, you've likely come across terms like "libraries" and "frameworks." Both are tools that developers use, but they serve different purposes. Let's break it down before diving into React!

Libraries: Imagine a toolbox filled with specialized tools for specific tasks. That's essentially what a library is. It provides a collection of pre-written code snippets (functions, classes) that developers can integrate into their projects to achieve particular functionalities. They offer flexibility and allow developers to choose the tools they need.

Example: Lodash (JavaScript Library)

// Shuffle an array using Lodash
const numbers = [1, 2, 3, 4, 5];
const shuffledNumbers = _.shuffle(numbers);
console.log(shuffledNumbers); // Output: [..., shuffled order of numbers]

Frameworks: Think of a framework as a pre-built structure, like a house frame. It provides a foundation and core functionalities that developers can build upon. Frameworks often dictate a specific way of doing things, offering a more structured approach to development.

Example: Django (Python Framework)

# Create a basic view function in Django
def hello_world(request):
  return render(request, 'hello.html', {'message': 'Hello, World!'})

Now, the star of the show: React!

React is a library, not a framework. It focuses on building user interfaces (UI) with reusable components. These components are like building blocks that developers can combine to create complex interfaces. React offers a declarative way of describing what the UI should look like, leaving the "how" to React itself.

This flexibility allows developers to choose other libraries for routing, state management, and other functionalities, creating a custom development stack.

Reasons React is a Library:

Focuses on a specific aspect (UI)
Offers flexibility in choosing other tools
Requires developers to make more decisions

Test Your Knowledge!

Which of the following best describes a library?
a) Provides a complete structure for development
b) Offers pre-written code for specific tasks
True or False: Frameworks offer more flexibility than libraries.

Remember, understanding the distinction between libraries and frameworks can help you choose the right tools for your projects. Keep coding and exploring new technologies to enhance your skills!

whether you're using a library or a framework, the key to great work is passion and dedication. Happy coding! 🧑‍💻

Motivational Quote:
"Every great developer you know got there by solving problems they were unqualified to solve until they actually did it." → Patrick McKenzie

Let vs. Const: Choosing the Right Tool for the Job in JavaScript

Henry Dioniz — Wed, 27 Mar 2024 22:48:02 +0000

Today we're diving into the world of variable declarations, specifically focusing on const and let. These keywords might seem similar, but understanding the subtle differences between them is crucial for writing clean, maintainable, and bug-free code.

Const: The Unchanging Guardian

The const keyword declares a variable with a fixed value. Once assigned, this value cannot be reassigned later in your code. Think of it as a constant – a fundamental truth that remains unwavering throughout your program. Here are some ideal use cases for const:

Constants: When dealing with values that shouldn't change, like mathematical constants (e.g., const PI = 3.14159;) or configuration settings.
Array and Object References: While you can't reassign the variable itself using const, you can still modify the contents of arrays and objects referenced by the variable. This allows you to create an array or object and then manipulate its elements without accidentally overwriting the entire reference.

Example:

const colors = ["red", "green", "blue"];
colors.push("yellow"); // This is allowed - modifying the array elements

console.log(colors); // Output: ["red", "green", "blue", "yellow"]

// This would cause an error:
// colors = ["purple", "orange"];

Let: The Flexible Friend

The let keyword is your go-to for variables whose values might change within the scope they're declared. It offers more flexibility than const while still preventing accidental reassignments from outer scopes. Use let for:

Loop Counters: In for loops, you typically need to update a counter variable. let allows you to do this without creating issues.
Conditional Assignments: When a variable's value might change based on certain conditions within its scope.

Example:

let age = 25;
if (age >= 18) {
  age = "adult"; // Reassigning within the same scope using let
}

console.log(age); // Output: "adult"

Test Your Understanding!

Here's a scenario to check if you've grasped the concepts:

const name = "Alice";
let age = 30;

function updateAge() {
  age++; // Can we modify age here? (Why or why not?)
}

updateAge();
console.log(age); // What will be the output?

Can you explain why age can be modified inside the function and what the final output will be? If so, you're well on your way to mastering const and let in your JavaScript coding adventures!

Remember: By adopting a const-by-default approach and only using let when necessary, you'll enhance your code's clarity, prevent accidental modifications, and make it easier for yourself and others to understand your logic. Happy coding!

Understanding JavaScript and TypeScript: A Beginner's Guide

Henry Dioniz — Tue, 26 Mar 2024 21:42:41 +0000

In the world of web development, JavaScript and TypeScript are two powerful programming languages used to build dynamic and interactive web applications. While they share similarities, they also have distinct differences that make each suitable for specific scenarios. In this blog post, we'll explore the short history of JavaScript and TypeScript, understand their differences, and learn where to use each and why.

A Brief History

JavaScript

JavaScript, often abbreviated as JS, was created by Brendan Eich in 1995 while he was working at Netscape Communications Corporation. Initially named "LiveScript," it was later renamed JavaScript to leverage the popularity of Java. JavaScript quickly gained traction as a versatile scripting language for web development, enabling developers to add interactivity to web pages.

TypeScript

TypeScript, on the other hand, is a superset of JavaScript developed by Microsoft. Anders Hejlsberg, known for his work on Turbo Pascal, Delphi, and C#, spearheaded the creation of TypeScript. It was first made public in October 2012. TypeScript enhances JavaScript by adding optional static typing, making it more scalable and maintainable for large-scale applications.

The Differences

Static Typing

One of the key differences between JavaScript and TypeScript is static typing. JavaScript is dynamically typed, meaning variable types are determined at runtime. On the contrary, TypeScript supports static typing, allowing developers to specify variable types during development. This helps catch type-related errors early in the development process.

// TypeScript
let message: string = "Hello, TypeScript!";

// JavaScript
let message = "Hello, JavaScript!";

Tooling and IDE Support

TypeScript offers better tooling and IDE support compared to JavaScript. IDEs like Visual Studio Code provide features such as auto-completion, type checking, and refactoring assistance, which significantly improve developer productivity. TypeScript's type system enables these advanced features, making it easier to write and maintain code.

Compilation

Another difference is in the compilation process. JavaScript is an interpreted language, meaning the code is executed line by line by the JavaScript engine. On the contrary, TypeScript code must be transpiled into JavaScript before execution. This extra step ensures compatibility with all JavaScript environments and browsers.

Where to Use Which and Why

JavaScript

JavaScript remains the go-to language for web development, especially for smaller projects, quick prototypes, and client-side scripting. Its ubiquity and ease of use make it accessible to beginners and experienced developers alike. JavaScript is well-supported across all modern web browsers, making it an excellent choice for building interactive web applications.

TypeScript

TypeScript shines in large-scale projects where maintainability and scalability are paramount. Its static typing system helps catch errors early, leading to more robust and bug-free codebases. TypeScript's tooling support and IDE integration make it an ideal choice for teams working on complex applications requiring collaboration and long-term maintenance.

Conclusion

In summary, both JavaScript and TypeScript are powerful languages with their own strengths and use cases. JavaScript, with its simplicity and versatility, is ideal for smaller projects and client-side scripting. On the other hand, TypeScript's static typing and advanced tooling make it a compelling choice for large-scale applications requiring maintainability and scalability. Whether you choose JavaScript or TypeScript depends on the specific requirements of your project and your team's preferences and expertise.

Happy coding! 🚀

Say Hello to Programming: Writing "Hello, World!" in 50 Different Languages

Henry Dioniz — Mon, 25 Mar 2024 21:38:26 +0000

Description:
In this blog post, we'll explore the fascinating world of programming by learning how to write the classic "Hello, World!" program in 50 different programming languages. From the simplicity of Python to the elegance of Haskell, we'll take a brief tour through a diverse range of languages, each with its own unique syntax and approach to programming. Whether you're a seasoned developer looking to expand your repertoire or a curious beginner eager to dip your toes into the vast ocean of code, this journey promises to be both educational and entertaining.

Now, let's dive into writing "Hello, World!" in 50 different languages:

1 Python:

print("Hello, World!")

2 Java:

public class HelloWorld {
    public static void main(String[] args) {
        System out println("Hello, World!");
    }
}

3 C:

#include <stdio h>

int main() {
    printf("Hello, World!\n");
    return 0;
}

4 C++:

#include <iostream>

int main() {
    std::cout << "Hello, World!" << std::endl;
    return 0;
}

5 JavaScript:

console log("Hello, World!");

6 Ruby:

puts "Hello, World!"

7 Swift:

print("Hello, World!")

8 Go:

package main

import "fmt"

func main() {
    fmt Println("Hello, World!")
}

9 Rust:

fn main() {
    println!("Hello, World!");
}

10 PHP:

<?php
echo "Hello, World!";
?>

11 Perl:

print "Hello, World!\n";

12 Kotlin:

fun main() {
    println("Hello, World!")
}

13 Scala:

object HelloWorld {
  def main(args: Array[String]): Unit = {
    println("Hello, World!")
  }
}

14 Lua:

print("Hello, World!")

15 Haskell:

main :: IO ()
main = putStrLn "Hello, World!"

16 Dart:

void main() {
  print('Hello, World!');
}

17 Shell:

echo "Hello, World!"

18 Batch:

@echo off
echo Hello, World!

19 PowerShell:

Write-Output "Hello, World!"

20 VBScript:

MsgBox "Hello, World!"

21 Objective-C:

#import <Foundation/Foundation h>

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        NSLog(@"Hello, World!");
    }
    return 0;
}

22 Assembly:

section  data
    hello db 'Hello, World!',10
    len equ $ - hello

section  text
    global _start

_start:
    ; write our string to stdout
    mov eax, 4         ; sys_write
    mov ebx, 1         ; file descriptor 1 (stdout)
    mov ecx, hello     ; message to write
    mov edx, len       ; message length
    int 0x80           ; syscall
    ; exit
    mov eax, 1         ; sys_exit
    xor ebx, ebx       ; exit status 0
    int 0x80           ; syscall

23 VBA (Visual Basic for Applications):

Sub HelloWorld()
    MsgBox "Hello, World!"
End Sub

24 Tcl:

puts "Hello, World!"

25 COBOL:

       IDENTIFICATION DIVISION 
       PROGRAM-ID  HELLO-WORLD 
       PROCEDURE DIVISION 
           DISPLAY "Hello, World!" 
           STOP RUN

26 F#:

printfn "Hello, World!"

27 Elixir:

IO puts "Hello, World!"

28 SQL (MySQL):

SELECT 'Hello, World!';

29 SQL (SQLite):

SELECT 'Hello, World!';

30 SQL (PostgreSQL):

SELECT 'Hello, World!';

31 SQL (Oracle):

SELECT 'Hello, World!' FROM DUAL;

32 SQL (SQL Server):

PRINT 'Hello, World!';

33 Smalltalk:

Transcript show: 'Hello, World!'; cr

34 R:

cat("Hello, World!\n")

35 Bash:

echo "Hello, World!"

36 Erlang:

-module(hello) 
-export([hello_world/0]) 

hello_world() ->
    io:fwrite("Hello, World!~n")

37 Julia:

println("Hello, World!")

38 MATLAB:

disp('Hello, World!');

39 AutoHotkey:

MsgBox, Hello, World!

40 Clojure:

(println "Hello, World!")

41 Groovy:

println "Hello, World!"

42 OCaml:

print_endline "Hello, World!"

43 D:

import std stdio;

void main()
{
    writeln("Hello, World!");
}

44 Crystal:

puts "Hello, World!"

45 Nim:

echo "Hello, World!"

46 Common Lisp:

(format t "Hello, World!~%")

47 Scheme:

(display "Hello, World!")
(newline)

48 Prolog:

:- initialization(main) 

main :-
    write('Hello, World!'), nl,
    halt

49 ABAP:

REPORT ZHELLO_WORLD 

WRITE: / 'Hello, World!'

50 VB NET:

vb net
Module HelloWorld
    Sub Main()
        Console WriteLine("Hello, World!")
    End Sub
End Module

That concludes our journey through "Hello, World!" in 50 different programming languages Whether you're just starting or have been programming for years, exploring different