On the other hand, it is also important to quickly get into the state of a running program, because only that allows for iterative development where you can catch bugs shortly after you wrote them, rather than having tons of bugs after weeks of (not sufficiently tested) work.
It makes laying out the program much simpler and gives me a birds eye view of how easy it's going to be to maintain.
It's surprisingly effective.
It can also be explained as way to postpone decisions you can't clearly make right now. First, you pretend to have made the decision, and later on you implement the decision "you wish you had made".
For smaller segments though, I'll just write out function signatures, an then go back and fill em out or restructure them.
aka coding by intention
I think a big shift in modern software development came about when people finally realized that developing software is by nature a "messy" process. Loose text files, REPL sessions filled with red lines on the console, randomly scribbled boxes with arrows on loose sheets of paper strewn about the room; traversing object graphs in your head while on the drive to work. There is no "outline" to frame any of that. The outline only exists after the software has been built.
I would agree about the general outcome, though - enterprise software often is built _despite_ the politics between various departments and vendors, and much of the solution is as a result of compromise and integrating with "not quite suitable for current purpose" legacy systems. That is where a large amount of the cost goes. (It's also important to remember that what we're building today is also going to become the legacy system of tomorrow, and to include that thought in the design).
Design is messy. The implementation need not.
> “Design Patterns”, “Code architecture”, “Scalability”, “OOP”, “Maintainability”
Apart from Scalability others can be implemented from day one.
Scalability is about a dumb proxy first. Change in Data structures next.
In software, you have two choices.
1) Dumb code that works aka kludge.
The author is advocating kludge programming.
(I want to use this word distinctly from hacks, which are fewer and atleast clever)
I advocate this.
2) SQlite, Games
I advocate this too. Software that is meant to last, requires rigor.
My point is, the author is considering all programming to be engineering programming. It's not. And I do hate project managers that confuse the two.
I even concede that you can mixmatch the two (testing for eg). Why don't people see this middle ground ?
The only way I can really describe it is (in terms of what you just said): "red, green, refactor" your life, not just your job. Constantly question everything you're doing, and find out what you don't like about it. Find the root cause of that feeling, and figure out what you can do to fix it. Find and take the steps to complete that.
Edit: I will add though, that the trick is to do so without stopping progress, as you said.
Great comment!
Ironically, I think this is something that affects seasoned programmers more than new ones; the more you know about the trade, the more voices you have saying "no, that's wrong! Don't do that!", which can freeze progress. The way I combat it is by writing down pseudocode in my source code - literally just english, non-compiling pseudocode - which I then "refactor" into working code (thus the first "green" is "it parses"). By making step 0 the expression of the idea rather "writing the fist line of code", I can get right into the process rather than getting hung up on the "how".