DEV Community: Random

The Company Is Strong. So Why Are 4,000 People Gone?

Random — Sat, 28 Feb 2026 06:10:58 +0000

Going to be a rant.

We just watched a CEO tweet that they’re making their company “smaller” and not because revenue collapsed, not because the product failed, not because customers left, but because they can. Nearly half the company, over 4,000 people, gone in one move while the business is still growing, improving profitability, and serving more customers.

Read that again. This wasn’t survival mode, this was optimization mode.

The tone of the tweet was calm, transparent, even generous with severance and benefits, which somehow makes it more unsettling.

The logic was simple: intelligence tools plus flatter teams equal a new way of running a company. Faster decisions, fewer layers, more output per person. So leadership chose to act now instead of cutting slowly over years. And this is what people are missing in the AI debate. It’s not about whether AI writes better code. It’s about compression.

If a strong, profitable company can say “we need fewer people because AI changes how work gets done,” then the baseline just shifted. Layoffs used to be reactive. Now they’re proactive. “Profitable” used to mean safe.

Now it doesn’t. This isn’t framed as survival, it’s framed as restructuring for an intelligence-driven future. And once companies realize 10 people can do the work of 15, they don’t keep 15 out of kindness. They optimize for margins. That’s the uncomfortable truth.

AI isn’t just a tool inside products anymore, it’s becoming the operating system of companies. And operating systems are designed for efficiency. If this is happening while models are still early, what happens in three years? Maybe the real question isn’t whether AI replaces developers. Maybe it’s how many developers a modern company actually needs. Because once leaders decide that number is lower, they don’t drift toward it. They jump. And that jump is what we just saw.

Rant over.

Built Something Crazy This Week – Inkash

Random — Sat, 14 Feb 2026 13:45:51 +0000

Hey dev's 👋 it's me Taqui

This week I built something that actually pushed me hard.

It’s called Inkash.

Live: https://inkash.vercel.app
GitHub: https://github.com/taqui-786/inkash (Drop a Star ⭐)

Inkash is a smart link generator that compresses real data into a short shareable URL.

No database.
No backend storage.
The data lives inside the URL itself.

That was the fun part.

What Inkash Actually Does

The idea is simple:

Take user input
Compress it using the deflate algorithm
Convert it into a URL-safe string
Generate a shareable link
On load, decompress and restore the original content

So large content becomes a compact link.

When someone opens it, everything rebuilds instantly on the client.

It feels kind of crazy seeing big data turn into a short URL and still restore perfectly.

it also has markdown editor you can us

Sharing Feature:

The cool thing is,

You can generate the QR-code of the link and share it

Core Compression Logic (Simplified)

Here’s a simplified version of how compression and decompression works:

import { deflate, inflate } from "pako";

export function compressData(input: string) {
  const compressed = deflate(input);
  return btoa(
    String.fromCharCode(...compressed)
  );
}

export function decompressData(encoded: string) {
  const binary = atob(encoded);
  const bytes = Uint8Array.from(binary, (c) => c.charCodeAt(0));
  return inflate(bytes, { to: "string" });
}

Under the hood, it:

Uses the deflate algorithm to reduce payload size
Converts binary compressed data into Base64
Makes the output URL safe
Restores everything safely on load

Technical Challenges

The real challenge was not just compression.

It was making sure everything works safely inside a browser URL.

Here are some things I had to handle:

Making compressed output URL safe
Handling corrupted or invalid hashes
Respecting browser URL length limits
Preventing UI crashes during decompression
Managing edge cases with large payloads
Keeping everything fully client-side

If even one character in the URL changes, decompression can fail. So proper validation and error handling was very important.

Tech Stack

Next.js
TypeScript
Client-side compression using pako
Modern UI components
Clean and scalable architecture

There is no database involved.

The link itself is the storage.

That was the main experiment and honestly the most fun part.

What I Learned

Building Inkash taught me:

How the deflate algorithm works in real usage
Binary to Base64 transformations
URL encoding and safety concerns
Browser URL length constraints
How easy it is to break decoding
How to build something useful without a backend

This project broke many times before it became stable. But once it worked, it felt clean and kind of magical.

If you check it out, I would really love honest feedback.

What would you improve or add to something like this?

This portfolio isn’t perfect, but it’s 100% mine

