A. Ghafoor Sayyed on Ghafoor's Personal Blog

Affiliate Disclosure

hello@ghafoorsblog.com (AG Sayyed) — Sun, 17 May 2026 00:00:00 +0000

Affiliate Disclosure

This page contains affiliate disclosure information for Ghafoor’s Blog (the “Site”), located at https://ghafoorsblog.com. This page was last updated 18 May 2026.

What Are Affiliate Links

Some of the links on this Site are “affiliate links.” If you click on an affiliate link and make a purchase or sign up for a service, we may receive a small commission at no extra cost to you. These commissions help cover the costs of running this site — hosting, domain, tools, and content creation.

How to use prompts with OpenManus

hello@ghafoorsblog.com (AG Sayyed) — Thu, 15 May 2025 15:00:53 +0000

OpenManus Usage Guide

This guide assumes you’ve already installed OpenManus — if not, start with the OpenManus installation walkthrough. To run it against a local model instead of OpenRouter, you’ll also need Ollama installed and serving, and a quick read of the hyperparameter reference will help you pick sensible max_tokens and temperature values for the config below.

Setup

1# Clone (already done)
2cd ~/Documents/projects/uv/OpenManus
3
4# Run from OpenManus directory (recommended)
5cd ~/Documents/projects/uv/OpenManus && uv run main.py --prompt "your task here"

Running from Anywhere

Option 1: Full path (easiest)

1cd ~/Documents/projects/uv/OpenManus && uv run main.py --prompt "your task here"

Option 2: From this folder (HBstack blog)

1uv run ~/Documents/projects/uv/OpenManus/main.py --prompt "your task here"

Option 3: Interactive mode

1cd ~/Documents/projects/uv/OpenManus && uv run main.py
2# Then type your prompt when asked

Option 4: Planning flow (for complex multi-step tasks)

1cd ~/Documents/projects/uv/OpenManus && uv run run_flow.py

Current Config

Setting	Value
Provider	OpenRouter
Model	`anthropic/claude-haiku-4.5`
Input cost	$1.00 per million tokens
Output cost	$5.00 per million tokens
Max steps	20 (per session)

Writing Good Prompts

✅ DO: Be specific with a deliverable

Good Prompt	Why
`Analyze my Hugo site at /home/ag-sayyed/Documents/projects/hbstack/ghafoors-blog and give a summary of the theme, config, and content structure`	Clear goal + output format
`Find all broken internal links in my Hugo site at /path/to/site`	Specific task, measurable result
`Add a new "contact" page with a form to my Hugo site at /path/to/site`	Concrete deliverable
`Update the homepage hero section to say "Welcome to my blog" in /path/to/site`	Small, focused change
`List all custom shortcodes in /path/to/site and explain what each does`	Specific scope
`Suggest 3 performance improvements for my Hugo site based on /path/to/site/config.toml`	Analytical, bounded task

❌ AVOID: Vague prompts with no deliverable

Bad Prompt	Problem
`Explore my Hugo site`	No goal — wanders aimlessly, wastes tokens
`Look at my site`	Same — no clear end condition
`Check my config`	Too vague, doesn’t know what to check for
`Help me with my site`	Way too broad

💡 Tips to Save Money

Be specific about which files — instead of “analyze my site”, say “check config.toml and the homepage content”
Set a clear output — “give me a bullet list”, “write the changes to file X”, “summarize in 3 sentences”
One task at a time — each prompt is a fresh session, so break big jobs into focused steps
Use full paths — always include the absolute path to your project so OpenManus finds it regardless of where you run from

Cost Reference (Haiku 4.5)

Activity	Approx Cost
Listing a directory + reading 2 files	~$0.02
Reading a whole Hugo config + summary	~$0.05
Creating a new page with content	~$0.10
Full site analysis (10+ files)	~$0.30
Complex multi-step task (20 steps)	~$1.00–2.00

Quick Alias (Optional)

Add to ~/.bashrc:

OpenManus for Local LLMs

hello@ghafoorsblog.com (AG Sayyed) — Sun, 11 May 2025 15:00:53 +0000

OpenManus Installation and Usage Guide

OpenManus repository on GitHub.

This post covers installation only. Once you have it running, see the companion guide on writing prompts for OpenManus for cost-effective usage patterns. OpenManus needs a local LLM endpoint — if you don’t yet have one, follow the Ollama install guide first.

Install uvicorn for running the FastAPI server.

