DEV Community: A.S Nasseri

Handle Browser Storage Like a Pro with Kando (2KB Magic!)

A.S Nasseri — Mon, 28 Apr 2025 05:42:57 +0000

Managing localStorage and sessionStorage should be simple, lightweight, and powerful not bloated or painful.
That's why I built Kando, a tiny (just ~2KB gzipped!) JavaScript library that gives you next-level control over browser storage with support for expiration times, deep nested objects, arrays, and TypeScript types.

No more writing repetitive boilerplate or worrying about browser quirks Kando handles it for you!

Why Kando?

Ultra lightweight: ~2KB gzipped
Deep object and array support: access nested keys easily
Session expiration: automatic expiry for sessionStorage items
Fallback ready: works even if storage is unavailable
TypeScript support: fully typed out of the box
Zero dependencies: pure and clean JavaScript
Open source and easy to extend

Installation

Node.js:

npm install kando-storage

Browser:

<script src="path/to/kando.js"></script>

Quick Examples

Node.js

const kando = require('kando-storage');

// Set a nested value
kando('local.user.name', 'John Doe');

// Get a nested value
const userName = kando('local.user.name');
console.log(userName); // John Doe

// Remove a value
kando('local.user.name', null);

// Session storage with expiration (in seconds)
kando('session.auth.token', 'abcd1234', 3600); // Expires in 1 hour

Advanced Examples

// Store a namespaced object with arrays
kando('local.appConfig', {
  theme: 'dark',
  languages: ['en', 'es', 'fr'],
  settings: { notifications: true, autoSave: false },
});

// Access nested array item
const languages = kando('local.appConfig.languages'); // ['en', 'es', 'fr']

// Update a setting within the nested object
kando('local.appConfig.settings.notifications', false);

// Add a new language to the languages array
kando('local.appConfig.languages[3]', 'de'); // ['en', 'es', 'fr', 'de']

Features You’ll Love

Deep Access:

kando('local.cart.items[0].name', 'Laptop');

Safe Expiration Handling: If a sessionStorage item expires, Kando automatically cleans it up for you.
Simple Deletion:

kando('local.settings.theme', null); // Deletes the theme

TypeScript Friendly: With provided .d.ts, you get full intellisense and stricter types while coding!

Why I Built Kando

Most storage utilities are either too heavy, too opinionated, or lack expiration support.
I wanted something minimal but smart enough for real-world applications, with deep nested paths and auto-cleanups built-in.

Thus, Kando was born: a "small but mighty" helper to make storage elegant again.

Get Involved

GitHub Repository: Kando
Star it if you like it contributions and feedback are super welcome!

Final Thoughts

If you're tired of bloated libraries for simple storage needs give Kando a try.
It’s tiny, powerful, and built with developer happiness in mind.

Let’s make browser storage simple again!

Fanos: The Ultimate Beacon API Wrapper for Reliable Data Transmission

A.S Nasseri — Tue, 25 Feb 2025 06:16:05 +0000

Sending data asynchronously in web applications can be tricky, especially when you need reliability without blocking the main thread. Meet Fanos, a lightweight JavaScript library that simplifies sending asynchronous requests using the Beacon API with a fallback to Fetch for maximum reliability.

Whether you're building analytics, logging systems, or tracking user interactions, Fanos ensures your data is transmitted efficiently and reliably, even in challenging network conditions.

Non-blocking requests: Uses the Beacon API for asynchronous data transmission.
Automatic retries: Stores failed requests and retries them automatically.
Fetch fallback: Falls back to the Fetch API if Beacon isn’t supported.
Multiple payload formats: Supports JSON, FormData, Blobs, and more.
Debug mode: Logs internal operations for easy troubleshooting.

Install

Install Fanos via npm:

npm install fanos

Or include it directly in your HTML:

<script src="https://cdn.jsdelivr.net/npm/fanos@latest/dist/fanos.umd.min.js"></script>

Basic Usage

Here’s how to get started in just a few lines of code:

import Fanos from 'fanos';

// Configure the global instance
Fanos.configure({
    url: 'https://example.com/api/log', // Your endpoint
    debug: true, // Enable debug logging
});