Random — Sat, 24 Jan 2026 06:26:18 +0000

Hey devs 👋 its me Taqui

Just wanted to share the story behind my last portfolio.

I already had a portfolio before this. It looked cool, it worked fine, but for some reason it never felt like it was really mine. I couldn’t fully connect with it.

The truth is, my older portfolio was mostly a rebuild of chandai’s portfolio. I learned a lot from building it, especially about layout, animations, and structure. But at the end of the day, it still felt like I was wearing someone else’s design.

So I decided to start again. From zero.

This time, I made one clear rule for myself:
Build something from my own ideas, my own layout decisions, and my own taste.

I did take inspiration from other great portfolios (because that’s how we all learn), but every section, spacing choice, and interaction was designed and built by me. No copying. No rebuilding someone else’s work.

Tech stack I used:

Next.js
Tailwind CSS (mostly custom styles)
Very little shadcn/ui, only where it made sense, like the contact form
Small UI details and interactions done manually instead of relying on libraries

When you open the site, you’ll notice a subtle fade-in blur animation. That was intentional. I wanted the site to feel calm and smooth, not flashy or loud. Something that feels pleasant to scroll through.

This isn’t my first portfolio.

But it’s the first one that truly feels like *me*.

And because of that, I’m calling it my last portfolio.

I’ve attached a demo banner image above so you can get a quick idea of the look and feel.

Live URL (new portfolio):

Checkout its live 🚀

Source code:

Drop a ⭐ on Github

If you’re curious, feel free to check it out.

And if the code helps you or inspires you in any way, dropping a GitHub star would honestly mean a lot ⭐

Feedback is welcome.

Happy Show Off Saturday 🚀

I Built Everything Fast… Then One Page Destroyed My Confidence

Random — Tue, 09 Dec 2025 07:04:12 +0000

Hey buddy,

So… I built almost the whole app. Shipped every hard thing. Solved every annoying bug.

And then one single page came out of nowhere and said:

“Bro, sit down.”

Welcome to my life with Snapgroove - a tiny tool I’m building to make your screenshots look less like a cry for help. Give them shadows, gradients, device frames… all in one click. Basically: make your work look expensive without knowing design.

And guess what?

The core app is done.

Like actually done.

Editor works
Image export is smooth
All features tested
Logo and branding ready

Live here → https://snapgroove.vercel.app

But then…

The landing page happened.

And suddenly I felt like I forgot how to think.

The Fun Part: Building the Actual App

As a full-stack dev, building features is my comfort zone.

Give me logic, give me APIs, give me bugs that ruin my sleep - I will survive.

Snapgroove came together pretty fast:

A clean editor
Nice export flow
Simple UI
It’s all open-source too: taqui-786/Snapgroove

Github Repo

I even vibe-coded some layouts for the landing page.

But honestly? Everything felt too generic or too messy.

I’m just not great at design stuff. And this is the part that always slows me down on every project I make.

And yes, I know the app itself is still not perfect. It’s in beta. I’m improving it as fast as I can. But landing pages… bro… they hit different.

The Not-So-Fun Part: The Landing Page Breakdown

It’s wild how I can build a full editor in a single sitting, but a landing page will take my brain hostage for days.

I tried multiple layouts.

I tried being creative.

I even told myself, “Just ship it, nobody cares.”

But I care.

And nothing feels right.

Landing pages are weird.

You need:

Good design
Clean layout
The right words
The right vibe
Something that doesn’t scream “bro, we know you’re a developer”

And I’m still figuring that out.

What I Need Help With (Yes, You 😭)

If you’re reading this, I’d honestly love your input.

Take a quick look at the app
Tell me what confused you
Suggest what the landing page should highlight
Share any design inspo sites you use

Anything helps.

I’m a developer who’s way better at building things than selling them.

So any tips, design ideas, or copy advice… I’ll take it all.

Why I’m Even Sharing This

Because building stuff is fun.

But being stuck alone makes it harder.

And I know I’m not the only dev who can ship complex features in 2 hours but can’t pick a font for 2 weeks.

If you feel the same, you’re not alone.

We’re in the same boat, staring at Figma like it’s a final exam.

Thanks for Reading 🙏

If you have even 2 minutes, your design brain cells could save my entire project.

Drop any tips.

Share any inspo.

Tell me what looks weird.

Or just say “yo this looks clean” so I don’t cry.

