Totally agree.

I think we should all strive to do better. Unit tests, mock-ups, UX design, 2 week sprints with actual working deliverables, well documented use cases, every thing neatly stacked in Jira, dev,test,staging,prod environments, continuous integration and every thing else we are told to do.

Then reality sets in……

With all that said, 25 years as a dev, this utopian environment is almost impossible to find unless forced by regulatory compliance. Medical devices, life critical systems, etc. or if you have big piles of money.

then you probably spend ten times longer writing and re-writing tests

This is always what I've seen personally when people use TDD. And it's worse because the inevitable time crunch towards the end of the project means the developers stop maintaining the tests, which renders all of the work put into the tests up to that point useless.

It's also great for bug fixes. Write that sucker first and you have an easy way to reproduce the issue and check whether it's fixed.

Well put.

I mean, it sounds more like "The messier your project, the more difficult the unit testing". What you're describing sounds like issues with SRP and LoD. Which will inevitably happen as big projects get rushed, but let's place the blame where it belongs: rushing.

Yes unit tests take longer up front, but for projects that you need to update and maintain for a long time, they're a huge boon.

You can't do everything with a unit test obviously.

And often if you box yourself into an API before you start implementing, it comes out worse.

I always learn a lot about the problem space once I start coding, and use that knowledge to refine the API of my system as I work.

Exactly, from my experience, most of the time (primarily when I need to do something new) I start writing code, when it starts working then I am starting to refractor it so it doesn't look like crap.

Perhaps TDD would make sense, when before any actual work starts, we would have POC phase to understand what needs to be done.

After many failed attempts at TDD, I realized/settled on test driven design, which is as simple as making sure what you're writing can be tested. I don't see writing the test first as a must, only good to have, but testable code is definitely a must.

This approach is so much easier and useful in real situations, which is anything more complicated than foo/bar. Most of the time, just asking an engineer how they plan to test it will make all the difference. I don't have to enforce my preference on anyone. I'm not restricting the team. I'm not creating a knowledge vacuum where only the seniors know how yo code and the juniors feel like they know nothing.

Just think how you plan to test it, anyone can do that.

I had a coworker who was big into TDD. He was using it on a disaster project that was way over budget and long overdue. I was sitting in on a meeting between him and the client when he tried to defend the project's status by saying "you don't understand - we've written six times as much test code as actual code!" The client almost punched him.

IMO it doesn't matter what methodology you use if a) you don't have the ability to understand what the client actually needs, and 2) you can't code your way out of a paper bag (or to put it more technically, if you over-architect your solution and then can't solve all the self-inflicted problems you run into).

This reminds me when a senior engineer asked me to write exception handling on a one-off python script, not a production code - just a script devs can use internally. The "handling" was that the program should exit when a file is not found. He wanted me to try the file open, except the file error, print "file not found" message and exit(1).

Guess what, genius. Python already does that for you. No need to write an extra wrapper needlessly.

I much prefer having an in-memory database than mock what a database does.

Which sounds great in theory but then you get to find where your prod DB and testing DB differ and you have to keep chasing that. Unless you are using something like SQLite which has both (disk and in-memory) as an option.

I worked at a place that used a different in-memory DB (H2, IIRC) in place of our MySQL DB for testing. It ended up being hell to maintain and had to have hacks for how H2 and MySQL differ (tests would work in H2 but fail if run against MySQL or vice versa).

Send help? We're all caught in the same fire.

Make it maintainable should be up there too.

I’ve worked with projects that does the right thing, but no one can add new features to it because it’s a nightmare to work with. It’s at the level of not being able to move a button on the UI without breaking how the software interacts with the cloud.

Add make it cheap and you got yourself a deal

I think you have a point with the moving target, but also I believe that development should pretty much always be a moving target. You should be refactoring your domain based on new experiences and new knowledge all the time. So, personally, I find integration tests much more useful, because they test the input and output of a system, rather than how it's implemented. I can change my domain without having to modify my tests and that makes changes to the domain much simpler.

That being said, I also definitely recognize the advantages of TDD, I just don't think it's a silver bullet; there's good projects for it and bad ones

Yeah but getting the hang of it is the hard part. I don't know any dev in my company or my circle that uses it; we all did learn about it alright.

It is a lifesaver in some cases

There's some things called software architecture, requirement engineering and software design. More dev teams should try this.

Well so before you code it you still have an idea of what you want the program to do, right? So you write a test for the program to pass or fail based on that idea of functionality, and then you write the program to pass the test.

So for something simple like programming a calculator you might write test code that verifies whether your addition function properly adds two numbers together then write the actual addition function.

Later on as you continue to build the program your addition test will still be out there verifying that you haven't broken anything with subsequent code.

Some people will tell you that TDD tends to work better with established codebases in corporate environments where you have huge interrelated programs and maybe hundreds or even thousands of developers working concurrently as opposed to simple projects or startups where you might want to prioritize having a product set out before you start to implement rigorous testing requirements.

A lot of people don't like TDD because they see it as extra overhead and don't want to spend time writing test code when they could be writing "real code."

Proponents of TDD tend to point to the fact that it contributes to stability in the overall codebase and allows you to quickly and easily find and diagnose problems, and it can make you a better developer to think ahead rather than just dumping code into the codebase and assuming it's going to work.

You don't write a whole app in tests and then write the whole app in code, you make tests for the functionality as you go.

The Test part of TDD isn’t meant to encompass your whole need before developing the application. It’s function-by function based. It also forces you to not have giant functions. Let’s say you’re making a compiler. First you need to parse text. Idk what language structure we are doing yet but first we need to tokenize our steam. You write a test that inputs hello world into your tokenizer then expects two tokens back. You start implementing your tokenizer. Repeat for parser. Then you realize you need to tokenize numbers too. So you go back and make a token test for numbers.

So you don’t need to make all the tests ahead of time. You just expand at the smallest test possible.

This is very true.

Unfortunately most product managers SUCK at designing or making software.

Agile tries to fix this be supporting frequent iteration.

Unfortunately most programmers SUCK at writing good code.

TDD tries to fix this by forcing the consideration of end results (testing) at the beginning. It forces programmers and product teams to actually think and work. Make clear design decisions earlier on, but not to the point of waterfall.

It’s just a giant cesspool of failure due to human laziness that usually falls on the shoulders of QA.

Bottom line, making good software is hard. It takes time. But the market won’t support slow development. The business and sales teams remind me of Veruca Salt in Willy Wonka.

Good way to figure out how an unknown code base works is to add unit tests tho