// Send a simple payload
Fanos.send({ event: 'click', timestamp: Date.now() })
    .then(() => console.log('Data sent successfully!'))
    .catch(err => console.error('Failed to send data:', err));

Browser Support

Fanos works in all modern browsers:

Chrome
Firefox
Safari
Edge

For older browsers, enable the Fetch fallback:

Fanos.configure({ fallbackToFetch: true });

Get Started Today!

Ready to simplify your data transmission? Check out the Fanos GitHub repository for more details, examples, and documentation.Give it a START or contribute if you like it.

Encode and Decode in JavaScript Using Base64Plus

A.S Nasseri — Tue, 04 Feb 2025 04:31:41 +0000

If you've ever worked with Base64 encoding and decoding in JavaScript, you know how essential it is for handling data like images, files, or API responses. However, the native JavaScript functions (btoa and atob) can sometimes feel limiting, especially when dealing with special characters or non-ASCII strings. Enter Base64Plus a lightweight and efficient npm package that simplifies Base64 encoding and decoding while addressing common pain points.

Why Choose Base64Plus?

Unicode Support: Handles multi-byte characters seamlessly, ensuring accurate encoding and decoding of Unicode strings.
Cross-Platform Compatibility: Works effortlessly in both Node.js and browser environments.
TypeScript Ready: Fully typed, making it ideal for modern JavaScript and TypeScript projects.
No Dependencies: Lightweight with zero external dependencies.

You can install Base64Plus using npm:

npm install base64plus

Alternatively, include it directly in your HTML via a CDN:

<script src="base64Plus.umd.js"></script>
<script>
  console.log(Base64Plus.encode("Hello, World!"));
</script>

In Node.js (CommonJS):

const Base64Plus = require('base64plus');

const originalText = "Hello, World!";
const encodedText = Base64Plus.encode(originalText);
console.log(encodedText); // Outputs: Base64 string

const decodedText = Base64Plus.decode(encodedText);
console.log(decodedText); // Outputs: "Hello, World!"

In ES Modules:

import Base64Plus from 'base64plus';

const originalText = "こんにちは";
const encodedText = Base64Plus.encode(originalText);
console.log(encodedText); // Outputs: Base64 string

const decodedText = Base64Plus.decode(encodedText);
console.log(decodedText); // Outputs: "こんにちは"

Conclusion

Base64Plus simplifies the process of encoding and decoding Base64, especially when dealing with Unicode characters. Its versatility across different environments and support for modern development practices make it a valuable tool for developers. For more information and to access the source code, visit the Base64Plus GitHub repository.

Animate Adding Items to Your Cart with cartflow, A Lightweight JavaScript Library

A.S Nasseri — Wed, 29 Jan 2025 07:55:52 +0000

The user experience on e-commerce sites is often enhanced by small visual effects. One such effect is animating the transition of an item to the shopping cart, which adds a dynamic touch to the process. cartflow is a lightweight JavaScript library that does just that animating the smooth movement of items to the cart.

What is cartflow?

cartflow is a modern and minimalistic JavaScript library designed to animate items being added to a shopping cart. It provides a smooth "fly-to-cart" effect, helping to visualize the process for users as items move seamlessly to the cart.

Key Features:

Smooth animations for "Add to Cart" interactions.
Customizable configuration for various options (duration, easing, shake effect).
Optional sound effect to enhance the animation.
Cart shake effect for added visual feedback after adding an item.
Fallback mechanism for GSAP (for animation).
Works in modern browsers and Node.js.

Installation and Usage:

You can install cartflow via npm or include it directly in your HTML. Here’s how:

Using npm:

npm install cartflow

Using a <script> tag (for browsers):

<script src="CartFlow.js"></script>

See CartFlow in action here: Live Demo

Once installed, here’s a quick example of how to use it:

import CartFlow from 'cartflow';

const animation = new CartFlow({
    cartSelector: ".shopping-cart",        // Selector for the cart element
    buttonSelector: ".add-to-cart",        // Selector for the add-to-cart buttons
    soundEffect: "click-sound.mp3",        // Optional sound effect
    onComplete: (item) => {
        console.log("Item successfully added to cart!", item);
    },
    onCartShake: (cart) => {
        console.log("Cart shake effect completed!", cart);
    }
});