1$ curl -LsSf https://astral.sh/uv/install.sh | sh
2uv -h
3uv -V

Essential uv Commands

Category	Command	Description
Environments	uv venv	Creates a new virtual environment in the .venv folder.
	source .venv/bin/activate	Activates the environment (macOS/Linux).
	.venv\Scripts\activate	Activates the environment (Windows).
	deactivate	Exits the currently active environment.
Project Management	uv init	Sets up a new project with a pyproject.toml file.
	uv add `<package>`	Adds a dependency and automatically updates the environment.
	uv sync	Synchronises the environment with the lockfile (installs/removes).
	uv run `<script>`	Runs a script without needing to manually activate the env.
Pip Interface	uv pip install -r reqs.txt	Fast alternative to pip install for existing requirement files.
	uv pip tree	Displays a visual tree of all installed dependencies.
Python Versions	uv python list	Shows available Python versions you can install.
	uv python install 3.12	Downloads and installs a specific Python version automatically.

Clone the OpenManus repository and navigate to the project directory.

1git clone https://github.com/FoundationAgents/OpenManus.git
2cd OpenManus

Install the required dependencies using pip.

1uv pip install -r requirements.txt

Configure toml file

OpenManus uses a config.toml file to specify the LLMs and their configurations. You can create this file in the root directory of the project.

OpenWebUI

hello@ghafoorsblog.com (AG Sayyed) — Sun, 11 May 2025 15:00:53 +0000

OpenWebUI transforms how you interact with your local language models, providing a sleek, feature-rich interface that makes working with models like Llama, Mistral, and others both powerful and intuitive.

What is OpenWebUI

OpenWebUI is an open-source, browser-based graphical user interface designed specifically for interacting with local large language models (LLMs), particularly those running through Ollama. It provides a ChatGPT-like experience for your self-hosted AI models, combining the privacy benefits of running local models with the usability of commercial AI platforms.

How to Run Private LLMs on Your Own Hardware

hello@ghafoorsblog.com (AG Sayyed) — Sat, 10 May 2025 23:19:42 +0000

Learn how to run powerful uncensored language models completely offline on affordable hardware for enhanced privacy and unrestricted access to information.

Introduction

Welcome to the Global Science Network! I’m going to show you how to download and run a large language model that was trained on what would be equivalent to:

Reading 127 million novels
Reading through all of Wikipedia 2,500 times

The best part? This model can be downloaded and run on an external flash drive that costs around $12. The model only requires about 10GB of storage space.

Hyper Parameters

hello@ghafoorsblog.com (AG Sayyed) — Tue, 11 Feb 2025 18:55:28 +0000

This guide covers the key hyperparameters that influence the performance of AI models, including context window size and embedding size.

If you haven’t set up a local model yet, start with the Ollama install guide or the broader local LLM ecosystem comparison. The settings below are exposed by most front-ends, including OpenWebUI.

Context Windows Size

Context window size is the maximum number of tokens the model can process in a single input. It determines the model’s ability to understand and generate text based on the context provided. If you increase the context window size, the model can consider more information when generating responses, but it may require more memory and processing power. It happens when it has to remember what was asked earlier. In other words, it’s how much of the conversation or input history the model considers when making its predictions. For example, if you’re having a conversation with the AI, the context window determines how many of the previous messages the model can “remember” and use to generate a coherent response. A larger context window means the model can take into account more of the previous conversation, leading to more contextually aware responses, but it can also require more computational resources, which can slow down performance. The context window size keep increasing as the conversation goes on.

AVX Technology Explained

hello@ghafoorsblog.com (AG Sayyed) — Fri, 31 Jan 2025 21:12:40 +0000

AVX Technology Explained

AVX (Advanced Vector Extensions) is a CPU instruction set extension designed for high-performance computing. It was first introduced by Intel in 2011 with the Sandy Bridge processor architecture.

How AVX Works

At its core, AVX allows a single instruction to operate on multiple data points simultaneously, following the SIMD (Single Instruction, Multiple Data) computing paradigm:

Without AVX: Process data one piece at a time
With AVX: Process multiple pieces of data in parallel with a single instruction

AVX Versions

AVX (2011): Original version with 256-bit wide vector operations
AVX2 (2013): Added more instructions and expanded integer operations
AVX-512 (2016+): Further expanded to 512-bit operations

Why AVX2 Matters for AI and Machine Learning

