I'm feeling such low energy right now. It might be because I'm awake at 4 am after only a few hours sleep, but part of me thinks it's indicative of what work is like right now. The end is nigh! Our goal is in sight, and we're pretty strict about staying on course and getting VS wrapped up and ready to ship. Of course, this means we don't want to be adding radically new features or doing other risky things. Instead, we want to take what we have and make sure it all works together as you'd expect. It's necessary, but as I'm learning, the last 5% seem to be the hardest. I think it's just my nature to want to keep working on the new things and not being able to an make you a little stir crazy. I can do it in my spare time, however, there doesn't seem to be much of that since there is *plenty* of work right now.
On a good note, we've gotten an amazing amount of feedback from the blogs and ladybug. Because of that we've found ourselves making different decisions as to how to allocate resources and to what we should be doing before we ship. Of the 3 groups I work with (the editor, the compiler and the debugger), the editor is getting the most feedback. That makes sense to me (although my logic might be totally off). The compiler is a rather simple tool in the minds of most user. It's just a single application that just takes a set of files and produces a library or executable. For the most part people want it to just do that and nothing much more, and as long as it has good error messages they're happy. I think that the debugger doesn't get hit a lot because people trying out the beta aren't necessarily using it for large real world tasks, but rather are just playing around with it and so aren't really living in the debugger and finding issues with it. Or, alternatively, they're like me and generally don't use the debugger 🙂
However, the editor is a different experience. For many people it's the primary interface to the IDE and where they spend the most time. It's also something that is very “in your face.” From colorization to our entire interaction model. If we get anything wrong it's always almost immediately obvious (and *annoying*) to the user. The editor is also an area that could be vastly improved over our current offering. The amount of useful feedback that we don't give the user is somewhat disappointing and I know it's an area that we'll be working hard on in the future. It's silly that you *have* to manually invoke a compile to get warning and errors. I'm unfortunate how many places where intellisense breaks down, or doesn't provide useful information (like what operators are valid at this location in the code). A lot is due to our architectural heritage, and a lot is due to the areas we really focused on for this release (like generics and refactorings).
Fortunately, this means that when we do the next version there will be a lot that we can do to make things better. What really interests me would be to provide a more extensible intellisense/editor model in the future. You don't like how intellisense works, or want to see it behaving differently? Fine, write your own plug-in (or extend ours) and use that instead. However, I've never written an architecture like that so there will certainly be a lot of learning going on at the same time. When we get to that, I think talking to the community will be absolutely necessary in order to get this right. After all, how do we give people an extensible model that will serve their needs unless we know what their needs are? It's also my perception that people are (rightly) expecting a lot out of IDEs. The amazing work done across the board by companies like Borland, IBM, Sun and Jetbrains show how drastically the quality and feature set of an IDE can affect ones performance. Traditionally I think that MS has provided that through a strong integrated experience with some extensibility points for other ISVs to come in and enhance the experience. In the future I see us shifting balance and working hard on the core services but having them designed with much stronger extensibility in mind so that the community can integrate with ease and can provide more value than today. This would allow us to release a strong platform with major advancements across the board, and to then provide incremental improvements over time ourselves or through ISVs
It's also going ot be interesting figuring out what the right path forward is for us with our current code base. We want to code in C# (yes, we're incredibly biased), but we have a very large legacy C++ code base. There are lots of options available as to how to make the transition, but looking forward it's not clear at all which path we should take.
Well, I'm suddenly all excited thinking about this. Now it's just a matter of how do i balance the need to work on getting 2005 done, and the want to start working on VS.NextXPExtremeUltraSuperEdition.