Customizable Configuration Options:

cartSelector: CSS selector for the cart element.
buttonSelector: CSS selector for the add-to-cart buttons.
animationDuration: Duration of the animation (in milliseconds).
easing: Easing function for the animation.
shakeEffect: Enable or disable the shake effect after adding an item.
soundEffect: URL or Audio object for an optional sound effect.

Why Use cartflow?

Easy Integration: With minimal setup and simple configuration, cartflow is a breeze to implement in your project.
Lightweight: It’s a small and efficient library, ensuring it won’t slow down your site.
Enhanced User Experience: The smooth animation and optional effects (like sound and shake) provide users with immediate feedback, making the shopping experience feel more dynamic.
Customizable: Tailor the animation speed, easing, and sound effects to fit your site’s design and user experience.

Conclusion:

For developers looking to add a smooth and visually appealing "add to cart" animation to their e-commerce site, cartflow is an excellent choice. It's simple, customizable, and helps improve user engagement without complex setup.

Check out the GitHub repository to get started and add a little magic to your shopping cart!

10 Hilarious Coding Memes That Only Developers Will Get

A.S Nasseri — Sun, 19 Jan 2025 04:58:24 +0000

If you’ve ever spent late nights debugging code, accidentally pushed to production, or wondered why your code isn’t working only to realize you missed a semicolon, you’ll love these memes. Here are 10 hilarious coding memes that perfectly capture the highs, lows, and laughs of being a developer. Humor plays a crucial role in the developer community by helping us cope with challenges and celebrate our shared experiences.

1. The Classic Debugging Process

"Why doesn’t this work?" → "Why does this work?"

We’ve all been there—you fix one bug, only to discover the code works in ways you can’t explain. Debugging is 10% fixing errors and 90% trying to understand what you’ve done. Like that time you spent hours on a bug, only to realize you forgot to save the file before running it.

# debugging moment
x = 5
def add_one(num):
    return num + 1

print(add_one(x)) # Did I save the file before running?

2. When the Code Finally Works

"It’s not a bug, it’s a feature!"

That sweet moment when you stop fixing the bug and convince the client it was meant to be like this all along.

3. Git: The Source of Truth and Anxiety

"When you accidentally git push to production."

The calm before the storm: 0.01 seconds after hitting enter, you realize you’ve made a huge mistake.

4. The Joys of Naming Variables

"Me: Names variable x... Future me: What does x even mean?"

Naming things is one of the two hardest problems in computer science. The other? Cache invalidation.

5. Hello, World!

"First day of coding: Prints Hello, World!. Feels like a genius."

Every programmer’s first victory. It doesn’t matter how small, you’ll never forget that first console.log success.

console.log('Hello, World!');

6. Stack Overflow to the Rescue

"When you copy-paste from Stack Overflow and it works on the first try."

Every developer’s secret weapon: Stack Overflow. Who needs to memorize syntax when you have this lifesaver?

7. The "Works on My Machine" Excuse

"It works on my machine. Not my problem."

Deploying your code only to find out it breaks everything for everyone else. Classic.

8. Tabs vs Spaces War

"Tabs are better! No, spaces are better!"

The debate that has torn the programming world apart for years. Developers argue about tabs vs. spaces because it reflects personal coding style, team preferences, and even IDE configurations. Where do you stand?

9. Deadline Panic

"Two days before the deadline: Let’s rewrite everything."

Because nothing says "productive" like a last-minute rewrite that you’ll probably regret.

10. Infinite Loops

"When you write an infinite loop and wonder why your program is stuck."

We’ve all done it. Sometimes, the bug is just you forgetting a break.

#include <stdio.h>

