1/ In early 2004 we were heads down executing on Edit and Continue across a large contingent of teams. There had been several iterations of scoping, redesigns, and customer feedback.
2/ We had a weekly meeting every Thursday morning when representatives from each of the teams would get together and review progress. It was fairly heavy weight, but there were so many teams involved that it was necessary to have a regular sync.
3/ Regardless, E&C was coalescing, but teams were stretched thin working diligently to enable scenarios, improve performance, fix bugs, etc. It had been a month or so since we decided to add support for C# to the matrix as well, so folks were a bit stressed.
4/ That set the stage for the meeting that we had on the first Thursday in April. A debugger PM named Habib Heydarian ran the meeting and after a brief intro he gave me a ring to come in and present.
5/ I walked in and handed out a document that I had written up, titled DCR: C# Edit and Continue for Venus. DCR meant design change request, and Venus was the design-time code name for ASP .NET support.
6/ I explained that we had a recent review with leadership and that while the feedback was very positive, we had been asked to enable E&C for ASP .NET as well.
7/ The room was shocked - their teams were already over-extended and ASP .NET support was something that we had scoped out essentially day 1.
8/ We then proceeded to review the document which went through the customer rationale, scenarios, the user experience design, and suggested architecture. The first Thursday of April in 2004 happened to be April 1st - April Fool's Day.
9/ The 'spec' looked and read legitimately for the first sections, but was intended to get wilder and more ridiculous as we read through it.
10/ In the final section it had statements like "happily, most of the work for edit and continue has already been done for the Client, so extending it to support Venus should be relatively trivial" (absolute nonsense of course). as well as
11/ "however, it is also necessary to make Office development support EnC."
12/ It went on to suggest that the only reasonable way to get design time support for this scenario was to run the language service on the server, which, despite what we've been doing with Codespaces recently, was absolute crazy talk at the time.
13/ This was the 'architecture diagram' included:
14/ When we got to this point in the document, I expected folks to catch on that this wasn't serious, or at least, call out that perhaps some more thinking would be needed :) I tried to make it as ludicrous as possible, without any detail, with arrows just randomly drawn in…
15/ but... TBH, I think folks were in shock as no one said anything. In fact, a good number of folks were busy writing emails to their teams and management - once Habib and I realized that, we finally told people it was a prank.
16/ I'm not *exactly* sure how many folks in that room hate me to this day, but based on the reactions then, it maybe wasn't quite as funny as I had hoped :-)
17/ I'm sure it'd make folks feel better to know that I spent a good portion of the rest of the day answering emails from various levels of management who were still convinced it was real and were uh, nonplussed, when I told them it wasn't.
18/ Habib and I did a brief Channel 9 video a couple of years later where we talked about it which is still available here: channel9.msdn.com/blogs/charles/…. Since the only comment on the video is "I missed what the prank is exactly…"
19/ we somehow managed to have perhaps the unfunniest prank in the history of computing, but we tried! FWIW, a few folks eventually got a laugh out of it, you know, after they stopped being enraged.
• • •
Missing some Tweet in this thread? You can try to
force a refresh
1/ Edit and continue was a beloved feature of VB6 and was a priority for making migration onto .NET easy for RAD developers. EnC is magical when it works correctly. For web developers that are used to hot reloading, it enables that type of rapid development, but maintains state.
2/ Unfortunately, it is an extremely difficult feature to implement in a JIT'ed world as we discovered that with .NET 1.0. We actually had a version of EnC in the early releases of VS 2002.
3/ I'm fairly sure it persisted all the way up to Beta 1, though the history of when we removed it is a little hazy. The initial implementation wasn't coalescing. There were a huge number of bugs, it performed poorly, and it often corrupted the debuggee.
1/ @werat asked about whether the debugger was using the C# compiler or language service in VS 2002. It was not. The debugger has a component called an ‘expression evaluator’ that is provided per language and is responsible for parsing and evaluating expressions when stopped at a
2/ breakpoint. For example, if you type into the immediate window, hover over a variable, type into the watch window, etc. the expression evaluator is involved. The debugger and the language service are actually deeply integrated in a number of scenarios in VS, which may
3/ initially seem surprising. I may talk about more of these scenarios in the future, but to give a flavor, when you set a breakpoint at design time the language service is involved, when you are using Edit and Continue the LS is involved, the range of what is being evaluated
1/ I haven't mentioned much about C# integration into Visual Studio yet, but at the same time we were working on creating a new language, a new runtime, and a new framework we also decided to take disparate shells (MSDEV, devenv, VB6) and combine them. This was… a lot.
2/ As you might expect, taking on so much at the same time meant a very long development cycle. For those folks using VS6 it was a long wait for VS7 (‘98 to ’02). Regardless, we wanted to continue to provide a compelling LOB (line of business) client app framework while also
3/ enabling web apps (via ASP.NET, web forms/services, etc.). The client app framework manifested as Windows Forms and was the next iteration of a RAD app creation environment. The Windows Forms designer is extremely rich and intended to make developing UI-rich
1/ An interesting bit of history for .NET and C# is that there used to be a public System.Variant type. It was actually a keyword in C# for a while, alongside of object. If you’re unfamiliar with variants, they are a tagged union type.
2/ This means that they can represent many different data types and contain a ‘tag’ (a small enumeration) that defines the type of data they hold. This evolved because COM uses variants heavily, as did VB6 (and many other languages).
3/ In the original iterations of VB.NET, Variant was used for any untyped declaration (e.g. Dim a, b). Variants and System.Object are similar in some ways, and as you might guess, this led to problems.
1/ The C# development team, for V1, consisted of 5 individual engineers, a lead, and a couple of PMs. 4 of the engineers worked on implementing the compiler, and the last engineer worked on the Visual Studio integration (e.g., IntelliSense).
2/ The C# compiler was written entirely in C++ as was much of Visual Studio at the time. Everyone on the team wanted to implement the compiler in C#, but as I mentioned previously, expediency was key and when we started, we needed to bootstrap. That was done in C++, so it stuck.
3/ The compiler was largely implemented as a batch compiler. We had a no-release heap, which was extremely efficient for straight-through compilation and totally useless for interactive scenarios. Therefore, the compiler and what we call the language service were implemented
1/ It's probably not the first thing you think of, but when we started .NET (COM+) in the late 90s, C# didn't exist yet. We were working on it at the same time as the CLR and the framework. So, you might wonder, what language was being used to generate IL and write the BCL?
2/ The answer is a language that we called SMC that Peter Kukol wrote the compiler for. Peter is a flat out amazing engineer and wrote the core parts of the compiler in just a few days. This unblocked the framework team, allowed vetting the runtime and interpreter, etc.
3/ SMC was a trimmed down C++ variant and the compiler was written in itself (i.e. SMC). It didn't support things like destructors, multiple inheritance, virtual base classes, etc. But, overall it enabled progress that would have otherwise been stalled.