These days you are hard pressed to find a language that uses dynamic scoping as the default.
The needle likes to swing back and forth between dynamic be static typing but we definitely seem to be coming back to static typing again
It's also my experience that a few well written integration tests are more useful and catch more actual bugs than a million unit tests. This is especially true of web apps which are inherently highly stateful.
The most powerful design paradigm I have ever found is to spend the first, say, 10-20% of my time making a rough prototype. Not with an eye of actually using a single line of it (although it happens) but just to do the quickest and dirtiest possible exploration of what the actual problem is.
you mean concerns that should be seperated but they did it in a wrong way?
patients = 400
x = pat / 2
This joke is like a decade old at this point https://xkcd.com/1172/
Namely, what does the following code do?
patients = 400
patents = 20
x = patients / 10
“Doing something” is the beginning of how to describe the actual truth of what some actions causes in relation to its affect on reality.
“Supporting something” has literally nothing to do with reality beyond what’s necessary to support a brain that can _intend_ a result or action regardless of what actually happens.
I linked the xkcd comic because the behavior described by the developer in the comic met the criteria for “doing something” but it didn’t meet the criteria for “supporting something” because the behavior of the software was not what the developer intended.
Back in my EE days in 90's, "full stack engineer" meant, for example, being able to build a physical calculator by connecting a numerical keyboard, bunch of 7 segment displays and a micro controller using bunch of wires on a circuit board, and THEN writing the assembly code to allocate memory and run your program in an infinite loop. You had to erase your EPROM with UV and burn your program to the chip over and over every time you changed a byte in your code. Debugging? You wish.
As a side effect, full stack engineers had the risk of getting electrocuted, or going blind :)
What makes software unique to other engineering disciplines is that it isn't a discipline at all. What makes software so great is how quick the iteration cycles are.
Software sits at a higher abstraction level than physical hardware, so much of our time is spent throwing at the wall and seeing what sticks because that's often (although not always) the best use of time.