App: https://snapgroove.vercel.app

Codebase: taqui-786/Snapgroove

Bun is joining Anthropic 🔥

Random — Wed, 03 Dec 2025 06:48:42 +0000

Big news - Bun is now joining Anthropic.

According to the official announcement, Anthropic acquired Bun so it can power Claude Code, the Claude Agent SDK, and future AI-dev tools.

👉 Official News

Bun - the super fast JavaScript/TypeScript runtime, bundler, package manager, and test runner — will now serve as core infrastructure for Anthropic’s developer-focused AI tools.

💠 Key points that i extracted

Bun becomes part of Anthropic’s core engineering stack
Bun will directly power Claude Code and future dev tools
Faster performance, better DX, and more stability expected
Bun stays open source
Anthropic will invest full-time engineering support into Bun
Goal: build a stronger, AI-supercharged dev workflow

What the community on Reddit is saying

Reddit thread: https://www.reddit.com/r/webdev/comments/1pch41f/bun_is_joining_anthropic/

A quick vibe check from the top comments:

“Is this the rug pull people were worried about?”
“They bought it because it’s critical infrastructure for them.”
“People are overreacting. It’s not a rug pull.”
Some users feel this is good for Bun’s long-term health
Some are worried it might become paid later (“Bun Pro”)
Others think Bun still isn’t mature enough for real-world teams

A few devs also pointed out they love Bun for:

Faster installs
Less tooling overhead
A cleaner experience than Node
Good standard library
Solid for new projects

But yep - the skepticism is still alive.

✅ Pros of the Bun x Anthropic deal

Stronger engineering support
Anthropic has the resources to make Bun more stable and production-ready.

Better dev tools powered by AI
Since Bun will power Claude Code and other AI tools, we might see faster, cleaner workflows.

Still open source
This is a big relief for many devs.

Better performance gains
Bun already has speed benefits - now with more backing, it could get even better.

⚠️ Cons & concerns from developers

Fear of monetization
A common worry: Bun might slowly drift into “Bun Pro” territory.

Corporate ownership shift
Some devs loved Bun’s indie vibe - now they’re unsure if direction will stay community-focused.

Optimized for Anthropic first
There’s a worry Bun will become tailored mainly for AI tooling, not general web development.

Maturity concerns
A few devs said Bun didn’t feel stable yet in real-world jobs.

🔥 My quick take

Honestly, this is a big move - and mostly a good one.

If Anthropic keeps Bun open-source and improves stability, we might see a new era of:

Faster dev workflows
AI-first tooling
Modern runtimes built for real projects

Still… the concerns are real.

Nobody wants to wake up one day and find half the runtime behind a paywall.

For now, I’m excited.

Let’s see how Bun grows with Anthropic behind it. 👀

That's it

What do you think is this a good deal or another free tool to be converted into paid stuff,

Let me know your honest thoughts on this in comments📩

See you in next blog, till then Happy Coding

Follow me in Github⭐

RandomFollow

I'm a self-taught Web developer who is always learning and creating cool Project stuffs.

Is Self-Taught Coding Still Worth It?

Random — Mon, 07 Jul 2025 08:02:59 +0000

So you’re broke, confused, 22, hate your job, and think learning to code will fix it all.

Hello friends it's me Md taqui imam and WELCOME to the most popular side quest of the 2020s.

You probably googled:

"How to learn to code in 3 months"
"Is self-taught coding dead?"
"Can I get a dev job with no degree and bad WiFi?"

And now you’re here, trying to figure out if teaching yourself programming is still a thing or just another internet scam like dropshipping crypto monkey NFTs.

Let’s talk 😅

✅ Yes. Self-taught coding still works.

If anyone tells you it doesn’t, they probably just failed at it and now run a bootcamp charging $10k to copy-paste ChatGPT responses into React components.

The truth is: companies still care more about what you can build than where you learned. A solid GitHub > random diploma from “Any Tech Institute.”

But no, it’s not “easy now because of AI”

Yeah yeah, you’ve seen the TikToks:

“Learn Python in 10 minutes!”

“Make $120k with just HTML and ChatGPT!”

Sure, and I can become a surgeon by watching Grey’s Anatomy.

AI is a tool, not a cheat code. It helps you learn faster, but it won’t do the learning for you. You still need to suffer through broken layouts, error messages, and existential dread like the rest of us.

