- Complexity and functionality of code chunks and programs are mostly not based on "a handful of facts and memories". I experienced this not only when working with my own code but also when collaborating with other students or in exercises or research on foreign code.
- Working in small steps with frequent feedback and course correlation has been a bigger issue at the beginning of my studies. Seeing the mistakes and troubles, caused by missing out on these frequent reviewing sessions, made me experience their importance and also lead me to use a VCS to increase the traceability of my work and the reproduceability of different working states during projects.
- Modularizing is also a convention that had to be learned after experiencing the troubles without it.
- A lack of testing and debugging could have lead me into bigger problems in bigger projects like my bachelors thesis but luckily it didn't.
- I still don't use debuggers and tests enough because it mostly feels like an overkill for small projects, even though it might highly increase the reuseability and readability of my code.
- In the context of optimization I didn't really have any practical experience yet, since I have been more focussed on the theoretical optimization during my studies.
When working on a coding project (group size doesn't matter) the code is predestined to have different stages, versions and additionaly completly different branches in development (e.g. for experiments). A Version Control System is able to not only track the changes as snapshots for every developer and branch but also roll the project back to the state of one of those versions if necessary. It therefore increases the traceability of work flows and mistakes besides enabling development in arbitrary group sizes.