And isn’t it such a dangerous overlap! The coder whose writing (in their native language) is unclear, repetitive, convoluted, or hard to follow too often produces code with the same qualities. It’s even worse when the same coder believes “code is self-documenting” without considering why. Code self-documents with careful and deliberate effort, and in my experience, it is the really good writers who are most capable of expressing code in this way.
The person who changed the code, it’s just ordinary maintenance. The comments may not execute, but I submit they are as much a part of the program as the executable code. Maybe over time those comments are condensed, or even removed; no different than any other refactoring or cleanup.
regexes are a well established solution for parsing strings. what exactly is the “proper” alternative you propose?
An autistic coder would have documented this feature to the point of pedantry.
I actually agree that “good enough” code can be self-documenting, but it isn’t always enough to achieve my goal which is to make the code understandable to my audience with minimal effort. With that goal in mind, I write my code as I would write a technical document. Consider the audience, linear prose, logical order, carefully selected words, things like that… In general, I treat comments as a sort of footnote, to provide additional context where helpful.
There are limits to self-documenting code, and interfaces are a good example. With interfaces, I use comments liberally because so many of the important details about the implementation are not obvious from the code: exactly how the implementation should behave, expected inputs and outputs under different scenarios, assumptions, semantic meaning, etc. Without this information, an implementation cannot be tested or verified.
I will read that post sometime (maybe). I wasn’t really referring to some well defined thing, but rather to something that happens naturally when complex software development is done right. Quasi-scientific: make assumptions, build the thing, test assumptions, update assumptions, rinse and repeat. The “architecture” ends up being the collected knowledge about the system which emerges from the development.
Something like that anyway. Interested to read about One and Two Way decisions.
I vividly remember some of the garbage code I’ve written in the past. Huge interface definitions… Weird and brittle abstractions… Overly complex processes to do what should have been a simple task…
Funny thing is, I read and understood the same kinds of things as any other coder worth their salt: agile, SOLID, YAGNI, do one thing well, and so on – but it was all just theory. It takes experience and mistakes to really grok it all.
Is there a meaningful difference between this idea of Post-Architecture and emerging architecture?
I’ve had a colleague or two like that before. “I’m willing to put in the work to fix the code” is something I would hear, as if it were some kind of virtue. To their credit, people like this move mountains to make shit work, and it usually does. Yet, trying to read and understand their code (much less change it) is a Sisyphean endeavor.
Afaict wine uses XWayland. Sometimes with my games I’ll have problems like the game running on one display and expecting input from the other, even when I’ve switched the second display off with wlr-randr. I also have occasional UI scaling problems. Most things works well most of the time though.
With a good compositor, Wayland itself is probably ready enough for most cases. A lot of applications need to be updated to better support it though., and that seems like a lot of work.
Removed by mod
Installed it, why not. Tried to run it.
error opening [PathLikeWithPosition { path_like: “/home/me/test”, row: None, column: None }]: NoSupportedDeviceFound
Then tried it in Xorg, and it runs normally. I guess it doesn’t run in Wayland?
…
So, I gave it a short test drive. Observations:
Suspect it’s shooting to be something like sublime text. Cool, but seems like there’s a lot of work to be done.