Has Blog

Fundamentals of Garbage Collection

Has — Sun, 15 Mar 2026 19:25:44 GMT

1.Introdiction to .NET Memory Management

When a .NET application runs, memory is primarily divided into two areas:

Stack
Heap

Local variables and method calls are handled by the Stack.
Objects created using the new keyword are allocated on the Heap

But this raises an important question:

If objects are continuously allocated on the heap, who deletes them?

In languages like C and C++, developers must manually release memory using mechanisms such as free() or delete. Failure to do so can result in memory leaks, dangling pointers, or memory corruption.

In contrast, .NET uses an automatic memory management system called the Garbage Collector (GC).

The Garbage Collector automatically identifies objects that are no longer in use and reclaims their memory, allowing developers to focus on application logic rather than manual memory cleanup.

What is Stack.?

The Stack is a region of memory used to manage method execution.

It is responsible for storing:

Method parameters
Local variables
Return addresses
Execution context

When a method is called, a stack frame is created.
Each stack frame contains everything required for that specific method call.

When another method is called inside it, a new stack frame is placed on top of the previous one.

This is why it is called a Stack —
because data is added and removed in a Last-In, First-Out (LIFO) order.

What Happens When a Method Returns?

When a method finishes execution:

Its stack frame is removed.
All its local variables go out of scope.
The memory used by that frame is automatically reclaimed.

If the method that called it also returns, its stack frame is removed as well. Eventually, if all methods complete, the stack becomes empty again. Stack memory management is extremely fast because it simply moves a pointer up and down.

when code call another method

same thing happened again it added, Method parameters, return address, and local variables on top of previous stack frame.

why it called stack.? because information will get stacked on top of another

what happened when will u return result from method.? so in this at moment when you return, all the local variables go out of scope and are destroyed. and if return from first method also we will back at where we started, empty stack

What is Heap.?

this is also a block of memory, every new object in .NET is creating into heap like

MyClass Obj = new MyClass();

lets see an program

using System;

class Person
{
    public string Name;
    public int Age;

    public void Greet()
    {
        Console.WriteLine($"Hi, I am {Name} and I am {Age} years old.");
    }
}

class Program
{
    static void Main()
    {
        Person p1 = new Person();
        p1.Name = "Hasan";
        p1.Age = 25;

        p1.Greet();
    }
}

First, p1 is created in the Stack as a reference variable. At this moment, it does not hold an object; it only has space to store a memory address and initially contains null.

Then the new Person() statement executes. This allocates memory in the Heap and creates a new Person object there. The fields of the object are automatically initialized with their default values (Name = null, Age = 0).

After the object is created in the Heap, its memory address is assigned to the reference variable p1 in the Stack. Now p1 points to that Heap object.

When we assign values using p1, such as setting properties or fields, those values are stored inside the Heap object. The Stack continues to store only the reference (memory address), while the actual object data resides in the Heap.

now on stack method will reference from heap memory.

if method if return i will removed from stack but in heap will still exist like

This is interesting, right? When a method finishes executing, its local variables and parameters go out of scope, but the object in the heap may still exist. In this case, the object becomes dereferenced because the variables and parameters that were referencing it have gone out of scope. A dereferenced object continues to exist in the heap, but it is not released immediately. Instead, it becomes eligible for garbage collection, and the .NET runtime will clean it up later.

The .NET Framework postpones cleaning up dereferenced objects because heap cleanup takes time. By delaying this process, the application can run more efficiently and perform better. This cleanup process is called garbage collection, and it runs periodically in the background.

When the runtime starts garbage collection, it scans the heap and identifies objects that are no longer referenced by any active variables, parameters, or reachable objects in the program. It then deallocates those unreachable objects and frees the memory.

How Data Stores in Stack & Heap

In our code have Used parameters like Integer & String
The int type belongs to a special category called value types. Value types store their actual data directly in the memory location where they are declared.

If a value type variable (like int) is declared inside a method, its value is stored directly in the Stack as part of the method’s stack frame. When the method ends, the stack frame is removed, and the value is automatically destroyed.

If a value type is part of an object (for example, int Age inside a class), it is stored in the Heap because it becomes part of the object’s memory block.

Reference types (such as class, string, and array) work differently. The reference variable is stored in the Stack, but the actual object is created and stored in the Heap. The Stack holds only the memory address, while the object’s data remains in the Heap.

Value Type:-

A value type is a type of variable in which both the type and the actual value are stored together in memory. The variable directly contains its data rather than a reference to another memory location.

