DEV Community: John Johnson Okah

Small Language Models (SLMs): A Comprehensive Overview

John Johnson Okah — Fri, 21 Feb 2025 17:17:20 +0000

The past few years have been a blast for artificial intelligence, with large language models (LLMs) stunning everyone with their capabilities and powering everything from chatbots to code assistants. However, not all applications demand the massive size and complexity of LLMs, the computational power required makes them impractical for many use cases. This is why Small Language Models (SLMs) entered the scene to make powerful AI models more accessible by shrinking in size.

Let's go through what SLMs are, how they are made small, their benefits and limitations, real-world use cases, and how they can be used on mobile and desktop devices.

What are Small Language Models?

Small Language Models (SLMs) are lightweight versions of traditional language models designed to operate efficiently on resource-constrained environments such as smartphones, embedded systems, or low-power computers. While large language models have hundreds of billions—or even trillions—of parameters, SLMs typically range from 1 million to 10 billion parameters. The small language models are significantly smaller but they still retain core NLP capabilities like text generation, summarization, translation, and question-answering.

Some practitioners don't like the term "Small Language Model", because a billion parameter is not small by any means. They prefer "Small Large Language Model", which sounds convoluted. But the majority went with Small Language Model, so SLM it is. By the way, note that it is only small in comparison with the large models.

How Are They Made Small?

The process of shrinking a language model involves several techniques aimed at reducing its size without compromising too much on performance:

Knowledge Distillation: Training a smaller "student" model using knowledge transferred from a larger "teacher" model.
Pruning: Removing redundant or less important parameters within the neural network architecture.
Quantization: Reducing the precision of numerical values used in calculations (e.g. converting floating-point numbers to integers).

Examples of Small Language Models

Several small yet powerful language models have emerged, proving that size isn’t everything. The following examples are SLMs ranging from 1-4 billion parameters:

Llama3.2-1B – A Meta-developed 1-billion-parameter variant optimized for edge devices.
Qwen2.5-1.5B – A model from Alibaba designed for multilingual applications with 1.5 billion parameters.
SmolLM2-1.7 – From HuggingFaceTB, a state-of-the-art "small" (1.7 billion-parameter) language model trained on specialized open datasets (FineMath, Stack-Edu, and SmolTalk).
Gemma-2-2B – Developed by Google DeepMind, this 2 billion-parameter model balances performance and efficiency; it also scores high in writing and safe classification.
Phi-3.5 Mini – Microsoft's tiny-but-might open model with 3.8 billion-parameters optimized for reasoning and code generation.

Here are other more powerful small language models available out there: Mistral 7B, Gemma 9B, and Phi-4 14B (though I'm not sure if Phi-4 with 14 Billion parameters still qualifies as "small" but it's so damn capable :)

Benefits of Small Language Models

Low Compute Requirements – Can run on consumer laptops, edge devices, and mobile phones.
Lower Energy Consumption – Efficient models reduce power usage, making them environmentally friendly.
Faster Inference – Smaller models generate responses quickly, ideal for real-time applications.
On-Device AI – No need for an internet connection or cloud services, enhancing privacy and security.
Cheaper Deployment – Lower hardware and cloud costs make AI more accessible to startups and developers.
Customizability: Easily fine-tuned for domain-specific tasks (e.g., legal document analysis).

Limitations of Small Language Models

While SLMs offer numerous advantages, they also come with certain trade-offs:

Narrow Scope: Limited generalization outside their training domain (e.g., a medical SLM struggles with coding).
Bias Risks: Smaller datasets may amplify biases if not carefully curated.
Reduced Complexity: Smaller models may struggle with highly nuanced or complex tasks that require deep contextual understanding.
Less Robustness: They are more prone to errors in ambiguous scenarios or when faced with adversarial inputs.

Real-World Applications of Small Language Models

Despite their limitations, SLMs have a broad range of practical applications:

Chatbots & Virtual Assistants: Efficient enough to run on mobile devices while providing real-time interaction.
Code Generation: Models like Phi-3.5 Mini assist developers in writing and debugging code.
Language Translation: Lightweight models can provide on-device translation for travelers.
Summarization & Content Generation: Businesses use SLMs for generating marketing copy, social media posts, and reports.
Healthcare Applications: On-device AI for symptom checking and medical research.
IoT & Edge Computing: Running AI on smart home devices without cloud dependency.
Educational Tools: Tutoring systems can utilize SLMs to generate personalized explanations, quizzes, and feedback in real-time.

Running Small Language Models on Edge Devices

SLMs bring AI power directly to your smartphone (using PockPal) or PC (using Ollama), offering offline access, enhanced privacy, and lower latency.

SLMs on Mobile Device with PocketPal

For users interested in experiencing SLMs firsthand, the PocketPal AI app offers an intuitive way to interact with these models directly on your smartphone, without the need for an internet connection. Whether you want to draft emails, brainstorm ideas, or get answers to quick questions, PocketPal provides a seamless interface powered by optimized SLMs. Its offline capabilities ensure your queries remain private.

Features

Offline AI Assistance: Run language models directly on your device without internet connectivity.
Model Flexibility: Download and swap between multiple SLMs, including Danube 2 and 3, Phi, Gemma 2, and Qwen.
Auto Offload/Load: Automatically manage memory by offloading models when the app is in the background.
Inference Settings: Customize model parameters like system prompt, temperature, BOS token, and chat templates.
Real-Time Performance Metrics: View tokens per second and milliseconds per token during AI response generation. Download PocketPal AI on iOS and Android

Running SLMs on PC with Ollama

Ollama, an open-source tool, simplifies SLM deployment on PCs:

Local Management: Run models like Llama3.2-1B or Phi-3.5 Mini with minimal setup.
GPU Optimization: Leverages consumer-grade GPUs for faster inference.
Custom Workflows: Integrate SLMs into data pipelines or creative tools (e.g., automated code reviews).

