Forem: Sam

Master LangChain in Typescript - A Practical Guide

Sam — Thu, 19 Jun 2025 12:22:09 +0000

I'm pretty sure you've already heard about LangGraph—otherwise, you wouldn't have clicked on this post :)

GenAI is the hottest topic in tech right now, and it feels like we're just getting started. New roles are popping up everywhere that require a solid grasp of the space, along with familiarity with the core tools, frameworks, and concepts.

The problem? Most of the resources out there are in Python.

So, I decided to start a series of bite-sized posts to teach you the key concepts of one of the core building blocks of GenAI-based development: LangGraph—but in TypeScript.

My approach is to be very practical. Instead of going deep into the theory early on, we’ll jump straight into code and learn by doing. Each post focuses on a small, self-contained concept with real, working examples.

We’ll keep things simple at first—no AI models, no agents—just the core building blocks. Once we have a good grip on the fundamentals, we’ll gradually move into more advanced topics like routing, conditionals, memory, tool calling, and building actual agents.

The source code of the entire series is available here:

🔗 next-gen-platforms

Also, the you can find the source code of this post here:
👉 1-simple-graph-chain

I suggest you fork and clone the repository, and open the file in your IDE so you always can see the full picture, follow along more easily, and tweak the code as you learn.

Introduction to LangGraph

LangGraph is a framework for building agents and multi-agent systems. At the core of LangGraph is a graph, which is a collection of nodes and edges.

Each node adds a specific functionality to the system, and edges define the flow between those nodes. Think of it like a flowchart where data moves from one step to the next.

In typical software, we have some sort of initial data which we process step by step in a deterministic workflow. But when we work with AI, decisions are often dynamic—based on model responses or environment inputs. LangGraph allows you to model those flows naturally using a graph-based structure.

What We'll Build

In this first lesson, we’ll build a simple graph chain:

A linear set of steps where each node is executed in sequence. This is a very basic use case, but it sets the foundation for more advanced patterns later.

State Graph in LangGraph

To build a graph, we use the StateGraph class.

Here’s a quick breakdown of the key concepts:

Node: A function that takes some state and returns new state.
Edge: A directional connection between two nodes.
State: The shared data passed between nodes.

Let’s take a closer look at each component.

State

In LangGraph, the execution flows through multiple nodes—each responsible for performing a part of the overall task. These nodes often need to share data: inputs, intermediate results, and outputs.

To make this possible, LangGraph introduces the concept of State—a shared structure that travels through the graph and can be read or updated by each node.

Here’s what it looks like in our example:

interface SimpleGraphState {
  step: number;
}

This very simple interface defines the shape of our graph’s state. In this case, we’re keeping track of a single field called step.

Channels

Each field in the state is controlled by a channel. Channels allow you to store and update different pieces of the state as the graph executes.

Here’s how we define the channel for step:

const graphStateChannels: StateGraphArgs<SimpleGraphState>["channels"] = {
  step: {
    value: (prevStep: number, newStep: number) => newStep,
    default: () => 0,
  },
};

This tells LangGraph two things:

Use 0 as the default value when the graph starts.
Always use the most recent update (newStep) if multiple nodes update the step.

And then, we pass these channels into the graph like so:

new StateGraph({ channels: graphStateChannels })

This gives LangGraph full control over how the state is initialized, updated, and maintained across the execution of nodes.

Nodes

A node in LangGraph is just a function that takes in some state and returns some (possibly updated) state. It’s the basic unit of logic in the graph.

Here’s how we define a simple node:

function firstNode(state: SimpleGraphState): SimpleGraphState {
  console.log("Executing Node 1");
  return {
    step: state.step + 1,
  };
}

This node does exactly one thing: it logs that it’s running and increments the step field in the state.

Edges

Once we’ve defined our nodes, the next step is to wire them together using edges. Edges determine the flow of execution—what node comes next after another.

We use the addNode method to register each node, and then use addEdge(from, to) to connect them:

const graphBuilder = new StateGraph({ channels: graphStateChannels })
  .addNode("first", firstNode)
  .addNode("second", secondNode)
  .addNode("third", thirdNode)
  .addEdge(START, "first")
  .addEdge("first", "second")
  .addEdge("second", "third")
  .addEdge("third", END);

A few things to note here:

START is a special entry point in the graph. It defines where the graph should begin execution.
END is a special marker that signals the termination point—once a node leads here, the graph stops.
Each addEdge call links two nodes together, forming a directed path.

Compile and Invocation

Once the graph is built, we compile it to create an executable graph object:

export const graph = graphBuilder.compile();

And then we invoke it like this:

const result = await graph.invoke({
  step: 0, // This could be any initial value
});

We start by passing an initial state—step: 0. Each node updates the step field, so by the end of the execution, we’ve gone from 0 to 3.

Run the Code

To run the example, first make sure you’ve cloned the repository:

git clone https://github.com/mkamrani/next-gen-platforms.git
cd next-gen-platforms/LangGraph/Typescript

Then install the dependencies - some of the dependencies will be used in the next lessons:

npm install

And finally run the code:

cd src/1-simple-graph-chain
npm run dev-1