Modern AI frameworks and LLM runtimes require AVX2 because:

Installing Ollama

hello@ghafoorsblog.com (AG Sayyed) — Fri, 31 Jan 2025 21:12:40 +0000

This guide explores the local LLM ecosystem and Ollama's place within it. The AI landscape includes cloud-based services like ChatGPT and local solutions that offer privacy, cost savings, and control. Local LLM tools function through inference engines (Ollama, LM Studio), various model formats (GGUF, GGML), and different user interfaces. Ollama stands out as an open-source tool that simplifies running large language models locally on personal computers. It provides a user-friendly interface for model management, enabling tasks like text generation, summarization, and code completion without cloud dependencies. While LM Studio offers a full GUI experience and LocalAI focuses on API compatibility, Ollama balances simplicity with power through efficient CLI and basic web interfaces..

AI Ecosystems and Local LLM Tools

The AI ecosystem for large language models (LLMs) consists of two primary deployment approaches: cloud-based and local. Cloud-based solutions like OpenAI’s ChatGPT, Claude, and Google’s Gemini offer powerful capabilities but come with subscription costs and data privacy considerations. Local LLM tools have emerged as alternatives that provide greater control over data, reduced costs, and customization options.

Within the local LLM ecosystem, several tools enable users to run AI models on their personal computers:

Inference Engines: Software like Ollama, LM Studio, and LocalAI that handle the actual execution of models
Model Formats: Different standards like GGUF, GGML, and PyTorch formats that define how models are stored and loaded
User Interfaces: Various ways to interact with models through CLI, GUI, web interfaces, or API endpoints

Ollama fits into this ecosystem as a leading inference engine that simplifies model management and provides an API for integrations. If you just want to get a model running quickly, my step-by-step Ollama install guide walks through the full setup on Ubuntu. Once you have models running, the hyperparameter reference explains how to tune context window, temperature and quantization for your hardware.

Popular Local LLM Tools

LM Studio

LM Studio is a desktop application designed to provide an intuitive graphical interface for running LLMs locally. Key features include:

GUI-based model management and inference
Support for GGUF format models
Built-in model browser for downloading models from Hugging Face
Chat interface with conversation history
OpenAI-compatible API for integration with other applications
Advanced inference parameter controls
Support for Windows, macOS, and Linux

LocalAI

LocalAI is an open-source, self-hosted alternative to the OpenAI API that supports various models and architectures:

OpenAI API compatibility for drop-in replacement
Support for multiple model formats (GGUF, GGML, PyTorch)
Multi-modal capabilities (text, image, audio)
Container-friendly design for easy deployment
Function calling and tools API

Text Generation WebUI

A comprehensive web interface for running LLMs with extensive features:

Web-based UI accessible from multiple devices
Support for many model architectures and formats
Extensions ecosystem
Character and persona creation tools
Training and fine-tuning capabilities

If your CPU does not support AVX2 (see why AVX matters for LLM runtimes), Text Generation WebUI is one of the few tools with a working non-AVX install path.

Koboldcpp

A lightweight C++ implementation focused on creative writing and storytelling:

Optimized for narrative and creative text generation
Low resource requirements
Integrations with role-playing interfaces

Comparing Local LLM Tools

Similarities

Feature	Ollama	LM Studio	LocalAI	Text Generation WebUI
Local Model Execution	✅	✅	✅	✅
Privacy-focused	✅	✅	✅	✅
Free to use	✅	✅	✅	✅
API capabilities	✅	✅	✅	✅

Differences

Feature	Ollama	LM Studio	LocalAI	Text Generation WebUI
User Interface	CLI + Basic Web	Full GUI	Web API	Advanced Web UI
Installation Complexity	Simple	Simple	Moderate	Complex
Model Format Support	Custom + GGUF	GGUF primary	Multiple formats	Multiple formats
System Resource Usage	Efficient	Moderate	Configurable	Higher
Container Support	Good	Limited	Excellent	Available
Model Customization	Modelfiles	Limited	Moderate	Advanced

Model Formats

Different tools use different model formats:

GGUF (GPT-Generated Unified Format): Successor to GGML, used by Ollama and LM Studio, optimized for efficient inference on consumer hardware.
GGML (GPT-Generated Model Language): Older format still used by some tools, being phased out in favor of GGUF.
PyTorch/Safetensors: Native formats used by many AI research labs, less optimized for consumer hardware.
ONNX: Open standard for machine learning interoperability, supported by various tools.

