DEV Community: Kamran Khan

From API Beginner to Architect: How to Design Scalable APIs (Without the Headache!)

Kamran Khan — Sat, 20 Dec 2025 04:49:09 +0000

So, you’ve mastered the basics of API modeling. You know how to create resources like /movies and add basic GET methods. But as your MovieHub app grows—adding actors, directors, reviews, and video trailers—your API definition starts looking like a giant, messy ball of code. 😱

Ready to stop "copy-pasting" and start designing like a pro?

In this post, I’ll show you how to take a basic API design and refactor it into a clean, modular masterpiece using advanced RAML techniques. Let's dive in!

The Goal: The CineStream API

We are building a streaming platform API. It needs to:

Manage huge lists of Movies and Actors.
Filter movies by genre or release year.
Allow admins to upload movie posters (files).
Ensure every movie entry has a valid ID and Title.

Step 1: Enforce Rules with Types (Schemas)

In a basic design, you just show a sample JSON. But what if a developer forgets the releaseYear? Types act as a contract: they define exactly what the data must look like.

types:
  Movie:
    properties:
      id: string
      title: string
      releaseYear: 
        type: integer
        minimum: 1888
      genre: string

Why this matters:

Data Integrity: It automatically rejects a movie if the releaseYear is 1500 or if the id is missing.
Consistency: Use this Movie type across your entire API.

Step 2: Create Blueprints with Resource Types

Most APIs follow a pattern: a collection (like /movies) and an item (like /movies/{id}). Instead of typing out get and post for every single category, we create a resourceType.

resourceTypes:
  collection:
    get:
      description: Get a list of <<resourcePathName>>
    post:
      description: Add a new <<resourcePathName | !singularize>>
      body:
        application/json:
          type: <<resourcePathName | !singularize>>

The Magic:

<<resourcePathName>> automatically becomes "movies" or "actors" depending on the path.
| !singularize is a built-in transformer that turns "movies" into "Movie" for your data type!

Step 3: Make Templates Dynamic with Parameters

Sometimes your blueprints need specific details, like a unique example for a Movie vs. an Actor. You can pass these as parameters.

/movies:
  type:
    collection:
      exampleCollection: !include examples/movies-list.json
      exampleItem: !include examples/new-movie.json

Why this matters: You can now manage 50 different resources by editing just one resourceType blueprint.

Step 4: Tidy Up with !includes

Don't let your main API file become a 5,000-line monster. Use !include to move long examples and schemas into their own files.

/movies:
  type: collection
  get:
    responses:
      200:
        body:
          application/json:
            example: !include movies-display.json

Why this matters: Your main file stays readable (the "blueprint"), while the data details stay in organized folders.

Step 5: Add "Plug-in" Features with Traits

Need searching, sorting, or paging? These aren't resources; they are behaviors. In RAML, we call these Traits.

traits:
  searchable:
    queryParameters:
      query:
        description: Search the list by <<field>>
  pageable:
    queryParameters:
      limit: { type: integer, default: 20 }
      offset: { type: integer, default: 0 }

/movies:
  get:
    is: [ searchable: {field: "title"}, pageable ]

Why this matters: You can "plug" paging into /movies, /actors, and /reviews instantly without writing the code three times.

Step 6: Handling File Uploads

For a movie app, we need to upload posters. You can define specific body types for binary data (the image file) and form data at the same time.

/movies/{movieId}/poster:
  post:
    body:
      image/jpeg:
      multipart/form-data:
        properties:
          file:
            type: file
            description: The movie poster image

Memory Hack: The S.R.I.T. Method

To design like an architect, remember S.R.I.T.:

Schemas/Types (Define the rules)
Resource Types (The blueprints for your URLs)
Includes (Keep it tiny and tidy)
Traits (Plug-in behaviors like paging)

Wrap-up

You’ve just leveled up from "API Writer" to API Architect. By using these advanced features, your MovieHub API is now scalable, professional, and—most importantly—easy to maintain.

What’s your biggest challenge when designing APIs? Let's chat in the comments! 🚀

How to Design Your First API with RAML (Without Losing Your Mind!)

