Hacker News Reader

Comment by retsibsi | Hacker News Reader

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.

View on HN

> 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.

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.

An old critique of software engineers that I've always found flimsy and find that Hillel Wayne addresses well: https://hillelwayne.com/post/are-we-really-engineers/

> So it all wishes and prayers?

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.

Reply on news.ycombinator.com