Forem: Nima Akbarzadeh

You’re Not Validating Your Traces (And That’s a Problem)

Nima Akbarzadeh — Sat, 04 Apr 2026 23:19:07 +0000

You validate:

API inputs
database schemas
configs

But your traces?

👉 Nothing.

So in production you get:

spans missing attributes
inconsistent naming across services
“valid-looking” traces that are actually wrong

And nobody notices.

The Hidden Problem with OpenTelemetry

OpenTelemetry gives you flexibility.

Too much flexibility.

You can write this:

ctx, span := tracer.Start(ctx, "payment")

And this somewhere else:

ctx, span := tracer.Start(ctx, "payment_authorize")

Or forget attributes:

span.SetAttributes() // missing critical fields

Nothing breaks.

But your observability?

👉 Silently degrades over time.

Meet spancheck

Instead of relying on discipline, you define a tracing contract.

And enforce it at runtime.

The Idea: Tracing Contracts

Define what “correct tracing” looks like — in YAML:

version: 1

attributes:
  - payment.processor
  - payment.id
  - payment.job_name

spans:
  payment.authorize:
    kind: internal
    required_attributes:
      - payment.processor
      - payment.id

  payment.reconcile:
    kind: consumer
    required_attributes:
      - payment.job_name

This becomes your source of truth.

No Code Changes Required

This is the key part.

You don’t touch your existing tracing calls.

Just plug into OpenTelemetry:

registry, _ := tracing.LoadRegistry(contractYAML)

processor := tracing.NewValidationProcessor(registry, logger)

tp := sdktrace.NewTracerProvider(
    sdktrace.WithSpanProcessor(processor),
)

otel.SetTracerProvider(tp)

Your existing code stays exactly the same:

ctx, span := tracer.Start(ctx, "payment.authorize")

What Happens at Runtime

When spans finish, SpanCheck validates them.

You get warnings like:

⚠️ unknown span → unknown_span
⚠️ missing attribute → missing_required_attribute

No crashes. No breaking changes.

But now:

👉 you see when your tracing is wrong

Why Runtime Validation > Linting

Static tools can guess.

Runtime sees reality.

Static linting	Runtime validation
checks code	checks actual spans
misses dynamic paths	sees everything
requires patterns	zero assumptions
partial safety	full coverage

Why This Matters

Bad traces don’t fail loudly.

They fail silently.

That means:

dashboards look fine
incidents take longer
debugging becomes guesswork

You think you have observability.

You don’t.

What This Unlocks

Once you have contracts:

consistent span naming across services
guaranteed required attributes
shared conventions across teams
confidence in your traces

This is the missing layer in most observability setups.

Try It

go get github.com/iw4p/spancheck

Then plug it into your tracer and add a YAML contract.

That’s it.

Final Thought

We enforce:

types
schemas
configs

But not traces?

Observability should be correct by default — not optional.

👉 Check the code here spancheck

Free Convert Web Content to Markdown

Nima Akbarzadeh — Sat, 08 Mar 2025 21:06:52 +0000

Introducing URL to Markdown API
Are you tired of dealing with cluttered web content when all you need is clean, structured Markdown? Meet URL to Markdown API, an open-source FastAPI service that transforms various types of content — including web pages, YouTube videos, PDFs, and documents — into Markdown, making it perfect for AI/ML pipelines, content aggregation, and data processing workflows.

🔗 Try the live demo: markdown.nimk.ir

Example for a youtube video: https://markdown.nimk.ir/https://www.youtube.com/watch?v=fkZFCyp-iHs

Why Use URL to Markdown API?
Universal Content Support: Convert web articles, YouTube videos, PDFs, Office documents, and more
LLM-Optimized Output: Clean, structured Markdown perfect for AI/ML processing
Rich Media Handling: Extract metadata from images, audio files, and videos
Smart Processing: OCR for images, transcription for audio, and intelligent content extraction
Simple Integration: RESTful API with clear error handling and response codes
🔥 Live Demo
Want to see it in action? Just enter any URL and get instant Markdown output:

Example 1: Convert a Web Article
https://markdown.nimk.ir/https://ask.library.arizona.edu/faq/407985
This API call converts the article into structured Markdown.