Kamran Khan — Fri, 19 Dec 2025 14:01:55 +0000

Ever wondered how developers design APIs that look clean, work smoothly, and scale like magic?

In this post, I’ll show you how to use RAML (RESTful API Modeling Language) to design a simple API for a MovieHub app.

And the best part? You’ll learn the essentials in 6 easy steps—with examples that stick in your mind.

Ready? Let’s dive in!

Why RAML?

RAML helps you model RESTful APIs in a structured, human-readable way.

Instead of messy docs and scattered notes, you get a single source of truth for your API design.

Think of it as the blueprint before you start building the house.

Step 1: Start with the Root

Every RAML file begins with a root section.

This is your foundation—everything here applies globally.

Here’s the code:

#%RAML 1.0
title: MovieHub API
baseUri: http://api.moviehub.com/{version}
version: v1

Why this matters:

title → API name
baseUri → starting point for all calls
version → keeps things organized

Step 2: Add Resources

Resources are collections like /movies, /actors, /directors.

Here’s how they look:

/movies:
/actors:
/directors:

Want to get details of a specific actor? Use nested resources:

/actors/{actorName}:

Step 3: Define Methods

Methods tell your API what to do. The big four:

GET → Fetch data
POST → Add new data
PUT → Update data
DELETE → Remove data

Example for /books:

/movies:
 get:
 post:
 put:

Step 4: URI Parameters

Need to fetch a specific book? Add a URI parameter:

/movies/{movieTitle}:

Example call:

http://api.moviehub.com/v1/movies/Inception

Step 5: Query Parameters

Want filtering? Use query parameters:

/movies:
 get:
  queryParameters:
    genre:
    releaseYear:
    rating:
    director:

Pro tip: Always document attributes like type, example, and required.

Example:

genre:
 displayName: Genre
 type: string
 example: Sci-Fi
 required: false

Step 6: Responses

Show what the API returns. Example:

responses:
  200:
    body:
      application/json:
        example:
          {
            "title": "Inception",
            "director": "Christopher Nolan",
            "rating": 8.8,
            "status": 200
          }

Memory Hack

Think of the flow as:

Root → Resources → Methods → URI Params → Query Params → Responses

(R → R → M → U → Q → R)

Say it twice and you’ll never forget it.

Wrap-up

And that’s it! You’ve just built your first API spec in RAML.

Ready to take it to the next level? 🚀
Check out my follow-up post: From API Beginner to Architect: How to Design Scalable APIs (Without the Headache!).

In that post, we’ll dive into the advanced features like Resource Types and Traits to help you stop copy-pasting and start designing like a pro.

Give yourself a pat on the back—you’re officially an API designer now! 🎉

🔧 How to Auto-Mount Partitions Without Password in Fedora and Access Them in File Manager

Kamran Khan — Sat, 19 Jul 2025 18:16:11 +0000

On Fedora, accessing additional disk partitions (like a separate storage or workspace) often requires entering your password. This guide explains how to auto-mount partitions at boot without a password, and have them appear in the GNOME Files app, similar to how drives show in Windows.

We’ll cover two methods:

Mounting under /mnt (clean layout, requires shortcut for GUI visibility)
Mounting under /media (auto-visible in GNOME Files sidebar)

🧭 Step 1: Identify Your Partition

In a terminal, run:

lsblk -f

or:

sudo blkid

Look for entries like:

/dev/sdXn: LABEL="YourLabel" UUID="XXXX-XXXX" TYPE="ext4"

Take note of:

UUID
LABEL (optional)
Filesystem type (e.g. ext4, ntfs, btrfs)

🛠️ Step 2: Choose Your Mount Method

✅ Option 1: Mount Under `/mnt` (Clean System Layout)

This method is clean and system-friendly but requires a shortcut to access from the GUI.

1. Create Mount Point

sudo mkdir -p /mnt/YourMountPoint

Replace YourMountPoint with a name like workspace or storage.

2. Edit `/etc/fstab`

Open the file:

sudo nano /etc/fstab

Add a line like this:

UUID=XXXX-XXXX  /mnt/YourMountPoint  ext4  defaults  0  2