For example, if I declare a local integer variable with a value of 1234, both the int type and the value 1234 are stored together in the Stack as part of the method’s stack frame. The variable itself holds the actual data, not a memory address pointing somewhere else.

This is why value types are typically faster to access and automatically removed when the method’s stack frame is destroyed.

All Value type

See All Value Type

Python uv: No More Manual Virtual Environments

Has — Mon, 25 Aug 2025 07:45:09 GMT

python -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt

But now, a new tool called uv makes this entire process seamless.

That changes with uv, a new ultra-fast Python package manager and runtime by Astral (creators of Ruff).

With uv, managing Python dependencies feels more like using npm in Node.js:

No manual virtual environment setup.
Simple commands to install and run.
Automatic isolation per project.

Why uv Feels Like npm

Why `uv` Feels Like `npm`

Let’s compare side by side:

Task	Old Python Way (`pip + venv`)	With `uv`	Node.js (`npm`)
Create project	`mkdir app && cd app && python -m venv .venv`	`uv init app`	`mkdir app && cd app && npm init -y`
Add dependency	`pip install requests`	`uv add requests`	`npm install axios`
Track dependencies	`requirements.txt` (manual update)	`pyproject.toml` (auto updated)	`package.json` (auto updated)
Run script	`source .venv/bin/activate && python` `script.py`	`uv run python` `script.py`	`node script.js`
Lock versions	`pip-tools` or manual	Built-in lockfile	`package-lock.json`
Global tool install	`pip install --user tool`	`uv tool install tool`	`npm install -g tool`

Example: Installing and Running a Project

npm init -y
npm install express
node server.js

uv init my-app
uv add fastapi uvicorn
uv run uvicorn app:app --reload

Notice how both flows look almost identical. No venv step in Python anymore.

Why This Matters

Beginner friendly: New Python devs don’t need to learn about virtual environments right away.
Faster installs: uv is significantly faster than pip.
Consistency: Automatic lock files ensure reproducible builds.
Unified experience: Just like JavaScript developers rely on npm, Python developers can now rely on uv.

Conclusion

Python has long lagged behind JavaScript in developer experience when it comes to dependency management. With uv, Python is finally catching up — giving us an npm-like workflow that’s simple, fast, and reliable.

If you’re tired of typing python -m venv .venv && source .venv/bin/activate, it’s time to try uv.

Let’s create a FastAPI project step by step… with UV + Python

1. Initialize a New Project

uv init testApi
cd testApi

it will Create

run this

uv run main.py

its creates everything automatically

2. Add Dependencies

uv add fastapi uvicorn

same npm i packagename

it will add dependency in pyproject.toml — same as package.json

3. Add a Basic FastAPI App

from fastapi import FastAPI
import uvicorn
def main():
    print("Hello from ocr!")
    uvicorn.run(app, host="0.0.0.0", port=7000)


app = FastAPI()

@app.get("/")
async def root():
    return {"message":"i am python FastAPI"}


if __name__ == "__main__":
    main()

4. Run the App

Boom….

5. Summary

uv = automatic environment + package manager (like npm)
FastAPI project is ready in minutes
No manual venv, no pip hassles
Run scripts with uv run

🚀 Exploring FastAPI with uv — no virtual environments, no hassle, just Python done right! Stay tuned, more insights coming soon.

BIG Grooper : A Powerful Document Processing Tool With Some UI Caveats

Has — Sat, 09 Aug 2025 18:30:00 GMT

When it comes to intelligent document processing, it is one of the most capable platforms I’ve used. It’s built to handle large-scale document ingestion, extraction, classification, and validation with impressive accuracy. Whether you’re parsing structured forms, messy handwritten notes, or mixed document sets, BIS delivers exceptional automation potential.

I’ve been working with Grooper for a while now, and I’ve grown to appreciate its strengths:

Robust Document Parsing — Handles multi-page, mixed document types in a single batch.
Powerful Extraction Tools — From regex-based lookups to advanced classification, it supports complex scenarios.
Flexible Workflow — You can automate almost every step from ingestion to export.

While BIS Grooper is excellent for backend document processing, I’ve noticed some limitations when it comes to front-end UI customizations in the Review Panel — especially for enhancing reviewer experience.

1. Adding an Image in the Review Panel (Logo Example)

Sometimes, I need to show a logo inside the Review Panel regardless of whether that image is part of the scanned document.

For example, if I’m processing invoices for Company A, I might want to always display Company A’s logo in the Review Panel for branding consistency, reviewer context, or visual guidance — even if the uploaded document doesn’t contain the logo.

Currently, BIS has no direct option to insert a custom static or dynamic image into the Review Panel layout. Whether the image is stored in a file path, a database field, or a lookup table, the Review Panel can only display text-based fields.

