PS: Granted if you deal with less than 30 people process tends to be overrated.
So, let's assume that different approaches work for different numbers of people (shocking).
How would you break down work for a > 1 MLoC codebase with lots of people on it? How do you ensure it gets done?
I would do it by having 1 person operate as a system integrator with responsibility for designing interfaces at the top level, then farming out the subcomponents to each subteam, until this reached the point of implementation. Lots of these things can be specified up front (front end! back end! database! integration with other systems! tooling! algorithms! shared utilities!) . As development ensued and new knowledge found, responsibilities would shift and new teams formed/older teams reassigned. Several key thoughts here: 1 person owns the vision of the system (call them the systems engineer), interfaces define interactions with other parts of the system, teams responsible for tightly cohesive components with loose coupling to other teams. Mind you, that's sort of Fred Brooks-ish, but why not? We haven't gotten too far from Psychology of Computer Programming in actual practice.
Systems engineering is especially important when software is part of a larger multidiscipline project. All discussions here seem to focus on pure software projects.
I do not know. IMO, the CMMI-esque approach reeks of paperwork and micromanagement, and Agile approaches reek of lacking of planning. Both seem to be a bit problematic in their own way.
At any rate, would you mind providing some references & resources to read over for what you term systems engineering methodology? I am keen to understand other disciplines' approaches for getting engineering work done.
The Systems Engineering Body of Knowledge (http://www.sebokwiki.org/) would also be a good place to start. Probably quite a bit of overlap with the INCOSE site, but better organized.
OCW has a systems engineering course posted: http://ocw.mit.edu/courses/engineering-systems-division/esd-.... There are some lecture notes available, but unfortunately the materials are a little thin.
The trick is not to have pointless meetings. Someone should get something out of the meeting besides warm fuzzies and new doodles.
Agreed. I should have been more specifically snarky.
Carry on.
[1]: http://www.alittlemadness.com/2009/01/09/continuous-integrat...
I'm only asking because I've seen "in my experience" sermons delivered by fresh-out-of-college kids one too many times, and have become wary of the phrase.
Here's my methodology.
* Figure out what the software does, what the business cares about, and what the users care about.
* Figure out what it kinda sorta needs to be under the covers
* Write prototypes of the technically gnarly bits.
* Flesh out the prototype and start writing integration/functional tests for the system.
* Ensure CI server is live, running integration/functional/unit tests and build documents on push.
* Primary work phase: code review, write tests, write code as you go along. Figure out if features are needed or not. Don't overdesign or underdesign.
* Document subsystems as they stabilize using comments and in-repo text files.
* End of project: everything is tested, documented, and working.
Rinse, repeat.