Replace:

UUID=XXXX-XXXX with your actual UUID
ext4 with your actual filesystem type
YourMountPoint with your chosen name

3. Mount Immediately

sudo mount -a

4. Add GUI Shortcut (Optional)

ln -s /mnt/YourMountPoint ~/YourMountPoint

This creates a visible folder shortcut in your home directory.

✅ Option 2: Mount Under `/media` (Visible in GNOME Files Sidebar)

This method makes partitions show up automatically in the Files app.

1. Create Mount Point

sudo mkdir -p /media/YourMountPoint

2. Edit `/etc/fstab`

sudo nano /etc/fstab

Add a line like:

UUID=XXXX-XXXX  /media/YourMountPoint  ext4  defaults  0  2

3. Mount:

sudo mount -a

Open Files app — you’ll now see the partition in the left sidebar.

🔑 Step 3: Set Permissions (Optional)

To ensure you have read/write access:

sudo chown -R $USER:$USER /mnt/YourMountPoint

or if using /media:

sudo chown -R $USER:$USER /media/YourMountPoint

✨ Optional: Change Partition Label

To customize the name that appears in the GUI:

sudo e2label /dev/sdXn NewLabel

Replace sdXn with your device (like sda3) and NewLabel with your desired label.

🧹 To Undo or Remove

Delete or comment the corresponding line in /etc/fstab
Unmount the partition:

  sudo umount /mnt/YourMountPoint

Remove mount point or symlink as needed

✅ Summary

Feature	`/mnt` Method	`/media` Method
Auto-mount on boot	✅ Yes	✅ Yes
GUI (Files) visibility	❌ Needs symlink	✅ Sidebar visibility
Password prompt	❌ No	❌ No
Use case	Clean setup, scripting	Windows-style file access

💡 Pro Tip

Always back up your /etc/fstab before editing:

sudo cp /etc/fstab /etc/fstab.bak

😴 Get Deeper Sleep on Fedora: Optimizing Suspend-to-RAM

Kamran Khan — Wed, 16 Jul 2025 11:11:07 +0000

If you're running Fedora on a laptop or desktop, you might have noticed your system defaulting to a lighter sleep state (s2idle) instead of the power-saving "deep sleep" (S3 Suspend-to-RAM). This can lead to faster battery drain and more warmth when suspended.

In this guide, you'll learn how to:

✅ Verify if your system supports "deep" suspend
⚙️ Configure Fedora to use "deep" suspend by default
🛠️ Add NVIDIA suspend/resume fix (optional)
🛠️ Apply MSI/ASUS-specific ACPI tweak (optional)
🔍 Understand the difference between sleep states

🎯 What is "Deep Sleep" (S3 Suspend)?

In the world of ACPI (Advanced Configuration and Power Interface), "deep sleep" typically refers to the S3 suspend state (Suspend-to-RAM). In this state:

The CPU, chipset, and most other components are powered down.
The RAM (Random Access Memory) remains powered to retain your session data.
The system consumes minimal power, making it ideal for battery life.
Resuming from S3 is fast, usually taking only a few seconds.

Fedora, by default, often uses s2idle (Suspend-to-Idle), which keeps more components powered on, consuming more energy, especially in modern hardware. While it's slightly faster to resume, S3 offers better power savings for true "deep sleep."

✅ Step 1: Verify "Deep Sleep" Support

Run:

cat /sys/power/mem_sleep

Example output:

[s2idle] deep

If deep is present, your system supports S3 suspend.
If it’s missing, check your BIOS/UEFI for power settings (sometimes called ACPI S3 or Legacy Sleep).

✅ Step 2: Configure Fedora for "Deep Sleep"

Edit the sleep config:

   sudo nano /etc/systemd/sleep.conf

Add the lines:

   [Sleep]
   SuspendState=mem
   MemorySleepMode=deep

Save & exit, then reboot:

   sudo reboot

After this, suspend should now default to deep sleep (S3).

🟢 Step 3 (Optional, NVIDIA users): Add GPU Resume Fix