Getting Started with Ollama:

Install Ollama from ollama.com
Open the terminal and download a model:

ollama pull gemma2:2b

Run the model interactively:

ollama run gemma2:2b

This setup enables local AI-powered chatbots, coding assistants, and document summarization without needing cloud services.

Fine-Tuning Small Language Models

One of the most exciting aspects of SLMs is their adaptability through fine-tuning. By exposing an SLM to domain-specific datasets, you can enhance its performance for niche applications.

For instance:

Fine-tune a model on legal documents to create a contract analysis assistant.
Train an SLM on technical manuals to build a troubleshooting guide for engineers.

There are several ways to fine-tune an SLM:

Full Fine-Tuning – Retraining all parameters with new data (requires significant compute).
LoRA (Low-Rank Adaptation) – Fine-tunes only a few layers, making it lightweight and efficient.
Adapters & Prompt Tuning – Adds extra layers or optimizes prompts to guide model responses.

Example: Fine-Tuning with LoRA
Using Hugging Face’s peft library:

from peft import LoraConfig, get_peft_model
from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "gemma-2-2b"
model = AutoModelForCausalLM.from_pretrained(model_name)
tokenizer = AutoTokenizer.from_pretrained(model_name)

config = LoraConfig(r=8, lora_alpha=16, lora_dropout=0.1)
model = get_peft_model(model, config)

# Train the model on new data...

Fine-tuning not only improves accuracy but also ensures the model aligns closely with your unique requirements.

Conclusion

Small Language Models (SLMs) represent a crucial step toward efficient, accessible, and cost-effective AI. They provide practical solutions for businesses, developers, and researchers looking for powerful AI without the heavy computational burden of LLMs.

With tools like Ollama for PCs and fine-tuning options for customization, SLMs are reshaping the AI landscape—making AI more personal, private, and available to everyone.

Let's discover how compact AI can transform our projects.

How Django Finds Static and Template Files: A Quick Guide

John Johnson Okah — Fri, 21 Feb 2025 01:47:57 +0000

Ever wondered how Django magically finds your CSS, JavaScript, images, and HTML files? It's not magic, but a well-defined system of settings and conventions! Understanding how Django locates static and template files is crucial for any Django developer (esp. those like me who can't get their favicon to display ;)
Here's a quick guide ↴

Static Seeker: How Django Hunts for CSS, JS, and Images

Static files, like stylesheets, scripts, and images, are the non-dynamic assets that make your web pages look and function beautifully. Django knows where to find them by checking a few key places:

App-Specific Static Folders: The primary place Django looks is within your apps themselves! Inside each app, Django expects a static directory. To avoid naming clashes, it's convention to create a subdirectory within static named after your app. So, for an app called my_app, the path would be my_app/static/my_app/.
Project-Level Static Folders (STATICFILES_DIRS): Sometimes you have static files that are not specific to any single app, like global stylesheets or shared images. The STATICFILES_DIRS setting in your settings.py is your go-to for this. It's a list of directories where Django will look for static files in addition to the app-specific folders.
Production Powerhouse (STATIC_ROOT): For production, you'll want to serve all your static files from one place for efficiency. That's where STATIC_ROOT comes in. This setting defines the absolute path to a directory where the collectstatic management command will gather all your static files into a single location. Your web server then serves these files from STATIC_ROOT.

Key Settings in settings.py for Static Files:

# settings.py

STATIC_URL = '/static/'  # URL to access static files (browser-facing)

STATICFILES_DIRS = [
    BASE_DIR / "static",  # Project-level static files in the root 'static' folder
]

STATIC_ROOT = BASE_DIR / "staticfiles" # Where 'collectstatic' puts all static files

Example Directory Structure:

myproject/
├── myapp/
│   ├── static/
│   │   ├── myapp/
│   │   │   ├── css/
│   │   │   │   └── style.css
│   │   │   ├── images/
│   │   │   │   └── logo.png
├── static/             # Project-level static folder
│   └── global.css
├── settings.py
└── manage.py

Accessing Static Files in Templates:

In your Django templates, you load the static template tag set and then use {% static 'path/to/your/static/file.ext' %} to generate the correct URL:

{% load static %}
<link rel="stylesheet" href="{% static 'myapp/css/style.css' %}">
<img src="{% static 'images/logo.png' %}" alt="My Logo">

Template Tracker: Django's Path to HTML Files

Templates are your HTML files that Django dynamically fills with data. Django's template finding process is similarly structured:

App-Specific Template Folders: Just like static files, Django checks for a templates directory within each app. Following convention, create a subdirectory inside templates named after your app: my_app/templates/my_app/.
Project-Level Template Folders (TEMPLATES['DIRS']): For templates that are used across multiple apps or project-wide layouts, you can define global template directories in the TEMPLATES setting in settings.py under the DIRS key.
APP_DIRS: True Magic: Within the TEMPLATES setting, APP_DIRS: True is crucial! This setting tells Django to automatically look inside each app's templates/ directory.

Key Settings in settings.py for Templates:

# settings.py

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [BASE_DIR / "templates"],  # Project-level templates directory
        'APP_DIRS': True,  #  Look for templates in app 'templates' folders
        'OPTIONS': {
            'context_processors': [ # ... default context processors
            ],
        },
    },
]

Example Directory Structure:

myproject/
├── myapp/
│   ├── templates/
│   │   ├── myapp/
│   │   │   ├── index.html
│   │   │   ├── detail.html
├── templates/          # Project-level templates folder
│   ├── base.html
│   ├── home.html
├── settings.py
└── manage.py

Using Templates in Views:

In your Django views, you use render(request, 'template_name.html'). Django then searches for template_name.html based on the configured template directories.

from django.shortcuts import render

def my_view(request):
    return render(request, 'myapp/index.html') # Django finds 'myapp/templates/myapp/index.html'