You should see the following logs in your terminal:

=== Starting Graph Execution ===

Executing Node 1
Executing Node 2
Executing Node 3
=== Graph Execution Complete ===
Final state: { step: 3 }
Graph execution completed successfully

Happy Coding!

Letting Agents Write and Review Code — A 0dev Milestone(Demo)

Sam — Sat, 12 Apr 2025 03:54:16 +0000

0devis an open-source platform that allows you to generate AI agents and query/visialize different data sources.

It’s a solo project I’ve been building from scratch, with no funding or backing. Just me, working on it alongside a full-time job. That’s why it’s taken some time to reach this point — but things are finally coming together.

In a recent demo, I asked the 0dev agent to send an email with HTML formatting to a specific address. The catch? It needed to fetch the content from an S3 bucket and follow a set of policies defined ahead of time.

The agent took the request, generated the code to complete the task, and passed it through an automated reviewer. This reviewer ensures the generated code not only meets policy requirements but also stays true to the intent of the original instruction.

It’s a small example of a bigger idea: agents that can reason about what they’re doing, stay within guardrails, and still move fast.

Watch the short demo:
https://youtu.be/W45FxIGdGeM

Source code:
https://github.com/0dev-hq/0dev

Flyte a great alternative for Airflow - Learn the basics

Sam — Fri, 28 Mar 2025 22:46:03 +0000

Flyte is an open-source, Kubernetes-native workflow orchestrator implemented in Go. It enables highly concurrent, scalable and reproducible workflows for data processing, machine learning and analytics.

Flyte is built on simple concepts and provides powerful and flexible tools and methods to orchestrate ML and data processing workflows. If you have no idea what Flyte does, you can compare it with Airflow but with its own flavour.

I personally find the simplicity of Flyte one of its key strengths. If you’re already familiar with Airflow, you should find it very simple to learn and master, and even without that, the learning curve is moderate.

In this post, without any unnecessary side information, I show you how to set up Flyte locally and will touch on different concepts so you can continue to learn the rest on your own easily.

We will create two dummy CSV files and process them through multiple tasks in a workflow. While the workflow is very simple, it gives the opportunity to cover all the necessary fundamental concepts.

Install `flytectl`

mac:

brew install flyteorg/homebrew-tap/flytectl

other:

curl -sL https://ctl.flyte.org/install | bash

Verify:

flytectl version

Start a local deployment

flytectl demo start

If everything goes as planned at the end of the logs in your terminal you should see an output like this:

👨‍💻 Flyte is ready! Flyte UI is available at http://localhost:30080/console 🚀 🚀 🎉 

❇️ Run the following command to export demo environment variables for accessing flytectl export FLYTECTL_CONFIG=/<HOME>/.flyte/config-sandbox.yaml 
🐋 Flyte sandbox ships with a Docker registry. Tag and push custom workflow images to localhost:30000 
📂 The Minio API is hosted on localhost:30002. Use http://localhost:30080/minio/login for Minio console, default credentials - username: minio, password: miniostorage

Now you can open the Flyte UI in your browser: http://localhost:30080/console

This demo also gives you access to a local Minio deployment which you can assess in your browser: http://localhost:30080/minio/login

username: minio

password: miniostorage

Create the test data

sales_fb.cs
----
date,product,quantity,price
2025-02-01,Widget,10,20.00
2025-02-12,Gadget,1,35.00
2025-02-20,Widget,2,20.00
2025-02-28,Gadget,7,35.00


sales_jan.csv
----
date,product,quantity,price
2025-01-03,Widget,4,20.00
2025-01-15,Gadget,2,35.00
2025-01-25,Widget,3,20.00
2025-01-30,Gadget,5,35.00

Upload the test data

Upload the files containing the test data to the default bucket in your local Minio

Create the project

export FLYTECTL_CONFIG=~/.flyte/config-sandbox.yaml

flytectl create project --id sales-analysis --name sales-analysis --description "Sales Analysis" --domain development

You can verify the project is created successfully in the UI:

Create the workflow

You use python to create your tasks and workflows which are comprised of multiple tasks. Annotations are the common way you dictate the behaviour and role of the functions.

#sales-analysis-wf.py

from flytekit import task, workflow
from flytekit.types.file import FlyteFile
import pandas as pd
import numpy as np
from flytekit import ImageSpec
from datetime import timezone



image_spec = ImageSpec(
   name="<your account on docker hub>/flytekit",  # docker image name - the name is arbitrary
   base_image="ghcr.io/flyteorg/flytekit:py3.11-1.10.2",  # the base image that flytekit will use to build your image.
   packages=["pandas", "numpy", "flytekit", "s3fs", "pyarrow"],
   python_version="3.11",  # Optional if python is installed in the base image.
   platform="linux/arm64" # Set this based on you OS as we're running Flyte locally
)


@task(container_image=image_spec)
def load_data(sales_jan: FlyteFile, sales_feb: FlyteFile) -> pd.DataFrame:
    df_jan = pd.read_csv(sales_jan.download())
    df_feb = pd.read_csv(sales_feb.download())
    combined = pd.concat([df_jan, df_feb], ignore_index=True)
    return combined

