jdw64

It seems you and I now have something in common inside our bodies: PFOS. I've finally found a point of connection between us.

Out of curiosity as to why 3M would insert this commonality into me to help us share a sense of solidarity, I looked up some safety-related research papers. I came across a 3M technical paper by Seacat et al. (2002)[1], which claims that under their experimental conditions, no harmful effects were observed up to a certain dose.

Seeing this perfectly illustrates just how much science and technology are dictated by the institutions they are affiliated with.

[1]https://pubmed.ncbi.nlm.nih.gov/12075127/

Older developers in the Node ecosystem still sometimes write callback hells, but it's true that it's less prevalent than in the .NET world.

The problem is that I am the one who has to maintain that code. The reality is that code ultimately follows the prevailing trends and paradigms of its era. Most developers tend to stop growing around their 5th to 7th year (this is purely my observation). They settle into the complacency of having shipped a single complete program, an experience they usually hit around their 4th year. As a result, when you do actual maintenance work, you end up facing things like C++98 code or .NET codebases where the dependency graph is a complete disaster.

Compounding the issue is that these types of companies have very little technical exchange with the outside world. And that specific way of writing code ends up acting as a sort of gatekeeping mechanism.

Sometimes, I feel like programming ultimately boils down to how well you can read and adapt to these shifts in paradigms. The coding trends of today will likely become the outdated legacy of tomorrow, and someone might eventually tell me, "You write old code." It is always a difficult problem.

I've had a very similar experience. Ironically, simple frameworks like WinForms, or tools that promise easy and rapid development, often turn into the absolute worst-case scenarios for maintenance.

This tendency is especially strong in code-behind frameworks. Because the domain logic directly relies on the state of UI controls, the business logic becomes entirely entangled with the view itself. And what is the result? Every single architectural layer ends up stuffed inside a specific event handler.

I could understand if this came from a small outsourcing shop, but what baffled me was that this was the codebase of the top company in the world in that specific domain.

And to top it off, you sometimes have to integrate with an SDK where the methods are literally named function1, function2, and so on. It is always a thrilling experience.

The worst I have experienced: A 30,000-line .cs file. A giant monolithic program tangled together by Singleton abuse, 6-deep nested if/else blocks, and the list goes on. There are too many to count. And this is a sight I see every single day. This is the exact landscape I encounter at many companies when I go in for maintenance work. Encapsulation completely shattered as a direct reflection of the subcontracting power hierarchy, among other things...

Code that completely disregards collaboration, utilizing outdated algorithms in the name of "optimization" and making it utterly unmaintainable for anyone else.

We learn about ADTs, Result-first approaches, Composition Roots, and code hygiene, yet at some point, code that simply "works" becomes what ships to production.

Communities advocate for building "good software," but the reality in the field is that most of it is "code written just to clock out for the day." I hear "it works, so don't touch it" in dozens of different variations.

The quality of an open-source project contrasts sharply with that of delivered enterprise software. People settle for the "if it works, it's fine" mindset because in open source, the code itself represents personal reputation, whereas in contract deliveries, meeting the deadline is ultimately the core objective...

It feels like the world is always polarized.

I think it's a matter of reach. Most ordinary people's good deeds have a small audience—the 'N' in a 1:N spread is limited. But the bigger the fame, the larger the audience becomes. From that perspective, when Keanu Reeves does something good, the number of people influenced by that act is much larger. I believe humans are creatures shaped by their environment—and they are influenced by it. So it's socially acknowledged that piling up these good actions is beneficial, and the greater the influence of such actions, the larger the impact they have. Of course, this is just my hypothesis.

Written laws are like spiders' webs; they will catch, it is true, the weak and poor, but would be torn in pieces by the rich and powerful.

wow really nice!!

Looking at this, maybe in the future, the tools that AI prefers will become the mainstream. Even now, the tools that AI gives the highest priority to are the ones people already choose. There might be a concentration effect toward the tools that AI selects

These days, it feels like we can't truly own anything anymore. Sure, physical media used to break often, but these days I just don't get that satisfying feeling of actually owning something.

I wonder what the point is of building a software factory

As always, I was working on modifying a CRUD program. It's been a while since I read through the documentation carefully and worked on it, so it feels refreshing.