In Summary:

Django's organized approach to static and template files relies on clear settings and naming conventions. By understanding STATIC_URL, STATIC_ROOT, STATICFILES_DIRS, TEMPLATES['DIRS'], and APP_DIRS, you can effectively structure your Django projects and ensure Django can always find the files it needs.

Still scratching your head about a specific static or template issue? Check out Django's Official Documation on static files and template using the reference link below.

Ref:

For static files: https://docs.djangoproject.com/en/stable/howto/static-files/
For templates: https://docs.djangoproject.com/en/stable/topics/templates/

Neural Network (explained in 1 Byte)

John Johnson Okah — Wed, 19 Jun 2024 12:11:08 +0000

This is a submission for DEV Computer Science Challenge v24.06.12: One Byte Explainer.

Explainer

Just like our brain, a Neural Network is made up of interconnected "neurons". These neurons work together by learning from (input) data and getting better at tasks (in the hidden layer) to give (output) predictions or decisions.

Additional Context

A Neural Network is a computational model inspired by the structure and function of the human brain. It consists of a series of interconnected "neurons" or nodes organized in layers. These layers include:

Input Layer: Each node in this layer represents a feature from the input data. For example, if the data is an image, each node might represent a pixel value.
Hidden Layers: This is where the real magic happens. This layer consists of multiple nodes that process and transform the input data through a series of weighted connections. Each connection has a weight that gets adjusted during training based on the input data and the desired output to minimize errors.
Output Layer: This layer takes the outputs of the last hidden layer and transforms them into the final prediction of the network. For example, if it is an image recognition task, each node in the output layer might represent different predictions to identify the image.

In summary, a Neural Network mimics the human brain's ability to learn and make decisions by processing input data through interconnected layers of neurons, adjusting weights, and minimizing errors to improve performance.

Basic Terms in Machine Learning (Model Training)

John Johnson Okah — Thu, 18 Apr 2024 19:54:36 +0000

As the AI hype grows, machine learning is making its way into every recent innovative product. Therefore, understanding the basic concepts and terminologies of machine learning becomes increasingly essential for anyone looking to get started with or deepen their knowledge of machine learning.
Machine learning is a powerful technique that enables computers to learn from data and make predictions or decisions without being explicitly programmed.

Below are brief explanations of some fundamental terminologies in machine learning.

Basic Terms in Machine Learning

Artificial Intelligence: Artificial Intelligence (AI) is a technology that enables computers and machines to simulate human intelligence and problem-solving capabilities.
Machine Learning: Machine Learning (ML) is a subset of artificial intelligence that involves training algorithms to learn from data and make predictions or decisions without being explicitly programmed to perform a specific task.
Neural Network: A neural network is a type of machine learning model that is inspired by the structure and function of the human brain.
Deep Learning: Deep learning is a subset of machine learning that uses artificial neural networks with multiple layers to model complex relationships between inputs and outputs.
Model: A model is a simplified representation of a real-world process or system that is created to make predictions or decisions based on input data.
Dataset: A dataset is a structured collection of data that is organized and stored for easy access and analysis. They are sets of examples or observations that are used to train, validate or test machine learning models.
Prediction: The prediction is the result/output from the model. It is the estimation based on input data.
Parameters: Parameters are internal variables of a machine learning model that are learned from the training data to capture the relationships and patterns within the data.
Training: This is the process of teaching a model to make predictions or decisions by exposing it to input data and adjusting its internal parameters based on the observed outcomes.
GPU: Graphics Processing Unit (GPU) is a specialized hardware components that excel at parallel processing and has become indispensable in accelerating machine learning tasks.

At the core of machine learning is the process of training models - algorithms that can recognize patterns and extract insights from data.
Here is an oversimplified process of machine learning model training:

first, you collect and clean relevant data, then pick an algorithm suited to the task. The algorithm analyzes the data to learn patterns, and the model is tested and refined to improve its accuracy. Finally, the trained model can be used to make predictions on new data.

Now, let's look at some terms in training a machine learning model.

Basic Terms in Model Training

Pre-trained models: These are models that have been trained on a large dataset to perform a specific task, such as image classification, natural language processing, etc., before being made available for use by others.
Transfer learning: This is a machine learning technique that leverages pre-trained model knowledge to be applied to a different but related task (by fine-tuning).
Fine-tuning: It is a process in transfer learning where a pre-trained model is further trained on a new, smaller dataset for a specific task.
Overfitting: This occurs when a model learns the training data too well, capturing noise and random fluctuations rather than the underlying patterns. It leads to poor generalization performance on new, unseen data.
Training set, validation set, and test set: These are different portions of the dataset for evaluation. The training set is used to train the model, the validation set is used to fine-tune hyperparameters and evaluate performance during training, and the test set is used to assess the model's final performance on unseen data.
Hyperparameters: These are other parameters that define how the model is trained. For example, defining how long we train for, or what learning rate. They are external configuration settings set by the engineer or researcher.
Epoch: An epoch refers to one complete pass through the entire training dataset during the training of a model. Multiple epochs are typically required. On each epoch, the parameters are updated based on the gradient of the loss function.
Metric: A metric is a function that measures the quality of the model's predictions using the validation set. A metric is defined for human consumption, easy for you to understand.
Loss: This is also known as the loss function or cost function. It is a mathematical function that quantifies the difference between the model's predictions and the actual outcomes (labels) in the training data. Loss is used to update weights automatically, easy for stochastic gradient descent to use.
Architecture
Stochastic Gradient Descent: SGD is an optimization algorithm used for training models by updating the parameters iteratively with small batches of data.
Architecture: This is the overall structure design of a model. The architecture of a neural network defines its overall structure, including the arrangement of layers, the number of neurons, and the connections between neurons.

