scorpiomover
The little professor
- Local time
- Today 2:31 PM
- Joined
- May 3, 2011
- Messages
- 3,383
This is a development process that I've found over the years, seems to really help in getting things done in development. This is copied from a post I made in INTf. But I'd been meaning to write it here for a long while. Thought you guys might like to read it, and see what you think.
Basic principles:
Ne works by non-focussing. It's really the experimentation function. It's best used in a 2-stage process: experiment to develop valid working Si prototypes, and then use the Si prototypes to knock out the tasks at super-speed. Think of Ne as the R&D element of mass production, and Si as the production element of mass production.
It's thus important to control the process, to give plenty of time to Ne to fully develop a decent prototype, but also to keep an eye on the time, to ensure that it doesn't extend forever, so it has some use. So you have to first assess how much time to give to Ne and Si in the beginning. Then you encourage Ne, but with an eye on the time, to make sure that at least a valid prototype is developed before it's time to go into mass production.
The problem:
Whenever you're in the flow and just done anything good, there's a temptation to keep going and make more and more improvements, to make the system better and better.
If you keep adding in improvements into the same version, it's only a matter of time until one of those versions screws things up, and then you've no longer got a working prototype. Then all of your work has gone to waste.
At that point, all you can do is try to reverse your changes, which takes even more time.
Plus, you're in the flow, and so you usually don't remember everything that you've done. So often, even if you can recover what you did before, you're not really sure if you got it right, which vastly reduces your confidence in your own prototype. So then you need to put in a massive amount of system testing to regain confidence in your work.
In addition, sometimes, you discover that you can't recover what you did that did work. Then you have to start all over again from scratch.
Do that several times, and you've repeated your work several times over. Then your project takes several times longer than it should. Even if you're super-fast and much faster than everyone else, you still take much longer than everyone else, which makes you slower than everyone else, when in reality, you're much faster.
So you don't get much done.
Eventually, people lose confidence in you, are unsupportive and even critical. It's also easy for you to get very despondent and give up.
You can also get so used to failure in this way, that you expect to fail in the future, and then give up before you've started.
The solution:
Making your Ne development into multiple working versions, each an improvement over the last, seems to work better.
That way, the following happens:
1) Ne keeps showing successes, because each version is a successful prototype in itself. So that gives everyone confidence in the Ne process, which in turn means that Ne-users get all the encouragement and support to make really great systems.
2) Each version is an improvement on the last. So that gives free rein to Ne's creativity, and means that things keep getting better.
3) When it's time for production, you only need to pick the last working version, as that version is viable for production, and is the best production-level version that you have.
4) Even if Ne gets confused and screws up what it's doing in the development process, we can go back to the previous version, and then go forwards from there again. So most of the development work is saved, and there's very little cost to the random brainstorming process.
The algorithm:
To do that, is actually really simple:
You end up with several versions, sometimes dozens. But given the cheapness of hard drive space these days, it's not really a big cost.
The key:
The key with this system is that whenever you're in the flow and just done anything good, to resist the temptation to keep on improving it, and pause just long enough to make a new version. It slows the flow of thoughts a little. But the overall benefits are far greater than the cost.
This is the most important part of the process, and is what makes it work so amazingly well.
Summary:
Speaking from experience, the benefits are pretty great: No matter what, you've always got something useful. The more you use it, the better your system gets. Because you've saved the old versions, no matter when it's needed, you've always got something that can be used.
Thoughts?
Basic principles:
Ne works by non-focussing. It's really the experimentation function. It's best used in a 2-stage process: experiment to develop valid working Si prototypes, and then use the Si prototypes to knock out the tasks at super-speed. Think of Ne as the R&D element of mass production, and Si as the production element of mass production.
It's thus important to control the process, to give plenty of time to Ne to fully develop a decent prototype, but also to keep an eye on the time, to ensure that it doesn't extend forever, so it has some use. So you have to first assess how much time to give to Ne and Si in the beginning. Then you encourage Ne, but with an eye on the time, to make sure that at least a valid prototype is developed before it's time to go into mass production.
The problem:
Whenever you're in the flow and just done anything good, there's a temptation to keep going and make more and more improvements, to make the system better and better.
If you keep adding in improvements into the same version, it's only a matter of time until one of those versions screws things up, and then you've no longer got a working prototype. Then all of your work has gone to waste.
At that point, all you can do is try to reverse your changes, which takes even more time.
Plus, you're in the flow, and so you usually don't remember everything that you've done. So often, even if you can recover what you did before, you're not really sure if you got it right, which vastly reduces your confidence in your own prototype. So then you need to put in a massive amount of system testing to regain confidence in your work.
In addition, sometimes, you discover that you can't recover what you did that did work. Then you have to start all over again from scratch.
Do that several times, and you've repeated your work several times over. Then your project takes several times longer than it should. Even if you're super-fast and much faster than everyone else, you still take much longer than everyone else, which makes you slower than everyone else, when in reality, you're much faster.
So you don't get much done.
Eventually, people lose confidence in you, are unsupportive and even critical. It's also easy for you to get very despondent and give up.
You can also get so used to failure in this way, that you expect to fail in the future, and then give up before you've started.
The solution:
Making your Ne development into multiple working versions, each an improvement over the last, seems to work better.
That way, the following happens:
1) Ne keeps showing successes, because each version is a successful prototype in itself. So that gives everyone confidence in the Ne process, which in turn means that Ne-users get all the encouragement and support to make really great systems.
2) Each version is an improvement on the last. So that gives free rein to Ne's creativity, and means that things keep getting better.
3) When it's time for production, you only need to pick the last working version, as that version is viable for production, and is the best production-level version that you have.
4) Even if Ne gets confused and screws up what it's doing in the development process, we can go back to the previous version, and then go forwards from there again. So most of the development work is saved, and there's very little cost to the random brainstorming process.
The algorithm:
To do that, is actually really simple:
- Do your Ne brainstorming.
- When you've got something even a little bit good, test it, save it and most important: give it a version number.
- Take a moment, have a coffee or a beer and a snack. Relax. Maybe add some documentation, so it will be easy to use in production. Also add a few comments saying what you've done in this version that is an improvement over the previous version.
- Then before starting work again, duplicate the project, giving it the next version number in the sequence.
You end up with several versions, sometimes dozens. But given the cheapness of hard drive space these days, it's not really a big cost.
The key:
The key with this system is that whenever you're in the flow and just done anything good, to resist the temptation to keep on improving it, and pause just long enough to make a new version. It slows the flow of thoughts a little. But the overall benefits are far greater than the cost.
This is the most important part of the process, and is what makes it work so amazingly well.
Summary:
Speaking from experience, the benefits are pretty great: No matter what, you've always got something useful. The more you use it, the better your system gets. Because you've saved the old versions, no matter when it's needed, you've always got something that can be used.
Thoughts?
