DEV Community: Adnan al-emran ontor

Integrating Scalar API Documentation in ASP.NET Core

Adnan al-emran ontor — Mon, 16 Mar 2026 07:44:59 +0000

Integrating Scalar API Documentation in ASP.NET Core

Modern APIs require clear and interactive documentation so developers can easily understand and test endpoints. Scalar is a modern API documentation UI built on top of OpenAPI, providing a clean and developer-friendly interface for exploring APIs.

In this article, we will integrate Scalar API Documentation into an ASP.NET Core Web API project.

What is Scalar?

Scalar is a modern API documentation tool designed for OpenAPI specifications. It allows developers to:

Explore API endpoints
View request and response schemas
Test APIs directly from the browser
Generate ready-to-use client code examples

Compared to traditional documentation tools, Scalar provides a more modern and intuitive user interface.

Step 1 — Install Scalar

Install the Scalar.AspNetCore NuGet package.

dotnet add package Scalar.AspNetCore --version 2.1.13

Or install it from NuGet:

https://www.nuget.org/packages/Scalar.AspNetCore

Step 2 — Configure Services

Open Program.cs and register the required services.

builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer(); // Required for OpenAPI generation
builder.Services.AddOpenApi();

Explanation

AddControllers() enables controller-based APIs
AddEndpointsApiExplorer() generates API metadata
AddOpenApi() generates the OpenAPI specification used by Scalar

Step 3 — Configure the HTTP Pipeline

Add Scalar and OpenAPI to the request pipeline.

if (app.Environment.IsDevelopment())
{
    app.MapOpenApi();

    app.MapScalarApiReference(options =>
    {
        options
            .WithTitle("ServerSide API")
            .WithDefaultHttpClient(ScalarTarget.CSharp, ScalarClient.HttpClient);
    });

    // Redirect root URL to Scalar documentation
    app.MapGet("/", () => Results.Redirect("/scalar/v1"))
        .ExcludeFromDescription();
}

What this configuration does

MapOpenApi() exposes the OpenAPI JSON document
MapScalarApiReference() enables the Scalar documentation UI
WithTitle() sets the API documentation title
WithDefaultHttpClient() generates C# HttpClient examples
The root URL automatically redirects to the documentation page

Step 4 — Run the Application

Run the ASP.NET Core project and open the documentation in your browser:

http://localhost:5000/scalar/v1

https://localhost:5001/scalar/v1

You will see the interactive Scalar API documentation interface.

Benefits of Using Scalar

Modern API documentation interface
Built-in API testing
Automatic OpenAPI integration
Code examples for multiple programming languages
Easy integration with ASP.NET Core

Conclusion

Integrating Scalar API documentation into an ASP.NET Core project is simple and significantly improves the developer experience. With only a few lines of configuration, you can provide a powerful and interactive API documentation interface.

Scalar helps developers understand and test APIs more efficiently.

Author

Adnan Al Emran

Software Engineer

GitHub

https://github.com/adnanalemran

Software Architecture: The Foundation of Great Software

Adnan al-emran ontor — Wed, 04 Dec 2024 05:16:15 +0000

When you build a house, you need a solid blueprint to ensure it stands strong and functions well. Software is no different. Software architecture is the blueprint that defines how a system is structured, how its parts work together, and how it can grow over time. It’s what makes software reliable, scalable, and maintainable. Without it, even the most well-written code can crumble under pressure.

What Exactly is Software Architecture?
At its core, software architecture is about making big-picture decisions. It answers questions like:

How will different parts of the system communicate?
Which technologies will we use?
How will we handle future changes and scaling?

Good architecture doesn’t just focus on the technical stuff. It also considers user needs, business goals, and practical constraints like deadlines and budgets.

Key Parts of Software Architecture
Architectural Patterns

Think of these as tried-and-tested recipes for building systems. Some common patterns include:

Monolithic: Everything in one big block (simple but hard to scale).
Microservices: Breaking the system into small, independent parts (complex but flexible).
Event-Driven: Components talk to each other using events (great for real-time systems).

