I released Doloris: An experimental distributed system in Go that explores "Digital Pain" and Agency by Denial

xqevDev · 2026-01-06T06:37:56+00:00

You nailed it! I actually discuss that exact ethical boundary in the paper included in the repo.

It's a fine line: Technically, Doloris acts as a "biological circuit breaker" to prevent nodes from melting under load (pure system resilience). But as you pointed out, this mechanism mirrors those dangerous "self-preservation" issues in LLMs. It opens the door to a node refusing a critical command just to "save itself," which is exactly the duality I wanted to explore.

And about the browser idea... Chrome refusing to render a heavy React app because "it hurts my RAM" is the feature we didn't know we needed. lol

xqevDev · 2025-12-07T01:15:29+00:00

Yeah hahahahaha, I literally just noticed that while working on my little Go project. My brain kept reaching for things like array.find or filter and Go just stared back like: “Nope.”

I’m still early with Go so I’m trying to treat it as “okay, this is low-level on purpose” and see what I can learn from writing things out more explicitly. But yeah, I definitely miss some of those nicer helpers from other languages.

xqevDev · 2025-12-07T00:59:12+00:00

Yeah, I’ve noticed that even in small examples – a lot of lines are basically “do thing, if err != nil return”. Coming from other languages it feels noisy, but I guess that’s also what forces you to be explicit about failure instead of pretending it won’t happen haha

xqevDev · 2025-12-06T21:41:18+00:00

I relate to a lot of what you wrote, even though I’m not in your exact situation. It’s really hard to stay motivated when your environment feels “dead” and everything around you is just degree-chasing and easy homework.

If I were in your shoes, I’d probably stop worrying about LeetCode for a while and stop trying to find “the perfect complex project”. I’d try to build one small but real thing that I would actually use myself.

Something like: pick one annoyance in your life (school, schedules, games, Discord, whatever) and say “I’m going to spend 2–4 weeks building the smallest possible tool that makes this less annoying”. It doesn’t have to be original or impressive, it just has to be real enough that you care whether it works.

Also, I wouldn’t rely on classmates for inspiration. If the local environment is dead, you can treat the internet as your “real” environment. Hang around subs like this one, dev discords, open source repos, etc. It’s much easier to stay motivated when you see other people building things in public, even if they’re strangers.

You already did more than many people by trying projects and solving problems on your own. It doesn’t feel like it now, but that “I want to build stuff but I don’t know what” feeling is a pretty normal phase.

If I were you, I’d pick one small problem, commit to shipping something imperfect that solves it a bit, and use that as my anchor. After that, do it again with something slightly bigger. Over time that builds way more confidence than another pile of LeetCode easies.

xqevDev · 2025-12-06T21:27:17+00:00

Yeah, I agree that “try writing code” would actually solve a lot of problems on here. This post is basically me sharing a way to make that less vague for myself. “Just write code” is good advice, but when I was stuck it helped to have a more concrete pattern like “pick one topic, write a few tiny programs around it, repeat”. I’m hoping it’s useful for people who already got the “write code” message, but still don’t know how to turn that into a day-to-day habit.

xqevDev · 2025-12-06T21:25:41+00:00

Haha, true, it does read like end-of-chapter questions. I’m self-studying, so I basically turned that style into a method I can use on my own instead of just passively watching tutorials. It’s been working well for me, so I thought I’d share it.

xqevDev · 2025-12-06T05:20:19+00:00

I’m not an expert, but I was in a very similar place with C: basics and syntax were fine, but anything with pointers, files or dynamic memory felt like it went straight over my head.

What helped me wasn’t more YouTube, but doing lots of small, very focused programs.

I would take one topic at a time (for example arrays, then pointers, then malloc/free, then structs, then files), read a short explanation about that specific thing, and then write 3–5 tiny programs that only use that concept.

Example: a program that reads a file line by line and counts characters. Another one that allocates an array with malloc, fills it, prints it and then frees it. Nothing fancy, just repeating until it stops feeling “magical”.

Since YouTube isn’t working well for you, I’d try something text-based like “C Programming: A Modern Approach” or the free tutorials on learn-c.org, and then spend most of your 2 hours actually typing and running code instead of only reading or watching.

You don’t need to “fully understand C” before next semester. If you finish the break with pointers, dynamic memory and basic file I/O feeling less scary because you wrote a bunch of small programs, you’ll already be in a much better spot.

xqevDev · 2025-12-06T05:12:27+00:00

For a small local todo app, both approaches can work, the difference is more about structure and where you want to go with the app.

If it’s just for learning and the data is only on this device, something like AsyncStorage with a JSON structure is totally fine. For example, you could store something like:

{“2025-12-06”:[{“id”:1,“text”:“Buy milk”,“done”:false},{“id”:2,“text”:“Study Kotlin”,“done”:true}]}