Example 2: Convert a YouTube Video
https://markdown.nimk.ir/https://www.youtube.com/watch?v=dQw4w9WgXcQ
This extracts the video title, description, and metadata in Markdown format.

Key Features
Convert various content types:

Web articles & HTML content
YouTube videos
PDF documents
PowerPoint, Word, and Excel files
Images (with OCR and metadata extraction)
Audio files (with transcription & metadata)
CSV, JSON, XML
ZIP files (processes contents)
Automatic URL handling Clean error messages & proper HTTP status codes

Why Markdown for LLMs?
Markdown is ideal for Large Language Models (LLMs) because:

Structured Format: Clean hierarchical text structure
Consistent Representation: Normalizes different content types
Preserves Semantics: Headers, lists, and formatting are maintained
Reduced Noise: Removes unnecessary styling, keeping content-focused
Enhanced Accessibility: Easier for NLP models to process
Installation for Self hosted version
Standard Installation
git clone https://github.com/iw4p/url-to-markdown.git
cd url-to-markdown
pip install -r requirements.txt
Docker Deployment
Using Docker Compose (Recommended):

docker-compose up -d
This starts the service in detached mode on http://localhost:8000

Using Docker Directly:

docker build -t url-to-markdown .
docker run -d -p 8000:8000 url-to-markdown
API Usage
Start the API server:

uvicorn main:app --reload
Access it at http://localhost:8000

API Endpoints
Convert a URL to Markdown
GET /{url}
Example:

http://localhost:8000/www.youtube.com/watch?v=dQw4w9WgXcQ
Returns the video title, description, and metadata in Markdown format.

Response Format

Article Title

Content

[Article content in Markdown format]
Development
Built with:

FastAPI for the web framework
MarkItDown for content conversion
Python 3.12+
Join the Community
Check out the repo, contribute, and star it on GitHub! ⭐

🔗 GitHub Repo: https://Github.com/iw4p/url-to-markdown

How time.After() Can Cause Memory Leaks in Go and How to Fix Them

Nima Akbarzadeh — Sat, 08 Mar 2025 21:05:22 +0000

As a developer working with the tonutils-go library to interact with the TON blockchain, I’ve spent a considerable amount of time building various side projects. Over time, I noticed a troubling pattern: the service I had built using the Echo framework was consuming resources more and more, even as I made minor tweaks and optimizations.

Time to Investigate: Detective Mode ON 🕵🏻‍♂️

I started my investigation by trying different strategies, making small adjustments to pinpoint the root cause. Was there a goroutine leak? I rarely used goroutines in my code, except in one small section. Could the issue lie in my queries? Perhaps GORM was messing something up?

I was stumped. So, I decided to dive deeper into debugging using pprof, the profiling tool from Google, to get to the bottom of it.

It didn’t take long before I uncovered something unexpected: a goroutine leak. But how could that be? I wasn’t even using goroutines directly!

I dug deeper and deeper, and eventually, I stumbled upon the culprit: time.NewTimer().

Wait… what? I wasn’t using any timers in my code! After spending more time researching, I realized that the problem wasn’t with my own code — it was stemming from the third-party libraries I was using. While it was a relief to know I wasn’t at fault, I couldn’t help but feel a little frustrated. How could I fix an issue with something I had no control over?

The Root Cause: Leaks from time.After()

Upon further investigation, I discovered that this was a well-known issue in Go: resources created by time.After() are never garbage collected. This can result in memory leaks, particularly when the timers are not stopped or handled properly.

select {
case <-time.After(time.Second):
// do something after 1 second.
case <-ctx.Done():
// do something when context is finished.
// resources created by the time.After() will not be garbage collected
}
Thankfully, I found a recommended solution from other developers. They suggested using a time.NewTimer() with a context to ensure that the timer is properly managed and cleaned up:

delay := time.NewTimer(time.Second)
select {
case <-delay.C:
// Do something after one second.
case <-ctx.Done():
// Do something when the context is finished and stop the timer.
if !delay.Stop() {
// If the timer has been stopped, read from the channel.
<-delay.C
}
}
A Step Toward a Solution: Contributing to tonutils-go