On systems with NVIDIA GPUs, you may experience black screens after resume. NVIDIA provides a kernel option to preserve VRAM allocations across suspend.

Open GRUB config:

   sudo nano /etc/default/grub

Find the line starting with GRUB_CMDLINE_LINUX= and add this at the end (inside the quotes):

   nvidia.NVreg_PreserveVideoMemoryAllocations=1

Example:

   GRUB_CMDLINE_LINUX="rhgb quiet mem_sleep_default=deep nvidia.NVreg_PreserveVideoMemoryAllocations=1"

Rebuild GRUB and reboot:

   sudo grub2-mkconfig -o /boot/grub2/grub.cfg
   sudo reboot

This helps the NVIDIA driver restore graphics properly after suspend.

🟠 Step 4 (Optional, MSI/ASUS laptops): ACPI Compatibility Tweak

Some MSI and ASUS laptops expose different suspend/resume behaviors depending on which OS they think is running. By default, Linux identifies itself as “Linux”, which may not unlock all ACPI features.

You can trick the firmware into using the same code paths as Windows 10/11 by adding:

acpi_osi=! acpi_osi="Windows 2020"

to your kernel command line.

Open GRUB config:

   sudo nano /etc/default/grub

Update GRUB_CMDLINE_LINUX, for example:

   GRUB_CMDLINE_LINUX="rhgb quiet mem_sleep_default=deep nvidia.NVreg_PreserveVideoMemoryAllocations=1 acpi_osi=! acpi_osi=\"Windows 2020\""

Rebuild GRUB and reboot:

   sudo grub2-mkconfig -o /boot/efi/EFI/fedora/grub.cfg
   sudo reboot

⚠️ Note:
This tweak is most useful on MSI and ASUS laptops that have issues resuming from suspend. If it causes problems (rare), just remove it again.

🔒 Understanding Sleep States (Briefly)

S0 (Working): Fully on.
S0ix (Modern Standby / s2idle): Low-power idle; fast resume but higher drain.
S3 (Suspend-to-RAM): Only RAM stays powered; lowest power, fast resume.
S4 (Hibernate): Saves memory to disk; no power use, slower resume.
S5 (Soft Off): Full shutdown.

📌 TL;DR Cheatsheet

Task	Command	Description
Check deep sleep support	`cat /sys/power/mem_sleep`	Shows if `deep` is available
Configure deep sleep	Edit `/etc/systemd/sleep.conf`	Sets S3 as the default
NVIDIA resume fix	Add `nvidia.NVreg_PreserveVideoMemoryAllocations=1` in GRUB	Prevents black screen after resume
MSI/ASUS ACPI tweak	Add `acpi_osi=! acpi_osi="Windows 2020"` in GRUB	Improves suspend/resume on some laptops
Apply changes	`sudo reboot`	Reboot to apply settings
Test suspend	`systemctl suspend`	Puts the system into configured suspend state

🚀 Final Thoughts

By enabling deep sleep, you ensure your Fedora system consumes less power when suspended. If you’re on NVIDIA hardware, the extra kernel option makes suspend/resume more reliable. On MSI/ASUS laptops, the acpi_osi="Windows 2020" tweak can further stabilize wake-up.

Together, these tweaks give you cooler standby, longer battery life, and a more stable wake-up experience.

⚙️ Dual GPU Setup on Fedora: NVIDIA + Intel (Optimus) with Offloading

Kamran Khan — Wed, 16 Jul 2025 01:17:47 +0000

If you're running Fedora on a laptop with NVIDIA + Intel hybrid graphics (like most modern laptops with Optimus), you're in luck — Fedora makes it easy to use GPU offloading, giving you the best of both worlds: power efficiency with Intel and performance with NVIDIA when needed.

In this guide, you'll learn how to:

✅ Install NVIDIA drivers with offloading support on Fedora
⚙️ Run any app using the NVIDIA GPU on demand
🛠️ Create a helper script and launcher to make offloading seamless
🔁 (Optional) Switch to full-time NVIDIA mode for gaming laptops

🎯 What is NVIDIA Offloading?

