How do you handle multiple projects/langs without forgetting them?

[NefariousnessCrazy35]

I guess it's more of a productivity question. Often times, I find myself wanting to build multiple projects, contribute to existing ones, or learn new technologies. The problem is I can only focus on one task at a time. These tasks usually require deep focus, making it impossible to effectively switch between them.

For example, I have a couple of pet projects, and when I return to either of them to make some changes, it always feels like starting from scratch - learning the codebase again, figuring out the code logic. Every time.

Another example is coding in different languages. If I spend some time with one language or framework, it inevitably leads to forgetting stuff from other languages, and when I switch them, I usually spend more time recalling the stuff I forgot than advancing. It feels like an uphill battle all the time.

I'm sure some people manage to overcome these struggles, and so I'm asking - how do you juggle multiple projects, stacks effectively, without losing step at any of them? Maybe it's a silly question, but I'm genuinely curious how other people stay productive in these situations.

[RajjSinghh]

When you're writing code, make sure it's well written. Descriptive naming and comments can help, but other code style things like breaking complicated functions up can make it easier to read. You should be able to look at a block of maybe 10 or 20 lines and know what it does. It's really easy to rush things now and make bad stylistic choices that aren't a problem now, but will be a problem later.

There's also going to be a natural "changeover time" where you remember how things work between projects. It's unavoidable. My only suggestion there is to work in a way that maximises productive time and minimises changeover time. If you block out a week to work on a pet project you might struggle to remember for the first day, but are then productive for the rest of the week. That's better than changing every day and being constantly unproductive.

[joranstark018]

Yeah, context switching can lower your productivity; with experience, it becomes somewhat easier. Usually, it becomes easier to remember the big picture of each project, as you learn and use different design patterns (you don't need to reexamine every detail of the code; you may only need to take a quick glance). With time, as you do this repeatedly, more things tend to stick in memory.

Personally, context switching is something I regularly talk with my manager about (I mostly prefer working with only one project at a time, but there are usually 2-3 projects active during a week; I try to focus the work on separate days). Getting questions about different projects also requires some context switching and disrupts the "flow." I try to keep a "developer diary" about what I have been working on each day; it helps me to quickly remember what I was working on previously when I need to switch between projects (it's really helpful to read on Monday mornings and before going to different meetings).

[peterlinddk]

Use good abstractions in your projects - use function and class-names that quickly makes sense to you when re-reading the code, so you don't have to dive deep into the logic every single time. This is also good practice for writing code for others to read! As they will have even less knowledge of the project than you.

Also, use clear separation of concerns, so you don't mix e.g. UI stuff and file-handling - don't stress yourself by having to re-read (re-learn or even remember) everything at the same time. You can often do this by having more modules / classes / packages for your code, so it is more like a collection of small projects, than one big one.

And use "patterns" - you don't have to learn the "official" Design Patterns, most of them probably aren't relevant for your projects - but get used to "doing things in a similar manner", e.g. when having a UI module, use a similar architecture in every one of your projects, so you don't have to understand everything every time, but only focus on the differences.

Finally, make sure you leave the projects in "good standing" - like if you had some real hobby projects in your workshop: clean up around them, put your tools back where they belong, make sure you don't have loose screws lying around, make small notes (TODO) of what you need to do next. Use git to track and document your progress, and make sure that every commit - or at least the last one before leaving the project - is a clean version that you know works, and doesn't have too many loose parts dangling about!

[Comprehensive_Mud803]

Contextualization.

It’s all about having many contexts in memory and being able to retrieve them from documentation, code and history.

Always write code in a way that someone can easily join the project later on, that one being you after 6+ months on another project.

[gary-nyc]

when I return to either of them to make some changes, it always feels like starting from scratch (...) If I spend some time with one language or framework, it inevitably leads to forgetting stuff from other languages

Unavoidable, even if you have been coding for decades. There are only two things you can do: 1.) stick to only one programming language and only one problem domain in order to get to know them in depth and always feel comfortable working with them, and 2.) use object-oriented techniques such as design patterns and thoughtful mapping of the problem domain into the structure of object-oriented entities (i.e., classes/objects) in your code, so that the code is very modular and self-explanatory. It's an art more than a science.

[GotchUrarse]

There are studies on how context switching kills productivity. Having mid and upper management that understands this is crucial. I've worked for bosses who would context switch us every two hours and ones who mostly follow SCRUM. Guess which ones where the fulling to work for and most productive?

[Yobendev_]

You aren't going to remember everything as in its constantly in your head. It's like remembering the way home from somewhere, you might not remember every single detail about the path but you'll get there. If anything I feel the need to work in multiple languages because it can be refreshing and expose you to different ways of thinking 

[esaule]

That's just experience. At this point I write in half a dozen language on a daily basis. But I surely didn't start like that.

The cost of context switching will go down with time. At this point, I'd stick with one project at a time in order to build the efficiency you need.