Microsoft is going to add “edit and continue” for C# on the next Visual Studio.
Edit and Continue in Whidbey
About The Author
Eugenia Loli
Ex-programmer, ex-editor in chief at OSNews.com, now a visual artist/filmmaker.
Follow me on Twitter @EugeniaLoli
Good innovation, but I suspect is going to be a memory eater,
It was about time.
This isn’t an innovation. You can do this with Java in Eclipse as well as in Apple’s IDE.
Sometimes. Frequently the hot-spot replace will fail in Eclipse, or the code will not reflect all of the changes properly. I’m confident that Microsoft will implement this in a more reliable manner.
I’m pretty sure I could edit code in VS6 and continue debugging.
Yes. It was in VB (and I believe VC++).
MS left out E&C and a few other things to concentrate on the core platform for v1 & 1.1. Now they’re adding it into both C# and VB.NET.
how about: stop adding features and make their current debugger work better/properly. multi project solutions are a real pain in the ass sometimes using vs .net.
what is the refactoring they keep talking about?
as far as i’ve always known, refactoring was going through your code again and again until you got it perfect. i cant imagine what a refactoring dev tool is… arch/subversion?
E&C was crude in VB6, at least the version i played it, but it was very fun. You could change mathematical statements for value computation, but it often wouldnt let you perform more complex serious changes. It was simplistic, but useful. Much how I _imagine_ eclipse is, imagine for not having used java or eclipse in the lattest two of the three years since Eclipse has shown up on the radar. another poster described it as limited, and prone to messing up. The MS implementaiton was pretty good about making clear what it just wouldnt allow, back in VB6.
This feature alone stands out as one of the unique functionalities of a MS platform. There’s plenty of room for implementation differences & polish to make a difference & argue back and forth with, but this stands out singularly as working & complete functionality under MS’s monopoly (aside from the bajillion research papers on the subject).
Fair and balanced? You decide! (j/k, but i am curious)
With relation to developer tools, seems to be mostly the ability to change, for instance, a function name, and have that change propogate throughout the code.
“Yes. It was in VB (and I believe VC++).”
I remember when I did VB6 specifically that I could not make changes in debug mode and have them stick, I always found it frustrating. Maybe I was missing some button or option pane somewhere?
How does it work?
I read the blog and couldn’t find any hype or propaganda. Just a simple explanation of the reason of why it is in now. If OSS hade marketing, they would say the same crap as marketing always does.
As for what edit and continue is:
When you have hit a break point in your debugger, you normally can’t change any faulty code. Perhaps you can change some values to make it “survive” temporarily. With edit and continue you can edit the faulty code, have it compiled on the fly while the software beeing debugged is halted, and then let it continue execution. Cuts down on time if you just need to fix little misstakes.
If I have understood the way it is done, you often get the new code in the method/function the next time you enter it. I don’t know if VB(.NET)/C#/Java does it differently though. And I am sure that a SmallTalk/Ruby/Perl/Python/etc debugger could do the most incredible things if they wanted it to:)
there are definitely exceptions to the feature which is most likely to be a simple implementation preserving the stack frame of the current page. i would imagine that is what they will go for because it is the only sane way of implementing edit-and-continue without blowing out a huge hole in the stack.
Yeah, and MS was doing this with VS 6 way before Apple’s IDE or Eclipse were even around. So what’s your point? Oh, I already know your point…you’re just another rabid anti-MS moron who can’t stand that so many developers appreciate MS’s good tools.
Our debugging tools are shit. Our development tools are shit. Our revision control tools are shit. The only “innovation” that is happening in the world of software development is to keep picking the same low hanging fruit over and over again. We need semantic based editors. Tools which understand the language. We need debuggers that allow you to stop, rewind and fast forward time. We need visualization tools that can generate standardized representations of static and dynamic software information in real time. We need automated software reasoning tools that can tell you if a function as written will complete with the stated post-conditions true if the given pre-conditions are met, and if not, what range of values will break them, or what pre-conditions need to be added. We need tools that can evaluate software and recommend areas of improvement or possible errors. We need more tight coupling between specifications and software such that software can be proven to be a correct refinement of those specifications. This is what innovation in software tools is. Recognise it. Everything else is just another feature tacked onto the wrong way of doing things (hack and test, hack and test).
Nice rant. But VS.NET and eclipse do understand the semantics of the language. That is how they can do refactoring.
If you want software that lends itself more to mathematical proving, you might want to take a look at functional languages such as clean http://www.cs.kun.nl/~clean/ .
Most of what you suggest is currently available in some academic projects. It is just not yet in mainstream use.
You can do this with Java in Eclipse as well as in Apple’s IDE.
and
Intellij IDEA (Java IDE) already has that (Hotswap debug) for about half year…
Guys, smalltalk ides (and I suspect lisp machines in ’60) had this for decades. I really mean, some tens years.
As someone that first used edit-and-continue 18 years ago [1], and currently uses it in Java environments, edit-and-continue is:
(a) nice to have, so long as it is used in a disciplined way
(b) much less useful than a good refactoring environment
[1] in Apple’s Smalltalk; yes, Apple did implement Smalltalk on the original Mac – 1MB RAM, no hard disk! It has taken other environments 20 years and 100 times the RAM to catch up
Thanks. To claim a tool understands the semantics of the language because it can do refactoring is not exactly doing justice to the term “understands”. These IDEs use preprogrammed tricks to do refactoring. They don’t actually reason about the software. As for academic environments, well they’re academic aint they? They tell us something about what could be, if only it was in the real world. The language you linked to is a perfect example. We’d love to have the capabilities of its programming environment in real software that exists in real languages in the real world (including all the software that has been already written) but its just so very very hard to do that all an academic study can give us is a programming environment for a strict and unrealistic language. On the other hand, Microsoft, if they focused more of their research dollars on software development than the “next hot thing” could crack this nut and give us real innovation for real languages. They could, but they don’t.
This is most certainly *not* innovation. This sort of feature has been old-hat in dynamic languages for decades now. In Smalltalk and Lisp environments, the IDE is integrated with a REPL (command evaluator). Together with the IDE’s ability to modify code on the fly, and the REPL’s ability to execute code on the fly, you get true interactive development. This allows you to adopt an incremental programming style, where you literally mould a running program into shape a single definition at a time. Since each dfinition is written and tested individually, and you never have to break your workflow to deal with the compiler, both code quality and productivity are phenomenal.
@Lumbergh: I don’t think people complain just because they hate Microsoft, but rather because they are just frustrated at their total lack of humility. You spend years just reinventing (poorly), what we’ve had since the 1980’s (or earlier), and then you have the gall to claim that you’re innovative? It’s like the new HP commercial, where they show the “HP Apple iPod” (which is exactly like the regular iPod in every way), then have a tagline at the end that says “HP – Invent.” It’s just embarassing for everyone involved.
@Tom Gardner: Apple seems to have a history of this, then. They hand an interactive development environment in their mid-90’s Dylan product too. First Smalltalk, then Dylan, now XCode? At least some commercial companies still appreciate good technology
Did you read the title of the thread, the actual link, or even read my comments? Not once was “innovation” mentioned. Take a remedial reading course. Geesh.
Although its a nice to have feature, I don’t use it myself though its a “cool factor” when I saw it in an IDE.
I am not a debugger type person, its slows me down too much if I am forced to use it. Generally I am forced to use it if I am venturing into code that I do not know and built like spaghetti.
I’ve seen many developers spend a lot of time traversing through code in debuggers and I just find it too slow. I’d rather just put a couple of println statements or Logger entries that I can filter on.
A good refactoring tool and automated unit testing integrated with the IDE reduces the work needed by developers to make better code. Of course these features do require more thinking time than debuggers.
In the Java development world, combining the development environment (not necessarily with the IDE itself, it could be with the build cycle) with JTest, CheckStyle, PMD, FindBugs, JDepend, JCoverage and Simian developers can create better code as common development mistakes provided your development team knows how to fix problems these tools generate.
Rayiner Hashem wrote
<quote>
Apple seems to have a history of this, then. They hand an interactive development environment in their mid-90’s Dylan product too. First Smalltalk, then Dylan, now XCode? At least some commercial companies still appreciate good technology
</quote>
Apple’s Smalltalk was a simple port of Xerox 1.0 Smalltalk to their 68000 box. There was no attempt to integrate it with any other Apple environment, nor to make it into a product. From Apple’s point of view, the importance was that the same surface concepts lead to Lisa and then Mac. Of course, later on they switched to Objective-C.
Of course, later on they switched to Objective-C.
Apple didn’t, they were taken over by NeXT. Then NeXT’s Objective-C development environment was upgraded to Cocoa and integrated with Apple’s legacy apis.
— Richard