Model Storage Locations

Model storage varies by tool:

Ollama: Stores models in ~/.ollama/models on Linux/macOS and C:\Users\<username>\.ollama\models on Windows.
LM Studio: Typically stores models in a user-configurable location, defaulting to ~/lmstudio/models on macOS/Linux.
LocalAI: Stores models in its configured models directory, customizable at setup.
Text Generation WebUI: Stores models in the models subdirectory of its installation.

Models can be shared between different tools with some limitations:

GGUF models: Can generally be used across Ollama, LM Studio, and LocalAI, though parameter settings may need adjustment.
Ollama specific models: Models pulled via Ollama may need to be extracted or converted before use in other tools.
Custom formats: Some tools have proprietary enhancements or metadata that don’t transfer to other platforms.

To use the same models across tools:

Store models in a central location
Configure each tool to access this location
Ensure format compatibility (most tools now support GGUF)
Be aware that quantization levels and parameters may vary between tools

Understanding Hugging Face and Model Hubs

Hugging Face serves as the central hub for machine learning models - essentially the “GitHub of machine learning models.” It provides a collaborative platform where researchers and developers can share, discover, and use pre-trained models.

Key characteristics of Hugging Face include:

Vast model repository: Hosts thousands of models for various AI tasks
Multiple access methods: Models can be:
- Downloaded manually through the website
- Accessed via APIs using libraries like Transformers
- Used directly by tools like LM Studio, KoboldCpp, and others
Community contributions: Allows users to upload their own fine-tuned models
Standardized formats: Primarily distributes models in formats like GGUF/GGML for efficient local inference

LM Studio primarily pulls models from Hugging Face in .gguf format, making it a cornerstone of the local LLM ecosystem’s model distribution infrastructure.

The Core Issue: Model Silos

A fundamental challenge in the local LLM ecosystem is that tools like Ollama and LM Studio use separate download systems and storage directories for LLMs. They do not share models by default, even if the same model has already been downloaded to your computer.

This creates “model silos” where:

Redundant storage: The same model might be stored twice in different locations
Format incompatibilities: Models downloaded for one tool often can’t be directly used by another
Inconsistent experiences: The same model might behave differently across tools due to different backends

Technical Reasons for Model Discrepancies

The technical reasons for these model discrepancies include:

Different formats and backends:
- Ollama uses a custom model packaging format for optimized serving (typically .modelfile or .bin formats)
- LM Studio and many other tools use GGUF or GGML formats (developed for the llama.cpp inference engine)
Isolated storage systems:
- Tools don’t look into each other’s directories for model files by default
- Each maintains its own metadata about models, making cross-tool discovery difficult
Runtime differences:
- Ollama: Optimized C++ backend with custom format and API emphasis
- LM Studio: llama.cpp-based with GGUF format and GUI focus

Best Practices for Model Interoperability

To maximize efficiency and avoid duplicating large model files, consider these approaches:

Choose a primary tool for model management:
- Use LM Studio if you prefer a GUI, GGUF models, and local experimentation
- Use Ollama if you want fast server-like local inference and better integration with CLI and APIs
Use Ollama’s API server approach:
- Start Ollama with your preferred model: ollama run mistral
- Connect other applications to Ollama’s API at http://localhost:11434
- This lets you use one model instance across multiple interfaces
Use advanced configuration:
- Some tools allow specifying alternative model directories
- This can reduce duplication but requires technical configuration

Advanced Option: Converting Between Formats

For advanced users, it is theoretically possible (though complex) to convert between model formats:

GGUF to Ollama format:
- Extract the GGUF model
- Create a Modelfile defining the model’s parameters
- Repackage using ollama create

However, this approach is not officially supported and may not work reliably due to backend differences and frequent updates to both tools and formats.

Setting Up Text Generation WebUI (No AVX Required)

hello@ghafoorsblog.com (AG Sayyed) — Fri, 31 Jan 2025 21:12:40 +0000

Setting Up Text Generation WebUI (No AVX Required)

Text Generation WebUI is a great alternative to LM Studio that offers non-AVX builds, making it compatible with older CPUs. If you’re not sure whether your CPU has AVX2, see my short explainer on what AVX is and why it matters for LLM runtimes. For a wider comparison with Ollama, LM Studio and LocalAI, see the local LLM ecosystem overview. There are several installation options available:

About Me