Typing after a long break—I can really feel how much slower I've gotten and how much my skills have degraded

If self-reference and strange loops aren't intelligence, and emergence is merely a byproduct of universality, then what on earth is intelligence? What is this thing we question as intelligence, and what are the values that take shape from it?

Can we truly define intelligence as prediction, prediction as compression, and compression as the process of finding the upper bound of Kolmogorov complexity?

Can the statistical compression of data really explain everything? I don't know. What exactly is intelligence? Honestly, in everyday life, I rarely think about what intelligence actually is. I usually just focus on what the task at hand is and how to get it done, which makes this a fascinating question.

When you code with AI, you realize there is something fundamentally different from humans. The qualities that make a good senior programmer and the qualities that make a programmer good at orchestrating AI agents are similar, yet there is a subtly different feel to them. I might not be able to fully articulate it, but...

What exactly is the fundamental difference that creates this subtle distinction?

I used to believe in free will like you, then I took an arrow in the knee.

I want to live like an NPC too, but preferably one that can't be attacked. I'd absolutely hate being an NPC in the Dark Souls series.

The biggest problem with Gemini is that its performance degrades the longer you use it for coding. Is it just me?

Probably. And that makes Vim the cockroach.

It's my fault. I'll follow the rules more carefully.

I am curious as to why the TRU is not adopted as a standard metric.

1.Corporations that sponsor scholars dislike it.

2.Politicians dislike it (because if TRU were adopted as the standard, the unemployment rate a critical metric for evaluating their political achievements—would drastically increase).

3.The current system fundamentally operates on legacy metrics, despite the widespread knowledge that they fail to accurately reflect reality.

It seems to me that TRU captures reality much better, so I am wondering why it is not widely used as the standard.

There used to be a joke that said, 'A great programmer should try building a text editor.'

By this standard, I could call myself a vegetarian starting today. Haha

loosing is fun

Do not guess. Measure, but only measure the bottlenecks that threaten the business

I'm in a similar situation.

Programming used to be painful, but coding with AI doesn't feel that way. In the old days, I had to write extensive planning documents before writing any code—work orders, UI layouts, and design specs. With AI, things happen right away. I think the immediate feedback is a huge difference.

To keep my skills from deteriorating, I avoid using AI when reviewing other people's work. I end up missing AI.

I'm currently a programmer with 8 years of experience(I've been coding for longer than that, but I started earning money from programming around then.). Some might say that's still short, but honestly, I'm not sure. I became a programmer during the COVID-19 hiring boom, and somehow I've managed to survive. But I'm not really sure what I should be doing next.

I design and decorate my own homepage

I've tried it a few times, but none of them went well. There are a few recurring issues:

1.When I try agent based orchestration and multi tasking, some parts work well overall, but certain areas keep repeating local issues.

2.So I tried having AI review each other's work and set up guardrails, like stopping when certain values or patterns repeat. That didn't work well either.

3.In the end, most of the time, if I define what the 'result' should look like and run it, the system eventually reaches that outcome.

The problem for me is that the orchestration code itself doesn't fit the style I like, so it's hard to look at. Using orchestration code basically means you're trusting the AI to handle everything without looking at the code. A lot of people say results come out quickly and work well, and models around the SOL level seem to perform decently. But for me, I haven't been able to get good results regardless

The truth is, the more a developed country is positioned at the consumer end, the more inescapable these problems become in our lives. Our world relies on outsourcing the production of manufactured and consumer goods to developing nations. But separate from that structural reality, vested interests refusing to acknowledge their faults is an entirely different issue.

Furthermore, I disagree with the radical ecological claims in the link. Humans might be developing technology that ends up destroying the public commons we call nature. However, I firmly believe there must be a better path to coexistence.

With climate change, it seems like poor people will die faster from 'climate poverty.' Science clearly points to human-caused greenhouse gas emissions driving climate change, but certain groups frame it as just another natural cycle of the Earth.

When I was younger, I learned that science was something pure. But as I've grown older, it seems like science is really about how it's used—and who gets to use it.

Taking my homepage as an example, when I allowed AI bots, I got about 1,200 visitors a day. But when I blocked them, that number dropped to around 140. It seems like over 70% of internet traffic these days is dominated by AI bots.