As I like to tell others: before my job was 70% architecture & patterns and 30% coding & algorithms. Now my job is 100% architecture & patterns. While I still spend the majority of my time on architecture & patterns, and while I enjoy this aspect more than coding and algorithms, I am still working a "different job" than I was when my hands steered the code completely.
People say stuff like this all the time, but what does it actually mean? Like, isn’t the details of the code, at least at some level, part of the “architecture”? I’m so curious about what people who say this are actually making where they just sit around all day and dream up new lego structures without ever having to look at any of the bricks.
The bricks are pretty standardized? I mean, you're not reinventing singly-linked and doubly-linked lists from first principles no? When I program I think in terms of data structures, data hierarchy, and algorithms. I want to use a queue here, a lock here, a double linked list there, an array list over here, maybe a hash dictionary with linked-list chaining for collisions. It's only a few times in my career that I built a bespoke data structure from the ground up and they were all for very hot loops and one case involved working on a lock-free algorithm.
I've done a lot of functional coding in the past (in academia, in Haskell as a hobby, and Scala for a unicorn where I was an early hire.) This probably affects how I think. But I find it quite natural to organize my code this way. After all the fundamental data structures and the hierarchies relating them are what often determine core properties of your programs such as being CPU, Memory, or IO bound.
I also work as a pretty senior engineer and my tasks before agents were usually about leading a team to implement something. I would often do the v0 implementation to make sure we met customer requirements and then take a step back and help the team scale the service up. These days the team is a lot smaller and maybe just another engineer; the agents make up the rest.
Surprisingly enough, before I led teams I wrote software by hand from tickets the way any other mid level software engineer did. And also quite oddly, when I contribute to open source I still just write it by hand, from scratch, and am at the mercy of the maintainers who give my patch feedback or reject it. So somehow, I know it's crazy but somehow, I am able to use my experiences to weigh in on this.
I may have it wrong, but I think 'architecture' can include relatively low-level details: you could even design a program down to the level of what each function does, and still only be doing 'architecture', not coding, so long as you're not writing the code or specifying exactly how it should work.
> you could even design a program down to the level of what each function does, and still only be doing 'architecture', not coding, so long as you're not writing the code or specifying exactly how it should work.
So it all wishes and prayers? no wonder software quality is down.
Software is built on wishes and prayers. Programmers don't ship pixels to be installed in monitors, nor do we (mostly) work with compiler internals. We write a detailed set of instructions and hope that a bunch of systems we don't necessarily comprehend follow them well enough to get the intended results. It works because some folks got together and wrote down their wishes and prayers so good that others were able to understand and follow them later.
We can be curious about how others approach problems or we can try to find the faults. I feel like this comment is a great example of jumping to the negativity rather than trying to understand a different perspective.
I ultimately think learning how other people structure programs is an enriching task and not one that should cause you to dig in and discredit differently-shaped approaches.
> I ultimately think learning how other people structure programs is an enriching task
Learning from others is great. But there should be actually something to learn. When someone says
so long as you're not writing the code or specifying exactly how it should work.
It means they’re not creating software. They’re just playing with randomly generating something.
A software is the recipe for some process. The code is the formal version where everything is exhaustively specified. Not thinking about the code means you’ve stopped thinking about the software somewhere and no longer can say if it’s ok or not.
What's the point of leaving a comment if you're not going to change your mind and they're not going to change theirs? Is it just to advocate for your position?
As you're being very vague, I write more about my opinion, which is based on a guess of what your approach. Basically the Q of P imply Q where P is the guess (and P is the thing you're being vague). I'd like if you can prove that either P is not valid or that there's a different Q that exists.
Axiom: A software is the recipe for some process. The code is the formal version where everything is exhaustively specified.
P: Not thinking about the code
Q: means you’ve stopped thinking about the software somewhere and no longer can say if it’s ok or not.
To further go with my point, it's like explaining how to make a cake and you said that instead of a recipe, it's fine to provide just the name of the ingredients and a general instruction like: mix everything together and put it in the oven.
When we write code we sit atop a tower of abstractions. You're trusting your language's stdlib, its compilers, the syscalls offered by your kernel, the virtual memory implementation of the kernel. Your coworkers wrote code that you only interact with as a library or over an API of some sort. Let's not even think about the lossy abstraction of taking the ultimate bytecode generated and actually mapping it to the actual CPU pipeline that's running the code.
Modern computing is an exercise in trusting abstractions and then zooming into the abstractions and figuring out what went wrong when something breaks. Just because I wrote a web route doesn't mean I've audited the code behind the web framework, the event loop, the HTTP implementation, the TCP implementation and so forth. By your argument then I've already stopped thinking about my software and can't tell you if it's okay or not.
I'm sympathetic to both the perspective of sadness from the loss of hand coding and the perspective of joy from working at a higher level of abstraction, despite its costs in understanding. It actually seems very simple to me to hold both perspectives within me.
The thing you’re forgot to mention is that the trust in the layers below your code is not blind. Sure you treat it as axiomatic foundation. But when something breaks and you’re sure it’s not about your code, then you can investigate the actual part that is wrong in that foundation.
Once that’s done, there’s a matter of accountability where you can report the issue to the people responsible for that. Then because they know their own code they can repeat what you did and try to find where things went wrong.
That chain of accountability is the main issue there. We still have tower of abstraction, but no one knows about their layers. Accountability is lost and with it the trust is gone.
I never care about code, whether you wrote the majority of it or it’s just a glue that hold several library. What I care about is that the semantics of that module that I interact or build upon can be trusted, and when something wrong is an accident and not a daily event.
Even when you’re writing an application and not a library or a platform, you’re not free to write whatever. Your users depends on you, and themselves may have clients that depends on them. Being cavalier about what you write is just recklessness and in any other (real in some countries) type of engineering, it would be labelled as malpractice.
> That chain of accountability is the main issue there. We still have tower of abstraction, but no one knows about their layers. Accountability is lost and with it the trust is gone.
Right this is the main difference between our viewpoints. I don't work on completely open systems. A lot of my life I've worked on closed platforms, cloud runtimes, a mix of work that's been in my control and out of my control. I've filed my share of AWS tickets but ultimately most of them ended up not fixed by AWS. I've made peace with not having accountability for layers of the stack and am comfortable assuming that there are bugs on the foundation that I have to work around.
> Being cavalier about what you write is just recklessness and in any other (real in some countries) type of engineering, it would be labelled as malpractice.