@task(container_image=image_spec)
def clean_data(df: pd.DataFrame) -> pd.DataFrame:
    df['date'] = pd.to_datetime(df['date'])
    df['total'] = df['quantity'] * df['price']
    return df

@task(container_image=image_spec)
def aggregate_monthly_sales(df: pd.DataFrame) -> pd.DataFrame:
    df['month'] = df['date'].dt.to_period('M')
    monthly = df.groupby(['month', 'product'])['total'].sum().reset_index()
    return monthly

@task(container_image=image_spec)
def detect_outliers(df: pd.DataFrame) -> pd.DataFrame:
    def z_scores(values):
        mean = np.mean(values)
        std = np.std(values)
        return [(x - mean) / std if std > 0 else 0 for x in values]

    df['z_score'] = df.groupby('product')['total'].transform(z_scores)
    return df[np.abs(df['z_score']) > 2]

@task(container_image=image_spec)
def create_report(monthly: pd.DataFrame, outliers: pd.DataFrame) -> FlyteFile:
    import tempfile

    report = "Monthly Sales Summary:\n"
    report += monthly.to_string(index=False)
    report += "\n\nDetected Outliers:\n"
    report += outliers.to_string(index=False)

    with tempfile.NamedTemporaryFile("w", suffix=".txt", delete=False) as f:
        f.write(report)
        local_path = f.name

    return FlyteFile(local_path)

@workflow()
def sales_data_workflow() -> FlyteFile:
    jan_file = FlyteFile("s3://my-s3-bucket/sales_jan.csv")
    feb_file = FlyteFile("s3://my-s3-bucket/sales_feb.csv")

    raw_data = load_data(sales_jan=jan_file, sales_feb=feb_file)
    cleaned = clean_data(df=raw_data)
    monthly = aggregate_monthly_sales(df=cleaned)
    outliers = detect_outliers(df=monthly)
    report = create_report(monthly=monthly, outliers=outliers)

    return report

We created a dummy workflow with a few steps and save it as sales-analysis-wf.py just to showcase a few features of Flyte.

As you can see we have defined image_spec and used it in our steps. This is a mechanism to build the docker image with all the dependencies to run our tasks. You can have different images all built this way for different tasks if needed.

Run the workflow

Now that you have created the workflow file, you can run it with this command - pay attention to the flags we pass to the command:

pyflyte run --remote -p sales-analysis -d development sales-analysis-wf.py sales_data_workflow

Note: You have to login to your docker account using docker login to be able to push the image. If the image is not pushed automatically, you can simply push the image and run the pyflyte run command above again.

Result

Once you run the command you can track the progress on the UI with the link you receive in the terminal.

This workflow generates a simple report with txt format and stores it on Minio. You can click on the task and get the details from the Outputs tab:

We can download the file from the Minio UI:

Well done! Now you know all the basics needed to find your way around when using Flyte in your platform.

0dev, agents that generate code

Sam — Mon, 20 Jan 2025 07:19:13 +0000

Tool calling is gaining more traction after two years of static content generation by LLMs.

I've taken a slightly different approach in 0dev. 0dev agents generate python code for their tasks on the fly, gather the information and finally execute it after getting confirmation.

I'm working on a few enhancement in the baseline features of the agents before releasing a demo video but if you're interested in the concepts in this space, particularly the OSS end of the spectrum, you can have a look at it here:

https://github.com/0dev-hq/0dev

Master Cron Expressions In 2 minutes

Sam — Sun, 03 Nov 2024 06:44:03 +0000

Cron is such a simple yet complex way of expressing schedules. In this short post I'll show you all you need to be able to understand and write cron expressions that cover almost 90+% of the cases.

Before we move on, I want to invite you to visit 0dev, an open-source data platform that works with natural language. Use 0dev to access your data without complex SQL queries, visualize it without any coding and generate insights without any data science experience.

Repository: https://github.com/0dev-hq/0dev

Basic Structure

A cron expression has five (or more) fields:

* * * * *
| | | | |
| | | | └─── Day of the week (0-7, where 0 and 7 both represent Sunday)
| | | └────── Month (1-12)
| | └───────── Day of the month (1-31)
| └──────────── Hour (0-23)
└─────────────── Minute (0-59)

You can memorize it as MHDMD. Not catchy but it helps!

Note: The values of the Day of the week can be numbers 0-7 or MON-SUN. Also the Month can be expressed as numbers 1-12 or JAN-DEC.

Setting Fixed Times

Each position can be set to a specific value:

0 9 * * * - Runs at 9:00 AM every day.
30 14 * * * - Runs at 2:30 PM every day.

Using Wildcards (*)

The * symbol represents "any" for that position:

* * * * * - Runs every minute of every hour of every day.
0 * * * * - Runs at the beginning of every hour, every day.

Specifying Multiple Values

You can specify multiple values for any position using commas:

0,15,30,45 * * * * - Runs every 15 minutes on the hour, at 15, 30, and 45.
0 9,17 * * * - Runs at 9:00 AM and 5:00 PM every day.

Using Ranges

