3 ms·
This article makes a lot of assumptions that only hold true in a very specific set of circumstances: - that it’s possible for the team developing the product t
by alkonaut 7y ago
This article makes a lot of assumptions that only hold true in a very specific set of circumstances:
- that it’s possible for the team developing the product to deploy or monitor it (example cases where it isn’t: most things that aren’t web based such as desktop, most things embedded into hardware that might not yet exist etc.)
- that if you can deliver continuously, customers actually accept that you do. Customers may want Big Bang releases every two years and reject the idea of the software changing the slightest in between.
- not validating a deployment for a long time before it meets customers is also only ok if the impact of mistakes is that you deploy a fix. If the next release window is a year away and/or if people are harmed by a faulty product then you probably want it painstakingly manually tested.
My point is: if you are a team developing and operating a product that is as web site/app/service and you are free to choose if and when to deploy, then most of the article is indeed good advice. But then you are also facing the simple edge case among software deployment scenarios.
- inetknght 7y agoI generally agree with your points, with one exception: > If the next release window is a year away and/or if people are harmed by a faulty product then you probably want it painstakingly manually tested. No, you manual testing should only be for the things which are difficult to automatically test. But I think you should _always_ strive for extensive automatic testing. Even with hardware which doesn't yet exist, mocks are perfect for that.
- alkonaut 7y agoAgreed. Whether something is manually or automatically tested is really an implementation detail, but it’s economically insane to not have computers do the testing to the largest extent possible. It’s also possible to extend the argument to the relation between “compiler verification” and “test verification”. That is: don’t spend time writing tests for things a compiler could catch.
- derefr 7y ago> that it’s possible for the team developing the product to deploy or monitor it (example cases where it isn’t: most things that aren’t web based such as desktop, most things embedded into hardware that might not yet exist etc.) In these cases, you can have a pre-production embedded (in the sense of "embedded journalism") field test, where the developers come out to the production line and/or testing field to iterate on the software together with other departments + the final customers. IIRC this is done often in military weapons testing—you'll often find the software engineer of a new UAV autonavigation system at the testing range for that system, doing live pair-debugging with the field operator.
- lazyasciiart 7y ago> This article makes a lot of assumptions that only hold true in a very specific set of circumstances: Yes. The assumption that you are working on a web based service is so core to this piece that it doesn't seem any more necessary to say "this doesn't work for desktop" than it would be to say "this doesn't work without internet". given that you are delivering software on the web, your customers are going to get changes to it and like it, because their other option is to run systems on the internet with known exploits. Customers who don't want changes host their own instance. And if your next release is a year away and you have no way to roll back the release, but you have no manual validation - then you aren't following this advice to begin with, and you have an appallingly broken process.
- alkonaut 7y agoAbsolutely agree, my complaint wasn't that the advice was bad but that it lacks the specifier "what follows is good avice for this small subset of scenarios". I really dislike the phenomenon that "software development" without qualifier has begun to imply web app/servic development.