NVIDIA Offloading allows you to use the Intel GPU as the default (great for battery life), but launch specific apps — like Steam, Blender, or Firefox — on the NVIDIA GPU for better performance.

Unlike Windows' automatic switching with Optimus, Linux uses explicit offloading — but it’s easy and powerful when configured right.

✅ Step 1: Enable RPM Fusion

First, enable RPM Fusion repositories (Free + Non-Free) to get access to proprietary NVIDIA drivers:

sudo dnf install \
  https://download1.rpmfusion.org/free/fedora/rpmfusion-free-release-$(rpm -E %fedora).noarch.rpm \
  https://download1.rpmfusion.org/nonfree/fedora/rpmfusion-nonfree-release-$(rpm -E %fedora).noarch.rpm

✅ Step 2: Install NVIDIA Drivers with Optimus Support

Update your system and install the required NVIDIA driver packages:

sudo dnf update --refresh
sudo dnf install akmod-nvidia xorg-x11-drv-nvidia-cuda

If you need 32-bit support (for Steam, Wine, etc.):

sudo dnf install xorg-x11-drv-nvidia-libs.i686

✅ Step 3: Verify Intel is the Default GPU

Fedora (with X11) uses Intel as the default renderer automatically.

To confirm:

glxinfo | grep "OpenGL renderer"

You should see something like:

OpenGL renderer string: Mesa Intel(R) UHD Graphics ...

✅ Step 4: Run Apps with NVIDIA Offloading

You can offload any app to the NVIDIA GPU using this command format:

__NV_PRIME_RENDER_OFFLOAD=1 __GLX_VENDOR_LIBRARY_NAME=nvidia <your-app>

Example:

__NV_PRIME_RENDER_OFFLOAD=1 __GLX_VENDOR_LIBRARY_NAME=nvidia firefox

To verify:

glxinfo | grep "OpenGL renderer"

It should now say something like:

OpenGL renderer string: NVIDIA GeForce RTX 3050 ...

✅ Step 5: Confirm with `nvidia-smi`

Want to make sure the NVIDIA GPU is active?

nvidia-smi

You’ll see the process listed if it’s using the GPU.

🔄 Bonus: Make It Seamless with a Helper Script

Let’s make offloading as easy as typing nvidia-run <app>.

🔹 Create the Script

mkdir -p ~/.local/bin
nano ~/.local/bin/nvidia-run

Paste the following:

#!/bin/bash
__NV_PRIME_RENDER_OFFLOAD=1 __GLX_VENDOR_LIBRARY_NAME=nvidia "$@"

Make it executable:

chmod +x ~/.local/bin/nvidia-run

Add to PATH (if not already):

echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc
source ~/.bashrc

🔹 Use It Like This:

nvidia-run blender
nvidia-run code
nvidia-run steam

🖥️ Optional: Create App Launchers

Want to launch apps from GNOME or KDE menu using NVIDIA?

Create a .desktop file:

[Desktop Entry]
Name=Blender (NVIDIA)
Exec=nvidia-run blender
Type=Application
Categories=Graphics;

Save it to:

~/.local/share/applications/blender-nvidia.desktop

This will now appear in your app launcher.

🔒 Secure Boot Note

NVIDIA kernel modules are unsigned, so Secure Boot will block them by default.

You can either:

Disable Secure Boot in your BIOS, or
Use MOK (Machine Owner Key) to sign and enroll the NVIDIA module (more complex).

🔋 Want Full-Time NVIDIA Mode?

You can switch your system to always use NVIDIA for everything (great for gaming, not so much for battery life), but it requires:

Setting NVIDIA as the primary GPU
Using Xorg configs or kernel parameters

Let me know in the comments if you want a full guide on that!

📌 TL;DR Cheatsheet

Task	Command Example	Description
Run app on NVIDIA GPU	`nvidia-run <app>`	Offloads app to NVIDIA GPU
Check GPU used	`glxinfo > temp && grep "OpenGL renderer" temp` or `nvidia-smi`	Shows whether Intel or NVIDIA is being used
Confirm Intel is default	`glxinfo > temp && grep "OpenGL renderer" temp`	Should show "Mesa Intel..." as the renderer
Create launcher	`.desktop` file with `Exec=nvidia-run your-app`	Launch app with NVIDIA from desktop environment