Ranges are specified with a dash -. You can read it as from n/nth to m/mth

0 9-17 * * * - Runs every hour from 9 AM to 5 PM.
15 14 1-7 * * - Runs at 2:15 PM on the first seven days of each month.

Step Values (/)

Steps allow you to specify intervals. You can read it as every n or nth.

*/15 * * * * - Runs every 15 minutes.
0 */3 * * * - Runs every 3 hours, at the top of the hour.
0 0 1 */2 * - Runs at midnight on the first day of every other month.

Day-Specific and Month-Specific Scheduling

You can use specific days by setting either:

* * ? * 1 - Runs every Monday.
0 9 ? * MON-FRI - Runs at 9:00 AM, Monday through Friday.

Notice that I'm using ? instead of *, which is a matter of preference. While both ? and * work similarly, ? is often used to emphasize that we don’t care about a particular field—in this case, the day of the month. By using ?, we make it clear that only the day of the week (e.g., Monday or Monday through Friday) is relevant to this schedule.

For instance:

0 12 15 * ? - Runs at 12:00 PM on the 15th of every month, with ? indicating that the specific day of the week is irrelevant.
0 12 ? * MON - Runs every Monday at 12:00 PM, with ? indicating that the specific day of the month is irrelevant.

Using ? is helpful when setting up schedules that depend solely on either the day of the week or the day of the month, as it makes the intention of the cron expression clearer.

Cron expression with 6 and 7 fields

If supported, you can add a field to the very right to indicate the year, or a field to the very left to indicate the second.

For instance:

30 20 12 * * * - Runs at exactly 12:20:30 PM every day.
0 0 12 15 6 ? 2024 - Runs at exactly 12:00:00 PM on June 15, 2024.

While I didn't cover every thing about the cron expressions, I hope you know better understand them and can easily write your own expressions.

If you're familiar with the cron expressions, what options would you add to this post? Share them in the comments so others can learn from it.

Happy coding :)

How to Remove a Specific Item From an Array in JavaScript?

Sam — Sat, 02 Nov 2024 04:54:58 +0000

It’s very common to need to remove a certain value from an array in JavaScript. In this post, I’ll show you not only how to do so, but also how to implement it as if it were a native method on arrays, with flexibility for handling different types of data, including objects, primitives, and custom comparison logic.

Before we start, I want to invite you to visit 0dev, an open-source data platform that works with natural language. Use 0dev to access your data without complex SQL queries, visualize it without any coding and generate insights without any data science experience.

Repository: https://github.com/0dev-hq/0dev

Let’s create a custom remove method on JavaScript arrays, allowing it to remove the first occurrence of a value by default or all occurrences when specified. Additionally, we’ll enhance it by adding support for a comparator function, giving us control over how values are matched.

Array.prototype.remove = function(value, removeAll = false, comparator = (a, b) => a === b) {
  if (removeAll) {
    return this.filter(item => !comparator(item, value));
  } else {
    const index = this.findIndex(item => comparator(item, value));
    if (index !== -1) this.splice(index, 1); // Remove the item if found
    return this;
  }
};

Explanation

`Array.prototype.remove`

Adding remove to Array.prototype makes this function available directly on any array instance, just like native methods such as map, filter, or splice.

`removeAll`

The removeAll parameter provides a simple way to control the behavior of the method. By default, removeAll is set to false, meaning that only the first occurrence of the specified value will be removed. If removeAll is set to true, the method will remove all occurrences of the specified value.

`comparator`

The comparator parameter might seem redundant at first, but it adds more flexibility to this method. When working with arrays of objects, you have to match values based on the properties rather than simple equality, this is where the comparator parameter comes handy.

For instance, if you have an array of user objects and want to remove a user with a specific name, you can use a comparator function to compare based on the name property.

Usage Examples

Removing Primitive Values

For basic use cases with primitive values like numbers, the remove method works seamlessly.

javascriptCopy codelet numbers = [1, 2, 3, 4, 2];
numbers = numbers.remove(2); // Removes the first occurrence of 2
console.log(numbers); // Output: [1, 3, 4, 2]

numbers = numbers.remove(2, true); // Removes all occurrences of 2
console.log(numbers); // Output: [1, 3, 4]

Here, removeAll defaults to false, removing only the first occurrence. Setting removeAll to true removes all 2s from the array.

Removing Objects with a Comparator

When dealing with arrays of objects, the comparator function can specify exactly how the method should identify matches.

javascriptCopy codelet people = [
  { id: 1, name: 'Alice' },
  { id: 2, name: 'Bob' },
  { id: 3, name: 'Alice' }
];
// Remove all occurrences of objects with the name 'Alice'
people = people.remove({ name: 'Alice' }, true, (a, b) => a.name === b.name);
console.log(people); 
// Output: [{ id: 2, name: 'Bob' }]

Happy coding! :)

10 First Git Commands You Need to Know

Sam — Sat, 02 Nov 2024 00:35:50 +0000

There are few technologies in IT that achieve such dominance that they become virtually unrivaled. Git is one of them. It plays an essential role in software development, so much so that it has rendered nearly all alternatives obsolete (RIP SVN, and Mercurial). Today, we can hardly imagine software development without Git.