What should you actually learn?

You don’t need a PhD in rocket science to start. Here’s a basic path:

HTML/CSS: Make things look not horrible.
JavaScript: Make things do stuff.
React or Next.js: Make things do stuff better.
GitHub: So you can tell employers “Look, I actually built something.”
Optional: Python + Flask/Django: If you prefer backend and chill.

That’s it. Don’t get lost in “Should I learn Rust or Go or Zig or Assembly for fun?” You’re not building a compiler, you’re building your way out of retail.

A request to senior dev's who are reading this, Can you please comment 📩 down a proper Web development roadmap for the new beginners of 2025.

Build real things. Not to-do apps.

Everyone makes a to-do app. Stop it. Build dumb but fun projects:

“Rate My Chai” — users rank local tea stalls
“Is It A Scam?” — submit WhatsApp messages for instant sussy score
“BrokenCSS” — a portfolio of your worst designs (trust me, it’s relatable)

Build stuff that you enjoy. Passion beats perfection.

Will you get a job?
Eventually, yes. But not on Day 30 of your Udemy course.

Be ready to:

Apply to 100+ jobs
Hear nothing
Doubt everything
Land one job

Suddenly feel like a genius again
This is normal. This is the grind. And yes, it’s still worth it.

Final thoughts

Self-taught devs built half the internet. The other half was built by unpaid interns and stackoverflow.com.

You don’t need permission to start. Just curiosity, caffeine, and stubbornness. So stop overthinking, pick a tutorial, and start building broken crap until it’s less broken.

And remember: The only thing worse than bad code is never writing any.

Now go. Learn. Build. Break. Repeat.
The future still belongs to those who Google error messages best.

Seeee you in next blog 👋

Happy Learning & Coding

Please take a Look 🙌

Random — Fri, 27 Jun 2025 04:59:25 +0000

I made a portfolio, Please clap 🙃

Random ・ Jun 26

#webdev #programming #javascript #opensource

JavaScript Date object is finally being replaced 😱

Random — Tue, 29 Apr 2025 10:47:53 +0000

The new Temporal API is coming to JavaScript and will make working with dates and times MUCH easier.

Hello Dev’s its me Md Taqui Imam, So let's explore the new javascript temporal Api and please don't forget to drop a "🔥❤️🦄🙌" and Follow me.

Follow me in Github⭐

🤔 What is Temporal Api ?

This new JavaScript feature makes working with dates and times easier and more reliable than the old Date object. It offers various types for handling dates, times, and durations, with many options to modify them.

Here’s why it’s a complete upgrade 🛠️:

1️⃣ Immutable objects (no more accidental mutations!)
2️⃣ Built-in timezone support without external libraries
3️⃣ Intuitive API for date arithmetic
4️⃣ Clear distinction between wall-clock time and exact time
5️⃣ First-class duration objects for time spans.

📌 How to access Temporal Api ?

Currently Temporal API can be accessed via Temporal API polyfill its you choice of using npm or yarn packages. This makes it possible for you to use Temporal even if the native support is missing, as you will see later in this document.

With NPM:

npm install @js-temporal/polyfill

With YARN:

yarn add @js-temporal/polyfill

Now Let’s See Some Examples 🔥

The code example in the image shows how much cleaner date operations become with Temporal.

1. Adding Time to a Date:

This code adds 2 hours to the current date and time, then formats it as a string.

2. Comparing Dates:

This code compares the current date and time with December 31, 2022, returning -1, 0, or 1 depending on whether the first date is before, equal to, or after the second date.

3. Creating a Date from a String:

This code creates a date object from an ISO date string and formats it as a string.

4. Subtracting Time from a Date:

This code subtracts 3 months from the current date and time, then formats it as a string.

5. Calculating the Duration Between Two Dates:

Works out how long the period between two dates is. You might use this when signing a JWT to work out how many seconds from now your expiry date is.

This code calculates the number of seconds between the current date and time and December 25, 2025

That’s it

For more examples and code reference checkout 👉 Temporal API Cheatsheet:

Who else 😅 is excited to never write “new Date()” again?

okay, see you in my next blog, till then

Happy coding.

RandomFollow

I'm a self-taught Web developer who is always learning and creating cool Project stuffs.

Have you Read this ?