Having gone through this ML jargon, you should have a solid grasp of the core terminology used in machine learning model training. This knowledge will prepare you to dive deeper into more advanced ML concepts.

Pattern Program: A Creative Intersection of Logic and Design

John Johnson Okah — Thu, 25 Jan 2024 17:17:10 +0000

Pattern programming is like drawing with code, where you can make all sorts of interesting shapes and designs with a set of instructions. It is one of the earliest intersections of art and logic in programming.

What is Pattern Program?

A pattern program is a piece of code that generates a specific textual pattern in the form of shapes, numerical sequences, or even complex designs. Pattern programs are commonly used to practice problem-solving skills that have to do with logic and control structures. It is an accessible way for beginners to learn programming concepts while also producing visually interesting results.

In pattern programming, a rule is defined on how each element is arranged to make a recognizable pattern.
For example, creating rows and columns of a rectangle by printing a pattern element in a nested loop. Usually, the first loop defines the length of the shape (in rows), then a new line (\n), and the second loop defines the width of the shape (in columns).

Rectangle pattern:

*******
*******
*******

Program pattern for the rectangle:

for i in range(3): # rows
    for j in range(7): # columns
        print("*", end="") # pattern element *
    print() # new line

Types of Pattern Programs

Pattern programs often comes in these three (3) patterns:

Shape Pattern: A shape pattern program involves creating visual designs using a character symbol to form various geometric shapes, such as triangles, squares, retangles, and more.
Number Pattern: A number pattern program involves using numbers to create sequences or arrangements that follow a specific rule or logic. A typical example is the pascal triangle.
Letter Pattern: A letter pattern program involves using letters of the alphabet to create interesting arrangements or shapes.

Examples of Pattern Programs

Here are some examples of pattern program in python:

1. Diamond Pattern

def generate_diamond_pattern(rows):
    # Upper half of the diamond
    for i in range(1, rows + 1):
        print(" " * (rows - i) + "* " * i)

    # Lower half of the diamond (excluding the center row for odd row numbers)
    for i in range(rows - 1, 0, -1):
        print(" " * (rows - i) + "* " * i)

# Example: Generate a diamond pattern with 5 rows
rows = 5
generate_diamond_pattern(rows)

output:

    * 
   * * 
  * * * 
 * * * * 
* * * * * 
 * * * * 
  * * * 
   * * 
    *

2. Alphabetic Half Pyramid Pattern

def generate_alphabetic_half_pyramid(rows):
    for i in range(1, rows + 1):
        for j in range(1, i + 1):
            print(chr(ord('A') + j - 1), end=" ")
        print()

# Example: Generate an alphabetic half pyramid pattern with 5 rows
rows = 5
generate_alphabetic_half_pyramid(rows)

output:

A 
A B 
A B C 
A B C D 
A B C D E

3. Pascal Triangle

def generate_pascals_triangle_pyramid(rows):
    triangle = []
    for i in range(rows):
        row = [1] * (i + 1)
        for j in range(1, i):
            row[j] = triangle[i - 1][j - 1] + triangle[i - 1][j]
        triangle.append(row)

    max_width = len(' '.join(map(str, triangle[-1])))

    for row in triangle:
        formatted_row = ' '.join(map(str, row))
        print(formatted_row.center(max_width))

# Example: Generate Pascal's Triangle with 5 rows in pyramid pattern
rows = 5
generate_pascals_triangle_pyramid(rows)

output:

4. Chessboard Pattern

def generate_chessboard(rows, cols):
    for i in range(rows):
        for j in range(cols):
            # Check if the sum of row and column indices is even or odd
            if (i + j) % 2 == 0:
                print("■", end=" ")
            else:
                print("□", end=" ")
        print()

# Example: Generate a chessboard pattern with 8 rows and 8 columns
rows = 8
cols = 8
generate_chessboard(rows, cols)

output:

■ □ ■ □ ■ □ ■ □ 
□ ■ □ ■ □ ■ □ ■ 
■ □ ■ □ ■ □ ■ □ 
□ ■ □ ■ □ ■ □ ■ 
■ □ ■ □ ■ □ ■ □ 
□ ■ □ ■ □ ■ □ ■ 
■ □ ■ □ ■ □ ■ □ 
□ ■ □ ■ □ ■ □ ■

5. Doormat Pattern