System Components

Any software system usually has these pieces:_

Frontend: What the user interacts with (like a website or app).
Backend: The engine that processes requests and handles data.
Database: Where all the data lives.
APIs: Bridges that let different parts of the system talk to each other.

Design Principles

A good architecture follows principles like:

Keep it simple: Don’t overcomplicate things.
Separation of concerns: Each part should focus on one task.
Flexibility: Make it easy to add new features or fix bugs.

Why Does Software Architecture Matter?
Here’s why you need good architecture:

Scalability: As more users join, your system needs to handle the load.
Maintainability: Easy-to-understand architecture saves time when fixing bugs or adding features.
Performance: A well-thought-out design ensures speed and reliability.

Best Practices for Software Architecture
Start Simple

Don’t over-engineer. Build what you need now but leave room for future growth.

Think About the Future

Plan for features and changes your system might need in a year or two.

Document Everything

Diagrams and notes help your team understand the architecture and avoid confusion later.

Test Early and Often

Regular testing ensures your architecture holds up under real-world conditions.

Focus on Security

Build protections like encryption and authentication into your system from the start.

The Architect’s Role

A software architect is like the captain of a ship. They make the big decisions, keep the project on course, and ensure everyone on the team is aligned. They don’t write every line of code, but their guidance is crucial for success.

Popular Software Architecture Styles

When it comes to building software, choosing the right architecture is like choosing the right foundation for a house. Each architecture has its strengths and trade-offs, so picking the right one depends on your needs. Let’s break down some of the most common styles:

1. Monolithic Architecture

This is the “all-in-one” approach, where every feature and function is packaged into a single codebase.

Pros:

Easy to develop and deploy initially.
Simple debugging since everything is in one place.

Cons:

Hard to scale as the app grows.
Even small changes require redeploying the whole system.
Best for: Small applications or MVPs where speed is more important than scalability.

2. Two-Tier Architecture
Two-tier architecture separates the system into two main layers: the client and the server. The client handles the user interface, while the server manages data and business logic.

Pros:

Clear separation of concerns between frontend and backend.
Easier to maintain than monolithic systems.
Cons:
Limited scalability for complex or large applications.
Best for: Simple applications that don’t require extensive scaling.

3. N-Tier Architecture
Think of this as the upgraded version of two-tier architecture. It adds more layers, like a presentation layer, a business logic layer, and a data access layer.

Pros:

Better organization and modularity.
Easier to scale and maintain compared to two-tier systems.
Cons:
More complex to design and implement.
Can introduce latency if layers are too tightly connected.
Best for: Large, enterprise-level systems that need to handle high traffic and frequent updates.

4. Modular Monolithic Architecture
This is like monolithic architecture but with better organization. The application is split into distinct modules that handle specific tasks, while still being part of the same codebase.

Pros:

Easier to maintain and update compared to traditional monoliths.
Retains the simplicity of a single deployment.

Cons:

Scalability is still limited.
Modules remain tightly coupled in some areas.
Best for: Medium-sized applications where you want structure without the complexity of microservices.

5. Microservices Architecture
This is the “divide and conquer” approach. Instead of one big system, you build multiple small, independent services that communicate through APIs.

Pros:

Each service can be developed, deployed, and scaled independently.
Fault isolation: If one service goes down, the rest can keep running.

Cons:

More complex to manage because there are many moving parts.
Requires advanced tools for orchestration and monitoring.
Best for: Large systems with diverse features that need high flexibility and scalability.

6. Event-Driven Architecture
In this approach, components communicate by sending and receiving events. It’s like a messaging system where different parts of the system only react when something important happens.

Pros:

Real-time responsiveness and high decoupling.
Easily scalable and flexible.
Cons:
Debugging can be tricky due to asynchronous communication.
Requires careful planning of event flows.
Best for: Real-time applications, like stock trading platforms or IoT systems.

7. Cloud-Native Architecture
Built specifically for the cloud, this architecture uses containers, microservices, and CI/CD pipelines to maximize flexibility and scalability.