Random — Fri, 20 Dec 2024 12:30:20 +0000

7 Secret UI Libraries No One Talks About 🔥

Random ・ Dec 15 '24

#webdev #javascript #programming #frontend

7 Secret UI Libraries No One Talks About 🔥

Random — Sun, 15 Dec 2024 11:14:59 +0000

Are you tired of building UI components from scratch? Let me introduce you to some amazing UI libraries that will save you tons of time and make your websites look fantastic!

These libraries offer ready-to-use components that are both beautiful and functional.

let’s Explore, And don’t forget to Follow Me in Github 🙏,

1. Lukacho UI

A minimalist and modern UI component library that focuses on clean design principles.

Checkout ✨

Key Features:

🎨 Clean and modern design aesthetic
⚡ Lightweight and performance-focused
📱 Fully responsive components
🎯 Easy integration with popular frameworks

2. HTMLRev

A comprehensive collection of HTML templates and components perfect for quick project setups.

Checkout ✨

Key Features:

🎁 Free and premium templates
💻 Cross-browser compatibility
🛠️ Easy customization options
✨ Regular updates and additions

3. HyperUI

An extensive Tailwind CSS component library that offers a wide range of pre-built elements.

Checkout ✨

Key Features:

🎯 Tailwind CSS optimized
📦 Copy-paste ready components
🎨 Customizable design tokens
💪 Production-ready code.

4. Material Tailwind Blocks

Material Tailwind PRO — Supercharge Your Development With Powerful Blocks
Beautiful material design components built with Tailwind CSS and Material Design principles.

Checkout ✨

Key Features:

🎨 Material Design aesthetics
⚡ Tailwind CSS integration
📱 Responsive by default
🔧 Easy customization

5. MagicUI Design

A magical collection of UI components with unique animations and interactions.

Checkout ✨

Key Features:

✨ Beautiful animations
🎯 Accessibility focused
🎨 Modern design patterns
💻 Developer-friendly API.

6. Aceternity UI

A next-generation UI component library with focus on modern web experiences.

Checkout ✨

Key Features:

🚀 Modern animations
📦 Ready-to-use components
🎨 Customizable themes
⚡ Optimized performance.

7. Motion Primitives

A specialized library focused on animation and motion components for web applications.

Checkout ✨

Key Features:

🎬 Advanced animation controls
⚡ Performance optimized
🎯 Easy to implement
📱 Cross-platform support.

Remember, these libraries are constantly evolving with new components and features being added regularly.

Pick the one that best matches your project needs and coding style! 🎉

And see you in next blog post, till then Byy, Have a Nice Day.

Happy coding!

RandomFollow

I'm a self-taught Web developer who is always learning and creating cool Project stuffs.

React 19 is now stable ! What’s New 👇

Random — Sun, 08 Dec 2024 12:43:56 +0000

React 19 has arrived with exciting new features and improvements!

Hello Dev’s its me Md Taqui Imam, The React 19 is now stable so let’s explore what’s new and how you can use these features in your projects.

This guide will walk you through the most important updates with practical examples.

Follow me in Github⭐

Actions and Form Handling ⭐

Actions are one of the biggest additions in React 19. They make it easier to handle form submissions and data mutations.

function UpdateProfile() {
 const [error, submitAction, isPending] = useActionState(
 async (previousState, formData) => {
 const name = formData.get("name");
 try {
 await updateProfile(name);
 return null; // No error
 } catch (err) {
 return "Failed to update profile";
 }
 },
 null
 );
return (
 <form action={submitAction}>
 <input type="text" name="name" />
 <button type="submit" disabled={isPending}>
 {isPending ? "Updating…" : "Update Profile"}
 </button>
 {error && <p className="error">{error}</p>}
 </form>
 );
}

Using Form Status 🟢

The new useFormStatus hook makes it easy to show loading states:

import { useFormStatus } from 'react-dom';
function SubmitButton() {
 const { pending } = useFormStatus();

 return (
 <button disabled={pending}>
 {pending ? 'Submitting…' : 'Submit'}
 </button>
 );
}

New Hooks 🎉

1. useOptimistic 🆕
This hook helps create instant feedback while waiting for server responses:

import { use } from 'react';
function UserProfile({ userPromise }) {
 const user = use(userPromise);

 return (
 <div>
 <h1>{user.name}</h1>
 <p>{user.email}</p>
 </div>
 );
}