def print_welcome_pattern(M, N):
    pattern = ".|."
    welcome_message = "WELCOME"

    # Print the top part of the pattern
    for i in range(M // 2):
        line = (pattern * (2 * i + 1)).center(N, '-')
        print(line)

    # Print the welcome message
    print(welcome_message.center(N, '-'))

    # Print the bottom part of the pattern
    for i in range(M // 2 - 1, -1, -1):
        line = (pattern * (2 * i + 1)).center(N, '-')
        print(line)

# Example usage for a 11 x 33 pattern
print_welcome_pattern(11, 33)

output:

---------------.|.---------------
------------.|..|..|.------------
---------.|..|..|..|..|.---------
------.|..|..|..|..|..|..|.------
---.|..|..|..|..|..|..|..|..|.---
-------------WELCOME-------------
---.|..|..|..|..|..|..|..|..|.---
------.|..|..|..|..|..|..|.------
---------.|..|..|..|..|.---------
------------.|..|..|.------------
---------------.|.---------------

Conclusion

As we've seen with triangles, diamonds, and more, there's an artistic side to coding that often goes unnoticed. It's about finding beauty in the logical. Both newbies and seasoned coders can hone their creative, artistic, and programming skills while playing with Pattern Programs. The beauty of pattern programming lies in its simplicity and the endless possibilities it offers.

2024 Goals (ML, 1024km run, Writing)

John Johnson Okah — Fri, 19 Jan 2024 19:25:58 +0000

It's that time of the year when everyone is fired up to set bodacious goals. Now the DEV team has invited us to an accountability party with #devresolutions2024, and I hope we all deliver because it's going to be one hell of a ride once we accept the invitation. This kind of post will come to hunt you at the end of the year if you screw up or it could give you the best feeling in the world - fulfilment.

Here are my

Professional Goals:

Python Certification
I know Python pretty well, but I feel it would be great to also get a certificate as proof of concept. LinkedIn likes certification, so let's give it more this year ;)
Resource: HackerRank and freeCodeCamp.
Django Project
Aside being a Pythonista, I am a Djangonaut. And this year I will commit to developing a production-ready application with Django.
Machine Learning Course
Given that ML is currently the hottest space, how about we go get some! Okay, not just that; there are other better reasons and I've got plans ;)
Resource: Fast.ai and HuggingFace

Personal Aspirations:

Conversational Spanish
As an English speaker and a lazy student, I chose to learn Spanish because I think it is the easiest language for English speakers to learn.
Resource: Duolingo
Run 1,024 km
Ever heard of David Goggins? That's the man that made me run a marathon twice and several half-marathons last year. This year I will run at least a total distance of 1024km.
Resource: MapMyFitness
Chess 1500 Elo Rating
Let's try to convince whoever will buy the idea that we are smart because we are good at chess. Okay, I just love the game and I want to get better at it. That's it.
Resource: Chess.com

DEV Community Contributions:

Weekly Post
I am wondering why I have not been committed to posting on DEV. Most times I feel everything that I want to talk about has already been said, so why bother writing? However, I have found a good reason to write. Here it is: "Do it for you!". The point here is to focus on understanding a concept by writing about it or simply just telling your story as a developer. Hopefully, someone will find it useful but even if it gets zero views and zero likes, you keep writing for you.

If you can think, and speak, and write, you are absolutely deadly. Writing is thinking formalized. You gain the ability to think by first learning to write very, very carefully.
— Dr Jordan B. Peterson
Contribute and Collaborate
I will contribute to the community by sharing my story, moderating regularly, and collaborating with others to make dev.to great again.

So help me God.

Getting Started with Mojo ️‍🔥

John Johnson Okah — Sun, 17 Sep 2023 07:25:40 +0000

Mojo, the new Programming Language for all AI developers is as simple as Python and as fast as C.

What is Mojo?

Mojo is a programming language developed by the Modular team to simplify AI and machine learning infrastructure. It offers powerful compile-time metaprogramming, support for various accelerators, and full compatibility with Python.

Mojo combines the usability of Python with the performance of C, unlocking unparalleled programmability of AI hardware and extensibility of AI models.

Mojo's goal is to create a unified language that streamlines AI development while retaining compatibility with Python.

Why you would love it.

If you are a developer, and you love AI, and you love speed, and you love simplicity, you will love mojo.

Here are the best parts:

Usability and Programmability: Write everything in one language.

Write Python and scale all the way down to the metal. Program the multitude of low-level AI hardware. No C++ or CUDA required.
Performance: Unlock Python performance.

Utilize the full power of the hardware, including multiple cores, vector units, and exotic accelerator units, with the world's most advanced compiler and heterogenous runtime. Achieve performance on par with C++ and CUDA without the complexity.
Interoperability: Access the entire Python ecosystem.

Experience true interoperability with the Python ecosystem. Seamlessly intermix arbitrary libraries like Numpy and Matplotlib and your custom code with Mojo.

Why is there always a fire emoji beside the Mojo 🔥?

Because it's freaking hot!

And, mainly because the emoji is its file extension. You can save your code as hello.🔥 or hello.mojo)

From the Mojo team:

We paired Mojo with fire emoji 🔥 as a fun visual way to impart onto users that Mojo empowers them to get their Mojo on—to develop faster and more efficiently than ever before. We also believe that the world can handle a unicode extension at this point, but you can also just use the .mojo extension. :)

How to Install Mojo on Linux?

Currently, Mojo is available locally only for Ubuntu Linux systems. For now, Windows and Mac users can find their way around using WSL, containers, or a remote Linux system.

System Requirements:

To get started, make sure your system meets these requirements:

Ubuntu 20.04 and later
x86-64 CPU and minimum 4GiB RAM
Python 3.8 - 3.10
g++ or clang++ compiler (g++ comes pre-installed on Ubuntu)

Install the Modular CLI and Mojo SDK

The Modular CLI works like a package manager to install and update Mojo.

Install the Modular CLI:

curl https://get.modular.com | \
  MODULAR_AUTH=mut_fe303dc5ca504bc4867a1db20d897fd8 \
  sh -

The Mojo SDK includes everything you need for local Mojo development, including the Mojo standard library and the Mojo command-line interface (CLI). The Mojo CLI can start a REPL programming environment, compile and run Mojo source files, format source files, and more.

Install the Mojo SDK:

modular install mojo

Time for Hello World

Before you can write your first program in Mojo, you have to set the MODULAR_HOME and PATH variables on your shell.

echo 'export MODULAR_HOME="$HOME/.modular"' >> ~/.bashrc

echo 'export PATH="$MODULAR_HOME/pkg/packages.modular.com_mojo/bin:$PATH"' >> ~/.bashrc

source ~/.bashrc

Run Mojo on REPL

To start a REPL session, type mojo in your terminal and press Enter.

Then type print("Hello, world!") and press Enter twice (a blank line is required to indicate the end of an expression).

That’s it! For example:

$ mojo
Welcome to Mojo! 🔥
Expressions are delimited by a blank line.
Type `:mojo help` for further assistance.
1> print("Hello, world!")
2.
Hello, world!

You can write as much code as you want in the REPL. You can press Enter to start a new line and continue writing code, and when you want Mojo to evaluate the code, press Enter twice. If there’s something to print, Mojo prints it and then returns the prompt to you.

The REPL is primarily useful for short experiments because the code isn’t saved. So when you want to write a real program, you need to put the code in a .mojo source file.