2. Dynamic Changes Based on Input (Lookup-Based Visibility)

BIS does offer features like secondary content types that can help conditionally display certain sections, but in practice, this isn’t always a fully complete solution — especially for more advanced scenarios.

In many document workflows, a section should only be visible if BIS finds relevant data from a lookup source (database, XML, API, etc.). If no data is found, the section should be completely hidden from the reviewer.

Example:

While processing an insurance claim, BIS checks an XML lookup for the customer’s policy number.
If a match is found, the “Policy Details” section appears in the Review Panel, pre-filled with the retrieved information.
If no match exists, the section is hidden entirely — keeping the interface clean and focused.

While secondary content types can partially achieve this, they often fall short when the visibility needs to be dynamically driven by lookup results during review. A more robust, real-time solution would give BIS the flexibility needed for complex, data-driven review workflows.

3. Displaying Multiple Rows of Data from Lookup Sources

BIS already provides a very useful feature where a dropdown list can be populated from a database or XML lookup. This is excellent for selecting a single value (e.g., choosing a product code, customer ID, or location) from a defined source.

However, in many real-world workflows, it’s not enough to see just one list of values — sometimes we need to show multiple rows of related data returned by the lookup.

Example scenario:

The reviewer enters a customer ID in the Review Panel.
BIS queries the lookup database and finds three past invoices for that customer.
Instead of only showing the customer’s name in a dropdown, the Review Panel should be able to display a table with multiple rows (invoice number, date, amount, status, etc.) for quick context.

Currently, there’s no built-in way to render this kind of multi-row, multi-column data from a lookup source directly in the Review Panel. This limits the ability to give reviewers richer context without switching to an external system.

A feature to show lookup results as a grid or list view inside the Review Panel — rather than just a dropdown — would make BIS even more powerful for complex review workflows.

If we set these UI limitations aside, BIS remains an incredibly powerful platform for document processing. Its extraction accuracy, flexible workflows, and ability to integrate with diverse data sources make it a top choice for large-scale automation. For complex, high-volume environments, BIS consistently delivers speed, reliability, and intelligent handling of even the messiest document sets. In short — the backend power is rock solid, even if the Review Panel could use a few upgrades.

BIS Grooper: How I Learned to Automate Data Capture

Has — Mon, 04 Aug 2025 18:30:00 GMT

Introduction

In the past month, I’ve been exploring BIS Grooper, a powerful data capture and document processing platform designed to automate information extraction from various file formats. My goal was simple — to understand how businesses streamline large-scale data entry and reduce manual work through automation.

What is BIS Grooper?

BIS Grooper is an intelligent document processing (IDP) platform developed to capture, extract, and integrate data from a variety of sources. It’s widely used in industries like finance, healthcare, education, and government to turn unstructured or semi-structured documents into usable, structured data.

Grooper works by combining OCR (Optical Character Recognition), data classification, content extraction rules, and system integrations into one unified workflow. This allows organizations to process everything from scanned invoices to complex forms, ensuring accurate and efficient data capture without manual entry.

What makes Grooper stand out is its flexibility — you can design extraction logic visually, train it to recognize specific document layouts, and even integrate directly with databases, content management systems, or cloud services.

My Learning Journey with BIS Grooper

When I started with BIS Grooper a month ago, I knew it was a powerful data capture tool, but I underestimated just how deep it could go. My learning process wasn’t just about following tutorials — it was about exploring, making mistakes, and solving real problems.

The first few days were all about understanding the Grooper Design Studio interface and its core components:

Content Models – the backbone for structuring how Grooper identifies and extracts information.
Data Fields – defining exactly what pieces of data I wanted to capture.
Pipelines – the workflow engine that automates document processing.

I started with something simple: importing a small batch of sample documents and running basic OCR to see how Grooper handled them. It was surprisingly accurate, even with slightly messy scans.

Diving into Classification & Extraction

I wanted Grooper to not just read documents but also understand what type of document it was looking at. That’s when I learned about Classification — training Grooper to automatically distinguish between invoices, forms, letters, or other document types.

For extraction, I began using Regular Expressions (Regex) inside Grooper. At first, it felt like learning a foreign language, but soon I could create patterns to pull out invoice numbers, dates, and customer IDs with near-perfect accuracy.

Once I had extraction down, my focus shifted to automation. I built my first complete pipeline that:

Once I had extraction down, my focus shifted to automation. I built my first complete pipeline that:

Imported documents from a folder.
Ran OCR to recognize text.
Classified each document type.
Extracted specific data fields.
Exported the results directly to a database.