Determined to resolve the issue, I submitted a pull request to the tonutils-go repository. To my relief, the project author reviewed and accepted the fix! You can find the pull request here: PR #297 on tonutils-go.

Does the New Golang Version Fix It?

Interestingly, I tested the fix with a newer version of Go, hoping it would address the issue, but I found that the behavior remained unchanged. It seems that, despite some updates, this problem persists in certain cases. You can check it here.

Exposing pprof for Production Monitoring and Visualizing Memory Leaks

Since identifying and resolving the issue required monitoring the application over time, I decided to expose it on NGINX to allow access to pprof. This would enable me to keep track of memory usage and any potential leaks that might arise during actual production traffic. It should not be exposed always, just for debugging.

I set up the pprof endpoint on my server and then started watching the application under real-world load. I knew that some leaks could take time to manifest, so it was important to observe the app during normal production requests.

To visualize the performance and memory usage, I installed Graphviz on my Mac using Homebrew:

brew install graphviz
With Graphviz installed, I could generate helpful visualizations of the memory allocations and goroutine activity, which greatly aided in pinpointing where resources were being consumed and not released.

Next, I used go tool pprof to capture and analyze the memory and goroutine data. Here’s how I did it:

For memory allocations:

go tool pprof -http=:8080 https://production.com/debug/pprof/allocs
And for goroutine profiling:

go tool pprof -http=:8080 https://production.com/debug/pprof/goroutine
By running these commands, I was able to open up a web interface that allowed me to visually explore the application’s memory allocation and goroutine states. This gave me valuable insights into where things were going wrong and where I could optimize further.

By exposing pprof in this manner, I was able to monitor production traffic and track down leaks that would’ve otherwise been hard to catch in a local environment. It’s a simple yet effective technique for diagnosing subtle performance issues that only appear under real-world conditions.

Before:

After:

After more monitoring, I realized there are more of them and I should find and fix them! But I hope It could help you to learn more about this issue.

Example codes are from this blog.

My Github: https://Github.com/iw4p

Parsing ChatGPT JSON stream response - Partial and incomplete JSON parser python library OpenAI

Nima Akbarzadeh — Fri, 24 Nov 2023 16:37:05 +0000

In today's world of APIs and microservices, working with streaming JSON responses is common. To simplify this, I've created a handy open-source library to easily handle OpenAI's streaming APIs. While tailored to OpenAI and ChatGPT, this versatile library can parse streaming JSON from any API.

This post will introduce you to my new open-source library and why it's useful for consuming OpenAI's streaming APIs. I'll also give a quick overview of how it works under the hood. Whether you're building an app with OpenAI or working with other streaming JSON APIs, read on to see how this library can save you time and effort.

The core benefit is the easy handling of sizable JSON responses, even as they stream in. No need to deal with the complexity - the library takes care of that. It also works for any API returning streaming JSON, not just OpenAI's. I'll share examples of both so you can see just how much it simplifies things.

Let's get started! First, I'll give a quick primer on OpenAI and streaming JSON for context. Then we'll dive into the library itself and see some code examples.

Here is an additional section expanding on the challenges of streaming JSON responses:

The Problem with Streaming JSON

Streaming text responses is straightforward - you can display each character or token to the user as it streams in. But JSON poses some unique headaches.

JSON responses are structured as nested objects and arrays. A streaming JSON response is essentially malformed until the full response is completed. For example, halfway through a response, you may see something like:

[{"age": "18

This isn't valid JSON yet! So if you try to parse it with JSON.parse(), it will fail.

You face a tradeoff - either:

✅ Wait for the full JSON response to complete before parsing/displaying it. But this negates the benefits of streaming for your users.

💥 Try parsing the incomplete streaming JSON, and get errors.
What we really want is a way to incrementally build and parse the streaming JSON in real-time as it comes in. Displaying it to the user with minimal lag, without running into errors.
This is exactly what my library enables! Keep reading to see how it works…

The Solution

My library provides a simple yet powerful solution. Install it via:

pip install partialjson

Then import the JSONParser class:

from partialjson.json_parser import JSONParser

Instantiate the parser, and pass any incomplete JSON string to the parse() method. For example:

parser = JSONParser() incomplete_json = '{"name": "John", "age": 18, "family":' print(parser.parse(incomplete_json))

Here's the magic - despite the JSON being incomplete, parse() incrementally parses what it has received so far into valid JSON objects.

So at each moment, you can work with the fully structured JSON consisting of only the data received up until that point. No more errors or waiting for the full response!

As more streaming data comes in, the parser seamlessly incorporates it into the existing JSON structure. This enables you to display the information to users with minimal lag. Just what we want.

So in a nutshell, it empowers real-time processing and display of streaming JSON responses. Solving the problem elegantly via incremental parsing.

This library is open source and the source is available on my GitHub.

Scraping tweets without Twitter API for FREE

Nima Akbarzadeh — Tue, 14 Mar 2023 21:40:34 +0000

In the past (before Elon Musk…), you could easily and freely apply for a developer account to get your own tokens and start using Twitter API without any struggle. One of the strengths of the developer account besides making bots and tweeting via API was search API. You could almost grab all the tweets you want. But after Elon Musk, unfortunately, you have to pay for it!

Tiers will start at $500,000 a year for access to 0.3 percent of the company's tweets. Researchers say that's too much for too little data. [source]

There is one solution that almost always works. Selenium! (Also, it's good to know that the great alternative for selenium in JS is puppeter).

It almost allows you to scrape everything on the surface of the web. Just you have to write a script for your use case with the selenium library.

How

The algorithm for scraping tweets is so easy.
These are the steps:

Open Twitter search with an advanced search query.
Scrape specific tags to get the value
scroll
Repeat the steps until you scrape the number of tweets you need.

Code

It can be written by your script or using other libraries like twitter_scraper_selenium
It's available on PyPI and GitHub.



pip install twitter_scraper_selenium

(Note: For saving as CSV and working as data frames, we must install pandas and other dependencies too)
Then you can write your own wrapper function like this

from twitter_scraper_selenium import scrape_keyword
import json
import pandas as pd
import asyncio



def scrape_profile_tweets_since_2023(username: str):
    kword = "from:" + username
    path = './users/' + username
    file_path = path + '.csv'
    tweets = scrape_keyword(
                            headless=True,
                            keyword=kword,
                            browser="chrome",
                            tweets_count=2, # Just last 2 tweets
                            filename=path,
                            output_format="csv",
                            since="2023-01-01",
                            # until="2025-03-02", # Until Right now
                            )
    data = pd.read_csv(file_path)
    data = json.loads(data.to_json(orient='records'))
    return data

You can call this function for multiple accounts at the same time, as this:



from twitter_scraper_selenium import scrape_keyword
import json
import pandas as pd
import asyncio

def scrape_profile_tweets_since_2023(username: str):
    kword = "from:" + username
    path = './users/' + username
    file_path = path + '.csv'
    tweets = scrape_keyword(
                            headless=True,
                            keyword=kword,
                            browser="chrome",
                            tweets_count=2, # Just last 2 tweets
                            filename=path,
                            output_format="csv",
                            since="2023-01-01",
                            # until="2025-03-02", # Until Right now
                            )
    data = pd.read_csv(file_path)
    data = json.loads(data.to_json(orient='records'))
    return data
You can call this function for multiple accounts at the same time, as this:
from multiprocessing import Pool

# Just one account
# scrape_profile_tweets_since_2023('elonmusk')

# Run in parallely
def functionToRunParallely(i):
    return i

noOfPools = 5

if __name__ == "__main__":
    with Pool(noOfPools) as p:
        p.map(scrape_profile_tweets_since_2023,['elonmusk', 'BarackObama', 'cathiedwood'])

Result
Your result will be something like this:

In the next post, we are going to scrape mentions/replies as well.

If you like the post, please use clap or follow me on GitHub and LinkedIn!
Github.com/iw4p

https://www.linkedin.com/in/nimk/

Machine Learning paradigms for beginners

Nima Akbarzadeh — Mon, 09 Jan 2023 17:21:00 +0000

These days, we are hearing a lot about Machine Learning, chatGPT, AI, Robots, etc. We should not skip the trends, specifically in technology.
But what if we want to classify the general topics and methods of Machine Learning to understand better what is going on?

Imagine you want to tell new things to a computer, and that computer learns those things and new experiences from you. How many ways do we have? Which methods and paradigms are acceptable?

Currently, there are 3 main paradigms:

Supervised Learning
Unsupervised Learning
Reinforcement Learning

Let's start with examples that make these categories more understandable.

Machine Learning paradigms for beginners
These days, we are hearing a lot about Machine Learning, chatGPT, AI, Robots, etc. We should not skip the trends, specifically in technology.
But what if we want to classify the general topics and methods of Machine Learning to understand better what is going on?
Imagine you want to tell new things to a computer, and that computer learns those things and new experiences from you. How many ways do we have? Which methods and paradigms are acceptable?

In the Supervised Learning paradigm, We have a supervisor. Our data is labeled by someone else. For instance, you are a student and your teacher learns you new things. If you try to memorize exactly what your teacher said, you will fail, and if you don't learn, you will fail too. (It's the example of overfitting and underfitting in model training). You have to really LEARN!
The model will learn from its labeled inputs and will learn it's a dog picture, it's a cat, it's a dog, it's a cat … and at the end, you can evaluate your trained model by providing a picture to predict that it is an image of cat or dog. Cat and dog are our labels here.

In the Unsupervised Learning paradigm, there is no label! Your data do not have labels. It's like a student that is trying to self-study by himself without a teacher or supervisor. The student tries to find patterns and relationships by himself.

Reinforcement Learning is the third Machine learning paradigm.

It is inspired by biological learning systems.
Imagine you are stuck in a maze! What is your strategy to escape from it?

One of the best strategies is Trial-And-Error.
You need to brute force the maze, But wait, Reinforcement learning is more interesting!
Another example. You can learn your pet what is bad and what is good by punishing or giving your animal a reward.
In Reinforcement Learning, there is an agent (your pet), there is an environment (you), and a reward signal (Only you can give rewards).

When you feed your dog after he successfully fetched the wood, you are indirectly telling your dog it's a good move. But when your dog is trying to bother your grandma, and you yell at your dog, he will receive a signal that this move was wrong. With the trial and error method, this dog (Agent) is trying to be a good pet (Maximizing his rewards) for you (his environment).

Verilog: Mux 2 to 1 (Multiplexer)

Nima Akbarzadeh — Thu, 05 Jan 2023 17:24:36 +0000

Understanding the low levels always helps me to know and learn better and touch the reality of computers, particularly when I am coding.

Mux 2 to 1 (Multiplexer) is one of the easiest digital circuits which is made by different gates such as AND and OR gates.

The point of the 2-to-1 multiplexer is that can help you to select your chosen input. For example, you have i0 and i1 as Input One and Input Two, and you need to select between inputs. You can set a Select to decide which inputs must transfer to output (F).

In the truth table you can see if you set your select equals to 0, then the first Input which is i0 (a) will choose and vice versa.

To implement this module you need to know what gates you need.

It consists of two AND, one OR, and one NOT gates.
The boolean logic equation for a 2-to-1 multiplexer is
(A. ˉS)+(B. S)
where A is the first input and B is the second input.

embed module mux2to1(sel, i1, i0, f);
    input i0, i1, sel;
    output f;
    wire nsel, w1, w2;

    not(nsel, sel);

    and(w1, i0, nsel);
    and(w2, i1, sel);
    or(f, w1, w2);
endmodule

To evaluate the code you can check it manually or write a testbench for it.

module test_mux2to1;
  reg s, a1, a0;
  wire q;
  mux2to1 mux(.sel(s), .i1(a1), .i0(a0), .f(q));
  initial begin
    $monitor("sel = %b: i0 = %b, i1 = %b --> f = %b", s, a0, a1, q);
    s = 1'b0; a1=1'b0; a0=1'b0;
    #10
    s = 1'b0; a1=1'b1; a0=1'b1;
    #10
    s = 1'b0; a1=1'b1; a0=1'b0;
    #10
    s = 1'b0; a1=1'b1; a0=1'b1;
    #10
    s = 1'b1; a1=1'b0; a0=1'b0;
    #10
    s = 1'b1; a1=1'b0; a0=1'b1;
    #10
    s = 1'b1; a1=1'b1; a0=1'b0;
    #10
    s = 1'b1; a1=1'b1; a0=1'b1;
  end
endmodule

The code is available on my GitHub. Here is the link.

Fragment.com API Library (TON - Telegram)

Nima Akbarzadeh — Mon, 12 Dec 2022 17:17:11 +0000

Fragment.com Library (TON - Telegram)
Last week, I was trying to scrape data from Fragment.com, But I didn't find any Official API.

📢 Advertisement & Important Disclaimer

⚠️ Disclaimer: I am not the owner, operator, or developer of the 'ton-fragment' library or the associated commercial API service. I am simply sharing this information.

TON Fragment

UnOfficial Fragment API (buy stars - premium - gift - ton ads) (Telegram - Ton Coin) Python library
Note 1: ⚠️ If you need API for buying stars and telegram premium (We Support Both KYC and no KYC Fragment), use @RobynHoodBot.

After that, I decided to make my scripts open-source, and then suddenly I asked myself "Why not make a library?"
So, I made an UnOfficial Fragment (Telegram - Ton Coin) Python library, so everyone can easily scrape what he/she needs.
Today's markets use the power of AI and robot traders. Classic trading methods are going to be deprecated as soon as possible.
For making trader robots, firstly you need data from the target's auctions and prices, etc.
This library can help you to grab and scrape what you need.

You can install it easily via Pip python package manager

pip install ton-fragment

Let's see some examples.
For example, you need to get recently listed for-sale numbers
You get fetch this data like that:

from ton_fragment.numbers.numbers import Numbers
all_numbers = Numbers('sale', 'listed')
print(all_numbers.result)

Or you need to get the status of a username or a number to realize it's still on sale or what's the highest bid price for it or when the auction will end:

from ton_fragment.numbers.number import Number
my_number = Number('8888888')
print(my_number.data)
print(my_number.number)
print(my_number.status)
print(my_number.ends_in)

This library is still under development, and it's a little buggy.
Contributions are welcome and feel free to submit issues and enhancement requests.

SOLID - Development principles

Nima Akbarzadeh — Thu, 25 Aug 2022 13:57:42 +0000

Object-oriented programming has its principles, and it is not just turning everything into objects and using them when we need them. It's important to create understandable objects.

Question #1
Is it important? Why?

Yes, It's important and makes more sense when the application grows and becomes bigger.
Design principles encourage us to make maintainable and flexible software.

Question #2
How?

In every work, if you have some principles and standards, your project will get a great structure to itself.
Like using a framework, here should follow some principles.

Question #3
So, What is SOLID?

S: Single responsibility principle
O: Open/Close principle
L: Liskov substitution principle
I: Interface segregation principle
D: Dependency inversion principle

Question #4
What do they mean?

S: Single responsibility principle

A class should only have one responsibility.
It should have one reason to change.

Benefits:
Testing: A class with fewer test cases is better.
Lower coupling: Less functionality in a single class will have fewer dependencies.
Organization: Smaller and more well-organized classes are better than monolithic ones. (For example, don't create a single class for both car and its functionality, create two separates class, one for car and one for car functions)

O: Open/Close principle

Open for extension, close for modification.
We are not allowed to modify existing class codes, because it creates new bugs.
For example, when a new type of car has to implement into the system, you should not modify the car class, the right way is to extend the car class.

L: Liskov substitution principle

A class and its subclass should be able to be replaced by each other. If you have a car and racing car class, and the racing car class is a subclass of car class, you should be able to change or replace them without disrupting the behavior of the program.

I: Interface segregation principle

Larger interfaces should be split into smaller ones.
For example, your barber interface consists of cutting the hair, shaving, and washing.
It can happen that you hire someone for just washing and shaving, not cutting hair, and he is not a barber.
So? It's really better if you split it into small pieces, don't put it all in one interface.

D: Dependency inversion principle

High-level and Low-level modules should both depend on abstraction, not each other. In another form, a class should depend on abstraction.

What is Kanban and how It helps big companies?

Nima Akbarzadeh — Wed, 24 Aug 2022 20:37:21 +0000

Have you heard Kanban? What about Trello?

Kanban is a good and famous project management methodology that helps startups or companies to have their task visually,
While scrum gives structure to the team and schedule.

Kanban and scrum are both considered project management methodologies that complete tasks in a short period of time.

The best example of Kanban is Trello. Trello is a web-based kanban.

The point of using kanban is that the tasks must be continuous, and it is not limited by time at all.

But, instead, in the scrum, the goal is to move all to-do or doing tasks to the Done section in a fixed amount of time, which is called "Sprint".

Companies like Toyota use kanban, and you can read more about their approach here.

Scrum Vs Agile - what's the difference

Nima Akbarzadeh — Wed, 24 Aug 2022 11:52:00 +0000

Scrum is a framework that helps teams to work together. This makes people in the team learn based on the experiences they gain.

But agile is a mindset. It's a set of rules and principles.
Scrum is about shipping value to customers.
All members of a team can use scrum like developers, HR, marketing, designing, and so on.

Scrum embraces changes. It is the best option for these types of things that change a lot. For example, in software engineering, when you divide big or complex tasks into smaller tasks, your goals change quickly.

In scrum, there are terms such as sprint, which means a short, time-boxed period to complete a work or task and move it to the done section.

It makes projects more manageable and for example, if you make a bad decision, unlike waterfall, it allows you to fix it faster. Because it's based on iterations.
Short iterations decrease risk and cost and help the team to stay focused.

People and teams still make mistakes about agile and scrum, but the fact is they're not the same.
Scrum is a framework, but agile is not. It is a mindset.
In scrum, we have a scrum master. Big companies hire scrum masters to go through the development stages of the project in the best condition and at a low cost.

The scrum master helps to facilitate scrum to the larger team by ensuring the scrum framework is followed. He/she is committed to the scrum values and practices, but should also remain flexible and open to opportunities for the team to improve their workflow.

He has the duty to organize the scrum stand-ups.
Stand-up is a daily meeting that involves the core team: product owners, developers, and the scrum master.
Scrum stand-ups are 15-minute daily meetings that occur each day of the sprint to discuss progress and quickly note any issues.

During the stand-up, everyone answers these three questions:
1 - What did you do last day (last task)?
2 - What are you going to do today?
3 - Is there any problem or obstacle?

I hope this post helped you to understand the differences between agile and scrum.

Also, if you like to know about other development methodologies, read the waterfall method from here.

Development methodologies - Waterfall

Nima Akbarzadeh — Sat, 13 Aug 2022 14:43:00 +0000

As a software engineer, you must have a good sight of development methodologies.
I always keep this sentence in my mind "Learn concepts, not languages".
So It gives you a great view when you learn and know the concepts.

What is development methodology? The software development methodology is a process or series of processes used in software development

You can do this process in different ways, but why reinvent the wheel again?

There are several methodologies to use, one of the most traditional methodologies is Waterfall.

Why waterfall? when a water from waterfall comes down, there is no way to get back, and it passes through some big rocks (Here we say stages).

In waterfall methodology, there are 5 stages:

Analysis
Design
Implementation
Testing
Maintenance

Analysis

It's rooted in sequence and logic, and it has a cycle. So when you complete a stage, you can not get back, you need to completely finish a stage to continue.
In the first stage (Analysis), developers must write down all the requirements they need inside a requirement document.
The document is about what the system is going to do, but not necessarily how it works. The document contains the future of the software.

Design

Developers use requirement documents to research and make decisions on how they should design the system, but without considering costs like hardware or software.
And also at the end of this stage, developers must make sure it works and it is not impossible with chosen hardware or software tech stacks.

Implementation

In this stage, the project enters the coding and implementing level, and developers write the actual code.

Testing

When coding is finished, the releases should test by beta testers, so they can report the bugs they face.
Developers patch and fix these bugs in this stage.

Maintenance

Deployment and review happen in this stage, some people consider two stages (Deployment - Review) for the last but it depends on you.
This stage is where you release the stable version of your product, support your customers, maintain, and so on …