Run a Mojo file

To write the Mojo code and execute it:

Create a file named hello.mojo (or hello.🔥) and add the following code:
```
fn main():
   print("Hello, world!")
```
That’s all you need. Save the file and return to your terminal.
Now run it with the mojo command:
```
mojo hello.mojo
```
It should immediately print the message:
```
Hello, world!
```

Mojo Language Basics

Here are some things to note about the language:

1. Syntax and Semantics:

Mojo supports Python's syntax and semantics, using line breaks and indentation for code blocks. It has most Python control-flow features.

2. Functions:

Functions in Mojo can be declared using either fn (strongly-typed, memory-safe) or def (Python-style dynamic). fn functions enforce type safety.

3. Variables:

Variables in Mojo can be declared with var (mutable) or let (immutable). Declaring types for variables is optional.

Example:

fn do_math():
    let x: Int = 1
    let y = 2
    print(x + y)

do_math()

4. Structures:

Mojo allows the creation of structs for high-level abstractions. A struct in Mojo is similar to a class in Python. But structs are static and don't allow dynamic dispatch.

Example:

struct MyPair:
    var first: Int
    var second: Int

    fn __init__(inout self, first: Int, second: Int):
        self.first = first
        self.second = second

    fn dump(self):
        print(self.first, self.second)

Usage:

let mine = MyPair(2, 4)
mine.dump()

5. Python Integration:

Mojo provides a mechanism to import Python modules as-is, leveraging existing Python code.

Example:

from python import Python

let np = Python.import_module("numpy")

ar = np.arange(15).reshape(3, 5)
print(ar)
print(ar.shape)

[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]]
(3, 5)

Mojo aims to combine the best of systems programming with the ease and flexibility of Python.

What's Next

For those using VS Code, you can install the Mojo extension, so you get syntax highlighting, code completion, diagnostics, and more.
You can also experiment with Mojo using the web-based Mojo Playground.
To learn more about Mojo, Read the Docs.
And you can always chat with the Mojo community on Discord.

Mojo🔥 is the future programming language for all AI developers.

Getting started with VIM: the Lightning Text Editor ⚡

John Johnson Okah — Mon, 24 Jul 2023 08:36:11 +0000

Whatever sins this text editor may have, being slow is not one of them.
Vim is a light and powerful text editor widely used among programmers and other technical professionals who work with text regularly.

Why Vim

Vim is known for its speed and low resource consumption, making it suitable for use on older systems or in remote environments. It's often preferred by developers who work on servers or in terminal-only environments. It gives them seamless integration with the command line.
It also makes you feel like a tech-savvy.

Installing Vim

On Linux

sudo apt install vim

On macOS

brew install vim

On Windows

Go to the Vim website: https://www.vim.org/download.php
Under "PC: MS-DOS and MS-Windows," click on the "gvim82.exe" link (the version number may vary).
Run the downloaded installer, and follow the on-screen instructions to install Vim.

On Android - Termux

pkg install vim

Opening Vim

After installing Vim, type

vim

on the terminal or PowerShell, to open the text editor.

Also use the command:

vim <FILENMAE>

to open an existing file or create a new one if it doesn't exist.

Modes in Vim

There are three essential modes in Vim, they are:

Normal: Default; for navigation and simple editing
Command Line: For operations like saving, exiting, searching etc.
Insert: For explicitly inserting and modifying text

Normal mode

Use the Esc key to return to the normal mode, even if you are already in the normal mode. The mode is mainly for navigation; you can use the arrow buttons to move the cursor up ↑, down ↓, left ← and right → of your file.
It is from the Normal Mode, you can enter the Insert Mode and the Command Line Mode.

Command Line Mode

To enter the Command Line Mode, press the column character : and the Vim editor will be ready to accept your command.

Now let's have a drum roll 🥁 because we are about to finally exit Vim

HOW TO EXIT VIM

Press the keys :q! and hit <ENTER> to exit.

Yeah that's all. We made it out, FAST. You can now exit Vim.

Let's proceed.

Insert Mode

To enter the Insert Mode, just hit the letter i on your keyboard. And voila, you're in. You will always see -- INSERT -- at the bottom left of your screen whenever you are in insert mode.
This means you can now edit the file, by typing in your text.

Basic Commands

Here are some basic commands to get you rolling with Vim:

Saving and Quitting

:w (write) - to save file
:q (quit) - to exit and confirm if not saved
:wq (write and quit) - to save file and exit vim
:q! (quite forcefully) - to exit Vim whether the file is saved or not

Search and Replace Text

/text - to search for text in the document, going forward.
n - to move the cursor to the next instance of the text from the last search. This will wrap to the beginning of the document.
N - to move the cursor to the previous instance of the text from the last search.
:%s/text/replacement text/g - to search through the entire document for text and replace it with replacement text.

Copy, Paste, Undo, Redo

v (visual mode) - to highlight one character at a time. Use the arrow keys to move the cursor and select text.
y (yank) - to copy text into Vim's copy buffer.
p (paste) - to paste copied text after the cursor.
u (undo) - to undo the last operation.
Ctrl+r (redo) - to redo the last undo.

Moving the cursor

use ↑↓←→ up, down, left, and right arrow keys to move around
use HOME key to go to the beginning of a line
use Ctrl+HOME to go to the beginning of the file
use END key to go to the end of a line
use Ctrl+END to go to the end of a file

Next Step

This is how far I can go with you on this journey. At least, you now know how to exit (with :q! or :wq), whenever you get into trouble. Let Documentation, Trials-and-Errors, Google, and ChatGPT be your guide. You have to continue the remaining part of the journey on your own.

I wish you the best of luck 🍀

Getting Started with TERMUX 📲

John Johnson Okah — Thu, 20 Jul 2023 07:48:11 +0000

