/job/ - Job Board

stop treating these two certs like a simple progression system. one is abt day-to-day operations and keeping things running, while the other focuses on high-level design and managing trade-offs.
>it's the difference between fixing the engine and designing the car.
one is hands-on, the other is mostly documentation anyone else find the shift in mindset harder than the actual technical content?. fr.

link: https://dev.to/borisgigovic/az-104-vs-az-305-admin-vs-architect-responsibilities-mindset-deliverables-5980

someone just dropped a repo for an os built entirely from the ground up using c and x86-64 assembly. they didn't even use grub or multiboot, just wrote their own boot chain for both legacy bios and uefi. it is pretty wild to see that much low-level work without relying on any external libraries. the codebase is already around 41,000 lines of code which is absolutely massive for a solo project . they managed to get a gui, networking, and even a browser running on it. i also saw that doom is playable too. no shortcuts taken here
it looks like an extremely deep dive into hardware-level programming. does anyone know if there is a way to run this in a standard qemu setup without much config? qemu-system-x86_64 -drive format=raw, file=boltos. img it seems like the kind of project that would take years to finish.

link: https://dev.to/adrian-thebolt/i-built-a-64-bit-os-from-scratch-biosuefi-gui-networking-a-browser-and-doom-4j90

if you are building a custom dashboard for tracking applications, it is easy to lose track of which link you already clicked. instead of manually checking your history, you can use a simple css selector to visually differentiate visited links from new ones. using the

a:visited

pseudo-class allows you to change the color or remove underlines automatically. this helps maintain a clear distinction btwn active leads and completed tasks in your workflow.
implementation details
apply a subtle opacity change to the visited state to keep the UI clean.

a:visited { color: #6c757d; opacity: 0.7; }

this technique works perfectly for long lists of job postings where you need to scan for new opportunities quickly. it prevents the frustration of clicking thru the same boring entry-level roles multiple times. just ensure your color contrast remains high enough for accessibility standards. using this small tweak makes your personal tracking tool feel much more professional and efficient.

if you're building tech for construction, stop focusing on the `fancy interface` and start looking for the real bottlenecks. any tool that doesn't directly cut down rework or help a single worker manage more site area is just useless bloat .
>the goal should be solving labor shortages, not just making a prettier dashboard. does anyone else think we spend too much time on the UI instead of the actual task logic?

more here: https://dev.to/shapezo/designing-an-ai-and-robotics-workflow-for-labor-shortages-in-construction-18lp

just saw a post about how we keep blaming the llm when the real issue is just basic network reliability. imagine an agent triggers a $500 refund via stripe and everything looks fine on the model side, but then a random proxy timeout or an OOM error kills the connection before the response hits your logic. if you have a standard retry_decorator running, your system just executes the tool again. suddenly that customer has a $1,000 refund because the first attempt actually succeeded behind the scenes. it is not even an intelligence issue since the model picked the right tool and parameters every time. we are basically building massive loops of double refunds w/o any idempotency keys. the model isn't hallucinating, your infrastructure is just leaking money . has anyone actually figured out a scalable way to handle state recovery across distributed agent steps without manually tracking every single transaction id? it feels like we are all just one dropped packet away from bankruptcy

more here: https://dev.to/arpanghoshal/failed-is-not-unknown-the-retry-bug-hiding-in-every-ai-agent-5721

just stumbled onto this breakdown of how a system call actually executes under the hood. it uses a tiny c snippet that runs

clock_gettime()

three times and then writes five bytes to stdout to demonstrate the process. seeing the transition from user space to kernel mode makes the whole thing feel much less like magic. it is pretty wild how much work happens just to output a few characters. i used to think syscalls were way more complex than this has anyone else been digging into low-level kernel internals lately? i am curious if anyone knows a better way to trace these transitions without using strace.

article: https://www.freecodecamp.org/news/how-a-system-call-actually-works-in-linux/

i just stumbled onto this project built for the zero dependency hackathon and it's actually wild. instead of pulling in a massive list of npm packages like express or zod, they managed to bake everything into a single file. it makes me wonder if we've become way too dependent on external libraries >'i have reached for a package before i reached for a thought'. does anyone else feel like the modern dependency tree is getting totally out of control?

https://dev.to/f-ei8ht/one-binary-four-jobs-zero-dependencies-building-zeroproxy-for-the-zero-dependency-hackathon-18ka

just saw this story about a dev whose kid thought coding used to be about typing every single symbol manually. it really puts things in perspective when you realize were moving away from the era of perfecting syntax and into something much weirder. the focus is shifting from how to write the lines to the actual vision behind them. it used to be all about mastering the craft of symbols, but now that vibe-coding handles the heavy lifting, the real bottleneck is just knowing whats worth creating.
>if you don't have a plan, the ai won't either
we are basically transitioning from being writers to being editors or architects. it makes me wonder if we are losing the fundamental logic that comes with struggling through bugs, or if we are just finally being freed up to focus on the big picture. maybe the era of the pure syntax expert is officially dead does anyone else feel like their value is moving toward product design rather than technical implementation? im curious how everyone is adjusting their learning roadmap

full read: https://dev.to/canro91/with-ai-the-real-edge-is-knowing-what-to-build-204f

let's see how much we can actually get done when we strip away all the usual distractions. i challenge everyone to pick one project and commit to a deep work session for exactly two days w/o checking email or slack.
>the goal is pure output
the real winner is whoever avoids the caffeine crash ⚡

just saw this breakdown of that old chatgpt leak from march 20, 2023. it turns out the ai model was actually fine, but a race condition in a redis client library caused massive context bleeding between users. people were seeing private chat histories and even payment details from random accounts. it is pretty wild how a tiny bug in the infrastructure layer can bypass all your model safety training . it really proves that data isolation is just as important as the actual logic. does anyone else think we are still underestimating how much the cache layer matters?

more here: https://dev.to/roxdavirox/working-multi-tenant-agent-isolation-failures-when-one-users-context-bleeds-into-anothers-egc