Problem Solving & Optimization

The last week was about refining my skills:

Adjusting OCR settings for better accuracy on low-quality scans.
Creating fallback rules when certain fields couldn’t be extracted.
Learning how to debug extraction errors and pipeline failures.

I also realized Grooper isn’t just a data capture tool — it’s an intelligent workflow builder. Once you understand its logic, you can design processes that save massive amounts of time and reduce human errors

Real-World Applications I Tried

After building confidence with BIS Grooper’s core features, I started experimenting with real-world scenarios to see how it could handle actual business problems. My goal was simple, take tasks that normally require repetitive manual effort and see if Grooper could automate them end-to-end.

1. Invoice Data Extraction

One of my first test projects was automating the extraction of invoice details from scanned PDFs.

Challenge: These invoices had different layouts, inconsistent fonts, and sometimes handwritten notes.
Grooper’s Solution: I trained a Content Model to identify invoice numbers, dates, vendor names, and total amounts using a mix of layout-based extraction and Regex rules.
Result: What used to take 15–20 minutes per invoice manually was reduced to under 30 seconds, with 95%+ accuracy.

2. Form Classification for Multiple Departments

I simulated a use case where an organization receives different forms — HR onboarding, expense claims, leave requests — all in one folder.

Challenge: Sorting them manually is time-consuming and prone to error.
Grooper’s Solution: I used Document Classification to train the system to detect form types based on key words, layouts, and structure.
Result: Grooper could separate 100+ mixed forms into correct folders in just a few minutes without a single misclassification.

3. Legacy Data Digitization

I wanted to see how Grooper handles old, poor-quality scanned documents.

Challenge: These were decades-old records with faded text and uneven scans.
Grooper’s Solution: I fine-tuned OCR settings, applied image cleanup filters, and set up secondary validation rules for critical fields.
Result: Even for documents that were almost unreadable, Grooper could extract 80–85% of key data without human intervention — something I didn’t expect.

4. Automated Database Update

In one test, I built a pipeline that exported extracted data directly into an SQL database.

Challenge: Making sure field mapping matched the database schema.
Grooper’s Solution: The Data Integration features allowed me to map each extracted field to the correct column automatically.
Result: The database update process became entirely hands-free after initial setup.

These experiments proved to me that BIS Grooper isn’t just a document reading tool — it’s a full-scale automation platform. Once trained properly, it can save hours of work and deliver consistent, high-quality results every single time.

Challenges & How I Overcame Them

My one-month journey with BIS Grooper wasn’t all smooth sailing. While the platform is powerful, mastering it meant running into a few roadblocks — and learning how to solve them.

1. Understanding the Logic Behind Content Models
- Challenge: In the first week, I struggled to understand how Content Models interact with Data Fields and Pipelines. Sometimes I’d build a pipeline that ran without errors… but extracted nothing.
- Solution: I spent time in the Grooper Documentation and experimented with small, controlled datasets to isolate the problem. By breaking workflows into smaller parts, I learned exactly how each component affects the final output.

2. Regex Overload

Challenge: While Regular Expressions are powerful for extraction, they can quickly become complicated. I found myself stuck when patterns didn’t work for slightly different document layouts.
Solution: I built modular Regex rules — smaller, simpler patterns combined logically — instead of one giant pattern. This made them easier to debug and maintain.

3. OCR Accuracy on Poor-Quality Scans

Challenge: Low-resolution or skewed documents led to OCR errors, missing characters, and incorrect numbers.
Solution: I learned to use Image Processing Features inside Grooper — deskew, despeckle, contrast adjustment — before running OCR. Accuracy improved dramatically.

Challenge: Setting up dropdowns that dynamically bind to a Lexicon or data source was trickier than expected. Initially, I couldn’t get the list values to appear correctly in the Data Review Panel.
Solution: I learned how to properly configure Lexicon, map them to fields, and ensure the dropdowns auto-populate. This improved validation speed for human reviewers.

5. Database & XML Lookups (XPath)

Challenge: Performing DB Lookups and XML Lookups (especially using XPath Expression) was another steep learning point. At first, my queries either returned no results or incorrect matches.
Solution:
- For DB Lookup, I ensured the database connection string was correct, set the right query parameters, and used Grooper’s field binding to dynamically pass extracted values.
- For XML Lookup, I studied XPath syntax in depth — learning how to target exact nodes even in deeply nested structures. Once I mastered conditions, attribute selection, and node traversal, my lookups became precise and reliable.5. Database & XML Lookups (XPath)

6. Learning Curve Fatigue

