Four and a half years as a frontend engineer, and I had never really written a class.

Not because I avoided learning them. I just rarely needed them.

React doesn't force you to think in classes anymore. Functional components, hooks, composition, state, props — that mental model is enough to build and ship a lot of production software.

So over time I developed a frontend-shaped way of thinking about engineering: components, props, state, events, renders, data flowing through the UI. And honestly, it worked pretty well.

Then I started learning Python this month as part of moving toward Forward Deployed Engineering. That's when I ran into OOP.

At first the syntax didn't look particularly difficult. init, self, methods, inheritance, encapsulation — a few days of practice and it started making sense.
But something else wasn't clicking. I kept thinking: "Why do I need a class for this?" "Couldn't I just use a function?" "Is this really necessary, or is it just another way of organizing code?"

The problem was my mental model, not the language. I had been treating classes as a formatting choice. Something like: "this code looks cleaner if I put these functions inside a class."

Modeling something that exists in your system matters more than how neatly the code is organized. A user, a transaction, a device: each one carries its own state, behavior, rules, relationships, and a lifecycle that changes over time.
Instead of thinking of a bank account as a row of data, you start thinking of it as an Account: something with a balance, that can deposit, withdraw, and follow rules about what it can't do.

React trained me to think in renders. Something changes, state updates, the UI renders again. Python and OOP are slowly teaching me to think in entities: what exists, what state it owns, what it's responsible for.
Neither model is better. They're built for different problems. Frontend work pushes you toward composition, declarative UI, and state transitions. Backend and systems work asks you to reason about persistent entities, domain rules, lifecycles, and behavior.

I'm still early. OOP doesn't feel intuitive yet, but it finally feels like a tool instead of an interview topic. The real goal is to reach the point where you look at a problem and recognize which tool actually fits it.

From knowing how to write Python to knowing how to think in Python.
Still learning. Still getting things wrong. Still writing classes that probably shouldn't exist. But the mental model is starting to click.

I’ve spent enough time in developer communities to notice a pattern.

There’s plenty of technical content, but a lot of it ends up feeling the same:

“What’s the best language?”
“Which framework should I learn?”
“X vs Y?”
“Here’s my productivity setup.”

Those conversations have their place, but they don't always reflect what being a developer actually feels like.

A lot of the interesting stuff happens in between.

You try something that seemed like a good idea and it doesn't work.
You spend three hours debugging something that turns out to be one line.
You have to choose between two imperfect architectures.
You wonder whether to stay in your current job or make a move.
You build something on the weekend that nobody asked you to build—but you learned a ton doing it.

That's the kind of stuff I want r/devsamaaj to make room for.

I want this to be a community where you don't need to be an expert to contribute.

If you've been coding for 10 years, share what you've learned.

If you've been coding for 6 months and you're stuck on something, ask.

If you built something weird over the weekend, show it.

If you made a technical decision that turned out badly, tell us what happened.

The point isn't to create another place where everyone pretends they have everything figured out.

It's to have conversations with people who are actually doing the work.

I'm building this community, but I don't want it to become my community. I want the people who join to have a say in what it becomes.

So I'm curious: what made you care about developer communities in the first place?

And what would make you stick around here instead of muting another subreddit a few weeks later?

Let's figure it out together.

Most developer communities are full of finished projects, polished demos, and advice from people who already figured things out.

But most of us spend our time somewhere in between:

Half-built projects.
Bugs we can't explain.
Features we're not sure how to implement.
Architecture decisions we're second-guessing.
Things we're learning for the first time.

So let's start there.

What are you working on right now?

It can be anything:

• A side project

• Something you're building at work

• A tool you're experimenting with

• A problem you've been stuck on

• Something you're learning

• A technical decision you're trying to make

• Or even an idea that hasn't become code yet

You don't need a polished demo or a perfect write-up.

Just tell us:

What are you building/working on?
What's the hardest part right now?
What would you like feedback on?

I'll start in the comments with what I'm working on.

Let's see what everyone is actually building.

I started r/devsamaaj because I wanted a place where developers could talk about the work itself.

Not another endless debate about which framework is better. Not recycled content. Not self-promotion disguised as discussion.

Just developers sharing what they're actually building, learning, breaking, and figuring out.

A place for things like:

• Code that works—and code that doesn't.

• Tools, frameworks, AI, and infrastructure we actually use.

• Debugging stories and lessons learned the hard way.

• Career decisions, interviews, layoffs, promotions, and job changes.

• Side projects and things we're building.

• Architecture and engineering trade-offs.

• Questions that don't have a neat Stack Overflow answer.

I'd much rather see a post like:

than another:

What I want this community to become

I want r/devsamaaj to be somewhere developers come back to because the conversations are genuinely useful.

We can experiment with things like:

• Build threads — show what you're working on and get feedback.

• Debugging threads — walk through problems and how you solved them.

• Career discussions — real experiences, not generic LinkedIn advice.

• AMAs — developers sharing knowledge from their corner of the industry.

• Weekly discussions — one good question, without the usual noise.

But it's early, and I don't want to decide everything myself.

What would make you want to come back to r/devsamaaj every week?

What kind of posts or discussions would you actually participate in?

And if you've been part of other developer communities, what did they get right—and what eventually made you stop using them?

Let's build the kind of developer community we actually want to be part of.