int main() {
    int i = 0;
    while (1) {
        printf("Loop iteration: %d
", i);
        i++;
        if (i == 5) {
            break;
        }
    }
    return 0;
}

Laughter is the Best Debugger

Coding can be stressful, but a good laugh can remind you why you love programming. Humor helps break the monotony of debugging for hours, softens the blow of unexpected errors, and brings teams together during tight deadlines. Which of these memes made you laugh the most? Let me know in the comments or share your favorite coding meme below!

Happy coding!

Top 5 Mistakes Junior Developers Make

A.S Nasseri — Thu, 16 Jan 2025 19:28:30 +0000

Starting your journey as a developer is exciting, but let’s be real—it can feel overwhelming at times. Mistakes are part of the process (we’ve all been there!). However, some mistakes can slow you down more than others. In this post, I’ll share the top 5 mistakes junior developers make and how you can dodge them like a pro. 🚀

1. Not Asking for Help

Picture this: you’re stuck on a problem, and instead of asking for help, you spend hours trying to solve it. Sound familiar? While being resourceful is great, spending too much time stuck can leave you frustrated and behind schedule.

🛠 How to Avoid It:

Spend some time (30 minutes) researching or debugging, then ask for help if needed.
Start by asking teammates or mentors—they’ve likely faced similar issues.
Remember: It’s better to ask and learn than to stay stuck.

2. Skipping Code Comments and Documentation

Ever revisit your code after a week and think, “What does this do again?” Trust me, future you (and your teammates) will thank you for good comments and documentation.

🛠 How to Avoid It:

Add short, meaningful comments where needed (not for every single line).
Use tools like JSDoc or Swagger to create consistent documentation.
Think about writing code like telling a story—would someone new understand it?

3. Focusing Too Much on Fancy Tools

Frameworks and libraries are cool, but diving into them without a solid understanding of the basics is a recipe for confusion. Imagine building a house without knowing how to use a hammer.

🛠 How to Avoid It:

Nail down the core language first (learn JavaScript before React).
Ask yourself: Do I understand how this works under the hood?
Learn one tool at a time—don’t try to master everything at once.

4. Being Afraid of Making Mistakes

It’s natural to feel nervous about breaking something, but avoiding mistakes altogether will stop you from growing. Fun fact: Even senior developers mess up (and that’s why Git exists).

🛠 How to Avoid It:

Use Git for version control so mistakes are reversible.
Test your code often and early—it’s better to find bugs locally than in production!
Remember, every mistake you make is a lesson learned.

5. Neglecting Communication Skills

Coding isn’t a one-person job—you’ll often need to explain your work to others. Poor communication can lead to misunderstandings, slower progress, or even conflicts.

🛠 How to Avoid It:

Practice explaining your code to someone without technical knowledge.
Keep your team updated about progress, blockers, and ideas.
Be open to feedback—it’s how you’ll grow.

Final Thoughts

Mistakes are normal (and even helpful), but avoiding these common ones will save you a lot of headaches as a junior developer. Focus on improving a little every day, and don’t forget to enjoy the process!

What’s a mistake you made early in your career? Let’s share and learn together in the comments!

10 Things I Wish I Knew Before Starting Web Development

A.S Nasseri — Thu, 16 Jan 2025 19:11:33 +0000

Starting your journey as a web developer can be both exciting and overwhelming. Like many beginners, I dove in headfirst, learning through trial and error. In hindsight, there are several things I wish I had known before I started. Hopefully, these insights can make your journey a little smoother.

1. HTML and CSS Are Deeper Than They Seem

HTML and CSS may look simple at first glance, but mastering them takes time. Semantic HTML, accessibility (a11y), and responsive design are essential skills often overlooked in beginner tutorials. Don’t rush through them—they form the foundation of everything you build.

2. JavaScript Is Everywhere

Learning JavaScript is non-negotiable for modern web development. It’s not just for adding interactive elements; it powers frameworks like React, backend environments like Node.js, and even mobile apps with tools like React Native. Get comfortable with vanilla JavaScript before diving into frameworks.

3. Frameworks and Libraries Aren’t Magic

Frameworks like React, Angular, and Vue can make development faster, but they come with a learning curve. More importantly, they aren’t a substitute for understanding core web development principles. Learn the basics before you rely on a framework.

4. Version Control Is a Lifesaver

I wish I had started using Git and GitHub sooner. Version control allows you to track changes, collaborate with others, and roll back to previous versions when things go wrong. Don’t wait until your first job to learn it—it’s an invaluable skill for personal projects too.

5. The Browser Is Your Best Friend

Modern browsers like Chrome and Firefox come with powerful developer tools. Inspect elements, debug JavaScript, and monitor network activity right in your browser. Learning to use these tools effectively can save you countless hours.

6. Responsive Design Is a Must

With the variety of devices people use to access the web, making your websites mobile-friendly is essential. Learn about media queries, flexible layouts, and tools like CSS Grid and Flexbox. Testing on different screen sizes should become a habit.

7. You Don’t Need to Learn Everything at Once

Web development is a vast field, and it’s easy to feel overwhelmed. Focus on one thing at a time. Start with HTML, CSS, and JavaScript. Once you’re comfortable, branch out into backend development, frameworks, or other specialized areas.

8. Accessibility Matters

Accessibility isn’t just a nice-to-have; it’s crucial. Learn about ARIA roles, semantic HTML, and testing tools like Lighthouse or WAVE. Building accessible websites not only widens your audience but also makes you a more responsible developer.

9. Soft Skills Are Just as Important

Coding is only part of the job. Communication, problem-solving, and teamwork are equally important, especially when working on collaborative projects. Don’t underestimate the value of clear documentation and the ability to explain your code to others.

10. You’ll Never Stop Learning

Web development evolves quickly. There will always be new languages, frameworks, and tools to learn. Instead of trying to keep up with everything, focus on building a strong foundation and staying curious. The ability to adapt is more valuable than knowing every trend.

Final Thoughts

Web development is a rewarding journey, but it’s also full of challenges. By focusing on the fundamentals, embracing lifelong learning, and staying patient with yourself, you can avoid some of the pitfalls I encountered. Remember, every expert was once a beginner. Enjoy the process, and happy coding!

What lessons have you learned in your web development journey? Share them in the comments below!

What I Learned After Coding for 24 Hours Straight

A.S Nasseri — Sun, 12 Jan 2025 16:55:36 +0000

Let me start by saying: coding for 24 hours straight is not for the faint of heart. Whether you’re pulling an all-nighter to meet a deadline, participating in a hackathon, or just testing your limits, it’s an intense experience that pushes you mentally and physically. I recently embarked on this journey, and it taught me a lot about myself, my coding habits, and the importance of balance. Here are the biggest lessons I took away from my 24-hour coding marathon.

1. Preparation is Key

Before I started, I made sure to:

Outline a clear plan: I broke down the tasks into manageable chunks.
Gather supplies: snacks, water, and caffeine were essential.
Set up a comfortable workspace: having a proper desk, chair, and lighting made a huge difference.

Takeaway: Preparation can save you time and energy. Spend a bit of time upfront planning so you don’t waste hours later.

2. Your Brain Has Limits

Around the 8-hour mark, I started noticing diminishing returns. Tasks that should have been simple took twice as long, and debugging became a frustrating process.

Takeaway: Cognitive fatigue is real. Even if you’re passionate about your work, your brain needs rest to perform at its best.

3. Breaks Are Non-Negotiable

I initially thought I’d power through with minimal breaks, but by hour 10, I realized that stepping away from the screen was essential. A quick 10-minute walk or stretching session every couple of hours worked wonders.

Takeaway: Breaks boost productivity. They help reset your mind and prevent burnout.

4. Sleep Deprivation Impacts Your Code

By the 16th hour, I introduced several bugs into my project—simple mistakes I wouldn’t normally make. Lack of sleep clouded my judgment, and I spent more time fixing errors than making progress.

Takeaway: Sleep is critical. If you’re sleep-deprived, your efficiency and code quality suffer.

5. Caffeine Isn’t a Solution

While coffee kept me awake, it didn’t keep me focused. After my third cup, I felt jittery and anxious, which made concentrating even harder.

Takeaway: Use caffeine sparingly. Don’t rely on it to push through exhaustion.

6. Collaboration Makes a Difference

During my marathon, I reached out to a friend for help with a tricky problem. Their fresh perspective saved me hours of frustration.

Takeaway: Don’t hesitate to ask for help. A second pair of eyes can spot things you’ve missed.

7. Tools Matter

Having the right tools and shortcuts made coding much easier. For example, using a linter and auto-formatting tools helped me maintain clean code even when I was tired.

Takeaway: Invest time in setting up your tools. They’ll save you time and effort in the long run.

8. The Importance of Balance

By the end of the 24 hours, I was proud of what I’d accomplished, but I also recognized that this isn’t sustainable. Pushing yourself occasionally can be rewarding, but it’s not a healthy long-term habit.

Takeaway: Balance is essential. Know when to push your limits and when to rest.

Conclusion

Coding for 24 hours straight taught me valuable lessons about productivity, focus, and self-care. While it’s an experience I’ll never forget, it also reminded me of the importance of rest and balance. If you’re considering a similar challenge, plan carefully, take breaks, and don’t forget to prioritize your health.

Have you ever coded for an extended period? What lessons did you learn? Share your experiences in the comments!

The Hidden Bug That Crashed a Satellite: Lessons for Every Developer 🚀

A.S Nasseri — Fri, 10 Jan 2025 17:51:30 +0000

In 1996, the European Space Agency’s Ariane 5 Flight 501 met a fiery end just 40 seconds after launch—all because of a tiny numeric conversion bug. This catastrophic failure, caused by a 64-bit floating-point number overflowing when converted to a 16-bit integer, destroyed a $500 million mission.

What can developers learn from this? Let’s explore practical lessons, with examples from my own open-source PHP repositories.

Lessons from Ariane 5 (and How They Apply to Your Code)

1. Reusing Code? Validate the Context

The Ariane 5 reused code from Ariane 4 without considering the new rocket’s higher speeds. This assumption caused the fatal bug.

💡 In your projects, when reusing code, always validate it against new use cases. For example, in my Laravel Encoder, which encodes and decodes IDs and strings, I included standalone support to ensure it works in different contexts—not just Laravel-based projects.

2. Test for Edge Cases

The bug wasn’t detected because it only occurred at high velocities. Edge-case testing could have saved the mission.

💡 When handling unexpected scenarios, tools like my PHP Flash Message ensure smooth feedback in any framework. Testing its integration across frameworks uncovered edge cases I hadn’t initially considered.

3. Handle Numbers with Precision

The Ariane 5 bug involved converting a large number that exceeded its type's limits. This shows why type safety and precision are crucial in programming.

💡 In apps that process large datasets or files, my Filesize Handler avoids such pitfalls by safely formatting file sizes from local, remote, or cloud sources. It demonstrates how to handle diverse environments without breaking.

Final Thoughts

The Ariane 5 disaster reminds us that small bugs can have massive consequences. Whether you're building rockets or PHP libraries, the principles remain the same:

Reuse with caution.
Test thoroughly.
Prioritize precision and resilience.

Want to dive deeper into the Ariane 5 story? Check out these resources:

ESA’s Report on the Ariane 5 Failure
Detailed Analysis by John L. Lions

Let’s learn from the past and write better code. What’s the trickiest bug you’ve tackled? Share in the comments—and feel free to explore my open-source repositories for ideas, contribute and give it STAR if you like it!

🚀 Supercharge Your PHP Projects with FileSizeHandler: A Flexible and Extensible File Size Utility

A.S Nasseri — Thu, 09 Jan 2025 16:40:19 +0000

Are you constantly dealing with files in your PHP projects and struggling with size calculations, storage inconsistencies, or integration with cloud platforms? Say goodbye to the hassle! Introducing FileSizeHandler, a lightweight, flexible, and extensible PHP utility that handles file sizes like a pro. Whether you're working with local files, remote URLs, or cloud storage, this library has got you covered.

In this post, we’ll explore what makes FileSizeHandler a must-have library for your PHP projects and how to leverage its powerful features.

🔑 Why You Need FileSizeHandler

Handling file sizes is more than just reading bytes. Different systems measure file sizes differently:

Binary vs. Decimal Units: OS file systems use binary units (MiB, GiB), while storage manufacturers use decimal (MB, GB). Confusing, right?
Cross-Platform Challenges: File size interpretations vary across operating systems and storage platforms.
Cloud and Remote Files: Measuring file sizes from FTP, S3, or Google Cloud often requires additional work or APIs.

FileSizeHandler simplifies all of this by providing a unified, fluent API for file size calculations, formatting, and integrations.

✨ Features That Make It Shine

Local, Remote, FTP, and Cloud Support Fetch file sizes seamlessly from:

Local file systems
Remote HTTP/HTTPS URLs
FTP servers
Amazon S3, Google Cloud Storage, and more!

Binary and Decimal Unit Support
Switch between binary (1024-based) and decimal (1000-based) units
with a single method.
Fluent Interface
Chain methods to create clean and readable code.
Localization
Format file sizes with localized unit names (e.g., Mio, Kio) for a
better user experience.
Extensibility
Easily extend the library with custom sources for specialized file
size calculations.

🛠️ Installation

Install the library using Composer:

composer require nassiry/filesize-handler

🚀 Getting Started

Local File Example
Let’s start with the basics. Fetch the size of a local file in binary units (default):

use Nassiry\FileSizeUtility\FileSizeHandler;  

$handler = FileSizeHandler::create()  
    ->local('/path/to/your/file.txt')  
    ->baseBinary();  

echo $handler->formattedSize(); // Output: "1.23 MiB"

Switch to decimal units with just one method:

echo $handler->baseDecimal()->formattedSize(); // Output: "1.30 MB"

💡 Why Developers Love FileSizeHandler

🔧 Simplifies File Size Handling
No more juggling different APIs and libraries for local, remote, or cloud file sizes.

🌍 Extensible and Future-Proof

Adding new storage platforms is as simple as creating an extension or implementing an interface.

⚡ Lightweight and Performant

Built for speed and simplicity, with zero unnecessary bloat.

📚 Learn More

Check out the GitHub Repository for more details, documentation, and examples. and give a STAR if you like it.

Introducing Extensions

The power of FileSizeHandler doesn’t end with the core library. Take your file size handling to the next level with official extensions:
Want to see official extensions in action? Explore them below:

FTP Extension
S3 Extension
Google Cloud Extension
Remote URL Extension

🎉 Get Started Today

With FileSizeHandler, handling file sizes in PHP has never been easier. Install it, extend it, and make your projects smarter and more efficient.

Happy coding! 🚀

XAMPP vs. Laragon vs. Laravel Herd: Which One Should You Use for PHP and Laravel Projects?

A.S Nasseri — Tue, 07 Jan 2025 05:27:40 +0000

When starting a PHP or Laravel project, choosing the right local development environment is crucial. Tools like XAMPP, Laravel Herd, and Laragon offer different features and workflows tailored for developers. Each of these tools has its strengths and use cases, but which one is better for your next project?

In this post, we'll explore:

What XAMPP, Laragon, and Laravel Herd are
Key features and comparisons
Which one is better suited for Laravel, PHP, and other programming languages

1. What are XAMPP, Laragon, and Laravel Herd?

XAMPP

XAMPP is one of the oldest and most popular local server environments. It includes:

Apache
MySQL (MariaDB)
PHP
Perl It’s simple to install, widely supported, and works well for generic PHP development.

Pros:

Easy setup and cross-platform (Windows, macOS, Linux).
Good for beginners learning PHP.

Cons:

Performance can be slow for large projects.
Limited modern tooling (e.g., no native SSL, Docker-like portability, etc.).

Laragon

Laragon is a modern local development environment specifically designed for Windows users. It’s lightweight, fast, and works not just with PHP but also with Node.js, Python, Ruby, and more.

Key features:

Portable and self-contained.
Supports SSL, Composer, and database management out-of-the-box.
Extremely fast startup times and customizable stacks.

Pros:

Best for Laravel and modern PHP projects.
Easy to switch PHP versions and create isolated environments.
Great performance compared to XAMPP.

Cons:

Windows-only (though WSL2 can be a workaround for Linux/macOS).

Laravel Herd

Laravel Herd is a Laravel-specific development environment created by the Laravel team for macOS users.

Key features:

Designed specifically for Laravel.
Includes Nginx, MySQL, and PHP.
Comes pre-configured with the Laravel ecosystem (like Sail, Valet).

Pros:

Best for Laravel projects.
Minimal setup for macOS users.
High performance with native macOS integration.

Cons:

Mac-only.
Limited flexibility for non-Laravel projects.

2. Comparison of Features

Feature	Xampp	Laragon	Laravel Herd
Platform	Cross-platform	Windows-only	Mac-only
Ease of Use	Beginner-friendly	Developer-friendly	Highly optimized
Laravel Focus	No	Yes	Yes
PHP Version Control	Manual setup	One-click switch	Pre-configured
SSL Support	Limited	Built-in	Built-in
Flexibility	Moderate	High	Laravel-specific
Performance	Moderate	High	High

3. Which One Should You Use?

For Laravel Projects

If you’re a macOS user, Laravel Herd is the easiest and most optimized choice for Laravel.
For Windows users, Laragon is perfect as it offers a Laravel-friendly stack with additional tools like SSL and Composer.

For General PHP Development

XAMPP is still a solid choice for beginners or those working on smaller PHP projects. However, for better performance and flexibility, consider Laragon.

For Other Programming Languages

If you work with Node.js, Python, Ruby, or other languages alongside PHP, Laragon is the most versatile option.

4. My Recommendation

For most developers:

Choose Laragon if you’re on Windows, as it’s versatile and designed for modern workflows.
Choose Laravel Herd if your primary focus is Laravel and you’re on macOS.
Stick to XAMPP only if you’re just starting out or need something very simple.

Conclusion

Choosing the right local development tool can make or break your productivity. While XAMPP has been a trusted solution for years, Laragon and Laravel Herd provide modern alternatives tailored for Laravel and other PHP projects. Ultimately, the choice depends on your operating system, your workflow, and whether you need flexibility or Laravel-specific features.

Which tool do you prefer for your projects? Let me know in the comments!

Discover Kando The Lightweight Storage Utility You Didn’t Know You Needed

A.S Nasseri — Sun, 05 Jan 2025 04:37:32 +0000

Managing data storage in web and Node.js applications can sometimes feel cumbersome, especially when dealing with localStorage or sessionStorage. Meet Kando—a versatile 2KB gzip storage utility that streamlines your storage tasks with its intuitive API.

Whether you're working on a small web app or a complex Node.js project, Kando's flexibility and developer-friendly design can make your life easier. Let's dive into why it's worth a try!

Why Use Kando?

Kando offers powerful features in a lightweight package:

Cross-Environment Support: Works in both browsers and Node.js, with a fallback to an in-memory Map if localStorage or sessionStorage is unavailable.
Namespace Management: Organize and group related data for easier retrieval and cleanup.
Nested Path Access: Use dot notation to access or update deeply nested properties.
Data Expiration: Automatically expire session data after a defined duration.
Flexible Data Handling: Easily work with single values, arrays, and objects.

Installation

Node.js

Install Kando with npm:

npm install kando-storage

Browser

Add Kando to your project using a script tag:

<script src="path/to/kando.js"></script>

Quick Examples

Here are a few examples to get you started. More advanced usage is available in the GitHub repository.

Setting and Retrieving Data

const kando = require('kando-storage');

// Store a single value
kando('local.app.theme', 'dark');

// Retrieve the value
console.log(kando('local.app.theme')); // Output: 'dark'

// Store an object
kando('local.user.profile', { name: 'Alice', age: 30 });

// Retrieve the object
console.log(kando('local.user.profile')); // Output: { name: 'Alice', age: 30 }

Clearing Data

// Remove a specific property
kando('local.user.profile.name', null);

// Clear an entire namespace
kando('local.user', null);

Session Storage with Expiration

// Store session data with a 60-second expiration
kando('session.tempData', 'Temporary', 60);

// Access it before it expires
console.log(kando('session.tempData')); // Output: 'Temporary'

// After 60 seconds, it will automatically expire

Dive Deeper into Kando

These examples only scratch the surface of what Kando can do. Check out the full README on GitHub for:

Advanced examples like handling nested paths, arrays, and namespaces.
Full API reference with parameter descriptions.
Guidance on using Kando’s fallback mechanism in Node.js environments.

Conclusion

Kando is a simple yet powerful tool to manage storage seamlessly across browsers and Node.js. Its small size, feature-rich API, and ease of use make it a must-try for developers.

Ready to simplify your storage? Get started on GitHub today! 🚀