Document Metadata Support

React 19 now supports metadata tags natively:

function BlogPost({ post }) {
 return (
 <article>
 <title>{post.title}</title>
 <meta name="description" content={post.summary} />
 <link rel="canonical" href={post.url} />

 <h1>{post.title}</h1>
 <p>{post.content}</p>
 </article>
 );
}

Also checkout This Blog

7 Secret UI Libraries No One Talks About 🔥

Random ・ Dec 15 '24

#webdev #javascript #programming #frontend

Asset Loading Improvements

New APIs for optimizing resource loading:

import { preload, preinit, preconnect } from 'react-dom';
function App() {
 // Preload important resources
 preload('/fonts/main.woff2', { as: 'font' });
 preinit('/styles/critical.css', { as: 'style' });
 preconnect('https://api.example.com');
return <Main />;
}

Web Components Support

React 19 now fully supports custom elements:

function App() {
 return (
 <div>
 <custom-element
 stringProp="hello"
 numberProp={42}
 objectProp={{ foo: 'bar' }}
 onCustomEvent={(e) => console.log(e.detail)}
 />
 </div>
 );
}

Other Improvements 🛠️

Ref as a Prop

// Old way with forwardRef
const OldInput = forwardRef((props, ref) => (
 <input ref={ref} {…props} />
));
// New way in React 19
function NewInput({ ref, …props }) {
 return <input ref={ref} {…props} />;
}

Better Error Reporting 🔥

React 19 provides clearer error messages and better hydration error reporting:

const root = createRoot(container, {
 onCaughtError: (error) => {
 // Handle errors caught by Error Boundaries
 logError(error);
 },
 onUncaughtError: (error) => {
 // Handle errors not caught by Error Boundaries
 reportFatalError(error);
 }
});

Conclusion / That’s it 😅

React 19 brings many exciting features that make development easier and more efficient. The new form handling capabilities, hooks, and improved asset loading will help developers build better applications with less code.

Remember that while these features are now stable, it’s recommended to test thoroughly when upgrading existing applications to React 19.

For more information, check out the official React 19 announcement and documentation.

And see you in next blog post, till then Byy, Have a Nice Day.

Happy coding!

RandomFollow

I'm a self-taught Web developer who is always learning and creating cool Project stuffs.

useActionState — A New Hook in React 🎉

Random — Tue, 02 Jul 2024 09:21:23 +0000

Hello Developers 👋,

It’s me your friend Md Taqui Imam, and today I’m going to explain a new and exciting hook in React called useActionState.

Follow me in Github⭐

What is useActionState?

useActionState is a new React hook that helps us update state based on the result of a form action.

It’s like a smart helper that remembers things for us and can change them when we submit a form.

Checkout Official Documentation🚀

Important Note: Right now, useActionState is only available in React’s Canary and experimental channels. To get the most out of it, you’ll need to use a framework that supports React Server Components.

How to use useActionState?

To use this hook, we first need to import it from React:

import { useActionState } from 'react';
Then, we can use it in our component like this:

const [state, formAction, isPending] = useActionState(actionFunction, initialState);

Here’s what each part means:

‘state’ is our current form state
‘formAction’ is a new action we’ll use in our form
‘actionFunction’ is the function that runs when the form is submitted
‘initialState’ is the starting value of our state

When to use useActionState:

Use this hook when you want to update state based on form submissions, especially if you’re using Server Components and want quicker responses.

Example:

Let’s make a simple counter form using useActionState:

import { useActionState } from "react";

async function increment(previousState, formData) {
  return previousState + 1;
}

function StatefulForm() {
  const [state, formAction] = useActionState(increment, 0);
  return (
    <form>
      {state}
      <button formAction={formAction}>Increment</button>
    </form>
  );
}

In this example, every time we click the button, our count goes up by one. The useActionState hook takes care of updating the state when the form is submitted.

For More Detail and example checkout this video 👇

That’s it 😅

Remember, the best way to learn is by doing.

So when useActionState becomes more widely available, give it a try in your projects and see how it can improve your forms!

Alert ⚠️

Don't forget to checkout my new article 🫡

Click Here👋

...

Happy coding!

RandomFollow

I'm a self-taught Web developer who is always learning and creating cool Project stuffs.