I developed our current project architecture and started developing it on my own (reaching something like,
We're developing a simple subway routing framework and my design seemed to be done extremely well - several main models, corresponding views, main logic and data structures were modeled "as they should be" and fully separated from rendering, algorithmic part was also implemented apart from the main models and had a minor number of intersection points.
I would call that design scalable, customizable, easy-to-implement, interacting mostly based on the "black box interaction" and, well, very nice.
Now, what was done:
- I started some implementations of the corresponding interfaces, ported some convenient libraries and wrote implementation stubs for some application parts.
- I had the document describing coding style and examples of that coding style usage (my own written code).
- I forced the usage of more or less modern
C++development techniques, including
no-deletecode (wrapped via smart pointers) and etc.
- I documented the purpose of concrete interface implementations and how they should be used.
- Unit tests (mostly, integration tests, because there wasn't a lot of "actual" code) and a set of mocks for all the core abstractions.
I was absent for 12 days.
What do we have now (the project was developed by 4 other members of the team):
- 3 different coding styles all over the project (I guess, two of them agreed to use the same style :), same applies to the naming of our abstractions (e.g
SubwaySchemeStructures.h), which are basically headers declaring some data structures.
- Absolute lack of documentation for the recently implemented parts.
- What I could recently call a
single-purpose-abstractionnow handles at least 2 different types of events, has tight coupling with other parts and so on.
- Half of the used interfaces now contain member variables
- Raw pointer usage almost everywhere.
- Unit tests disabled, because "
(Rev.57) They are unnecessary for this project".
- ... (that's probably not everything).
Commit history shows that my design was interpreted as an overkill and people started combining it with personal bicycles and reimplemented wheels and then had problems integrating code chunks.
Now - the project still does only a small amount of what it has to do, we have severe integration problems, I assume some memory leaks.
Is there anything possible to do in this case?
I do realize that all my efforts didn't have any benefit, but the deadline is pretty soon and we have to do something. Did someone have a similar situation?
Basically I thought that a good (well, I did everything that I could) start for the project would probably lead to something nice, however, I understand that I'm wrong.