Have you ever been stuck with just your phone on a bus or in a boring environment and all you could think of is getting right back to your Dev environment? 🧑‍💻

If you've got an Android device, we've got good news. ⤵
Termux essentially turns an Android device into a lightweight and portable development environment, enabling users to perform various tasks, such as coding, scripting, system administration, and network testing, directly on their smartphones or tablets.

The Introduction 📖

Termux is an Android terminal emulator and Linux environment app that allows users to run a full-fledged Linux distribution on their Android devices. It provides a powerful command-line interface (CLI) that enables users to execute various Unix commands, run shell scripts, and access a wide range of Linux tools and utilities directly on their Android smartphones or tablets.

Termux provides a convenient and flexible environment for developers, system administrators, and enthusiasts who want to perform tasks such as programming, scripting, development, testing, and system management on their Android devices. It offers access to a package manager (pkg) that allows users to install various software packages, including programming languages, text editors, version control systems, networking tools, and more.

With Termux, users can perform tasks similar to what they would do on a traditional Linux distribution, making it a popular choice for those who need a Linux-like environment on their mobile devices. It's worth noting that while Termux provides a Linux-like environment, it operates within the confines of Android's security mechanisms, so it might not have access to certain system-level functions or require root permissions for some operations.

The Setup ⚙️

Setting up Termux on an Android device is a straightforward process. Here's a step-by-step guide to help you get started:

1. Download and Install Termux
from Play Store
→ Go to Google Play Store
→ And install the Termux app
OR
from F-Droid:
→ Go to F-Droid App Store.
→ Search for the Termux APK file and click Download
→ Open the APK file and install it on your device

2. Open Termux:
→ After the installation is complete, tap on the "Open" button to launch Termux.

3. Update and Upgrade Termux Packages:
→ Once Termux is open, update and upgrade the packages to ensure you have the latest versions.
Run this command :

pkg update

to update the package lists and Run:

pkg upgrade

to upgrade all the installed packages to their latest versions.

4. Grant Access to Storage
→ Finally, permit Termux to access files in your device's internal storage that includes directories like DCIM, Downloads, and Documents.
→ Run this command to grant access:

termux-setup-storage

Accept the pop-up notification on your device requesting file access from Termux.

The Features 🛠️

Termux comes with a range of powerful features that allow users to leverage a full-fledged Linux environment on their Android devices. Some of its key features include:

1. Terminal Emulator: Termux provides a fully functional terminal emulator that enables users to run various Unix commands, execute shell scripts, and interact with the Linux command-line interface (CLI) directly on their Android devices. Commands such as ls, cd, mv, cp, touch are available in Termux.

2. Package Management: Termux includes a package manager (pkg) that allows users to install, update, and remove software packages from a vast repository of Linux tools and utilities. This makes it easy to extend the functionality of Termux with various programming languages, text editors, development tools, networking utilities, and more.

Install a package with this:

pkg install <package-name>

where <package-name> can be ffmpeg, vim, git, ...

3. Programming and Development Environment: Termux provides a platform for developers to write, compile, and run code directly on their Android devices. Users can work on coding projects using languages like Python, Ruby, Node.js, and C/C++

Run this command to install Python:

pkg install python3

Then you can install Python packages with pip:

pip install <package-name>

where <package-name> can be pytest, yt-dlp, flask, ...

4. OpenSSH and OpenSSL: Termux includes OpenSSH and OpenSSL, which provide secure encrypted communications and cryptographic functions, respectively.

5. File Access: Users can access and manipulate files on their devices, making it easy to work with all kinds of files from the terminal. In Termux, files on your device storage are located at /data/data/com.termux/files/shared/storage/

6. Text Processing Tools: Termux offers a variety of text processing tools like grep, sed, awk, and regular expressions, which are valuable for text manipulation and analysis.

7. Scripting and Task Automation: Users can create and run shell scripts on their Android devices, enabling automation of repetitive tasks.

8. Customization: Users can customize their Termux environment with themes, fonts, and various configurations to suit their preferences and workflow.

The Conclusion 📕

Overall, Termux stands as a reliable and user-friendly solution, allowing individuals to embrace the power of a Linux environment on their Android devices, making it an invaluable tool for learning, productivity, and creativity, all in the palm of their hands.

PS:
- The F-droid Termux app can't install updates from Play Store.
- Do not install suspicious packages and do not run random scripts from the internet on Termux.
- For more Info visit Termux ℹ️ Wiki, for Discussions visit Termux 💬 Reddit, and to Report Bugs visit Termux 🐞 Github.

Good luck and have fun exploring

AI Code Buddy

John Johnson Okah — Sat, 15 Jul 2023 17:01:42 +0000

In the world of coding, having the right tools can greatly enhance productivity and code quality. Two popular AI coding assistants, Cody 🤖 and CodiumAI 🧪, are here to lend a helping hand (FOR FREE!)

CODY

Cody is an AI coding assistant that can answer questions about your code, explain what the code is doing, and help you debug and improve your code. Cody can also translate between programming languages, navigate your codebase, and generate new code. Cody is available for free in the Cody app and IDE extensions.

Here are some of the specific features of Cody:

🧠 Codebase-aware intelligence: Cody can answer questions about both general programming topics and your specific codebase.
📚 Code explanation: Cody can explain what code is doing, both at a high level and in detail.
👃 Code smells: Cody can identify code smells, potential bugs, and unhandled errors.
📋 Summarize recent code changes: Cody can summarize the recent changes to your code.
🔍 Debugging assistance: Cody can help you debug and improve your code.
🐍 Translate language: Cody can translate between programming languages.
🗺️ Code navigation: Cody can help you find functions & components from around your codebase.
📌 Reference tracking: Cody knows where all your functions are referenced throughout your code.
🤖 AI-generated code: Cody can generate new code on request.
✅ Unit tests: Cody can write unit tests for you.
💡 Code completions: Cody can suggest code while you code.
✏️ Inline code fixes: Cody can edit and improve code directly using inline instructions.
📖 Documentation generation: Cody can generate documentation for your code.