🚀 Final Thoughts

Fedora makes hybrid GPU support smooth and developer-friendly. With just a few commands and a tiny helper script, you can run games, Blender, Steam, or CUDA tools using the power of NVIDIA — while keeping Intel as the default for efficiency.

Have questions or want help creating .desktop entries for your apps? Drop a comment!

How to create a responsive image gallery without using media queries

Kamran Khan — Fri, 28 Oct 2022 19:23:38 +0000

In this article I'll teach you how to use CSS Grid to create a super cool image grid, which varies the amount of columns with the width of the screen.
And the most beautiful part: the responsiveness will be added with a single line of CSS.
This means we don't have to clutter up the HTML with ugly class names (i.e. col-sm-4, col-md-8) Or create media queries for every single screen size.
Now let's jump into it!

The setup

For this article, we'll add the images at the end of the article. Here's how our initial grid looks:

Here's the HTML:

<div class="container">
  <div>1</div>
  <div>2</div>
  <div>3</div>
  <div>4</div>
  <div>5</div>
  <div>6</div>
</div>

And the CSS:

.container {
    display: grid;
    grid-template-columns: 100px 100px 100px;
    grid-template-rows: 50px 50px;
}

Note: the example also has a little bit of basic styling, which I won't go into here, as it's got nothing to do with CSS Grid.
Let's start by making the columns responsive.

Basic responsiveness with the fraction unit

CSS Grid brings with it a whole new value called a fraction unit. The fraction unit is written like fr, and it allows you to split the container into as many fractions as you want.
Let's change each of the columns to be one fraction unit wide.

.container {
    display: grid;
    grid-template-columns: 1fr 1fr 1fr;
    grid-template-rows: 50px 50px;
}

What happens here is that the grid splits the entire width into three fractions and each of the columns take up one unit each. Here is the result:

If we change the grid-template-columns value to1fr 2fr 1fr, the second column will now be twice as wide as the two other columns. The total width is now four fraction units, and the second one takes up two of them, while the others take up one each. Here's how that looks:

In other words, the fraction unit value makes it super easy for you to change the width of the columns.

Advanced responsiveness

However, the example above doesn't give us the responsiveness we want, as this grid will always be three columns wide. We want our grid to vary the amount of columns with the width of the container. To achieve that, you'll have to learn three new concepts.

repeat()

We'll start with the repeat() function. This is a more powerful way of specifying your columns and rows. Let's take our original grid and change it to using repeat():

.container {
    display: grid;
    grid-template-columns: repeat(3, 100px);
    grid-template-rows: repeat(2, 50px);
}

In other words, repeat(3, 100px) is identical to 100px 100px 100px. The first parameter specified how many columns or rows you want, and the second specifies their width, so this will just give us the exact same layout as we started out with:

auto-fit

Then there's auto-fit. Let's skip having a fixed amount of columns, and rather replace 3 with auto-fit.

.container {
    display: grid;
    grid-gap: 5px;
    grid-template-columns: repeat(auto-fit, 100px);
    grid-template-rows: repeat(2, 100px);
}

This results in the following behaviour:

The grid now varies the amount of columns with the width of the container.

It simply tries to fit as many 100px wide columns into the container as possible.

However, if we hard code all columns to be exactly 100px, we'll never get the flexibility we want, as they'll rarely add up to the full width. As you can see on the gif above, the grid often leaves white space on the right hand side.

minmax()

The final ingredient we need in order to fix this is called minmax(). We'll simply replace 100px with minmax(100px, 1fr). Here's the final CSS.

.container {
    display: grid;
    grid-gap: 5px;
    grid-template-columns: repeat(auto-fit, minmax(100px, 1fr));
    grid-template-rows: repeat(2, 100px);
}

Notice that all the responsiveness happens in a single line of CSS.
This results in the following behavior:

And as you can see that works perfectly. The minmax() function defines a size range greater than or equal to min and less than or equal to max.
So the columns will now always be at least 100px. However if there are more available space, the grid will simply distribute this equally to each of the columns, as the columns turn into a fraction unit instead of 100 px.