Pros:

Scales easily to meet demand.
Enables faster deployment and iteration cycles.

Cons:

Requires expertise in cloud technologies.
Costs can add up if not managed properly.
Best for: Applications with global reach or fluctuating workloads.

8. Serverless Architecture
This is the ultimate “hands-off” approach. Developers write code, and the cloud provider handles all the infrastructure behind the scenes.

Pros:

No need to manage servers or scale resources manually.
Pay only for what you use.

Cons:

Limited control over infrastructure.
Vendor lock-in is a potential concern. Best for: Event-driven systems or applications with unpredictable traffic.

Choosing the Right Architecture
There’s no one-size-fits-all solution. A monolithic architecture might be perfect for your small startup, while an event-driven or cloud-native approach might be better for a fast-growing enterprise. The key is to match the architecture to your project’s size, goals, and team expertise.

Good architecture is about building something that doesn’t just work today but continues to perform well as your needs grow.

What’s Next in Software Architecture?
Technology never stands still, and neither does architecture. Here are some trends shaping the future:

Serverless Computing: Let cloud providers handle your infrastructure.
AI-Driven Architecture: Use artificial intelligence to optimize your system’s design.
Edge Computing: Process data closer to where it’s generated for faster responses.

Wrapping Up
Software architecture isn’t just about building software — it’s about building software that lasts. It’s the invisible framework that ensures everything works smoothly, scales easily, and adapts to new challenges. Whether you’re designing a simple app or a complex system, investing time in good architecture is always worth it. After all, great software starts with a solid foundation.

Linux File Permissions Cheat Sheet

Adnan al-emran ontor — Sun, 17 Nov 2024 01:01:14 +0000

What Are File Permissions?

Linux file permissions control who can read, write, or execute a file or directory. They are set for three user groups:

Owner: The file creator.
Group: A user group that can access the file.
Others: All other users.

Viewing File Permissions

Use the ls -l command to display file permissions:


ls -l

Example Output:


-rwxr-xr-- 1 user group 1234 Nov 16 14:00 file.txt

Part	Explanation
`-rwxr-xr--`	Permissions (explained below).
`1`	Number of hard links.
`user`	Owner of the file.
`group`	Group associated with the file.
`1234`	File size in bytes.
`Nov 16 14:00`	Last modification date.
`file.txt`	File name.

Permission Breakdown

Each permission has three parts:

[Type][Owner][Group][Others]

Symbol	Type/Permission
`-`	Regular file.
`d`	Directory.
`r`	Read permission.
`w`	Write permission.
`x`	Execute permission (or enter a folder).

Changing File Permissions

Using chmod (Symbolic Mode):
```
chmod [permissions] [file]
```
Example: Add execute permission to the owner:
```
chmod u+x file.txt
```
Symbol Meaning

u User (owner).

g Group.

o Others.

a All (user, group, others).

Actions:

Symbol Action

+ Add permission.

- Remove permission.

= Set exact permission.

Example: Remove write permission for others:
```
chmod o-w file.txt
```

Symbol	Meaning
`u`	User (owner).
`g`	Group.
`o`	Others.
`a`	All (user, group, others).

Symbol	Action
`+`	Add permission.
`-`	Remove permission.
`=`	Set exact permission.

Using chmod (Numeric Mode):

Each permission level is represented by a number:

Permission Value

r (read) 4

w (write) 2

x (execute) 1

- (none) 0

Combine values to set permissions:

Owner (u) Group (g) Others (o) Command

rwx (7) r-x (5) r-- (4) chmod 754 file.txt

Permission	Value
`r` (read)	`4`
`w` (write)	`2`
`x` (execute)	`1`
`-` (none)	`0`

Owner (u)	Group (g)	Others (o)	Command
`rwx` (7)	`r-x` (5)	`r--` (4)	`chmod 754 file.txt`

Changing Ownership

Change file owner:


chown [owner] [file]

Example:


sudo chown user file.txt

Change group:


chown :[group] [file]

Example:


sudo chown :staff file.txt

Change both owner and group:


chown [owner]:[group] [file]

Example:


sudo chown user:staff file.txt

Recursive Changes

To apply changes to all files and directories:

Change permissions recursively:


chmod -R [permissions] [directory]

Example:


chmod -R 755 /path/to/folder

Change ownership recursively:


chown -R [owner]:[group] [directory]

Example:


sudo chown -R user:staff /path/to/folder

Testing Permissions

Create a test file or directory to practice:


touch test.txt
chmod 600 test.txt  # Owner can read/write, others denied.
chmod 755 test.txt  # Everyone can read, owner can write.
chmod -R 770 /test  # Owner/group full access, others denied.

AWK Cheat Sheet

Adnan al-emran ontor — Sun, 17 Nov 2024 00:53:00 +0000

What is AWK?

awk is a powerful text-processing tool in Linux used to manipulate and analyze text files by processing patterns and performing actions.

Basic Syntax


awk 'pattern {action}' file

pattern: The condition to match (optional).
action: Commands to execute on matching lines (optional).
file: The file to process.

Common Examples

1. Print All Lines


awk '{print}' file.txt

Outputs all lines in file.txt.

2. Print Specific Columns

 awk '{print $1, $3}' file.txt

Prints the 1st and 3rd columns.

3. Match a Pattern


awk '/error/ {print}' log.txt

Prints lines containing the word error.

4. Conditional Filtering


awk '$3 > 100 {print $1, $3}' data.txt

Prints rows where the 3rd column is greater than 100.

5. Add or Modify Columns


awk '{print $1, $2, $2 + $3}' data.txt

Adds a column with the sum of the 2nd and 3rd columns.

6. Count Matching Lines


awk '/pattern/ {count++} END {print count}' file.txt

Counts and prints lines matching pattern.

7. Format Output


awk '{printf "Name: %s, Age: %d\n", $1, $2}' names.txt

Formats and prints fields with a custom output.

8. Use Field Separator


awk -F ':' '{print $1, $NF}' /etc/passwd

Uses : as a separator and prints the 1st and last columns.

Key Concepts

Symbol	Meaning
`$1`, `$2`	Represents the 1st, 2nd columns (fields).
`NR`	Line number (e.g., `NR == 5` matches line 5).
`NF`	Total number of fields in a line.
`FS`	Field Separator (`-F` or `FS=","`).
`BEGIN`	Executes before processing lines.
`END`	Executes after processing all lines.

Advanced Examples

Print Line Numbers


awk '{print NR, $0}' file.txt

Prints line numbers alongside the content.

Find Maximum in a Column


awk '$3 > max {max = $3} END {print max}' data.txt

Finds and prints the maximum value in the 3rd column.

Sum a Column


awk '{sum += $3} END {print sum}' data.txt

Sums up all values in the 3rd column.

Filter by Field Count


awk 'NF == 3 {print}' file.txt

Prints lines with exactly 3 fields.

Practice Data

Create a sample.txt to test commands:


John 25 500
Mary 30 600
Alex 28 450

Tips

Test commands with awk on small files before applying to large ones.
Combine with other commands like grep or sed for complex workflows.

Multi language in react i18next (easy example)

Adnan al-emran ontor — Wed, 13 Nov 2024 19:03:03 +0000

Step 1: Install Required Dependencies

First, install the required packages:


npm install react-i18next i18next i18next-http-backend

This will install react-i18next for React integration, i18next for managing translations, and i18next-http-backend to load JSON translation files from the server.

Step 2: Set Up Translation Files

Create translation JSON files for each language in the public folder of your React project.

For example:


/public
  /locales
    /en
      home.json
      about.json
    /bn
      home.json
      about.json
    /th
      home.json
      about.json

Each language folder contains JSON files for each page (home, about, etc.). You can add more languages or pages as needed.

Example of `/locales/en/home.json`:


{
  "welcome": "Welcome to our website",
  "slogan": "CONNECT, SHARE, GROW - ALL IN ONE TAP"
}

Example of `/locales/en/about.json`:


{
  "aboutTitle": "About Us",
  "aboutDescription": "We are a company dedicated to growth and innovation."
}

Similarly, add the corresponding files for other languages (bn, th, etc.).

Step 3: Initialize i18n

Create an i18n.js file to configure i18next with the backend loader and set up the languages and namespaces.

`/src/i18n.js`:


import i18n from "i18next";
import { initReactI18next } from "react-i18next";
import HttpBackend from "i18next-http-backend";

i18n
  .use(HttpBackend) // Enables loading JSON files
  .use(initReactI18next) // Initializes react-i18next
  .init({
    fallbackLng: "en", // Default language if not set
    backend: {
      loadPath: "/locales/{{lng}}/{{ns}}.json", // Load path pattern for the JSON files
    },
    ns: ["home", "about"], // Define namespaces for each page
    defaultNS: "home", // Default namespace
    interpolation: {
      escapeValue: false, // Disable escaping for simplicity
    },
  });

export default i18n;

loadPath specifies where to fetch the translation files.
ns defines the namespaces, which are the translation files like home.json, about.json, etc.
defaultNS is the default namespace used for missing keys.

Step 4: Load Translations in Components

Use the useTranslation hook to load translations in different components.

Example of `Header.js` Component:


import { useTranslation } from 'react-i18next';
import { Link } from 'react-router-dom';
import { useEffect } from 'react';

const Header = () => {
    const { t, i18n } = useTranslation('home'); // Use 'home' namespace

    const changeLanguage = (e) => {
        const selectedLanguage = e.target.value;
        i18n.changeLanguage(selectedLanguage)
            .then(() => localStorage.setItem('language', selectedLanguage)) // Store selected language in localStorage
            .catch(err => console.error("Language change error:", err));
    };

    useEffect(() => {
        const savedLanguage = localStorage.getItem('language') || 'en'; // Load saved language
        i18n.changeLanguage(savedLanguage)
            .catch(err => console.error("Language load error:", err));
    }, [i18n]);

    return (
        <div>
            <div className="navbar container mx-auto">
                <div className="navbar-start">
                    <Link to="/">
                        <div className="font-queensides text-3xl text-primary font-bold">
                            Card<span className='text-5xl text-secondary'>X.</span>
                            <br />
                            <p className='relative bottom-3 text-[8px]'>
                                {t('slogan')} {/* Use translation key */}
                            </p>
                        </div>
                    </Link>
                </div>

                <div className="navbar-end flex gap-8 font-poppins">
                    <select
                        onChange={changeLanguage}
                        value={i18n.language}
                        className="p-1 border rounded-md bg-white shadow-sm focus:outline-none focus:ring-2 focus:ring-blue-500"
                    >
                        <option value="en">🇺🇸 English</option>
                        <option value="bn">🇧🇩 বাংলা</option>
                        <option value="th">🇹🇭 Thai</option>
                    </select>

                    <Link to="#" className="text-sm text-black whitespace-nowrap">{t('contactUs')}</Link>
                </div>
            </div>
        </div>
    );
};

export default Header;

useTranslation('home') loads the home.json file. For the "about" page, you would use useTranslation('about').

Step 5: Use Translations in Other Pages

Similarly, use the useTranslation hook in other components and pages.

Example of `About.js` Component:


import { useTranslation } from 'react-i18next';

const About = () => {
    const { t } = useTranslation('about'); // Use 'about' namespace

    return (
        <div>
            <h1>{t('aboutTitle')}</h1>
            <p>{t('aboutDescription')}</p>
        </div>
    );
};

export default About;

Step 6: Update `App.js` or Routes

Ensure that your routes are set up properly to render different components and load translations based on the selected language.


import React from 'react';
import { BrowserRouter as Router, Route, Routes } from 'react-router-dom';
import Header from './Header';
import About from './About';

function App() {
    return (
        <Router>
            <Header />
            <Routes>
                <Route path="/" element={<Home />} />
                <Route path="/about" element={<About />} />
            </Routes>
        </Router>
    );
}

export default App;

