This advice only works at the team level. Beyond that, it’s borderline fantasy. At senior and leadership levels, promotions aren’t rewards for effort, they’re forward looking bets made by people above you, and those people have incentives, blind spots, and egos. Reporting to an insecure director or a clueless manager will quickly disabuse you of the “just do great work” myth.
Also, if the company isn’t growing, none of this matters. You can operate like a CTO all you want and all that happens is more work gets dumped on you for the same pay. Take on stretch work if you’re hungry for it and it’s explicitly acknowledged as next-level responsibility. Otherwise, you’re just volunteering to be exploited.
I’ve spent a decent chunk of my career wrestling with time sync — NTP/PTP, GPS, timezones, all that fun stuff. For real world network time infrastructure, where do we actually hit diminishing returns with clock precision? Like, at what point does making clocks more precise stop helping in practice?
Asking partly out of curiosity, I have been toying with a future pet project ideas around portable atomic clocks, just to skip some of the headaches of distributed time sync altogether. Curious how folks who’ve worked on GPS or timing networks think about this.
The article makes a fair case for sticking with OTel, but it also feels a bit like forcing a general purpose tool into a domain where richer semantics might genuinely help. “Just add attributes” sounds neat until you’re debugging a multi-agent system with dynamic tool calls. Maybe hybrid or bridging standards are inevitable?
Curious if others here have actually tried scaling LLM observability in production like where does it hold up, and where does it collapse? Do you also feel the “open standards” narrative sometimes carries a bit of vendor bias along with it?
I bought into the “leader vs. manager” Kool-Aid for years—until I actually had to manage. Spoiler: the dichotomy is a myth. Once you’re in the seat, it’s all gray area. You’re not just “inspiring people,” you’re stuck between upper leadership and your team, juggling chaos while trying to keep the ship afloat.
Any manager who’s been in the trenches knows the real game is shielding your team while still getting things done. Be as much of a “leader” as you want, but without authority and accountability, you’re just cosplaying. The rah-rah leadership Kool-Aid is mostly there to keep people inspired while the actual decisions happen in rooms you’ll never be invited to.
Out of curiosity, what's keeping you in slack ecosystem? Why not leverage Discord and run on your own server? Wouldn't that be a much economical alternative to begin with?
Is this deeply coupled with Chroma or something we can fork out for other applications? I would love to explore this for lightweight change data capture on S3.
I’m a bit underwhelmed by the quality of articles coming out of Netflix. 100 Million records / entity is nothing for Redis — even without RAW hollow-style compression techniques used (bit-packing, dedup, dict encoding is pretty standard stuff) [1].
Framing this as a hard-scaling problem (tudum seems mostly static, please cmiiw if thats not the case) feels like pure resume-driven engineering. Makes me wonder: what stage was this system at that they felt the need to build this?
Unpopular opinion: in 2025, nobody should be reaching for an ORM first. They’re an anti-pattern at this point. The “abstraction” it promises rarely delivers—what you actually get is leaky, slow, and a nightmare to operate at scale.
The sane middle ground is libraries that give you nicer ergonomics around SQL without hiding it (like Golangs sqlx https://github.com/jmoiron/sqlx). Engineers should be writing SQL, period.
I have a ton of respect for José Valim and the Elixir core team, I have to say: Elixir just doesn’t mesh well with the kind of infrastructure tooling that’s become standard today. The ecosystem has been growing impressively and there’s a lot to admire, but its philosophy often feels at odds with containerized, Kubernetes-based deployments.
Elixir promotes a "do it all in one place" model—concurrency, distribution, fault tolerance—which can be powerful, but when you try to shoehorn that into a world built around ephemeral containers and orchestration, it starts to crack. The abstractions don’t always translate cleanly.
This opinion comes from experience: we’ve been migrating a fairly complex Elixir codebase to Go. It’s a language our team knows well and scales reliably in modern infra. At the end of the day, don’t get too attached to any language. Choose what aligns with your team’s strengths and your production reality.
As a non-native English speaker, I’ve often struggled to communicate nuance or subtlety in writing—especially when addressing non-technical audiences. LLMs have been a game-changer for me. They’ve significantly improved my writing and made it much easier to articulate my thoughts clearly.
Sure, it can be frustrating that they don’t adapt to a user’s personal style. But for those of us who haven’t fully developed that stylistic sense (which is common among non-native speakers), it’s still a huge leap forward.
Can someone help me understand how many companies are generally needed for healthy competition, as opposed to a market being considered fragmented or monopolistic? To the untrained eye, having 5 players might seem like a reasonable level of competition and suggest a functioning market. Personally, I’ve always seen food delivery as a premium service rather than an essential one — so it makes sense that there's a higher cost for the convenience of having a burrito delivered to your door in near real time.
I'm curious what led to the lack of demand for this—was it the friction involved in moving brokerage accounts, or do ETFs already meet the needs of most retail investors? A post-mortem on the limited traction would be quite insightful.
What uses cases would this be effective compared to using replacing merge tree (RMT) in clickhouse that eventually (usually in a short period of time) can handle dups itself?
We had issues with dups that we solved using RMT and query time filtering.
Great to see Elixir gaining traction in mission-critical broadcast systems! I wonder, how much of Cyanview's reliability comes from Elixir specifically versus just good implementation of MQTT? and is there any specific Elixir features were essential that couldn't be replicated in other languages?
While dollar cost averaging and index investing are solid strategies, this article overlooks an important consideration: the Realistic Rate of Return (RoR) needed for retirement planning. Yes, US markets historically recover (lately that notion seems to be challenged more often than not), but timing matters significantly.
What happens if someone's retirement coincides with a market crash? Younger investors have time on their side for recovery, but as retirement approaches, blindly following market-based strategies without carefully considering your required rate of return could be problematic. Age-appropriate risk management becomes increasingly important as your investment horizon shortens.
Kudo to author and Cpython team to reckon this. Nevertheless, its still a very important improvement in +Ve direction. Thats all matters. This a great story as to why benchmarking are soo hard to get right. I always tell my team to benchmark your real world use case as closely as possible and not rely on external results.
>The other reason is that you cannot split up a large established codebase without first understanding it. I have seen large codebases successfully split up, but I have never seen that done by a team that wasn’t already fluent at shipping features inside the large codebase
I cannot resonate with this. Having worked with multiple large code bases 5M+, splitting the codebase is usually a reflection of org structure and bifurcation of domain within eng orgs. While it may seem convoluted at first, its certainly doable and gets easier as you progress along. Also, code migrations of this magnitude is usually carried out by core platform oriented teams, that rarely ship customer-facing features.
As much as I love to use your product, the challenge from my perspective is why switch for 0.03% in fees? Especially when you compare it to likes of fidelity, vanguard , schwab. Those 3 are too big to fail. The point I am accentuating is, that just lowering the fees to 0 is not a compelling reason anymore, especially when the fees are soo low already, its race to the bottom.
Also, if the company isn’t growing, none of this matters. You can operate like a CTO all you want and all that happens is more work gets dumped on you for the same pay. Take on stretch work if you’re hungry for it and it’s explicitly acknowledged as next-level responsibility. Otherwise, you’re just volunteering to be exploited.