hello@ghafoorsblog.com (AG Sayyed) — Fri, 24 Jan 2025 01:40:23 +0000

Image credit: Unknown author

Hello, I'm Abdul Ghafoor Sayyed, and I welcome you to my website. Here's a bit about me and what you can find here.

Background

I am based in the suburbs of London, in Reigate, Surrey Hills, UK. My interests span a wide spectrum — from physics and cognitive psychology to software engineering and neuroscience. I hold a BSc in Science with majors in Physics, Mathematics, and Statistics, along with two Postgraduate Diplomas: one in Cognitive Psychology and another in Cognitive and Clinical Neuroscience.

About This site

hello@ghafoorsblog.com (AG Sayyed) — Thu, 23 Jan 2025 01:40:23 +0000

Introduction

This site serves as a comprehensive platform for sharing knowledge, blog posts, and course materials. It is built using modern web technologies and is designed to be fast, responsive, and user-friendly. The site is part of the HBStack framework and leverages Hugo for static site generation.

Technologies

Hugo

Hugo is a powerful static site generator that allows for rapid development and deployment of websites. It is known for its speed and flexibility, making it an ideal choice for this project.

Contact Us

hello@ghafoorsblog.com (AG Sayyed) — Wed, 22 Jan 2025 01:40:23 +0000

Have a question, a suggestion, or just want to say hello? Fill in the form below and I'll get back to you as soon as I can, usually within one to two business days. If you'd like to discuss collaboration, tutoring, or course content, please include as much detail as possible so I can respond helpfully.

Credits

hello@ghafoorsblog.com (AG Sayyed) — Tue, 21 Jan 2025 01:40:23 +0000

Credits Mentioned

Banner images are from Unsplash.
Icons are from Bootstrap Icons.

Image Credits

Blog Banner: free image, credit to Engin Akyurt.
Docs Banner: free image, credit to Ben Karpinski.
Video credit: free video, credit to Lux Werk

Disclaimer

hello@ghafoorsblog.com (AG Sayyed) — Mon, 20 Jan 2025 01:40:23 +0000

Disclaimer

The information provided on this website is for general informational purposes only. All information on the site is provided in good faith, however, we make no representation or warranty of any kind, express or implied, regarding the accuracy, adequacy, validity, reliability, availability, or completeness of any information on the site.

Under no circumstance shall we have any liability to you for any loss or damage of any kind incurred as a result of the use of the site or reliance on any information provided on the site. Your use of the site and your reliance on any information on the site is solely at your own risk.

Open AI Quasi Religious

hello@ghafoorsblog.com (AG Sayyed) — Sat, 18 Jan 2025 20:53:23 +0000

