Below, you'll find ContextKeeper, a session manager for Visual Studio, compared to alternatives.

All extensions included in the comparison work with Visual Studio 2022. I've included free extensions, with the exception of Task Canvas, which is a paid one. I've invested several hours testing Favorite Documents, Workspace Manager, and Task Canvas to get a clearer picture of how they all stack up against ContextKeeper

Task Canvas

I must say, I'm a bit surprised by how Task Canvas, the only paid competitor, performed in the comparison. It was built with a different workflow in mind, which is why it lacks in certain areas. However, it's still quite powerful and presents an interesting concept with its independent task canvas (separate, physical tab). Kudos to Sergey for trying something different. I'll take a closer look to see if there are any elements from this concept that could add additional value to ContextKeeper. What are your thoughts on this?

Favorite Documents

It appears that the most popular extension is based on the simple VS API - VsShellUtilities.OpenDocument(). Unfortunately, it lacks more sophisticated use cases. Nonetheless, it's still better than relying solely on Visual Studio's default state engine and the inherently flawed .suo file.

Workspace Manager

The spiritual successor to the (broken) approach of Save All the Tabs, utilizing the IVsUIShellDocumentWindowMgr.ReopenDocumentWindows() API. Unfortunately it is nothing more than wrapper for the default Visual Studio state engine, which which has had persistent, unresolved issues for years. It's unreliable, sometimes functioning properly but often failing. My experience with it has been similar to Save All the Tabs, which I tried using with mixed success in the past.

The fail of the Save All the Tabs extension, to deliver a stable and reliable restore mechanism, really push me to work on the a truly independent session restore engine. I distinctly recall my thought process during that time -

If it doesn't work, I'll at least give it a shot and try to build it. There's nothing wrong with failing, but if I succeed, it will be a big deal one day! I will try to make it the state-of-the-art session manager that Visual Studio has never had but always deserved.

Later, the context engine has become the heart of ContextKeeper. It was entirely written from scratch, and it is fully independent from Visual Studio session restore API. It is rock solid, and works in VS 2022, including olders versions VS 2019/2017/2015. It has taken thousands of hours and years of work to bring it to a state where it is a true pleasure and an enjoyable experience to use, and to have the session manager that Visual Studio has always deserved. 🚀 Cause there ain't room for more than one King 👑 in this town.

This article is part of C# Advent 2023. For more articles in the series by other authors, visit https://www.csadvent.christmas/

Everyone has struggled with procrastination at some point in their lives. If they say otherwise, they are just lying. We are not robots and we have biological, physical and mental limitations. If you are not aware of them, you will often have problems with procrastination without realizing what is the root cause.

"No pain, no gains". It is the simplest, most powerful tip possible. Works every time - just follow your pain. "Just fucking do it, now" - let it be your mantra from now on. It hurts the most at the beginning, the first 10-15 minutes is crucial for any activity which your brain recognize as "unpleasant" (no instant dopamine rush). Just start working on a "hard task" despite the (mental) pain and it will fade away.

Your brain is lazy and likes nice things (dopamine). The trick is to "hack" dopamine feedback loop. If you're starting an activity, and you feel mental pain, you're on the right track. The "mental pain" is yours brain trick to force you to conserve as much energy as possible if it doesn't bring immediate reward (dopamine), or if the outcomes are uncertain (any long-term activities).

Because your limbic system has two main modes: fight or flight. Due date is a trigger to fight. Hard task is a trigger to flight. This is why "due date" is working. "Hard task" is the trigger for procrastination.

How to "hack" your brain

1. "Dopamine detoxing" - watch this video by Leon Hendrix and you will know how to do it. It's really good. Probably the best introduction so far and I have watched a lot of them. Or if you like more scientific approach by Andrew Huberman.
   • Block social media, block any media that allows infinite scrolling with immediate reward (dopamine rush): Twitter, TikTok, Facebook etc. (News Feed Eradicator plugin for Chrome/Firefox does the job)
   • No music, no games, no podcasts, nothing,
   • Books are allowed. But be careful, reading too much can be another form of procrastination.
2. Internal "due dates" made by you. Check them weekly.
3. Doing the most important thing ("hard task") as the first thing in the morning, or when you start you work. That means no reading, no social media before. Just starts working.
4. Measure you daily activates. I personally use Toggl Track (free). If you don't measure, you just guessing how you perform.