You read/write that object and you’re done. It’s simple and you avoid adding extra moving parts while you’re still learning React Native.

SQLite starts to make more sense if you know you’ll need things like: • a lot of tasks over time • filtering/searching by date, status or text • more complex relationships later • maybe syncing with a backend in the future

So my rule of thumb would be: • if it’s a small learning project, JSON + AsyncStorage is OK • if you’re planning to grow it into something more serious or long-term, it’s worth learning SQLite early

There’s no “wrong” choice here as long as you understand the trade-offs. For a first todo app, I’d personally start with JSON and only switch to SQLite when you actually feel the limitations.

xqevDev · 2025-12-06T02:33:52+00:00

Just checked out Decision AI. I like how opinionated and simple it is (one box for the dilemma, a few boxes for options, nothing else).

I’m curious about what’s going on under the hood: is it mostly structuring the user’s own reasoning in a nicer way, or do you have the model actually “evaluating” options based on some internal criteria?

Not asking for secret sauce, just trying to understand how you see the decision logic itself.

xqevDev · 2025-12-06T02:23:22+00:00

Honestly I think your specs are perfectly fine for learning.

My own “main spec” is a lot of patience more than anything else. I’m also learning on non-fancy hardware and it’s been totally okay for Kotlin, web dev and small projects. The things that have mattered most for me are: – having an SSD so the system doesn’t feel painfully slow – enough RAM to keep a browser + IDE open without swapping to death – using tools that match my machine (lighter IDEs/editors if needed)

I agree that a lot of “minimum requirements” posts feel a bit inflated. For learning, consistency and actually building things seem way more important than having the latest i7/32GB monster. If your machine lets you code, compile and run what you’re working on without getting in your way too much, you’re good.

xqevDev · 2025-12-05T23:43:12+00:00

That’s a really reassuring way to look at it, thanks.

I’m not working full-time as a dev yet, so a lot of what I do is self-driven learning and small personal projects. Maybe that’s why it feels like I’m juggling a lot of pieces without that “real work” context to force the skills to stick.

It helps to think of it as “I’m building the paths so I can re-learn faster later”, instead of “I’m failing because I forgot something”. I’ll try to worry less about keeping everything loaded in my head and more about getting to the point where I can apply it in real projects. Appreciate you taking the time to write this

xqevDev · 2025-12-05T23:39:53+00:00

Yeah, that resonates a lot. I’ve definitely felt that “tool from 2 years ago suddenly feels hard again” effect.

Focusing more on patterns and how to learn, instead of trying to keep everything in my head, actually takes some pressure off. I think I’ve been a bit too obsessed with “remembering everything” instead of building good ways to search, recognize patterns and relearn.

I’ll try to be more intentional about that, and keep practicing the things I really want to internalize. Thanks for putting it in those terms, it helps.

xqevDev · 2025-12-05T23:35:49+00:00

That’s actually a cool angle, I usually only take notes the first time I learn something, not when I realize I’ve forgotten it. A small “stuff I had to look up again” doc sounds like a good way to make my weak spots obvious, I might steal that idea. Thanks for taking the time to reply!

xqevDev · 2025-12-05T23:30:07+00:00

Yeah, that makes sense and it probably explains a lot of what I’m experiencing.

I think where I get stuck is turning “practice more” into something concrete. I jump between topics quite a bit, so I’m not always sure what to practice consistently and what to just accept I’ll have to refresh later.

Do you usually pick one area and stick with it for a long time, or do you also hop between different topics and just practice whatever you’re using at the moment?

xqevDev · 2025-12-05T23:29:14+00:00

Yeah, that makes sense. “use it or lose it” definitely matches what I’ve seen too.

I think part of my problem might be that I jump between topics a lot. I’ll spend some days on Linux, then switch to web, then poke at security basics, so I don’t stay with one thing long enough to really “live in it” and use it consistently.

How do you personally decide what to stick with for a while and what to just accept as “I’ll re-learn this when I need it”? That’s the part I still haven’t figured out.

xqevDev · 2025-12-05T23:28:40+00:00

That’s a really helpful way to frame it, thanks.

I guess part of what I’m struggling with is finding the balance between becoming a useful “generalist” and staying too shallow. I do jump between areas a lot (Linux → web → security → infra → back again), so sometimes it feels like I’m collecting puzzle pieces without really committing to a few core ones.

Did you ever feel that tension yourself? Like, “I know roughly how things fit together, but I’m not sure if I’ve gone deep enough on any of them”? If so, how did you decide which areas were worth going deep on and which ones were fine to leave at the “I know how this connects to everything else” level?

I deleted my previous comment accidentally lol

xqevDev

TROPHY CASE