Slashdot Mirror
First Look At Visual Studio 2010 Beta 1
snydeq writes "InfoWorld's Martin Heller takes VS2010 Beta 1 for a test drive and finds the upgrade promising, particularly with regard to improved thread debugging and a revamped UI. But the biggest enhancements have to do with parallel programming, Heller writes. 'I'm not sure that I've completely grasped the power of the new .Net Framework and native C++ support for task and data parallelism in VS2010, but what I've seen so far is impressive.' Heller points to intriguing parallel programming samples posted to CodePlex and offers numerous screenshots of VS2010 Beta 1 functionality. He also notes that the beta still lacks support for ASP.Net MVC, smart devices, and the .Net Micro Framework."
So what does it do then, exactly??
But the biggest enhancements have to do with parallel programming,
It means: developers, developers, developers, developers.
Disclaimer: I am not god.
We may not be created equal
But we can be treated equal.
No, like this:
developers
developers
developers
developers
deverlopee
elsdeverlpr
opesdeveos
Or something like that. Threading is hard! :)
Look at that fourth screenshot. What possible harm could loading a project do, I wonder? Does it already (partially?) execute even when it is just sitting there in the development environment? Is this an attempt to banish evil compilers from accidentally compiling source?
And why is the answer always "make the user choose" even though there is absolutely no way to make an informed choice (same problem as with UAC or sudo: I don't want to hand over the keys to the kingdom, I only want to give out narrow and specific permissions, based on useful information, rather than some nebulous feeling of 'trust')?
Heck no one I've worked with has even upgraded to 2008 yet, it's been either VS 2005 or 2003.
I love how you have to post anonymously in order to support Microsoft products on Slashdot.
Screw it, I second this. Visual Studio has the best code completion implementation ever written. I can type lines like obj.GetSomething().Append(item) in about four keystrokes.
This makes me warm and fuzzy inside.
Whenever MS apps get themes, Office 2k7 for example, they get slower. I'll admit VS 2k10 does look nicer, it really does, but even my Core i7 with cheetah blood thermal compound sits there drawing slow UI. MS, please use native widgets, allow us to disable theming, or whatever it takes to make it go as fast as 2k8.
ParallelFX is definitely interesting, but I'd say that another very major addition is Visual F# - to the best of my knowledge, this is the first time a primarily functional language goes mainstream, and gets documentation, tooling (IDE/debugging/profiling), and general support on par with the likes of C# and VB. It's not Haskell (read: no typeclasses), and it's not quite OCaml either (no functors), even though the core language is recognizably ML. But it's got most of the nice FP bits OCaml has to offer, some syntactic sugar on top of that (e.g. ability to declare locals as mutable when needed, and arithmetic operators overloaded for all numeric types), and it's got direct and full access to one of the largest class libraries on the market today.
(I'm sure someone will remind me of Scala, which is in many ways similar to F#. It's definitely comparable, but its tooling support is lagging behind, and, most importantly, it's not backed by any of the "big players" in Java land - not Sun, not Google, not IBM - or indeed, any other company.)
The second, smaller, but still interesting bit is improved language interop. It seems that, as new core (i.e. MS-supported) .NET languages are added to the batch, the framework itself is extended as needed to provide primitives for them where more than one language uses them. For example, both F# and IronPython work with tuples, but they have previously each defined their own type for that - and so .NET 4 introduces the standard System.Tuple type, and all languages are changed to use that. So now you can actually make a tuple in IronPython, and pattern-match it in F# - nice.
Another bit along the same lines is C# 4 dynamic type - which is nothing but opt-in duck typing - and the associated DLR framework for exposing runtime dynamic type information in a common way. This means that static/dynamic language interop on .NET is now two-way - previously, you could easily call C# class methods from IronPython/IronRuby, but there was no easy way to call methods on IronPython/IronRuby objects in C# - but now you can do the latter just as easily.
obj.GetSomething().Append(item) in about four keystrokes.
I believe that should be:
System.Csharp.Adding.Namespace.Collections.Stuff.Object.Manipulation obj;
obj.GetSomething().Append(item);
You *need* an IDE that allows code completion, or no-one be able to write more than 7 lines of code a day.
Compatibility and conformance with standards (TR1), also going that extra step forward and implementing some of the upcoming 0x features I can truly say that since VS05 MS has gone a long way. WRT Language/IDE/Debug integration nothing comes close in the OSS world for the C++ language (and please don't say CDT, I've tried using 5 and it can't even do the simple C++ syntax properly let alone templates or even simple metaprograms).
Disappointing/sad thing with VS10 is that a lot of the interesting source code metric/analysis stuff is only available for C++\CLI. For pure C++ code metrics I've been pinning my hopes for the past 5 years on someone getting around to implementing to-do #6 of doxygen.
Arash Partow's Philosophy: Be a person who knows what they don't know, and not a person who doesn't know.
If someone hasn't gotten the hang of the 'using' keyword, then they probably shouldn't be writing more than 7 lines of code a day.
Irony: Agile development has too much intertia to be abandoned now.
No, what you need is a sane programming language/technique.
factor 966971: 966971
VC6, to me, is the '57 Chevy of IDEs; it's out of date, lacking in features, isn't to everyone's tastes, but just keeps on runnin' with a strange magic that Microsoft has never been able to reproduce in its later versions. I've used every VS version since 2, and all the versions after 6 were plagued by bugginess, general slowness, and, here's the real subjective part, a feeling of fragility that I never experienced with VC6. I have used VS8 quite a bit and while I appreciate having a more up-to-date compiler (stupid BS "security warnings" aside), VC6 still, for whatever reason, remains the IDE I want to use if I have to write Windows-specific C++.
Frankly, I don't *want* to use VC6, just like I don't want to put a bottle of lead-substitute into my gas tank every time I fill up, it's just that it has that perfect mix of speed, usefulness, and the ability to get out of my way that none of the .net versions have been able to capture.
I heavily use both Visual Studio 2005 and 2008, so I was excited to use 2010. The thing I found most obnoxious about it was the the text in the code editor was blurry at normal font settings (Consolas 10pt). Let me restate that. The text in the primary window of the software that you will be staring at for hours daily... is blurry. How on earth did that get past QA?
Section 2.4.2.2 of the Readme describes why the code can appear blurry:
You can also take a look at this white paper for more information on the issue.
The ClearType Tuner PowerToy can also help. If you are running Windows 7, it's built into the control panel.
Sadly the real problem is that it uses Windows Presentation Foundation, which renders text in an idealized grid rather than snapping glyphs to a pixel grid. In other words it renders the font exactly as it is supposed to look, and then blends this into the pixel grid, which makes it appear blurry. GDI, on the other hand, will deform the glyphs to fit them into the pixel grid thus offering better readability at the expense of accuracy.
WPF can't render aliased text either, which some people prefer, and also has a silly text animation system that will wait a second before doing the blending meaning (to prevent scrolling artifacts) so that if you scroll fast you'll initially get really blurry text that gradually turns somewhat clearer.
These are well-known problems with WPF, and has always been pushed as "by design" even though it results in horrible text. Microsoft seems to have changed their tune lately and will apparently be adressing the problem in .NET 4. I suspect the reason is because VS 2010 now uses it and the poor text quality was just not acceptable for an application like that.
Messing with the ClearType settings in Windows doesn't really help much, as WPF's renderer is completely separate.
WPF is just a big mess really, and far too complex. I'm all for a new GUI toolkit (even though it's .NET-based), but WPF just isn't it.
Quite a bit actually. Personally for me, the top 3 features are:
Apart from the above it includes a completely new intellisense for C++, using the EDG frontend. All this in addition to the usual .Net stuff.
The ClearType Tuner PowerToy [microsoft.com] can also help.
It will not, since it only tunes Windows's built-in ClearType renderer. Visual Studio uses WPF, which has its own renderer. There isn't really anything you can do to make it better.
That said, the blurriness is recognized as a problem, and will be fixed for 2010:
We are replacing WPF's text rendering stack in WPF 4.0, and this should allow you to render text with comparable sharpness to what you're used to with GDI. The reason the existing text stack in WPF looks blurrier than GDI's is that GDI text is typically rendered with Compatible Width Layout, whereas WPF's existing text stack always uses Ideal Width Layout. Compatible Width Layout snaps glyphs to pixel boundaries, Ideal Width does not, which is why WPF's text looks blurrier than GDI's. WPF's existing text stack also does not support use of the embedded bitmaps that are included in many fonts and are intended to be used when rendering at smaller sizes.
The new text stack in WPF 4.0 will allow Compatible Width Layout, and it will also support embedded font bitmaps. We believe this will solve all of our text blurriness issues.
Thanks!
-The WPF Graphics Team
It just didn't get into beta 1 yet.
Apparently you need to go and read a book on namespaces.
You can use namespaces that horribly badly in other languages too including Java and C++ if you really want to, but any professional programmer should be at a level where they're not that bad at it.
Allow me to introduce you too... http://www.microsoft.com/Express/ There will be VS2010 versions. It's not the high-end dev environment, but it does quite a bit.
Sorry about the mess.
Screw it, I second this. Visual Studio has the best code completion implementation ever written. I can type lines like obj.GetSomething().Append(item) in about four keystrokes.
Have you tried IntelliJ IDEA? It's Java-only, but I found its code completion to be many, MANY times better than VS. For one, instead of showing you every symbol that matches a prefix, it narrows down to the appropriate type.
For example, in VS, if you create two methods with similar names ("int Test1()", "string Test2()"), and try and tab complete something like string "foo = T", it'll show you Test1() first, even though Test2() is a far better match.
Note that I use VS 2008 daily, and I've got 2010 installed as well. I just tested that in VS 2010, and it still shows you every single identifier available, including class names. I know that technically, the intention may have been to reference a static, but in practice, they could go to some lengths to select a "most likely" set and an "alphabetical" set, and show the most likely first, and only show the complete set if you try to complete twice, or something.
It's a great IDE, but it could be a lot better. Microsoft really needs to get over their "not invented here" attitude, install a competing IDE at least ONCE, try it, and learn that other people sometimes do things better.
May I interest you in a truly advanced OS/Environment/Editor?
Or do you lack the skills necessary to make the machine obey your every whim?
oblig: http://xkcd.com/378/
If you think that writing software in Visual Studio consists of "point and click programming" then you haven't used it enough to have a valid opinion, or at all.
I would concur that when it comes to code completion and refactoring, IntelliJ IDEA still beats everyone, and NetBeans and Eclipse generally beat VS when you compare apples to apples (i.e. Java to C#). You can get to roughly the same level if you add ReSharper (which isn't exactly surprising, as it's made by the same guys who make IDEA), but that's extra $$$ ...
On the other hand, Visual C++ still has the most reliable C++ code completion of all IDEs that I've seen, and it's got even better in VS2010.
And just to reiterate... it's been free (as in beer) for years!!!
Bill
It's my Sig and you can't have it. Mine! All Mine!
Actually Visual Studio is one of top developer platforms and is used for just about anything you can imagine on a regular basis.
Doesn't exist in Visual Studio anymore without some tweaks. If your program targets multiple platforms beyond Microsoft your in for a few headaches.
I wonder if Martin Heller used the VS10 compiler for cross platform Wx/Gtk/Qt development (Check Audacity out). I (or someone) should do this in a future slasdot review.
The OpenWatcom, g++, and Intel compilers are a much better solution if your targeting multiple platforms (ARM, Mac, Power5, Mainframes, cellphones etc.) I use VS6 and GCC, but your mileage may vary.
I appreciate the fact that Microsoft is pushing for VS studio C#/.Net acceptance. As of today, that solution is just as slow and portable as Java is/was ten years ago. For some strange reason I refuse to write a program that takes twenty to thirty megabytes of RAM to run when it should only take two. Why? Because that RAM belongs to the user and the other programs they may be running, not me. Waste not, want not. If you can do it faster and for less RAM in a different language then you owe your users to do so.
And no, I've never written a C/C++ program that was un-secure (yet), thanks for asking. And yes, I like C#/Java programming, I just have deployment issues that I've never recovered from.
My opinion or experiences may not be yours.
Enjoy,
It's just the normal noises in here.
I don't know what you're doing with it then, but as someone paid to write C++ all day every day with VS2008, I can hand on heart say that the C++ code completion in VS2008 is fucking awful. It kills my dual core CPU updating the intellisense database frequently (ok, I'm working on a large project made up of about 140 modules), then fails to find globals and class members quite often in the same file.
Most times it's only about as useful as grep, but even then manages to be worse since it gives no priority to context - if I have two global variables in two different modules with the same name and ask for the definition in one module, it will quite often open a source file in the other module.
When testing alternatives, I found eclipse-cpp and netbeans-cpp to be far superior at C++ code completion. Unfortunately, I work for an American corporate who "standardise" on Microsoft products :-(
try Resharper. It'll fix that code completion for you, and do tons of more useful stuff.
Knowing that F# came out of Microsoft Research and that some other .NET code has been released as free software by Microsoft in the past, I was hoping that the F# compiler would be free software too. Sadly this is not the case - at least as far as the licence in fsharp.zip here is concerned; it's distributable for non-commercial use only. So while F# looks very interesting, for now it's something of a Microsoft lock-in, and I won't be adopting it because it removes the possibility of porting to Mono.
Don Syme said, and more recently confirmed, that F# will be released under MS-PL (effectively a BSDL with patent clause) for the VS2010 release - it's only "shared source" currently because it is still in beta.
Schmidt349: managing to be wrong twice in a sentence with only 17 words.