Mastering Git is one of the first skills every software developer should acquire. Although it might seem complex at first, once you get a handle on the basics, it becomes a powerful and intuitive tool for version control. In this post, we’ll cover 10 essential Git commands that will help you take control of your code and workflow, moving you one step closer to Git mastery.

I assume you have git installed on your machine. If you're not sure about it, simply run this command in your terminal or shell:

git -v

If you see a version it shows you're ready to use it, otherwise you need to install git or fix your installation.

Commands

Now let's start looking at the 10 first git commands you need to learn. These are the commands you use most of the times and also are the foundation of anything else you do with git.

1. `git init`

The git init command initializes a new Git repository, meaning it sets up everything Git needs to start tracking your project. When you run this command, Git creates a hidden .git directory in your project. This directory is where Git stores all the tracking data, including information about the project’s history, branches, and configuration.

Example

$ mkdir my_project
$ cd my_project
$ git init

After running this command, your project is now under Git version control.

2. `git clone`

Unlike git init, which creates a new, empty repository, git clone is used to copy an existing repository from a remote server to your local machine. This command is commonly used to pull down repositories from hosting services like GitHub, GitLab, and others, allowing you to have a complete copy of the project, including all of its history, branches, and files.

Example

$ git clone https://github.com/0dev-hq/0dev

This command creates a folder named 0dev in your current directory and copies all the content into it.

3. `git add`

When you make changes to your codebase, whether adding new files or updating existing ones, you’ll need to tell Git which changes to track. The git add command stages these changes, preparing them for a commit. This step is crucial, as Git requires you to specify exactly which modifications you want to include in the next commit. Staging with git add allows you to control what gets recorded in the project’s history, enabling you to group related changes together for a cleaner, more organized commit history.

Example

$ git add index.html

To stage all changes, use:

$ git add .

4. `git commit`

