4 ms·
For myself, I have found that the more detailed an estimate, the more detailed an "up front" plan. This is a classic pattern, and techniques like Waterfall and
by ChrisMarshallNY 5y ago
For myself, I have found that the more detailed an estimate, the more detailed an "up front" plan. This is a classic pattern, and techniques like Waterfall and TDD rely on it. It's an extremely good way to get the costs and plan formalized (critical, in many organizations). Further, with TDD, this allows a very detailed and complete test matrix to be established, so the end quality can be quite high.
I worked this way for most of my career. One of the big reasons, is that I spent a lot of my career, writing software in support of hardware devices, and coordinating parallel development efforts was crucial. Lots of critical paths.
Also, hardware people tend to be very "waterfall-y," so I was often never given a choice.
As a result, we learned to give fairly accurate estimates, for pretty long-term projects.
The main problem with this approach, is that it delivers yesterday's technology, tomorrow. By the time the project is released, no one wants it. Also, it's quite possible to deliver features and algorithms that aren't useful, inherently flawed, or actually detrimental to the user's workflow.
Once it has been written into the lists, it is set in stone; even if it is found to be a mistake.
After leaving my last job, I started experimenting with more flexible development methodologies. I think I've had some success[0]-[4], but the scope of the projects has been much more humble than my previous works (out of necessity).
In the project that I'm developing now, there has been almost no "up front" plan at all, and no set schedule. I've been working on the frontend app (a native Swift iOS app) for over a year. The backend is a couple of servers that I wrote years ago. One has since become a standalone open-source initiative, run by a different team[5], and the other was one that I made as "practice," several years ago[6].
In developing the frontend, I created a TestFlight-ready app, almost immediately (I made my first TestFlight release about a month after I started coding). This has been a "running prototype," ever since. The entire team gets releases, quite quickly, and gives feedback and testing. Additionally, the app is continuously being vetted by Apple, so we are unlikely to have the "App Store Approval Brick Wall" problem.
This has allowed the specification to "morph," throughout the life of the project. I have actually thrown away months' worth of code, as we have decided to pivot direction, many times, throughout the lifecycle.
We're all very happy with where it's at, now. We are in the home stretch (but we still have at least a couple more months of work on the frontend app). It is almost entirely different from the original, unworkable, "idea man" concepts, that were presented to me, over a year ago.
I've also been doing this for free. I can't imagine any company that wanted to make money, doing it this way. I would have been forced to deliver a crap hack, six months ago.
[0] https://littlegreenviper.com/miscellany/thats-not-what-ships-are-built-for/ https://littlegreenviper.com/miscellany/thats-not-what-ships...
[1] https://littlegreenviper.com/miscellany/forensic-design-documentation https://littlegreenviper.com/miscellany/forensic-design-docu...
[2] https://littlegreenviper.com/various/evolutionary-design-specification/ https://littlegreenviper.com/various/evolutionary-design-spe...
[3] https://littlegreenviper.com/various/concrete-galoshes/ https://littlegreenviper.com/various/concrete-galoshes/
[4] https://littlegreenviper.com/various/testing-harness-vs-unit/ https://littlegreenviper.com/various/testing-harness-vs-unit...
[5] https://bmlt.app https://bmlt.app
[6] https://riftvalleysoftware.com/work/open-source-projects/#baobab https://riftvalleysoftware.com/work/open-source-projects/#ba...
- necovek 5y ago> Further, with TDD, this allows a very detailed and complete test matrix to be established, so the end quality can be quite high. TDD is exactly not this. The main tenet of TDD is refactor early and often as you expand on the supported features. You do not write out all the tests up front, because some of those tests depend on the implementation (eg. the way you integrate components). TDD actually requires a very specific approach to testing, and some of the tests that you end up with are completely unexpected because they depend on how did you structure your code. TDD allows you to achieve an excellent level of quality, but it does not presuppose any "detailed and complete test matrix", because that defeats the purpose. If you do have very precise requirements, they'd usually be expressed in end-to-end tests that are commonly not done as part of a TDD workflow (even though they are crucial when it comes to scaling your team size). TDD only ensures that "internals" of your codebase are healthy, and that it's easy to refactor when requirements change. If requirements don't change that often, TDD might not win you much.
- ChrisMarshallNY 5y agoFair 'nuff. I was taught to write as many tests as possible up front. Start with failing tests, then make them work. We may not be able to write them all, up front, because of the "implementation not ready" thing, but we still need to have a plan for that point. Also, keep the tests forever. In my experience, it was a fairly rigid (and rightly so) process. I like the idea behind TDD. I desperately want software, in general, to have drastically higher quality. Might want to take a gander at [4], above. I take Quality very seriously.
- quesera 5y agoI don't think TestFlight builds go through Apple review. Maybe an automated static analysis step, but not human reviewer, which is where all the weird stuff crops up IME.
- ChrisMarshallNY 5y agoThey go through a review, every time the main version changes. Takes a couple of days. That said, I don’t think they do a “legal” review, but they do seem to look for things like private API use, general stability, and other things like that. In one instance, they ran into an obscure crash, that I missed, in my testing. If it’s just the build, it’s almost instantly approved. During this project, I have made hundreds of TestFlight releases. Also, they are constantly logging in (my app has user accounts). That is probably bot-driven. The profile photos are weird. There doesn't seem to be a real pattern to that. I do think that some of these logins were by humans, though. This was because of the type of information that was changed.