Step 7: Test the Language Switch

Now, you should be able to switch languages using the dropdown in the Header, and the translations should be updated accordingly across your pages.

Final Directory Structure


/src
  /components
    Header.js
    About.js
  i18n.js
/App.js

/public
  /locales
    /en
      home.json
      about.json
    /bn
      home.json
      about.json
    /th
      home.json
      about.json

Conclusion

Namespaces are used to organize translations per page or component (e.g., home.json, about.json).
The useTranslation hook loads translations based on the current namespace.
The i18next-http-backend plugin loads JSON files from the server.
LocalStorage helps persist the selected language across sessions.

How to Set Up GitHub with SSH Keys on Windows 10 or 11

Adnan al-emran ontor — Fri, 08 Nov 2024 07:53:27 +0000

Why Use RSA with SSH Keys?

RSA (Rivest-Shamir-Adleman) encryption is one of the most widely supported algorithms for SSH keys. It provides a balance between strong security and compatibility, making it ideal for authenticating with services like GitHub.

Step-by-Step Guide

Generate an SSH Key To generate an RSA SSH key with your email as a comment, follow these steps:

Open Command Prompt or PowerShell on Windows 10.

Type the following command to create a new SSH key using RSA encryption:

ssh-keygen -o -t rsa -C "youremail@email.com"

When prompted to specify a location to save the key, press Enter to use the default directory (C:\Users\YourUsername.ssh\id_rsa).
Press Enter (no passphrase needed).

like :

Access the SSH Key Navigate to the .ssh folder located in:

C:\Users\YourUsername.ssh\

like :

Open the id_rsa.pub file with Notepad and copy the public key.

Add the SSH Key to GitHub Now, you need to add the SSH public key to your GitHub account.

Go to your GitHub profile.

Navigate to Settings > SSH and GPG keys.

Click New SSH Key.

Paste the SSH public key in the "Key" field and give it a meaningful title.
Click Add SSH key, and you're done!

use SSH :

Understanding Constraints for Designing a REST API

Adnan al-emran ontor — Tue, 08 Oct 2024 05:46:39 +0000

In the world of web development, REST (Representational State Transfer) has become a dominant architectural style for building APIs. A well-designed REST API is not just about functionality but also about adhering to specific principles and constraints that ensure scalability, maintainability, and usability. Let’s dive into the essential constraints that guide RESTful API design.

1. Client-Server Architecture

One of the fundamental principles of REST is the separation of concerns between the client and server. The server handles the backend logic, data storage, and resource management, while the client interacts with these resources through a well-defined interface. This decoupling allows the two to evolve independently, enabling flexibility and scalability.

2. Statelessness

In a RESTful system, each request from the client must contain all the information necessary to process it. The server does not store any state information about the client session. This stateless nature simplifies server design and improves scalability, as any server can handle any request without relying on session data.

For example:

GET /users/123 Authorization: Bearer <token>

The request includes all the information (like authentication) required for processing.

3. Uniform Interface

A consistent and uniform interface is a cornerstone of REST. This includes:

Resource Identification: Resources are identified through URIs (e.g., /users/123).
Standard HTTP Methods: Use verbs like GET (read), POST (create), PUT (update), and DELETE (remove).
Consistent Responses: Provide responses in a predictable format, such as JSON, across all endpoints. This uniformity makes APIs easier to understand and use, even for developers unfamiliar with them.

4. Cacheability

To enhance performance, REST APIs should allow caching of responses wherever possible. Responses must include appropriate HTTP headers to indicate their cacheability, such as:

Cache-Control: max-age=3600 (caches the resource for 1 hour).
ETag: "unique-resource-id" (validates the resource's freshness).

5. Layered System

RESTful architecture is designed to support a layered system. Clients should not know whether they are interacting with the actual server or an intermediary like a load balancer or cache. This abstraction enhances security, scalability, and flexibility.

6. Code on Demand (Optional)

While optional, REST allows servers to extend client functionality by transferring executable code, such as JavaScript, to the client. This is rarely used in practice but can be helpful for dynamic applications.

7. Resource and Representation

In REST, resources are the key entities, represented as nouns rather than verbs. Each resource can have multiple representations, such as JSON, XML, or HTML. For example:

A user resource might be accessed via /users/123.
The client can request the resource in JSON (Accept: application/json) or XML (Accept: application/xml).

8. Stateless Authentication

Statelessness extends to authentication. Token-based mechanisms like JWT (JSON Web Tokens) are commonly used. These tokens, included in every request, eliminate the need for server-side session management.

9. Pagination, Sorting, and Filtering

For APIs dealing with large datasets, pagination and filtering are essential for performance and usability. Example:

GET /users?page=2&limit=10&sort=name&filter=active
This query retrieves the second page of active users, sorted by name, with 10 results per page.

10. Versioning

APIs evolve over time, and breaking changes are sometimes unavoidable. Versioning ensures backward compatibility. Common approaches include:

URI versioning: /v1/users.
Header versioning: Accept: application/vnd.api+json; version=1.0.

11. Error Handling

A well-designed API provides clear and consistent error messages. For example:

{ "error": { "code": 404, "message": "Resource not found." } }

Standard HTTP status codes like 400 Bad Request, 401 Unauthorized, and 500 Internal Server Error should be used.

Rate Limiting To prevent abuse and ensure availability, REST APIs should implement rate limiting. This can be communicated to clients through headers:

X-RateLimit-Limit: 100
X-RateLimit-Remaining: 50

12. Security

Security is critical in any API design. Best practices include:

Using HTTPS for encrypted communication.
Implementing token-based authentication (e.g., JWT, OAuth).
Validating and sanitizing inputs to prevent injection attacks.
Avoiding sensitive information (e.g., passwords) in responses.

Conclusion

Designing a RESTful API is not just about making endpoints functional; it’s about adhering to constraints that ensure the system is robust, scalable, and user-friendly. By following these principles, you can build APIs that are not only efficient but also a pleasure for developers to work with. Whether you’re building a simple application or a complex system, these constraints will guide you toward a better design.

Happy coding!

DEV Community: Adnan al-emran ontor

Integrating Scalar API Documentation in ASP.NET Core

Integrating Scalar API Documentation in ASP.NET Core

What is Scalar?

Step 1 — Install Scalar

Step 2 — Configure Services

Explanation

Step 3 — Configure the HTTP Pipeline

What this configuration does

Step 4 — Run the Application

Benefits of Using Scalar

Conclusion

Author

Software Architecture: The Foundation of Great Software

Linux File Permissions Cheat Sheet

What Are File Permissions?

Viewing File Permissions

Permission Breakdown

Changing File Permissions

Changing Ownership

Recursive Changes

Testing Permissions

AWK Cheat Sheet

What is AWK?

Basic Syntax

Common Examples

1. Print All Lines

2. Print Specific Columns

3. Match a Pattern

4. Conditional Filtering

5. Add or Modify Columns

6. Count Matching Lines

7. Format Output

8. Use Field Separator

Key Concepts

Advanced Examples

Print Line Numbers

Find Maximum in a Column

Sum a Column

Filter by Field Count

Practice Data

Tips

Multi language in react i18next (easy example)

Step 1: Install Required Dependencies

Step 2: Set Up Translation Files

Example of /locales/en/home.json:

Example of /locales/en/about.json:

Step 3: Initialize i18n

/src/i18n.js:

Step 4: Load Translations in Components

Example of Header.js Component:

Step 5: Use Translations in Other Pages

Example of About.js Component:

Step 6: Update App.js or Routes

Step 7: Test the Language Switch

Final Directory Structure

Conclusion

How to Set Up GitHub with SSH Keys on Windows 10 or 11

Why Use RSA with SSH Keys?

Understanding Constraints for Designing a REST API

Example of `/locales/en/home.json`:

Example of `/locales/en/about.json`:

`/src/i18n.js`:

Example of `Header.js` Component:

Example of `About.js` Component:

Step 6: Update `App.js` or Routes