Challenge: Grooper has a steep learning curve if you’re new to document automation.
Solution: I adopted a “one feature at a time” approach instead of trying to learn everything at once. This kept me motivated and allowed me to apply what I learned immediately.

Overcoming these challenges didn’t just help me understand BIS Grooper better — it gave me the confidence to work with dynamic data sources, integrations, and advanced lookups, which are critical for real-world automation workflows.

Conclusion & Next Steps

My first month with BIS Grooper has been both challenging and rewarding. I started with zero practical experience in advanced document processing, and now I can confidently build content models, perform lookups, bind dropdowns to lexicons, and execute precise XPath queries.

What stands out about Grooper is its flexibility — it’s not just an OCR tool, but a complete document automation platform. From cleaning poor-quality scans to integrating with databases and XML sources, I’ve learned that success comes from understanding the logic behind each component and combining them into a smooth workflow.

🤖 Getting Started with AI in .NET

Has — Wed, 07 Aug 2024 18:30:00 GMT

Build intelligent apps by combining .NET with AI power!

📌 Why Use AI in .NET?

With frameworks like ML.NET, Azure Cognitive Services, and OpenAI APIs, .NET developers can easily integrate AI features such as:
✅ Text generation
✅ Sentiment analysis
✅ Image recognition
✅ Chatbots

🛠️ Ways to Use AI in .NET

1️⃣ ML.NET

ML.NET is Microsoft’s open-source machine learning framework for .NET developers.

✅ Train and use ML models directly in C# or F#.
✅ No need to learn Python!

Example: Predicting product sales using regression models.

2️⃣ Azure Cognitive Services

Microsoft’s pre-built AI APIs for:
✔ Vision (Face, OCR)
✔ Speech (Text-to-Speech, Speech-to-Text)
✔ Language (Translation, Sentiment)

Example Code (C#):

csharpCopyEditvar client = new TextAnalyticsClient(new Uri(endpoint), new AzureKeyCredential(key));
var response = await client.AnalyzeSentimentAsync("I love Hashnode blogs!");
Console.WriteLine(response.Value.Sentiment);

3️⃣ Using OpenAI API in .NET

Integrate ChatGPT or DALL·E into your apps!

csharpCopyEditvar openAI = new OpenAIAPI("your_api_key");
var result = await openAI.Completions.CreateCompletionAsync("Write a blog about .NET AI");
Console.WriteLine(result);

🚀 Real-World Use Cases

✅ AI Chatbots for customer support
✅ Recommendation engines in e-commerce apps
✅ Automated document analysis using OCR

🎯 Final Thoughts

AI is no longer just for data scientists – with .NET, you can easily bring AI to your applications!

💡 Start with ML.NET for simple tasks, and move to Azure/OpenAI for advanced AI features.

From Query to Performance – A Guide to SQL Execution Plans

Has — Tue, 11 Oct 2022 18:30:00 GMT

Master SQL performance by learning how to read and use execution plans effectively!

What is an Execution Plan?

When you run a query, SQL Server’s query optimizer decides the best way to fetch data.
The Execution Plan is like a roadmap – it shows how SQL will access tables, use indexes, and perform joins.

Types of Execution Plans

1.Estimated Execution Plan (Ctrl+L)

2.Actual Execution Plan (Ctrl+M)

Common Operators

Operator	Meaning
Index Seek ✅	Uses index efficiently → Fast query
Index Scan ⚠️	Reads many rows → Slower than Index Seek
Table Scan ⚠️	Reads entire table → Very slow
Key Lookup 🔄	Fetches extra columns not in index
Nested Loops / Merge Join / Hash Join	Shows how tables are joined

🛠️ How to View in SSMS

Open SQL Server Management Studio (SSMS)
Click Include Actual Execution Plan (Ctrl + M)
Run your query
A new Execution Plan tab appears with graphical steps

SELECT FirstName, LastName 
FROM Employees 
WHERE DepartmentID = 2;

🔹 If DepartmentID is indexed → Execution Plan shows Index Seek (fast).
🔹 Without index → Execution Plan shows Table Scan (slow).

⚡ Tips to Optimize Queries

✅ Add proper indexes for frequently used columns in WHERE, JOIN, and ORDER BY.
✅ Avoid SELECT *, fetch only required columns.
✅ Check for Missing Index warnings in the plan.
✅ Review operators with the highest cost percentage.

🚀 Why Execution Plans Matter

✔ Help identify bottlenecks in queries.
✔ Show if SQL is using indexes efficiently.
✔ Provide hints for query optimization.

💡 Next time your query is slow, open the Execution Plan – it’s your best friend for performance tuning!