Adding the images

Now the final step is to add the images. This has nothing to do with CSS Grid, but let's still look at the code.
We'll start off by adding an image tag inside of each of the grid items.

<div><img src="img/forest.jpg"/></div>

To make the image fit into the item, we'll set the it to be as wide and tall as the item itself, and then use object-fit: cover;. This will make the image cover its entire container, and the browser will crop it if it's needed.

.container > div > img {
    width: 100%;
    height: 100%;
    object-fit: cover;
}

Which ends up like the following:

And that's it! You now know one of the most complex concepts in CSS Grid, so give yourself a pat on the back.
Thanks for reading! My name is Kamran Khan. Follow me on Twitter and Instagram if you want to keep in touch.

DEV Community: Kamran Khan

From API Beginner to Architect: How to Design Scalable APIs (Without the Headache!)

The Goal: The CineStream API

Step 1: Enforce Rules with Types (Schemas)

Step 2: Create Blueprints with Resource Types

Step 3: Make Templates Dynamic with Parameters

Step 4: Tidy Up with !includes

Step 5: Add "Plug-in" Features with Traits

Step 6: Handling File Uploads

Memory Hack: The S.R.I.T. Method

Wrap-up

How to Design Your First API with RAML (Without Losing Your Mind!)

Why RAML?

Step 1: Start with the Root

Step 2: Add Resources

Step 3: Define Methods

Step 4: URI Parameters

Step 5: Query Parameters

Step 6: Responses

Memory Hack

Wrap-up

🔧 How to Auto-Mount Partitions Without Password in Fedora and Access Them in File Manager

🧭 Step 1: Identify Your Partition

🛠️ Step 2: Choose Your Mount Method

✅ Option 1: Mount Under /mnt (Clean System Layout)

1. Create Mount Point

2. Edit /etc/fstab

3. Mount Immediately

4. Add GUI Shortcut (Optional)

✅ Option 2: Mount Under /media (Visible in GNOME Files Sidebar)

1. Create Mount Point

2. Edit /etc/fstab

3. Mount:

🔑 Step 3: Set Permissions (Optional)

✨ Optional: Change Partition Label

🧹 To Undo or Remove

✅ Summary

💡 Pro Tip

😴 Get Deeper Sleep on Fedora: Optimizing Suspend-to-RAM

🎯 What is "Deep Sleep" (S3 Suspend)?

✅ Step 1: Verify "Deep Sleep" Support

✅ Step 2: Configure Fedora for "Deep Sleep"

🟢 Step 3 (Optional, NVIDIA users): Add GPU Resume Fix

🟠 Step 4 (Optional, MSI/ASUS laptops): ACPI Compatibility Tweak

🔒 Understanding Sleep States (Briefly)

📌 TL;DR Cheatsheet

🚀 Final Thoughts

⚙️ Dual GPU Setup on Fedora: NVIDIA + Intel (Optimus) with Offloading

🎯 What is NVIDIA Offloading?

✅ Step 1: Enable RPM Fusion

✅ Step 2: Install NVIDIA Drivers with Optimus Support

✅ Step 3: Verify Intel is the Default GPU

✅ Step 4: Run Apps with NVIDIA Offloading

Example:

✅ Step 5: Confirm with nvidia-smi

🔄 Bonus: Make It Seamless with a Helper Script

🔹 Create the Script

🔹 Use It Like This:

🖥️ Optional: Create App Launchers

🔒 Secure Boot Note

🔋 Want Full-Time NVIDIA Mode?

📌 TL;DR Cheatsheet

🚀 Final Thoughts

How to create a responsive image gallery without using media queries

The setup

Basic responsiveness with the fraction unit

Advanced responsiveness

repeat()

auto-fit

minmax()

Adding the images

✅ Option 1: Mount Under `/mnt` (Clean System Layout)

2. Edit `/etc/fstab`

✅ Option 2: Mount Under `/media` (Visible in GNOME Files Sidebar)

2. Edit `/etc/fstab`

✅ Step 5: Confirm with `nvidia-smi`