This is a good starting point. Later you could develop your own custom system based on different resources. My personal recommendations: book "The War of Art" by Steven Pressfield, and videos by Alex Becker - dopamine detox and treating life as a game .

You are not your brain

I also want to share with you two amazing videos that had a huge impact on my (not only) developer productivity many years ago and taught me how to balance my life energy better throughout the day. They gave a better understanding of how our brain and mind work, especially under heavy stress (e.g., deadlines), and provided great tools for everyday challenges.

Short form, packed with value (only 29 and 23 minutes). Those are little gems 💎 from my private “diamonds” list:

• You are not your brain, Dr Jeffrey M Schwartz (2011)
• Making Badass Developers, Kathy Sierra (2015)

After watching them, you won’t ever again fall for your brain's tricks that easily. Dude's smart, but you'll be prepared. Your brain is just a tool for your consciousness and mind. And remember, “You are not your brain”.

I’m really happy and excited that finally the two biggest features, breakpoints and bookmarks, have finally been implemented and are now available the ContextKeeper version 1.95! 🎉🍾

Bookmarks, breakpoints, and relative paths (implemented in May 2022) were the big missing pieces from the 2022 roadmap that I always wanted to include as ContextKeeper’s cornerstones.

Not only are open files remembered, but so are their order, pinned and selected state, line and column position, document groups, window position, breakpoints, and bookmarks. And last but not least, you can seamlessly open them across different development environments (thanks to relative paths).

From the early days of ContextKeeper, I wanted to be sure that every released feature was of top quality and production-ready, despite the fact that we are still in the Private Beta 😄. Therefore, the polishing phase for breakpoints and bookmarks support has taken a lot longer than I had originally expected. Surprisingly, the bookmarks support was a lot more complex than I had initially thought based on the early December prototype.

Generally, when a snapshot is created, breakpoints and bookmarks are saved only for the currently open files. This behavior differs from that of Visual Studio, which remembers all breakpoints and bookmarks across different sessions for all files. However, I believe that saving them only for open files is more practical. I remember countless examples of finding old breakpoints from days before that were no longer relevant because I was working on a different task.

The second important thing is that when they are restored for a file, all old breakpoints or/and bookmarks are removed if there were any, but only for that file and nothing else.

Breakpoints

Standard and conditional breakpoints are currently supported. When breakpoint is disabled it will be still saved to a snapshot with IsEnabled property set to false and restored in a disabled state later in the Visual Studio. A single conditional expression is supported with two modes Is true and When changed

Although the supported area is probably enough for about 90-95% of use cases, there are some limitations:

• only a single conditional expression,
• no support for Hit Count or Filter expressions,
• no support for Actions, “Remove breakpoint once” hit or “Only enable when the following breakpoint is hit” options.

I will be looking for ways to support excluded areas, starting from “Hit Count” and combined conditions (e. g. Conditional Expression with Hit Count). Unfortunately not every breakpoint’s detail is easily exposed via API but I will be extensively digging in Visual Studio’s internals to cover more use cases.

Bookmarks

Bookmarks are stored using line numbers in a similar way to breakpoints.

Visual Studio API for bookmarks is really limited; therefore, currently there is no support for:

• named bookmarks - only the line number is stored but not the bookmark name,
• folders - bookmarks folder structure is not restored.

I hope you will enjoy using new breakpoints & bookmarks support!

Peek implementation, Ctrl + Alt + Q

Navigate using arrows ⬆ ⬇ + Enter to select

🎅 Day 3 - Go To Line and Displaying Line Numbers

Go To Line, Ctrl + G

To display line numbers go to Tools->Options>Text Editor->All Languages

🎅 Day 2 - Go To Definition and Peek Definition

To navigate to implementation details (Go To Definition), press F12 or
Ctrl + mouse click.

To only peek on a definition, press Alt + F12, which will open small panel below your cursor allowing you to edit the code without losing current context.

Pressing Alt + F12 multiple times will recursively open Peek Definition panel. You can navigate back (Ctrl + Alt + -) and forth (Ctrl + Alt + =) between different fragments using breadcrumbs.

You can close the Peek Definition view by pressing Esc and switch between the editor and the definition window by pressing Shift+Esc.

🎅 Day 1 - Navigate to Recent Cursor Positions

To navigate to recently visited/edited code in the current session, press Ctrl + -. You can do this multiple times.

To navigate forward, press Ctrl + Shift + -. The forward and backward mouse buttons also work in the same way.