This document explores the quasi-religious nature of OpenAI's artificial general intelligence mission, examining how Sam Altman's company operates more like a belief system than a scientific endeavor, with competing factions of believers and environmental consequences that threaten democratic governance. This is taken from a Youtube video by the author titled [Open AI Quasi Religious](https://www.youtube.com/watch?v=Z4k1h3jvGmA)

The Quasi-Religious Nature of OpenAI

OpenAI’s mission represents a unique phenomenon in the technology sector - a company that operates more like a religious movement than a traditional research organization. The company’s pursuit of artificial general intelligence (AGI) is fundamentally based on belief rather than scientific evidence.

Privacy Policy

hello@ghafoorsblog.com (AG Sayyed) — Sat, 18 Jan 2025 00:00:00 +0000

This Privacy Policy explains what information is collected when you use this website, how it is used, and the options you have to manage it.

Last updated: 30 September 2025

A.G. Sayyed operates this website (the “Site”). The Site is hosted as a static Hugo build and embeds a contact form powered by Formspree. Because the experience is intentionally lightweight, only a small amount of personal data is collected and it is handled with care.

Overview of Bash

hello@ghafoorsblog.com (AG Sayyed) — Thu, 05 Dec 2024 18:48:26 +0000

This article provides an overview of the Bash shell, detailing its startup behaviour across different environments (Linux, macOS, Windows). It explains the initialization files involved in configuring the shell, the differences between login and non-login shells, and the sequence of events that occur when starting a Bash session. Additionally, it includes a flowchart to visually represent the Bash startup process.

Bash Startup Overview (1.0)

The behaviour of Bash when starting up depends on the environment, whether you are on Linux, macOS, or Windows. For more on Bash scripting, refer to the Advanced Bash Scripting Guide.

History of Bash

hello@ghafoorsblog.com (AG Sayyed) — Mon, 04 Nov 2024 18:22:26 +0000

This article briefly explores the history and evolution of the Bash shell, highlighting its origins, features, and significance in Unix-like systems. It also discusses modern alternatives to Bash, such as Zsh, Fish, and Elvish, and clarifies common terminologies like terminal, console, and shell.

History of Bash (1.0)

The Bash Shell, short for Bourne Again Shell, was created in 1989 by Brian Fox for the GNU Project as a free software replacement for the original Bourne Shell (sh). The Bourne Shell, developed by Stephen Bourne in the late 1970s at AT&T Bell Labs, was designed to enhance Unix’s usability for direct programming in the shell. Bash expanded upon the Bourne Shell’s features while incorporating elements from the C Shell (csh) and KornShell (ksh) to create a user-friendly experience for both interactive use and scripting.

Example Post

hello@ghafoorsblog.com (AG Sayyed) — Mon, 15 Jan 2024 00:00:00 +0000

This is an example post in the posts section.

JavaScript Basics

hello@ghafoorsblog.com (AG Sayyed) — Mon, 15 Jan 2024 00:00:00 +0000

Learn the fundamentals of JavaScript programming.

What and why in JS

hello@ghafoorsblog.com (AG Sayyed) — Wed, 03 May 2017 23:00:00 +0000

1.0 Since JS has no interfaces how it is implemented

To understand what interface do and what is required one needs to have some object oriented programming knowledge. It is similar to class but can not be instantiated. It only exposed methods that interested object or class can implement the way they want. When a class implements an interface it is said to inherits the abstract functions, along with any other members defined in interface. e.g, any constant , methods , static methods and any nested types. NOte> Abstract methods do not have any code that are only blue prints for those who inherit them so provide the body by writing the code.

JavaScript Modules

hello@ghafoorsblog.com (AG Sayyed) — Tue, 11 Apr 2017 23:00:00 +0000

1.0 What are modules

Modules play a crucial role in organizing and structuring code within an application. They allow developers to break down large codebases into smaller, manageable pieces. In this article, we’ll delve into the concept of modules, their evolution, and how JavaScript and TypeScript handle them.
It is a technique which keep the code organizes in any programme. Java Script default way of creating object using literals is one of the ways of module pattern.

How to Understand Functional Programming

hello@ghafoorsblog.com (AG Sayyed) — Fri, 31 Mar 2017 23:00:00 +0000

Functional programming

Early languages like C, BASIC were not functional languages. Then came OOP C++ was a super set of C with Object Oriented approach the came Java but none of them offered functional programming technique. The only functional programming from early days was and still is LISP and its descendant like PROLOG. When Brenden Eich was hired by Netscape to write a language that can be embedded in their web browser. He came up with JavaScript, which was not an object oriented language but object based prototype language. But it was not all, there were some features of functional programming. As JavaScript evolved it turned out that functional programming technique can prove to be more powerful than its counterparts. To understand these techniques, one has to have at least some concept of what a function is and how it works. The term function has come from Mathematics.

JavaScript Objects

hello@ghafoorsblog.com (AG Sayyed) — Wed, 22 Feb 2017 00:00:00 +0000

1.0 Object Oriented Programming

JavaScript was not at all intended to be an Object Oriented Programming Language. At the time of its creation there were already other languages present which were doing this task, namely C++ was the modified version of C with Classes and other object oriented features. Another language which took the grounds was Java which was basically designed to serve the concept revolving around Object Oriented Programming and to overcome the shortcomings present in C++.

Introduction to Functions

hello@ghafoorsblog.com (AG Sayyed) — Thu, 05 Jan 2017 00:00:00 +0000

Objectives

At the end of this chapter you will learn to :

Define all different kinds of functions
Distinguish between an statement and the expression
Handle functions from JS perspective
Invoke functions directly and indirectly
Understand how functions inherits properties too
Appreciate functions role in object creation
Explore the power of functional programming

Introduction to JavaScript Functions

They are main building blocks of JavaScript, usually assigned a name so that they can be used time and time again by identifying with the given name.They are self-contained modular units.The structure of the function is shown below.

JavaScript Conditionals

hello@ghafoorsblog.com (AG Sayyed) — Sat, 10 Dec 2016 00:00:00 +0000

What are conditions

Programming is all about using logic of if and then. No matter what computer language you are using the rules always revolves around if and then. If this happens do that otherwise do something else, and so on

JavaScript is not different from other languages, in fact it is a c-based language and most of its syntax is like c language. But it is not a high level language like C. It has almost same procedure to check the conditions of any statement like the way it is done in c-language.

JavaScript Arrays

hello@ghafoorsblog.com (AG Sayyed) — Sat, 26 Nov 2016 00:00:00 +0000

Arrays

Array is a topic of data structure and deals with collecting of data known as data collection. Data can be homogeneous or heterogeneous, arrays usually deal with homogeneous items. The item in an array or a component (element stored) in an array is accessed by its position using index. Thus there is one-to-one relationship between each index and its component. Take an example of student marks achieved in five subjects var result = [70,69,83,93,73]. Marks are stored in an array which is referenced by the identifier result. Thus the relationship b/w its index and value can be shown as below.

JavaScript Variables

hello@ghafoorsblog.com (AG Sayyed) — Tue, 08 Nov 2016 00:00:00 +0000

Introduction to variables

In computer programming, a variable represents a very small chunk of memory which is a part of memory pool reserved for a program in which it is declared to allow the manipulation of its value.

For example, if you want to add two numbers, say 5 and 8 and would like to see the result displayed on your standard output. You would ideally need to have three variables so that you can hold their values into these variables. Let’s say x,y and z are those variables which will hold the values of 5,8 and their sum respectively.

History of JavaScript

hello@ghafoorsblog.com (AG Sayyed) — Sun, 17 Apr 2016 07:59:10 +0000

This document provides a comprehensive overview of the history and development of JavaScript, from its inception in the early 1990s to its current state. It begins by describing the static nature of early web pages and the need for a programming solution to enhance interactivity. Netscape's introduction of LiveScript, later renamed JavaScript, marked a significant milestone in web development. The standardization of JavaScript as ECMAScript by ECMA is discussed, along with the major updates in various ECMAScript editions. Key features introduced in ECMAScript 6 (ES6) and subsequent editions are outlined, including `const`, `let`, arrow functions, classes, async/await, and more. Overall, the document emphasizes JavaScript's continuous evolution and its importance in modern web development, ensuring it remains a fundamental technology for years to come.

A. Ghafoor Sayyed on Ghafoor's Personal Blog

Affiliate Disclosure

Affiliate Disclosure

What Are Affiliate Links

How to use prompts with OpenManus

OpenManus Usage Guide

Setup

Running from Anywhere

Option 1: Full path (easiest)

Option 2: From this folder (HBstack blog)

Option 3: Interactive mode

Option 4: Planning flow (for complex multi-step tasks)

Current Config

Writing Good Prompts

✅ DO: Be specific with a deliverable

❌ AVOID: Vague prompts with no deliverable

💡 Tips to Save Money

Cost Reference (Haiku 4.5)

Quick Alias (Optional)

OpenManus for Local LLMs

OpenManus Installation and Usage Guide

Essential uv Commands

Configure toml file

OpenWebUI

What is OpenWebUI

How to Run Private LLMs on Your Own Hardware

Introduction

Hyper Parameters

Context Windows Size

AVX Technology Explained

AVX Technology Explained

How AVX Works

AVX Versions

Why AVX2 Matters for AI and Machine Learning

Installing Ollama

AI Ecosystems and Local LLM Tools

Popular Local LLM Tools

LM Studio

LocalAI

Text Generation WebUI

Koboldcpp

Comparing Local LLM Tools

Similarities

Differences

Model Compatibility and Sharing

Model Formats

Model Storage Locations

Model Sharing Between Tools

Understanding Hugging Face and Model Hubs

The Core Issue: Model Silos

Technical Reasons for Model Discrepancies

Advanced Solutions for Model Sharing

Best Practices for Model Interoperability

Advanced Option: Converting Between Formats

Setting Up Text Generation WebUI (No AVX Required)

Setting Up Text Generation WebUI (No AVX Required)

About Me

Background

About This site

Introduction

Technologies

Hugo

Contact Us

Credits

Credits Mentioned

Image Credits

Disclaimer

Disclaimer

Open AI Quasi Religious

The Quasi-Religious Nature of OpenAI

Privacy Policy

Overview of Bash

Bash Startup Overview (1.0)

History of Bash

History of Bash (1.0)

Example Post

JavaScript Basics

What and why in JS

1.0 Since JS has no interfaces how it is implemented

JavaScript Modules