After staging files with git add (meaning you've selected specific changes to track), use git commit to save them in the repository’s history. Each commit records a snapshot of your files at that point in time, preserving the exact state of your project.

Remember that after you run git commit, these changes are only saved locally. They won’t be shared with others or saved to a remote repository until you use git push to upload them. This two-step process ensures that you have control over when your changes are finalized locally and when they’re shared remotely.

Example

$ git commit -m "Add index.html with initial content"

The -m flag allows you to add a message describing the changes. Make your messages clear and descriptive to keep your history meaningful.

5. `git push`

As we saw in git commit your changes won’t be reflected in the remote repository, hence to anyone else using that repository until you push your local changes to the remote origin.

git push is the command that sends your committed changes to a remote repository, making them available for others.

Example

To push your changes:

$ git push origin main

Replace main with the branch name as necessary.

Notes:

Typically, you don’t push your changes directly to the main branch. Instead, you create a separate branch to work on features or fixes. This approach keeps the main branch stable and avoids disrupting other collaborators.
If you’ve created a new branch and are pushing it for the first time, you’ll need to specify the branch name with the following command:
```
$ git push -u origin your-branch-name
```
The -u flag sets the upstream branch, so future pushes can be done simply with git push, without specifying the branch name.

6. `git branch`

As we just saw, it’s usually best not to push changes directly to the main or default branch, typically called main. Git allows you to isolate your work from others—or even from your own other work on the repository—by using branches. You can think of a branch as a parallel line of development where you can make changes without affecting the main project. Each branch represents a separate version of the repository, enabling you to work on features or bug fixes independently.

The git branch command is used to create, list, or delete branches. This command is essential for managing different lines of development in a project and keeping your work organized.

Example

To create a new branch:

$ git branch feature-branch

7. `git checkout`

The git checkout command allows you to switch between branches or restore files to a previous state. It’s frequently used in a multi-branch workflow, letting you work on different features or bug fixes simultaneously without interfering with each other.

Example

To switch to an existing branch named feature-branch:

$ git checkout feature-branch

The git checkout command has multiple options. For example, if you want to create a new branch and switch to it immediately, you can use the -b flag:

$ git checkout -b new-branch-name

This command creates new-branch-name and checks it out in a single step, making it convenient to start work on a fresh branch.

8. `git pull`

We saw how you can push your changes to a remote repository, but in a collaborative project, you’re usually not the only one working on the code. Sometimes, even you might have worked on a different machine, creating updates that aren’t on your current device.

The git pull command is used to fetch and integrate updates from a remote repository into your local branch. This command combines two actions: it retrieves the latest changes (using git fetch) and merges them into your current branch (using git merge). Regularly pulling changes keeps your local work up-to-date with the remote repository, ensuring you’re working with the latest code.

Example

To pull changes from the main branch on a remote repository (usually origin):

$ git pull origin main

This command fetches the latest updates from the remote main branch and merges them into your current branch. If there are any conflicting changes, Git will prompt you to resolve them before the merge can be completed.

9. `git merge` and `git fetch`

The git merge command is used to combine changes from one branch into another, making it essential when you’re ready to bring new features or updates into the main branch. This command integrates changes from the specified branch into your current branch, preserving the history of both branches.

Meanwhile, git fetch allows you to retrieve updates from a remote repository without merging them into your branch right away. This is useful if you want to review changes first before merging, as it brings down updates to your local repository without altering your current branch.

Example: Merging Branches

To merge a feature branch into main, first switch to the branch you want to merge into:

$ git checkout main

Then, merge the changes from feature-branch:

$ git merge feature-branch

If there are conflicting changes between main and feature-branch, Git will prompt you to resolve them before completing the merge. Once you’ve resolved conflicts and saved the files, complete the merge with:

$ git commit

Example: Fetching Changes

To fetch updates from the remote repository without merging:

$ git fetch origin

After running git fetch, you’ll have the latest updates from the remote repository in your local copy, and you can then decide to merge specific branches or review the changes first.

10. `git status` and `git log`

Often, you’ll find yourself needing to check the current state of your branch or review the history of your commits. Git provides two essential commands for this purpose: git status and git log.

The git status command gives you an overview of the current state of your working directory and staging area. It shows which files have been modified, added, or removed, and whether these changes are staged or unstaged. This command is essential for checking the status of your changes before committing them, helping you keep track of which modifications will be included in the next commit (staged) and also if there are any untracked files that Git has not yet started tracking (unstaged).

Example: Checking Status

$ git status

The git log command displays the commit history, giving you a detailed view of each commit’s unique ID, author, date, and message. This command allows you to review the sequence of changes made to the project, making it easier to track the history and understand who made which updates.

Example: Viewing Log History

$ git log

To simplify the log view, you can use git log --oneline, which condenses each commit into a single line with just the commit ID and message, providing a more streamlined overview of the commit history.

These commands form the foundation of Git and are essential for managing your project’s history and collaborating effectively. Mastering these basics will give you confidence in version control, setting the stage for more advanced techniques.

In the next posts of this series, we’ll dive into some intermediate and advanced Git commands, exploring ways to streamline workflows, manage conflicts, and optimize collaboration even further.

Open-source NL-based data platform

Sam — Thu, 31 Oct 2024 23:08:01 +0000

In this brief introductory post I want to share 0dev, an open-source NL-first data platform.

The main goal of 0dev is to make data consumption accessible and to minimize the skills required to use the data. This consumption can be in form of querying, visualizing or drawing insights from the data.

While these tasks are deemed complex and carried out by developers, data scientists and data analysts, we can lower the barrier and empower more and more people to take advantage of their data with simple natural language.

The goal of 0dev is not to replace any of those experts, but to make all these advantages accessible to numerous teams and individuals who simply would give up on any of these advantages due to the complexities and costs involved.

0dev is being built with modularity and extensibility at its core, allowing more on-demand customization and improvements supported by the community.

This is the first official introduction of the project, and I appreciate your support by adding a star to the repository, sharing it with others and using the project.
In this world of closed-source AI products, we need more and more open-source projects.

Repository:
https://github.com/0dev-hq/0dev

Running locally

Both the front-end and back-end of the project are written in Typescript and in the future there will be some Python modules added to the project.

Running the project locally is very simple, you just go to each folder, run npm install and then npm run dev.

The application will be dockerized in the near future (contributions are welcome) to make it easier for people who prefer to run just a docker compose up/down to run the project.

Cloud version

If you don't want to run the project locally, you can access the cloud version of 0dev too. It's free and while in beta, it's ready to use.

Support

You can raise issues on the repository for bug reports or feature requests or send a message on the Discord server (link in the repo).

Make Money Just by Writing a Function!

Sam — Sat, 03 Aug 2024 08:33:39 +0000

Make Money Just by Writing a Function!

Ever wondered if you could monetize your coding skills without having to build an entire application or service? Good news—you can! With the rise of AI and no-code platforms, there's an increasing demand for developers to create simple yet powerful functions that can be utilized by businesses and individuals. In this post, we'll explore how you can make money by writing functions and selling them on platforms like PromptIntellect.

What is PromptIntellect?

PromptIntellect is a marketplace for AI-based services. It’s designed to help businesses and individuals harness the power of artificial intelligence without needing deep technical expertise. As a developer, you can create and sell AI-driven functions that solve specific problems.

Why Focus on Functions?

Functions are the building blocks of any application. They perform specific tasks and can be reused across different projects. By focusing on writing functions, you can:

Leverage Specialization: Use your expertise to solve niche problems.
Save Time: Functions are typically smaller in scope than full applications, so you can develop and deploy them quickly.
Scale Effortlessly: Once deployed, your functions can serve multiple users without additional effort on your part.

Getting Started

Here's a step-by-step guide to start making money with your functions:

Identify a Problem: Think about common tasks or problems that businesses face which can be automated or simplified using AI. Examples include generating SEO-friendly blog posts, creating personalized email content, or automating customer support responses.
Create Your Function: Develop a function that addresses the identified problem. Ensure it is robust, efficient, and easy to integrate. For example, you could write a Python function that generates blog post ideas based on given keywords.
Test Your Function: Thoroughly test your function to ensure it works as expected. Consider edge cases and potential issues that users might encounter.
Document Your Function: Write clear and concise documentation explaining how to use your function. Include code snippets, examples, and any dependencies required.
Upload to PromptIntellect: Sign up as a vendor on PromptIntellect and upload your function. Provide a detailed description, pricing, and usage instructions.
Promote Your Function: Share your function on social media, developer forums, and your personal network. The more visibility it gets, the higher the chances of making sales.

Tips for Success

Focus on Quality: Ensure your function is well-written, efficient, and free of bugs. High-quality functions are more likely to be recommended and reused.
Keep It Simple: Aim for simplicity and ease of use. Users should be able to integrate your function with minimal effort.
Stay Updated: Keep your functions updated with the latest trends and technologies. Regular updates can also address any issues and improve functionality.

Real-World Examples

To give you some inspiration, here are a few examples of functions that can generate revenue:

Content Generators: Functions that create blog posts, social media content, or marketing emails based on user input.
Data Analyzers: Functions that process and analyze data to provide insights, such as sentiment analysis or trend detection.
Automation Tools: Functions that automate repetitive tasks like data entry, report generation, or customer follow-ups.

Conclusion

Making money by writing functions is not only possible but also a highly rewarding endeavor. By leveraging platforms like PromptIntellect, you can monetize your coding skills and contribute to the growing field of AI and automation. Start small, focus on solving specific problems, and watch as your functions help businesses and individuals while generating income for you.

So, what are you waiting for? Dive into the world of function development and start making money just by writing a function!

If you need assistance or have any questions, feel free to reach out. I'm here to help!

References

Happy coding!

Add Google Analytics Tracking Code to All Pages Automatically

Sam — Tue, 30 May 2023 01:33:53 +0000

If you have many HTML pages in a directory, adding Google Analytics tracking code to all of them can be a bit frustrating.

In this short tutorial, I show you how to do it with a bash script that automatically does the job.

First, copy the code from your Google Analytics console, and paste it to a file named google-analytics.

Then, write the following code to a file, say add-gtag.sh and give it the execution permission:

chmod u+x ./add-gtag.sh

#!/bin/bash

# From: dotenx.com

# description: 
# Add Google Analytics to all HTML files in a directory. Google Analytics code should be in a file called google-analytics in the same directory as this script.

# usage:
# ./add-gtag.sh directory

# Tested on Mac-zsh


directory="$1"

if [ -d "$directory" ]; then
  for file in "$directory"/*.html; do
    if [[ -f "$file" ]]; then
      sed -i.bak '/<head>/r google-analytics' $file
    fi
  done
else
  echo "Directory not found."
fi

rm $directory/*.bak

Now, all you need to do is to execute the script like this:

./add-gtag.sh <your directory>

You can find this code here on GitHub too.

Closures in JavaScript - the Simplest Explanation

Sam — Mon, 23 Jan 2023 23:51:03 +0000

Closures in JavaScript are like secret passageways for a function to remember certain variables, even after it's done running. In this article, I'll try to answer the question "how do JavaScript closures work?" in the simplest way so you can start using them right away.

Before we move on, I want to invite you to visit 0dev, an open-source data platform that works with natural language. Use 0dev to access your data without complex SQL queries, visualize it without any coding and generate insights without any data science experience.

Repository: https://github.com/0dev-hq/0dev

Let's say you want to create a simple counter, but you don't want other parts of your code to mess with the counter's internal number. You can create a function that returns an object with methods that can change the internal number, but only the function knows about it. Here's an example:

function counter() {
  let count = 0;

  return {
    increment: function() {
      count++;
    },
    decrement: function() {
      count--;
    },
    getCount: function() {
      return count;
    }
  };
}

let myCounter = counter();
console.log(myCounter.getCount()); // 0
myCounter.increment();
console.log(myCounter.getCount()); // 1

In our example, you could say the counter function returns an object with three methods: increment, decrement, and getCount.

Each of these methods have access to the count variable, which is defined within the parent counter function. But, because the counter function has completed execution, the count variable is not directly accessible from the global scope while the inner functions still have access to it.

In other words, the returned object and its methods are closures that have access to the count variable.

So, this was one of the common use cases of closures and now let's take a look at another example.

Another common use case for closures is to create a function that we want to pass as a callback and maintain access to variables in its parent scope. For example, take a look at this code:

function createFullName(firstName) {
  return function(lastName) {
    return firstName + " " + lastName;
  };
}

let myFullName = createFullName("John");
console.log(myFullName("Doe")); // "John Doe"
console.log(myFullName("Smith")); // "John Smith"

In this overly simplified example, we have a function createFullName that takes a person's first name as an argument and returns a new function which itself takes a person's last name as an argument and returns the full name.

The inner function is a closure because it "closes over" the firstName variable and remembers it, even though the parent function has finished running. This can be useful for example in a form where user fills first name and last name in two different inputs.

This technique is also one of the fundamentals of functional programming in JavaScript.

Can you add any other use cases or examples?

All the Ways to Remove an Item from an Array

Sam — Fri, 13 Jan 2023 22:43:35 +0000

You might be wondering how can I remove a specific item from an array. In fact, this is a common task in programming, and there are several different ways for it which we'll cover in this article.

Before we move on, remember you can build your websites, landing pages, APIs, and more, on DoTenX for free. DoTenX is an alternative for Wordpress (and much more) in 2023!

Make sure to check it out and use it in your projects. DoTenX is open-source and you can find the repository here: github.com/dotenx/dotenx.

1. splice

I start with the most common way, which is using splice. splice is a powerful function that you can use to add, remove or replace elements in an array.

let students = ['John', 'Mary', 'Mike', 'Jane'];
let index = students.indexOf('Mary');
students.splice(index, 1);
console.log(students); //Outputs: ["John", "Mike", "Jane"]

The first element of splice is the start index, and the second one is the number of elements to be deleted. Just keep in mind that this method is not an option if you want to keep the original array intact.

2. filter

Another method, that I often use, especially if I want to remove multiple elements based on a condition is by using filter method.

let students = ['John', 'Mary', 'Mike', 'Jane'];
let filteredStudents = students.filter(student => student !== 'Mary');
console.log(filteredStudents); //Outputs: ["John", "Mike", "Jane"]

As you can see this method gives us more flexibility and doesn't alter the original array.

3. spread operator

This is not something you use that often just to remove an element is more used for instance if you want to merge some arrays too.

let students = ['John', 'Mary', 'Mike', 'Jane'];
let index = students.indexOf('Mary');
let newStudents = [...students.slice(0,index), ...students.slice(index+1)];
console.log(newStudents); //Outputs: ["John", "Mike", "Jane"]

While we're at it, let me show you a simple trick related to this operator and the problem we're trying to solve.

let students = ['John', 'Mary', 'Mike', 'Jane'];
let index = students.indexOf('Mary');
let [first, ...rest] = students;
console.log(rest); //Outputs: ["Mary", "Mike", "Jane"]

4. without

So far, all the methods were using vanilla JavaScript without any external library. But, this article wouldn't be complete if we don't cover the solutions using the lifesaving lodash library.

First, we use the method without that creates a new array without the given elements.

let students = ['John', 'Mary', 'Mike', 'Jane'];
let newStudents = _.without(students, 'Mary');
console.log(newStudents); //Outputs: ["John", "Mike", "Jane"]

5. pull

pull method simply removes all the given values from the array. This is less desired compared to without as it's not immutable.

let students = ['John', 'Mary', 'Mike', 'Jane'];
_.pull(students, 'Mary');
console.log(students); //Outputs: ["John", "Mike", "Jane"]

6. remove

I particularly use this method more often as not only it removes all elements from array that predicate returns truthy for, but it also returns an array of removed elements.

let students = ['John', 'Mary', 'Mike', 'Jane'];
let removed = _.remove(students, function(student) {
  return student === 'Mary'; // Remove if this is true
});
console.log(removed); //Outputs: ["Mary"]
console.log(students); //Outputs: ["John", "Mike", "Jane"]

Can you suggest any other methods?

Forem: Sam

Master LangChain in Typescript - A Practical Guide

Introduction to LangGraph

What We'll Build

State Graph in LangGraph

State

Channels

Nodes

Edges

Compile and Invocation

Run the Code

Letting Agents Write and Review Code — A 0dev Milestone(Demo)

Flyte a great alternative for Airflow - Learn the basics

Install flytectl

Start a local deployment

Create the test data

Upload the test data

Create the project

Create the workflow

Run the workflow

Result

0dev, agents that generate code

Master Cron Expressions In 2 minutes

Basic Structure

Note: The values of the Day of the week can be numbers 0-7 or MON-SUN. Also the Month can be expressed as numbers 1-12 or JAN-DEC.

Setting Fixed Times

Using Wildcards (*)

Specifying Multiple Values

Using Ranges

Step Values (/)

Day-Specific and Month-Specific Scheduling

Cron expression with 6 and 7 fields

How to Remove a Specific Item From an Array in JavaScript?

Explanation

Array.prototype.remove

removeAll

comparator

Usage Examples

Removing Primitive Values

Removing Objects with a Comparator

10 First Git Commands You Need to Know

Commands

1. git init

Example

2. git clone

Example

3. git add

Example

4. git commit

Example

5. git push

Example

6. git branch

Example

7. git checkout

Example

8. git pull

Example

9. git merge and git fetch

Example: Merging Branches

Example: Fetching Changes

10. git status and git log

Example: Checking Status

Example: Viewing Log History

Open-source NL-based data platform

Running locally

Cloud version

Support

Make Money Just by Writing a Function!

Make Money Just by Writing a Function!

What is PromptIntellect?

Why Focus on Functions?

Getting Started

Tips for Success

Real-World Examples

Conclusion

References

Add Google Analytics Tracking Code to All Pages Automatically

Closures in JavaScript - the Simplest Explanation

All the Ways to Remove an Item from an Array

Install `flytectl`

`Array.prototype.remove`

`removeAll`

`comparator`

1. `git init`

2. `git clone`

3. `git add`

4. `git commit`

5. `git push`

6. `git branch`

7. `git checkout`

8. `git pull`

9. `git merge` and `git fetch`

10. `git status` and `git log`