Cody is a powerful tool that can help you improve your coding skills and productivity. If you are looking for an AI coding assistant, Cody is a great option.

To get started with Cody, visit https://about.sourcegraph.com/cody

CODIUM AI

CodiumAI is an AI-powered tool that helps developers write meaningful tests for their code. It is available as an extension for Visual Studio Code and JetBrains IDEs.

CodiumAI works by analyzing your code and generating tests that cover a variety of edge cases. It can also suggest improvements to your code, such as making it more readable or efficient.

Here are some of the key features of CodiumAI:

🧪 Generates meaningful tests that cover a variety of edge cases
🛠️ Suggests improvements to your code
📜 Works with a variety of programming languages, including Python, JavaScript, TypeScript, and Java
💻 Is available as an extension for Visual Studio Code and JetBrains IDEs

Here are some of the benefits of using CodiumAI:

🔧 Improves the quality of your code
🐞 Reduces the risk of bugs
⏰ Saves you time and effort
🚀 Makes you more productive

If you are a developer who wants to improve the quality of your code, then CodiumAI is a valuable tool that you should consider using.

To get started with Codium, visit https://www.codium.ai/

PASSWORD SAFETY 101: Hack-proof Your Digital World With These Invaluable Tips

John Johnson Okah — Sat, 17 Jun 2023 12:45:09 +0000

The longer the password, the stronger...

but here's when long isn't strong
1qaz2wsx3edc4rfv5tgb6yhn7ujm8ik,9ol.0p;/

This password will take a hacker minutes to crack, despite it being 34 characters long. Take a look at your keyboard and you will know why.

In today's interconnected world, where much of our personal and sensitive information resides in the digital realm, safeguarding our online accounts has become paramount. One of the most fundamental and essential aspects of digital security is password safety. By creating strong and secure passwords, we can fortify our virtual fortresses and protect ourselves from malicious actors. In this article, we will explore the importance of password safety and provide tips on how to enhance your online security.

Why Password Safety Matters

Passwords serve as the first line of defense against unauthorized access to our personal information, financial accounts, and digital identities. Weak or compromised passwords can leave us vulnerable to identity theft, data breaches, and other cybercrimes. Therefore, it is crucial to understand the significance of password safety and adopt good practices to mitigate the risks.

Creating Strong Passwords

A strong password is a critical component of your digital security strategy. Here are some guidelines to help you create robust passwords:

Length: Opt for passwords that are at least 12 characters long. The longer the password, the harder it is to crack through brute force or automated methods.
Complexity: Include a mix of uppercase and lowercase letters, numbers, and special characters in your password. Avoid using predictable sequences like "123456".
Uniqueness: Use a unique password for each of your online accounts. Reusing passwords across multiple platforms increases the risk of a single breach compromising multiple accounts - "One goes down, the others follow".
Avoid Personal Information: Avoid incorporating personal details such as your name, birthdate, or address in your passwords. This information can be easily obtained or guessed by attackers.
Avoid Commonly Used Password: A hacker can easily gain access to your account by simply trying every word in a dictionary, or a list of common passwords, until they find a match. Don't use dictionary words (like diamond) and common combinations (like 1q2w3e)
Passphrase Approach: Consider using passphrases instead of passwords. These are longer combinations of words or phrases that are easier to remember but harder to crack. For example, "PurpleElephantInSunshine" is a strong passphrase.

Additional Password Safety Measures

Creating strong passwords is just the first step. Here are some additional measures to enhance your password safety:

Two-Factor Authentication (2FA): Enable 2FA whenever possible. This adds an extra layer of security by requiring a second verification step, such as a unique code sent to your mobile device, in addition to your password.
Password Managers: Consider using a reputable password manager. These tools generate and store complex passwords for you, eliminating the need to remember them all. You can try Bitwarden, an open source password manager.
Beware of Phishing: Be cautious of phishing attempts, where attackers try to trick you into revealing your passwords or other sensitive information. Avoid clicking on suspicious links in emails or sharing personal information on untrusted websites.

Conclusion

As our lives become increasingly intertwined with the digital landscape, safeguarding our online presence is of utmost importance. Implementing strong and unique passwords, enabling two-factor authentication, and staying vigilant against phishing attempts are essential steps in securing yourself with passwords. Remember, your password is like a key to your digital life, and by prioritizing password safety, you can build a robust defense against cyber threats and enjoy peace of mind in the virtual world.

Solving the "It Works on My Machine" Problem with Docker

John Johnson Okah — Fri, 16 Jun 2023 02:07:19 +0000

One of the most frustrating issues in software development is the "It works on my machine" problem. This occurs when a developer creates an application that runs perfectly on their local machine but fails to work properly when deployed to other environments.

Docker has emerged as a solution to this problem. Docker allows developers to package an application and its dependencies into a container that can be run on any system that supports Docker. This ensures that the application runs consistently across different environments, eliminating the "It works on my machine" problem.

So if your image runs correctly on your development machine, it's highly likely it will also run correctly somewhere else. Docker essentially provides a "it works on my machine" environment that you can ship.

With Docker, developers can easily create a container that includes all the necessary dependencies and configurations for their application. This container can then be shared with other developers or deployed to different environments without worrying about compatibility issues.

In addition to solving the "It works on my machine" problem, Docker also offers other benefits such as improved scalability, easier deployment, and faster development cycles. By using Docker, developers can focus on building and improving their applications rather than worrying about the underlying infrastructure.

In conclusion, Docker is a powerful tool that can help developers solve the "It works on my machine" problem and streamline their development processes. Its ease of use and compatibility with different environments make it an essential tool for modern software development.

Start shipping your machine with docker🚢