Release v1.9 is here! 🎉 Grab it if you haven't updated already. ContextKeeper 1.9 is mainly feature release packed with cool new features that will make switching contexts even more smoother than before. There are some UX upgrades and git integration improvements. Also, a lot of small annoying bugs 🐛 were squashed during the process (changelog).

This year, will bring at least one additional feature release, making your every snapshot more dense and filled with new contextual metadata. Did I say we're just getting started? Hell yes!💪 The gas pedal is pressed to the floor. If you already enjoy using ContextKeeper, you will shortly fall in love with it in the coming months. I can guarantee that!

Git integration improvements

Finally, a full branch name is displayed for auto-generated git snapshots. A new GitBranch property was introduced to the snapshot JSON format. Now it stores the actual full branch name for a given snapshot:

There are also nice new icons for a git branch and a stashed snapshot, instead of the temporary text placeholders that were before - <Git Branch> and <Stashed>.

The previous implementation did not display git special characters in the branch name. The special characters were always removed because the output string should be a valid filename to save a branch snapshot.

The implementation is still not perfect because it does not support naming collisions. There are still rare situations when they can occur. Improved support will appear in the future releases. If you will notice any problems where a context is not restored properly please report an issue here.

Small finishing touches are important for a good UX which is why a tool tip was added to display the actual type of a snapshot (standard, git branch or stash) with a full path name. Now it's now easier to recognize where a given snapshot is stored.

Selected and active documents in tab groups

There can be multiple tab groups opened at once and single document selected in each:

The state of both selected documents is now preserved using IsSelected JSON property.

Additionally, support for the active tab was added. When a document has focus while generating the snapshot, it will be tagged internally using IsActive property.

If you have noticed that sometimes document's line and column position wasn't restored properly - there is a good news! At least two line&column bugs were fixed in the v1.9 (changelog).

Bookmarks support is coming soon

Bookmarks support is part of the 2022 Roadmap and I'm happy to annouce it is almost ready🔥:

I want to share with you the best methods to maintain high productivity. These are carefully selected practices that work. I've tried every method I heard about in the last 17 years. Some do work but some definitely don't. Let's focus this time on the ones that work:

• Working in the morning
• Fasting and razor-sharp focus
• Focus (time) blocks
• Tracking working hours, you don't know when you don't measure
• Good night sleep, at least 7+ hours
• Low stress level

Working in the morning

Your mental energy tank is refilled after good night sleep. Don't waste it in the morning on the non-essential activities like emails, meetings, reading news or even gym/physical activity. Try to do as much creative work and coding as possible. And take a break. Remember that the maker's schedule is different and not compatible with the manager's schedule. You will be amazed how much you can do in 3-4 hours in the morning when you're really focus in the distraction free environment.

Mental energy is finite and it's draining through the day. Those hard limitations are put in place by the human brain. There is no magic hack or pill that will extend your ability to concentrate. After sometime you will finally hit "the wall" and more coffee, quick naps or meditation won't help. Remember to use your mental energy wisely through the day. To turbo-charge your ability to focus I recommend reading "Your Brain at Work" by David Rock.

Kathy Sierra has really good explanation why mental energy is finite and how to protect yourself from losing it.

You can be surprised why I'm against gym in the morning? It will exhaust your body nervous system and you will have hard time to concentrate. A pump you feel in your muscles is nice when training, but it gets in the way of your creative work. Also, physical exhaustion doesn't help to maintain high level of mental focus. I've been weight training and powerlifting for more than 25 years (with longer breaks) and I recommend training in the afternoon or evening, but not too late because it may cause problems with falling asleep.

... to be continued. Subscribe to the part 2, "Fasting and razor-sharp focus", below.

Interruptions and context switching are the two most costly factors that directly impact a programmer's daily productivity. Although there is no permanent way to avoid them, there are some interesting strategies to minimize their impact.

The Cost of an Interruption

Based on various scientific studies, it takes at least 10-15 minutes to get back into the "zone" after an interruption (Parnin:10, vanSolingen:98). Depending on the complexity of the task and your mental energy, it can definitely take more than just 15 minutes:

If an interruption occurs when you have a lot of balls in the air - multiple pieces of unfinished code fitting together in a complex way - then returning to the flow state can be more challenging. This concept is well-known to every programmer, but probably only a few have heard about The Parable of the Two Watchmakers, which perfectly captures all those details in a comprehensible form, even for non-programmers:

There once were two watchmakers, named Hora and Tempus, who made very fine watches. The phones in their workshops rang frequently and new customers were constantly calling them. However, Hora prospered while Tempus became poorer and poorer. In the end, Tempus lost his shop. What was the reason behind this?

The watches consisted of about 1000 parts each. The watches that Tempus made were designed such that, when he had to put down a partly assembled watch, it immediately fell into pieces and had to be reassembled from the basic elements. Hora had designed his watches so that he could put together sub-assemblies of about ten components each, and each sub-assembly could be put down without falling apart. Ten of these sub-assemblies could be put together to make a larger sub-assembly, and ten of the larger sub-assemblies constituted the whole watch.

The Cost of Context Switching

When switching between complex programming tasks, it is typically more mentally challenging to return to the flow state than it is from a "simple" interruption. Fully switching to something else requires flushing the cache (short-term memory) and loading an entirely new context. This process takes time, effort, and mental energy, which is finite and depletes throughout the day. These hard limitations are imposed by the human brain.

There is an exceptional book written by David Rock, called Your Brain at Work, that I highly recommend if you are interested in improving how you spend your mental energy throughout the day. The gist is to treat your brain, during a deep work session, as a stage. As a session starts, you slowly introduce essential actors (objects, tasks, and pieces of information) into a scene (short-term memory aka cache). To properly light up a scene, you need to use some energy - mental energy.

When you get distracted, the entire stage collapses, and it takes effort to rebuild it from the ground up. However, there are some handy techniques to rebuild it faster.

Rebuilding The Context

For programmers, rebuilding the context after a task switch usually involves going back to old code that was previously edited or debugged. Before editing starts, programmers navigate to several locations to rebuild the context (Parnin:10). However, task resumption can become much more painful if an IDE doesn't remember the previous working state. This usually means:

• last opened files,
• cursor position (line & column) for every opened file,
• breakpoints, watch variables and expressions,
• bookmarks,
• windows positions with the same layout (including tab's splits).

Rebuilding the last working state in an IDE manually is usually a real pain and mentally challenging:

Losing this functionality interrupts my workflow beyond imagination. The opened documents represent a "bookmark" for me and I'm barely able to pick up work again without them.

Every time this happens (...) I am willing to put hours into finding a solution, because the thought of losing my opened document state once more after a work session is terrifying. But this time around (...) nothing of the usual remedies helps (...) This has added another 20 minutes and counting to my two hours put into solving this.

and programmers are perfectly aware of the problem:

This is a much bigger problem than it sounds as you then need to use other ways to remember what you were working on. This causes A LOT of lost time - source.

It’s so frustrating to have to keep pinning the same tabs over & over & over & over & over & over (I think you get the point). (...) My productivity goes down, and my stress level goes up! - source.

Which is why, the ability to save working state is now considered a fundamental feature of every good IDE nowadays. However, this was not always the case. Vim introduced :mksession command in the v5.2 around 1998:

A Session keeps the Views for all windows, plus the global settings. You can save a Session and when you restore it later the window layout looks the same. You can use a Session to quickly switch between different projects, automatically loading the files you were last working on in that project.

The 640 x 480 resolution was the standard from 1990 to around 1996, but it was possible to get more screen real estate back then. There is a famous photo of John Carmack working on Quake using a 28-inch 1080p monitor in 1995.

Why did he choose 45 kg monitor for about $10k in 1995? The higher screen real estate allowed for more code to be visible at once, resulting in a more dense context. Productivity greatly increases when you have the ability to store and access more detailed context. It's like having a larger desk to hold documents when studying for an exam or doing any task that requires the use of multiple sources of information from a common domain, such as solving puzzles.

I still remember working on my Amiga 1200 in the early 90s, using HiRes resolution (640x256) and coding in C using CygnusED editor.

Only one file can be opened at a time on this screen, and it does not offer as much real estate as my primary 4K monitor does these days. From a developer's standpoint, the effect and advancements of display resolutions on daily productivity are immense. Let us attempt to define this observation.

The Law of Context Density

A larger context naturally emerges with a bigger screen real estate.

The Role of Prospective Memory

Why is it so important for programmers to have access to their last working context? Let's start with the definition of prospective memory by John A. Meacham:

Prospective Memory - information with implications for actions to be performed in the future.

Prospective memory is akin to a sticky note posted on a fridge with a reminder to buy milk after work, or an important document placed near an exit door so that you won't forget it when leaving the next morning.

A last working context is a form of prospective memory task, so a resumption failure is also a prospective memory failure (Dodhia:05). Have you ever tried to remember a shopping list by only memorizing it? It can be a nightmare, unless you know how to do it properly (e.g., through visualization techniques). Even a short list is hard to remember. That's why we constantly help our prospective memory by storing bits of information here and there, acting like anchors. When you enter your (remote) office in the morning, there are visual anchors that automatically trigger certain areas of your prospective memory, such as flowers that need to be watered or a document lying on the desk that needs to be processed today. Opening an IDE allows another set of anchors to fire up prospective memory-related tasks.

While modern IDEs can be fairly good at remembering the last working state, they usually lack the ability to switch between them easily. There are few exceptions. Vim with :mksession, Emacs with support for sessions via different packages, Qt Creator with similar functionality, and IntelliJ-based IDEs with task and contexts support.

Looking for a way to save working state in Visual Studio? Check out my ContextKeeper plugin with automatic working state switching when changing branches.

💬 There’s a great discussion about this post going on on Hacker News. Join the conversation!

References

• Parnin:10 Resumption strategies for interrupted programming tasks

  • also highly recommend reading Programmer Interrupted which summarizes various research papers

• vanSolingen:98 Interrupts: Just a Minute Never Is

• Dodhia:05 A Task Interrupted Becomes a Prospective Memory Task

• This Is Why You Shouldn't Interrupt a Programmer

• Parable of The Two Watchmakers

• Making Badass Developers - Kathy Sierra

• John Carmack coded Quake on a 28-inch 16:9 1080p monitor in 1995

• CygnusEd Professional in Action on an Amiga 2000 with exceptional fluent scrolling, video by Casey Muratori

• Amiga screen modes

• Prospective Memory

• Vim and :mksession

• Emacs session management

• Qt Creator and managing sessions

• IntelliJ IDEA

• ContextKeeper with automatic snapshot switching when changing branches and relative paths support

I want to share a couple of useful Visual Studio plugins that I'm using daily when working on the ContextKeeper. Those are mainly fitting in the "deep work" category and help to move a little faster when you're in the zone. There is noticeable compound effect when you start using them.

Better visual cues during coding session

• RockMargin - replaces VS vertical scrollbar with current text overview that works as scrollbar at the same time. Where the magic happens: in source files of up to a few thousand lines, it's really easy to navigate through the code using the file's thumbnail view, and it's super compact compared to the default VS map mode scroll bar which takes up way too much space. If you are using or have ever tried to use the default map mode but you have given up, just try using RockMargin and you will be pleasantly surprised:
  • unfortunately, there is no official build for VS 2022 but someone prepared PR. If you don't want to compile it yourself you could use my VS 2022 build which already includes this PR. To get RockMargin looking better when using VS Dark theme, I recommend changing colors, Tools->Options->RockMargin,
• Git Diff Margin - displays live Git changes of the currently edited file on Visual Studio margin and scroll bar,
• Viasfora - adds rainbow braces, keyword highlighting and some XML improvements. For VS Dark mode I recommend using Viasfora's dark light theme (Tools->Options->Viasfora->Export/Import->Load Theme). VS 2019 version is available here,
• Iconizer - shows icons on tool windows tabs (if possible) which greatly improves tabs discoverability. It's faster to recognize familiar icon than to read text.

More dense coding playground

• Shrink Empty Lines - more visible code shrinking lines that contain neither letters nor numbers by 25% vertically, allowing more lines to be displayed in the editor. The VS 2019 version is here,
• not a plugin but useful trick: set smaller font size: 8 px and use JetBrains Mono font.

Time-saving

• StopOnFirstBuildError - stops a solution build immediately if one project fails to build. Build for VS 2022 could be compiled from sources or use my build for VS 2022,
• Farticus - A broken build you didn't notice? Not anymore, thanks to random fart sound (22 different options!). It will not only save you time but also put a smile on your face, practically everyday. Just try it 😁.

Making context switching painless

• ContextKeeper (my own plugin) - remembers last opened files, pinned tabs, documents state (line&number) and position. It automatically saves and restores context when switching between Git branches and has relative paths support.

ContextKeeper is Visual Studio plugins that lets you switch between last opened files (documents sets). Everything is saved to simple JSON files aka snapshots.

Every snapshot saves:

• logical state
  • your favorites files (non-solution files are also supported)
  • last opened files, order and state, including last selected line & column
  • pinned tabs
• visual state
  • main IDE window position and size
  • floating windows position and size
  • docked state and horizontal/vertical orientation

The plugin has powerful git integration with automatically restored context when changing branches.

ContextKeeper on the Jesse Liberty's podcast

Lately during Yet Another Podcast Show 206, Jesse Liberty asked Mads Kristensen:

Jesse: "What I want in Visual Studio is to be able to say, take a snapshot of everything where I am. All the opened windows, all the breakpoints. All, everything that has to do with my development and let me save it under a name. And then switch, because if I'm in the middle of development, and the bug comes in, I want to be able to save it under my name, switch to what I'm doing. (...) and I'm back in that environment exactly the way I was."

Mads: "Someone wrote this extension like a 6 months ago. What you're asking for - exists. (...). It something about Context (Keeper)". Since May it's on the VS Marketplace and a little easier to find than before 😉

Huge thanks for Mads Kristensen for mentioning the ContextKeeper!

ContextKeeper v1.8 release and relative paths

I'm really proud 🎉🎉🎉 to announce that support for relative paths is finally implemented in the version 1.8. Relative paths support is part of the 2022 Roadmap and major milestone. The feature was one of the missing puzzle pieces, that I always wanted to include.

Adding support for relative path is essential part to allow sharing your context between different dev environments and also inside your team. It will unlock potential to e. g.:

• switching between laptop and workstation
• faster onboarding developers to new tasks, taking over responsibilities
• sharing mental models of the project across team members
• fixing complex bugs easier, using targeted mental snapshots

Every time a new snapshot is created it will include RelativePath property for every entry in a *.ck file. When a snapshot is restored, relative paths will be used by default. There is still FilePath property used, as a fallback strategy, for global files. All different types of files are supported including:

• solution and projects files
• "loose" files (not included in a solution/project) but still part of the folders structure
• global files (relative paths cannot be created for them, absolute paths are used)

Current limitations:

• Full Restore works the best when when switching between the same or similar monitors setup (laptop/dev machine), when monitor's size and resolutions are different than the original snapshot please use:
• Restore Files which is using the current active window (main IDE or floating window) to restore all files from a snapshot
• machine-independent snapshots restore process is not implemented yet but it's part of the 2022 Roadmap

Learn more

The latest news and releases are announced at the ContextKeeper's blog. You could also join the Beta program and get latest updates via newsletter.

July 16th 2021 was the first ContextKeeper beta release. It was late Friday when I had finished release note. Later it was sent to the 67 people who joined the beta program. The next week on Tuesday there was official "Hello World" blog post announcing version v0.71. The initial vision from 2015 came to fruition.

2021 recap

They were 12 releases through last 9 months including some major new features like:

• v0.8 - automatic snapshot switching when changing branches and later first build for VS 2022
• v1.0 - continuous auto-saving branch snapshots
• v1.3 - Git worktree support
• v1.6.26 - snapshot stashing

From the beginning, the most expected feature was definitely automatic snapshot switch when changing branches which is also highly voted on the official VS forum.

The core foundation for future versions is already built. And I think I've only implemented about 10-15% of what I want to achieve with the plugin. The plans are really bold and ambitious. Some of them includes introducing features that doesn't exists in any other IDE on the market. Moreover Visual Studio session management support haven't improved for years and with ContextKeeper I want to deliver completely new quality and create the new standard in this area.

The goal is to build ultimate contexts manager for Visual Studio that will significantly improve your daily work. I'm inviting you to join the ride and be sure to invite your friends 🚀

2022 Roadmap

The roadmap for 2022 includes major milestones, like support for:

✅ bookmarks

✅ breakpoints

✅ relative paths and machine-independent snapshots restore process (update: relative paths implemented 1st June)

✅ storing snapshots outside of the solution folder

✅ search dialog (update: implemented 15th April)

The bookmarks, breakpoints and relative paths are those big missing puzzles that I always wanted to include. Now it's the time to lift off ✈

Adding support for relative path and machine-independent restore process will remove last obstacle from sharing your context between different dev environments and also inside your team. It will unlock potential to e. g.:

• switching between laptop and workstation
• faster onboarding developers to new tasks, taking over responsibilities
• sharing mental models of the project across team members
• fixing complex bugs easier using targeted mental snapshots

And last but not least on the 2022 roadmap is 🔥:

• first version for Visual Studio Code with unique ability to load snapshots created in ... Visual Studio 😉

The Visual Studio Code plugin will have basic features at first, and gradually I will try to add more complex ones, to close features gaps between those two IDEs. The VS Code API is a little limiting compared to Visual Studio, but I will do my best to overcome any obstacles, and push VS Code APIs to its limits.

Breaking news, from the last minute. I just have found out, when I finished writing, that finally API access to "Open Editors" have been implemented by VS Code Team. The GitHub issue was closed just 1 day ago (21 April). It was created in 2016! It's really huge milestone making possible to provide almost full support for VS Code using official API 🚀

Beta program

Beta program will continue and the plugin will remain free during the beta phase. I don't have any specified date in mind when beta will end. I thinking about different options to secure financial stability for the future development. Since January 2021 I'm in full-time, bootstrapping mode funding the development. It wasn't an easy decision to go 💯 in, but since 2018 I was actively preparing to make the jump.

ContextKeeper v1.71 is released with long awaited search dialog! If you have more than few snapshot it will definitely improve your daily interactions with the plugin. I already have 29 snapshots, that touch different areas in the plugin source code, and navigating through them, started to be more and more challenging.

The search dialog is a native VS control with search history and behaves like a standard search component which you used before (e. g. in the Solution Explorer). The search filter is case-insensitive and use only a snapshot name for matching. I'm planning to add more sophisticated search options later, including searching through snapshot's files.

The search dialog for the first time was added in the version 1.7 but only to VS 2022 at the beginning. Starting today is available, as usual, for VS 2022/2019/2017/2015 and VS 2013.

Happy Easter 🥚!

I'm happy to announce that ContextKeeper v1.6.25 with snapshot stashing feature is available for Visual Studio 2022/2019/2017/2015 and 2013.

I want to thank everyone for their time and participating in the last survey. A lot of proposed features were directly from the feedback I've gathered during development. There were a lot of different propositions from the community that I had put in the survey, e. g.:

• keyboard shortcuts for creating “quick snap” (stash) snapshot and restore it later (implemented in v1.6.25)
• full screen state remembered for the main IDE window and floating windows (implemented in v1.6.25)
• improvements around deleting snapshots (partially implemented in v1.5)
• storing .contextkeeper folder outside the solution folder (configurable path) (coming soon)

It was a nice surprise to see "quick snap" proposition got a lot of votes because it wasn't a feature I was initially planning to implement. To be honest, I even didn't have it in the backlog. But you asked and it's here 😀

From the other side the top voted features confirmed a strong desire for storing bookmarks and breakpoints. From the very beginning, I was planning to build a tool that will catch all those subtle pieces of puzzles, that every developer is laying around during a development session. Bookmarks and breakpoints are the the most important goals on the 2022 roadmap.

Survey results

I've prepared the results graph for the highest voted features. The two highlighted features are already implemented:

✅ snapshot stashing - creating "quick snap" snapshot and restore it later with keyboard shortcut support,

✅ full screen state is remembered for every opened window in a snapshot.

Create stash snapshot and restore it later

There are two additional commands in the toolbar. Stash and unstash. The idea is from git workflow but here it's applied to a current context you're working on. You could quickly save it (stash) and switch to something else** that needs an urgent attention. After stashing a snapshot all tabs will be closed automatically, similarly how stashing works in git - current context is cleared and ready for a new work.

A stash snapshot is always displayed as a first on the list. Currently only single stash is supported but multiple stashes will be supported in the future.

A stash has additional description, like "<stashed> 2 hours ago", to get you additional awareness how long it's awaiting to be unstashed. It's really easy to lose track of time, during coding session, and it will act as an useful reminder how long your "main" task was put on hold. The stash timestamp description is live updated. If you decide that more meaningful name for stash snapshot is needed, you can simply rename it and it will become a regular snapshot.

Keyboard shortcuts

You could assign your favorites keyboard shortcut combination for stash and unstash commands from the toolbar. There aren't default shortcuts assigned but I found useful to use:

• Ctrl+Shift+S, Ctrl+Shift+S for snasphot stashing
• Ctrl+Shift+S, Ctrl+Shift+U for snasphot unstashing

Full screen (maximized) windows support

There is a support added to remember if windows is maximized during snapshot creation. No more problems with restoring maximized windows, especially during git branch switching 😍 Only maximized windows will have additional property serialized in a snapshot.

Celebrating 25th Visual Studio Birthday

You could noticed that current version is 1.6.25. I've added 25 to celebrate 25th Visual Studio Birthday. Officially, first Visual Studio 97 was released 19th March, 1997. But if you really curious there were several MS Visual C++ versions before 1997 that later were rebranded to Visual Studio. There is also really interesting documentary about Visual Studio - part 1 and part 2 - really worth to watch.

I've first started using VS around 2002/2003 when I was studying Computer Science at UMCS University in Lublin, Poland. It's more than 20 years I'm using VS on daily basis 🎉 and I'm looking forward for the next 20 years! Really unbelievable how one tool can impact your professional career.

ContextKeeper v1.5 is available for Visual Studio 2022/2019/2017/2015 and 2013. I want to highlight some UX improvements.

Quick snapshots deletion

​The last survey has shown some directions for new features and improvements. One of them was an easier way to delete snapshots. The introduced better keyboard support is the first step in this direction. The plan is to get all the “low-hanging” fruits before picking the biggest and sweetest ones: bookmarks and breakpoints 😁 There are also really interesting features in the middle, like:

• keyboard shortcuts for creating “quick snap” (stash) snapshot and restore it later
• support for relative paths and the ability to restore snapshots in different dev environments
• storing .contextkeeper folder outside the solution folder (configurable path)
• full screen state remembered for the main IDE window and floating windows
• search dialog

If you want to propose some additional features or report a bug, don’t hesitate and add it here or reply to this email.

Restoring multiple snapshots

Sometimes it useful to "scan" snapshots as quick a possible. From now on it's possible to use only keyboard (arrow keys + Enter) to restore multiple snapshots which significantly speed up entire process. There are also smaller bug fixes and changes in this release.

Starting from v1.0 ContextKeeper continuously auto-saves a git branch snapshot if a change is detected. When tabs with code are opened, moved or closed a new snapshot is generated. Also any changes in tabs layout triggers auto-save. When there are multiple changes in a short time, auto-save will be fired with a delay, after no more changes are detected (with 15 seconds threshold). Auto-save feature is disabled during debugging session to prevent accidental updates.​

Before the change ContextKeeper had updated a branch snapshot only at solution closing or before switching to another branch. It was a first step to a more robust solution.

Continuous auto-saving branch snapshots

Introducing continuous auto-saving feature is a step closer in improving default Visual Studio session management experience that had stopped improving for years - session is still saved only once, when solution is closed (or saved). It unfortunately doesn't work well when VS crashes in the middle of a work, .suo file gets corrupted in the process or VS is closed "blank" by mistake.

The outcomes are similar: you cannot use your latest opened documents. I work daily with Visual Studio since 2005 and still, after those years, I vividly remember overwhelming surprise mixed with anger when VS opened blank and forgot whole context, built carefully, usually by days. Latest VS version looks more polished but still it can happen. Before ContextKeeper I usually had backuped .suo file for important contexts and switched between them by overwriting original .suo file. This little hack seems to be pretty popular.

When automatic snapshot switching for branches was first introduced in v0.8 a branch snapshot was saved a moment before Visual Studio was closing or changing branches. The solution was simple but it had some hidden flaws. Some files in a snapshot could get lost after changing branches because VS closed them really fast and generated snapshot didn't include those files. Also if VS crashes or you need to kill the VS process from Task Manager a snapshot won't be up to date. All those issues were fixed by introducing branch auto-save feature.

Git worktree support

The git worktree support, introduced in v1.3, allows even more streamlined context switching. If you sometimes clone entire repository when working on a feature I recommend checking git worktree. Long story short, working tree is like clean, cloned repository but better because:

• repository "cloning" is done instantly - it's a local operation,
• worktree uses less disk space - there is a single .git folder shared across multiple working trees,
• often more convenient than stashing

Git rebase detection

ContextKeeper has small and simple built-in engine detecting git branch changes. It uses .git/HEAD file to actively detects current branch and also switching between branches. This approach allows switching between branches to work with any git client and also with VS 2013 which doesn't have native git support. ContextKeeper can even detect and automatically restore a snapshot when git branch is changed from a command line:

The branch detection engine is really simple and didn't support rebase operation properly at the beginning. During rebase multiple "intermediate" snapshots were generated but it was fixed in the v1.1 and v1.2 releases. Thanks to Piotr Solarczyk for reporting the issue.