The Jeff and Casey Show on Visual Studio 2010 and Direct2D

A while ago I posted an excerpt from the Jeff and Casey Show, on advertising in games. That seemed to go over well (there sure was some animated discussion!) so let’s do some more. This episode is mainly for programmers who have to work on Microsoft platforms.

Their first rant is about Microsoft Visual Studio 2010, the upcoming version of the IDE that most game developers use for Windows and the Xbox 360 (and sometimes other platforms as well):

[audio:http://mollyrocket.com/9112?action=download]

(Here’s a direct download link).

I’ve tried to correspond with lead members of the Visual Studio team in the past about issues like this, and they seemed to just be in complete denial that anything was less than perfect.

The second rant is about Direct2D, Microsoft’s upcoming API for fast 2D drawing in Windows 7. I could see that maybe Direct3D is too complex an API for the general-purpose use of people who just want to draw 2D stuff, and so you’d want something simpler and more robust, and that’s probably why the project was conceived. How they got from that initial idea, to what has now been presented as the Direct2D API, requires such a sheer volume of incompetence that it’s nearly inconceivable that this happened. Somehow they made a 2D API that is more needlessly complicated, more brittle, and less readable than Direct3D… which provides a superset of all the functionality anyway.

The code sample that Jeff and Casey go over in this rant is not a joke. If you want to follow along, you can find it here on Microsoft’s site.

[audio:http://mollyrocket.com/9123?action=download]

(Here’s a direct download link).

God help us all.

You can listen to all the episodes of The Jeff and Casey Show by going to jeffandcaseyshow.com.

51 thoughts on “The Jeff and Casey Show on Visual Studio 2010 and Direct2D”

  1. Now, I realize that a team of people probably worked very hard on this and it’s pretty harsh to use phrases like “sheer volume of incompetence” in reference to their work. I would feel bad if someone were saying that about something I had spent a couple of years slaving over.

    But, you know what? Sometimes you just have to call a spade a spade. This shit is terrible and it is harming the world. Maybe as an individual programmer you are not incompetent, but it’s just being embedded in this corporate structure and having to comply with all these weird requirements people are giving you that is generating such a poor product. Well, it’s still your fault for participating in that mess. We live in a time when independent programmers are making hundreds of thousands of dollars from iPhone apps they wrote in a few weeks. What is your excuse for wasting your life working on stuff like this?

    Any corporate structure that would generate this API is not working and is going to collapse sooner or later. Probably sooner.

  2. Oh my god. This is the most (err.. MOST) complex 2D API that I’ve ever seen. I mean, how can you create a 2D API thats actually HARDER to learn than a fully blown 3D API (like… Direct3D?). Nice show, but the voices are quite annoying.. It wasn’t THAT funny…

  3. This may very well be one of the worst APIs ever designed – I surely will stay as far away from it as possible and hope I never have to work with it.

    Microsoft should have rather taken the milcore.dll (microsoft imaging layer) and turned it into a public API. It’s the unmanaged native core of WPF and could have been a powerful base for a 2d API – after all it’s already doing the same stuff Direct2d has on its feature list (actually much more) and I would love to have the power of WPF available in native C/C++ code 🙁

  4. I have 7 mbit ADSL… downloads about 700KB/s or 41 MB/minute or 2.4 GB/hour or 57.7 GB/day. So I could download it 8 times in one day.

    I also have a little over 1 Tebibyte hard drive space. So I could install it over a dozen times.

    You guys are major-fucking-annoying whiners.

  5. I think the really sad thing is that Microsoft can basically do what they want, no matter if developers who use it would like to see different changes – Direct* is a success.

    Suck it up. 🙂

    The only thing I do not quite understand is why anyone would actually use Direct2D if Direct3D provides a simpler way (if you only have to learn Direct3D that is)

  6. I don’t know what you guys are getting so up in arms about. This API is a clear improvement over both GDI and GDI+, which it seems to be clearly designed to supplant, based on the fact that it offers a near identical feature set (with things like support for rendering without a video device attached, or rendering without hardware acceleration, etc). The fact that it happens to have ‘Direct’ on the beginning of its name or support using Direct3D for rasterization is irrelevant – I really don’t know why you would expect anything different. It’s basically GDI adapted to a COM object model, with improvements and adjustments to make sense on modern hardware and OSes. It seems like a perfect fit for Windows 7 and I’m honestly surprised we didn’t get anything like this in Vista.

    You can basically translate the ‘terrible’ example you linked to use GDI, line-for-line, and it will be just about as large – it’ll actually be larger since you can’t just toss a GDI brush handle into a COM smart pointer like they do there. There’s a little additional scaffolding to set up a device for the window, but creating GDI device contexts from scratch isn’t any simpler; it just happens to be done behind the scenes for you when you create a Win32 window.

    This isn’t by any means an amazing API for games, but I don’t think it should be either. As a replacement for GDI (and the extremely shoddy GDI+), it’s offers tangible improvements in display quality and performance with a slightly better programming model. If they were to backport it to WinXP, I’d strongly consider using it for building the UI in my tools pipeline, even if it’s not helpful for developing my games – I’m stuck using GDI for a good tools pipeline right now, unless I fancy reimplementing the entire Win32 UI stack from scratch (which I’ve done before, and didn’t enjoy).

    I’d also like to point out that the text API based on Direct2D looks extremely promising as well, and is far superior to anything you can do with raw Direct3D or raw GDI unless you sink a *ton* of effort into it. The fact that it’s built directly on Direct2D also means that text no longer lives in a walled-off GDI Font garden, requiring you to generate textures and kerning tables and write your own typesetting routines if you do happen to want to use fonts in a game – it means that if your user’s machine has Direct2D, you can create a Direct2D device attached to your Direct3D framebuffer and draw some text to it, and get a fairly performant and good-looking result, without losing any of the flexibility you had before.

    It’s stupid that they’re not backporting it to WinXP or Vista, but that doesn’t justify calling it the result of incompetence.

    Can you point to specific design flaws and issues with the design of the API? Can you provide use cases where it is insufficient? All I see is ranting without any context.

  7. Kevin: I have more extensive thoughts on this matter that I will be putting in a new post later tonight.

    You could compare this stuff to GDI, and cosmetically that’s true, but GDI has one massive point of superiority: you don’t have to worry about all your resources arbitrarily disappearing at any time. Having to deal with that is terrible; the bigger and more complicated your app gets, the more extra weird easy-to-get-wrong bookkeeping it has to do.

    As someone who had to implement pretty good font rendering for a game I just shipped (implemented on top of FreeType 2, which is great, so I didn’t have to do rasterization) I think it’d be nice if they would provide that in the future, yeah. But what they ought to provide is not very much like what they are actually providing, I think.

    As I said, more detail later today.

  8. I do agree strongly with you on the resource loss issue; my understanding from what I read was that you only had to deal with that problem if using hardware acceleration – you can still create a surface in software emulation mode which shouldn’t be subject to those limitations.

    One could argue, though, that end-users shouldn’t have to worry about it at all, and that the API should do in-memory buffering for you, and I tend to agree with that point. I look forward to your post on the subject.

  9. Wow – 4 minutes in and this has to be the most annoying unlistenable podcast ever.

    We get it – everything Microsft does is crap, etc. Are these guys real developers? Could they not imagine a scenario why a VPC might be a valid way to get feedback on a preview? Maybe the install code is not ready, maybe they don’t want bug reports about a zillion different OS configurations yet. Maybe just shut up and don’t look a gift horse in the mouth.

    As a .net developer, I was really interested in your impressions. I just can’t continue to listen. Is there a text transcript available?

  10. Uhh, believe me, these guys are “real developers” as you put it. One of them runs a company that ships development-oriented products to a lot of customers, so I would think he is qualified to weigh in on what is a reasonable distribution and what isn’t.

  11. Major dicks. Downloaded but wouldn’t install VS2010… and then you ramble on about it? And Direct2d… it’s pretty clear you don’t know how to access COM from C++… but don’t let that stop you… charge on it! Double major dicks.

  12. Yeah, you got me. Obviously I just don’t know how to program. I can’t possibly have a legitimate argument, which I actually put forth in this post and in the next one, which could be responded to by actual counter-claims if you had any. Nope, ad hominem is always the best way to go!

    Somebody call the Xbox 360 guys and tell them to take down that game that I obviously couldn’t have programmed, because I don’t know how to program.

  13. Ok, I’m really trying to be fair here. So far. their comments…
    – tell me they don’t know anything about UML diagrams or that many corporations use UML diagrams and therefore would find them useful in a SDLC tool. I don’t care for UML diagrams myself.
    – complaints about MS marketing & naming. Original.
    – complaints about the marketing bullet points describing the product. Not complaints about actual usage of 2010 – just the marketing text.
    – complaints about improvements to source control & branch visualization(which I know applies only if you use TFS). Again, not sure why this annoys them so much. I know some dev shops that would appreciate this.
    – arguments about IDEs in general – nothing specific to 2010.
    – complaints about changes to solution files but since they didn’t try opening a copy of their own solution, they can’t really tell what impact it will have.

    I am a programmer on the MS platform but more on the corporate/web side of things (not so much game programming). I’m just tired of superficial complaints and/or lack of substance found in a typical slashdot comment.

    I would be interested in hearing what tools you use for xbox & game development and what works or doesn’t.

  14. For game development we use Visual Studio. We have to, because there is nothing else. This is why we are so annoyed — this stuff causes problems with everything we do, all day, every day.

    Visual Studio has a history of getting more and more useless with each revision. This is maybe part of the background knowledge that a lot of game developers have that might be assumed in the podcast. When they say “10 is the new 6” they are talking about Visual Studio 6, which is the last revision of the IDE before the whole thing got rewritten in .NET.

    We don’t want a 7GB IDE. We don’t want a 500MB IDE. We don’t even want a 50MB IDE, probably. Most of the stuff in there is useless. We want a good compiler and a good linker and a good debugger and some of us want a lightweight IDE to tie it all together, but we could do without that really. The problem is that nobody at Microsoft seems to care about the linker or the debugger or the compiler. They are all working on stuff of highly questionable utility for *anyone* — certainly things that we would never use — that just screws up the workflow for everyone.

    Trust me, Jeff and Casey know what UML diagrams are. They wouldn’t use them (neither would I). Why are they being built into the IDE? Why is the Visual Studio team working on that, rather then figuring out why compilation gets slower and slower with every new release?

    Most of the complaints in the podcast come from familiarity with every previous version of Visual Studio, how it has just gotten further and further off the tracks, and seeing that the new version is just more of the same — but to the extreme, much more than could have been imagined.

    A lot of developers who I know don’t use the integrated source control in Visual Studio. The times I have seen it used, it was always a mistake, slowing the process down. Like the podcast guys, I don’t even use the Visual Studio editor, so the last thing I want is to accidentally check out files via some source control hook. I use svn on the command line and the workflow is much smoother than anything I have seen in the way of Visual-Studio-integrated stuff. The idea of having that stuff more-integrated and therefore more-intrusive just makes me shudder.

    That’s a start… I could talk about this all day. But I have another posting to go finish.

  15. For point of comparison of what, say, the debugger would be like if anyone had a clue, check out nvperfhud (http://developer.nvidia.com/object/nvperfhud_home.html). It’s a debugger for a different domain (rendered polygonal graphics) but it goes way beyond anything that anyone on the Visual Studio team is even thinking about in their wildest dreams.

    If you are going to make an IDE that visualizes things for me, I want to see my program’s data, stack history and control flow visualized like *that*. I don’t want to see UML boxes and lines. Please.

  16. Re AndyB’s comments:

    The podcast is a comedy podcast, it’s not actually supposed to be arguing various points about VS2010 or Direct2D. Our listeners already know that these things are terrible, and we are just poking fun at them for their amusement.

    On the factual side, yes, Jeff and I are real developers. Combined, the libraries we wrote run in an estimated 7000-ish games, although it’s always hard to get an exact count (that’s probably low, the counts are updated that often). We both have many years of shipping API design experience.

    If you want a more detailed analysis of how APIs should be designed, you can listen to my game-tech 2004 lecture on the subject at

    http://mollyrocket.com/873

    I don’t actually know anyone who is a professional API designer (meaning that API design is a core part of their job) who thinks Microsoft’s APIs are even remotely competent, so I guess I didn’t realize that there would be programmers who would reasonably look at Direct2D and not think it was horribly broken. Since that seems to be the case, I guess it would be a good idea for one of us to do a non-humorous analysis of the API to explain why it’s about as poorly designed as an API can possibly be without being actively antagonistic.

    – Casey

  17. Whaoo … The last rant about Visual Studio causing all sort of problems all day long kinda stoke me as I’ve just been through part of the “linux dev tools flame” (http://braid-game.com/news/?p=364). I had gotten the impression that you were at least midly satisfied with tools on Windows.
    Have I just read wrong ?

    Is there actually any programming environment / set of tools that you are , like, happy to work with ? I know that tools are for a non-unsignificant part a matter of personnal taste, but still … what would you suggest to someone willing to use tools that don’t suck too much ? To stop programming and stick to carpentry ?

    Anyway, good luck with your efforts on your games … and have patience with the trollers and name-callers, they just don’t know what they’re doing 😉

    PH

  18. The assertion that Visual Studio gets worse for each version is bollocks. Certainly versions 7-9 were much worse for C++ developers but 9 is light years ahead of 7 for .net development. And don’t even try to claim 1.5 was better than 4.

    However the Visual Studio team seems to be putting a lot more effort into version 10 for C++ developers (hence 10 is the new 6) not sure what the end result will be but looking at their blog is seems an improvement.

    Also not sure why you must use Visual Studio for DirectX development can’t you use the command line tools with your editor of choice.

    Never had a problem with the source code integration either.

    Now I will get back to work in Visual Studio 6.

  19. I supposed it’s comedy like listening to a comedian complain about airplane food. Same old stuff.

    They complain about bloat in an IDE but then complain IE doesn’t have a download manager.

    I know of plenty of dev shops that use UML and have been begging for support in MS tools for it – but I don’t see how the developers working on that can help your compiler out. Would the compiler be that much better with 1000 on it vs. hiring 1-2 really smart guys?

    There is also this “customized install” option that lets you not even bother with any of these add-ons.

    I guess my point is that I found the feedback here on this blog from Jonathan more insightful in terms of his pain points.

  20. Well, as I mentioned somewhere in the giant Linux dev tools thread, I think Visual Studio is pretty bad, but it’s *still* leaps and bounds beyond the Linux development tools. So, it’s a matter of relative vs. absolute. Visual Studio is on a relative scale way better than the Linux tools; on an absolute scale it is pretty bad and has all kinds of problems.

  21. Yes, Linux tools are worse than VS right now. But they are getting better, and VS is getting _worse_. That’s worth complaining about.

    There is a reason that MS themselves was claiming 10 is the new 6 – they know they have sucked.

  22. “We don’t want a 7GB IDE. We don’t want a 500MB IDE. We don’t even want a 50MB IDE, probably. Most of the stuff in there is useless. We want a good compiler and a good linker and a good debugger and some of us want a lightweight IDE to tie it all together, but we could do without that really.”

    Then, uh, install Visual Studio C++ Express and not the entire Visual Studio?

    I don’t disagree with a lot of the stuff you, Jeff and Casey are saying, especially when it comes to the absurdity of Microsoft still creating new APIs using all of the COM cruft that was clearly braindead even 10 years ago. If they were going to make Direct2D at all they really should have just written a clean C/C++ API for it and then maybe have written a .NET wrapper on top of that to expose it to the .NET languages and called it a day. But attacking the full Visual Studio package for size and features you don’t want (as a C/C++ programmer that just wants basic language features) is kind of like attacking a full install of Microsoft Office Ultimate for having a bunch of crap that is useless for people who just want to make spreadsheets. Well, yeah, of course it is, and if that’s all you want to do with it, you should have just installed Excel.

  23. Jonathan,

    I’ve seen the other blog and he makes some good points. He says you can draw a simple rectangle in Direct3D, but you can’t draw text or other stuff on top of Direct3D wihout a ton of code. Text is pretty darn compilcatd (look at DXUT), so hes got a point. Maybe you could extend your sample to do it? Would be useful code to have. I think your sample would be a lot bigger tho.

    COM has a bad rep because of the limits on threading, remoting, and stuff. But, the Direct2D and Direct3D docs say there only using COM for ref-counting of objects and interface abstraction. If that’s so, I don’t see what the problem is. Interfaces are interfaces, and you need to free objects when you don’t need them anymore. Why is deleting a handle or a piece of memory any worse than releasing an object thru COM? Id like to know your opinion on that. Your sample doesn’t release any objects once you create them. Maybe you dont care about mem leaks. Why not?

    Whoever told you or Jeff or Casey that Direct3D no longer needs to handle device loss, that’s just flat-out wrong. Direct3D has gotten much better about reducing the number of situations where devices can get lost, but you still have to handle it if you want your app to be robust to failure. I’m guessing you guys dont bother because your either writing games and don’t care or you just dont know better or your using a managed code framework like XNA which does it for you. I thought that I’d point it out to you tho so you don’t stick your foot in your mouth.

  24. I don’t get the whole “Visual Studio gets worse every version” comments.

    in C++ I used VS5, VS6 and VS2003. I didn’t see a whole lot of difference between VS5 and 6, but VS2003 was a huge improvement.

    in C# I’ve used VS2003, 2005 and 2008. Each has been an improvement over the prior in almost every aspect. The only complaint I have is some stability in 2005 and 2008, they crash about 1-2 times a week – but as far as usability goes, much better and enough that I’ve been able to deal with the crashes (just some grumbling).

  25. Yes, there’s some functionality, like text drawing, that would be nice to have implemented in an easy-to-use way. But this does not necessitate complication of the API! Also, the presence of such a feature provided by the API does not change the fact that the overall API design is quite bad.

    For Braid, I used FreeType2 to do the rasterization of text, and wrote a system that packs this stuff into texture maps dynamically at runtime for fast rendering. This took some time, and it would be nice if I didn’t have to do it, but at the same time it actually worked out better (my version will kern if I want it to, whereas the DirectWrite one won’t; also, my code is cross-platform and it will run next week on a Mac or a Playstation 3, whereas you would have to rewrite the same code I just did if you were using DirectWrite, and then you would get inconsistent visuals between platforms).

    I’ve explained multiple times in these comments why deleting a handle through a reference count is bad. I don’t want to keep repeating myself. I will ask you, though, if you are using a Microsoft higher-level API like D3DX, how do you know when D3DX is holding references to objects and when it is not? They sure as hell don’t document it. Not knowing that, but also knowing that sometimes the lower-level graphics API is going to require you to make the reference counts to go 0 at arbitrary times, what are you going to do? How are you going to make it work? And is any of this garbage necessary in the first place?

    The sample I posted here doesn’t free the objects because when you exit a process, the memory is freed, and that is the only case in which I need those objects to be freed. Have you ever clicked the close button on a window and it takes like half an hour to close, and thrashes your disk in a very frustrating way? It’s because the programmer is meticulously going through all his data structures and freeing all that stuff… which would have been freed anyway, much faster and more-efficiently, if he’d just left them there.

    Game developers definitely care a lot about memory leaks. To ship a game on the Xbox 360, for example, it has to be able to run for 72 hours straight, on a system that has only 512MB of RAM and no virtual memory; and since our games are not driven by event loops, they crank through everything 60 times per second, as opposed to just sitting there as a Windows app might. So we care about memory leaks than most app developers.

    But finally, I don’t think that anyone said that there are no circumstances in which D3D needs to think about device loss. However, D3D at this point goes through significant effort to minimize the number of cases where that happens, whereas D2D does not. In Braid, the main thing I need to worry about is texture maps that I allocate in video memory that do not have a D3D-managed local memory copy. That’s a pain and requires extra work, but it’s nowhere near as ridiculous as what D2D puts you through. Also, note that I didn’t need to do this at all in my sample app because the tasks that app performs are simple enough not to need them. That was my entire point!

    But I am finding your comment kind of tiresome because it seems like yet another “obviously you guys don’t really know how to program” reply. Willard, can I ask about the biggest and most-complex program you’ve written that uses hardware acceleration (either Direct3D, Direct2D, OpenGL or SDL or something else, I don’t care) — how long is the program, what did it do, and where did it ship, to how many users? And how much quality did those users expect (e.g. was it free software or were they paying for it and therefore expected something robust?) That will help contextualize your comments.

  26. I’m not seeing what the big deal is.

    * A lot of what is shown in the Microsoft examples is fairly elementary Win32 stuff (e.g. SetWindowLongPtrW, CreateWindow, RegisterClassEx).
    * All of the following APIs are fairly-straightforward:
    – m_spRT->SetTransform(D2D1::Matrix3x2F::Identity()); // May require you to have worked with Transforms and Identity Matrices to get this one…
    – m_spRT->Clear(D2D1::ColorF(D2D1::ColorF::White));
    – D2D1_SIZE_F rtSize = m_spRT->GetSize()
    – D2D1_POINT_2F startPoint = D2D1::Point2F(0.0f, 0.0f);
    – m_spRT->DrawLine(startPoint, endPoint, m_spLightSlateGrayBrush, 0.5f);
    – m_spRT->FillRectangle(&rectangle1, m_spLightSlateGrayBrush);
    – hr = m_spRT->EndDraw();

    Take the example, and work off it. They could have designed it in a way that required less code, and I’m sure they considered that (I don’t think that’s as big of a deal in C++ land). This looks like a fairly non-wasteful, non-assumptive API with minimal side effects.

  27. Mac os X is heaven. Linux is earthish. But man Windblows is like LIVING HELL. The guys over at redmond should share with us what it is that they are chogging cause they are out of it. If this is what `professional’ programmers can churn out I am not impressed. It’s marketing that keeps windows running – not their `technology’.

  28. Hi Jonathan,I am a huuuge fan.I love Braid.I want to try my hand at creating my own game.Could you please tell me where to start and also which tool you used to create the masterpiece that is braid.

    Thank you

  29. You could start reading the articles on places like gamedev.net. Not everything you read there is good advice, but it will give you context and a place to start. You can branch out from there.

  30. You might want to consider working in a higher level environment like Game Maker. Many people prefer the fast-prototyping power it provides to the in-depth technical control provided by something like C++, and some games made with its tools have enjoyed some degree of popular and/or commercial success. Flash is also a possibility.

    If you’d like to stick with C++, I’d highly recommend that you check out the SDL library, and particularly lazyfoo’s tutorials on the same. These are a great introduction to the fundamentals of game loops and drawing content to the screen using SDL. It also touches on the basics of getting OpenGL working with SDL, which is great if you want some more sophisticated graphics effects.

    While Jon says having high expectations is good (it is, in the long term), to start with you should work on getting small simple games/prototypes working. Braid itself started out as an ugly quick prototype, so don’t worry if whatever you make doesn’t look amazing at first. First, worry about getting something on the screen; then worry about making it move; then worry about making it move well; then worry about making it a game. After that, you can start worrying about making it look good.

    Sites that may be worth checking out:
    http://www.gamedev.net
    http://lazyfoo.net
    http://www.tigsource.com

    I’m sure there’s many I’m forgetting so if anyone else wants to throw any more in there please feel free.

  31. now what this does is it draws a rectangle.
    what this does is it draws a rectangle.
    john, what this does, is it draws a rectangle.

    this program, direct 2d, draws a rectangle.
    it draws a 4-sided figure in which all opposite sides are congruent, and where each member meets, a right angle is formed.

    it draws a rectangle.

  32. Hi Jonathan,

    Thanks for this post. There’s lots of points here, and lots of follow-up commentary I want to get to in detail as well, but I wanted to just lead off with this question (and maybe this is for Casey too).

    With regards to the comment Casey makes early in the podcast: “Every single time they’ve updated their development environment (and their operating system), they’ve made it less likely that you will be able to distribute a program. That is not exaggeration. […] We are at the point where there is no question that if you installed Ubuntu, you can get a program working on it faster than you can get it working on a Windows PC, *without question*, like, I mean, there’s no question at all.”

    I don’t mean to cherry-pick here, and I realize the Jeff and Casey show is meant mostly as comedy and satire, but given your experience with looking at porting Braid to Linux, do you think this is true? My sense is that the game development on Windows and PCs in general has many pitfalls, especially around OS and hardware compatibility/support, but I still think the Linux landscape is more cumbersome overall compared to Windows in this regard.

    I don’t think Casey is comparing apples to apples in his comment above. His Windows comment concerns a developer writing an app and being able to distribute it and have it run on other versions of Windows; the Ubuntu comment only mentions how easy it is to run a program installed with it out of the box, but I assume he meant to include the case where a developer writing an app on a certain version of Ubuntu and the ease of distributing that and having it run on another version of Ubuntu. Again, not a big deal for the purposes of this question.

    Thanks in advance. I want to dive in more on this thread, and will catch up on the commentary so far.

  33. OK, I’ve had a chance to catch up on commentary on this post, but not the follow post, yet. I’m still avoiding API related comments here, instead I wanted to comment more on Visual Studio 2010 gripes.

    Some preliminaries: I came “late” to every Visual Studio release after 6. I ran VS6 concurrently with other releases as late as early 2007. I skipped VS.NET (2002) entirely. I only installed Visual Studio 2008 for actual development use *in 2008*, some time shortly before SP 1 was released; I now use VS2008 daily. I generally wish Microsoft would slow down on releasing new Visual Studio versions; I don’t expect to be switching to VS2010 until sometime in 2011 or 2012, depending on a lot of variables. I switched from VS2005 to VS2008 primarily for the ability to target different .NET versions from the IDE, better multithreaded debugging, and for some OpenMP and C/C++ standards and strictness improvements. I do not do game development for a living.

    I can understand that for game development needs, especially C/C++ based game development (which to say the majority of it, still, today), most of Visual Studio is overkill. I can understand why you and Jeff and Casey don’t care about integrated UML designers or extensive Team Foundation Server specific functionality, or .NET features, etc. What you seem to be arguing for is a toolchain from Microsoft geared specifically for professional game development (i.e. not what XNA is today) as a separate product from Visual Studio.

    It’s clear, I hope, that Visual Studio is a huge, sprawling product (really, product line) that caters to the largest possible set of all its buyers as possible, which is no longer solely C/C++ developers on Windows writing desktop client applications, but also client-server developers, ASP.NET developers, .NET application developers, large distributed teams working on complex business software stacks, etc. etc. We could argue about the relative utility and overwroughtness of all of that, and the requirements each of those development communities (and more) ask of the product, and what Microsoft decides to add in. There’s ample arguments to be made, but the point I’m getting at is that’s what Visual Studio is targeted to a much broader audience, most of whom have concerns far more abstract and less about writing code, perhaps, (certainly, at least, less about writing high-performance C/C++ code) than professional game developers do.

    PerfHUD is intersting, and makes total sense given NVIDIA as a company wanting developers to make the most use of their hardware to enhance their product offering to consumers (who are primarily gamers), but for PC development, games alone must not equate in providing value to Windows consumers, compared to the other priorities shown in what Visual Studio exposes in its feature set. On the other hand, all is not doom and gloom. There’s thinks like PIX, which I’m sure you’re more familiar with than I am, and the real and important work people like Andy Ayers and the Phoenix group (http://connect.microsoft.com/Phoenix) are doing to make an all new compiler infrastructure (see a [large] video at http://channel9.msdn.com/Showpost.aspx?postid=396461).

    XNA shows at least a willingness on the part of Microsoft to make a focused game development product, even if you and Casey and Jeff aren’t the market for it either. I think it might be possible to get what you want from Microsoft given the right combination of the right people, luck, timing, and enough strong demand from professional game developers seriously interested in continuing to develop for the PC, in addition to consoles like Xbox 360. The fact that what you want is, by comparison to Visual Studio, such less work to make, should be an easier sell. I don’t have any sure-fire ways to go about making that a reality, but I think the less you rail against Visual Studio and the more you carve out yoru own set of requirements and find external support and an internal champion or two, the more likely it is to happen.

  34. I have not ported Braid to Linux! I have never even tried to do that. I’m not sure why so many people think that’s the case. When I was looking at Linux stuff a while back, it was with an eye to making that the development platform for my next game. I couldn’t deal with the (in my opinion of course) poor quality of the tools, so eventually I gave up on the idea.

    I do think that Casey’s comment compares two different situations, as you say, but maybe they connect up in his mind in a way he didn’t verbalize. Not sure!

  35. “Then, uh, install Visual Studio C++ Express and not the entire Visual Studio?”

    The Express edition is for non commercial use and only works for .NET development unless the Platform SDK is also installed.

    Best usage scenario for me is to use Microsoft headers and libraries and install the Intel C++ compiler.

  36. @Blow:

    Your comment above seems a bit backwards
    “I will ask you, though, if you are using a Microsoft higher-level API like D3DX, how do you know when D3DX is holding references to objects and when it is not? They sure as hell don’t document it. Not knowing that, but also knowing that sometimes the lower-level graphics API is going to require you to make the reference counts to go 0 at arbitrary times, what are you going to do? How are you going to make it work? And is any of this garbage necessary in the first place?”

    This is exactly the problem that reference counting tries to solve. Let me ask you this, would you rather not ref-count and not know if you can delete the object without leaving a dangling pointer?

    Also, can you give an example of an MS api that “require[s] you to make the reference counts to go 0 at arbitrary times”. I mean, if you’re holding an object that _requires_ a pointer to another object, then the ref-count of said object better not go to zero out from under it. seems like memory management 101.

  37. I think Microsoft with VS isn’t even thinking about the small indie developer anymore – they’re trying to target some megacorp with 5000 programmers all working on some bloatware app. Some massive ERP payroll data processing app, where you have to wear a tie to the office. Then again, it’s always sort of felt like that now for years, IMHO. They’re just taking it to a whole new level it looks like, hearing Jeff and Casey talk about it.

    That and it really does begin to look like that all the smart people have left Microsoft as well, and all that are left are people who can’t leave to go find another job somewhere else.

    I shudder to think about some poor kid who wants to write some code to draw to the screen nowadays. Back when I was a kid, it was all open, you wanted to scribble on the screen, go at it. Now, you have to know and understand what COM is, and about 2 or 3 other infrastructure overhead systems before you can even begin to think about drawing. And COM isn’t exactly fun to learn either, and that’s speaking as an adult. As a kid, no f—ing way!

    At some point, we’re gonna lose all the kids to something else, you know. They’re going to say f— it and go do something else.

  38. You know, Owen is right, specially at the part of his comment regarding the kids nowadays. Things from the real life/world should be kept in the same relation when they are transposed into something virtual if you like, in this case programming. What I want to suggest is that for most of the people, thinking and drawing in 2D in the real world is something quite easy. On the other hand, if another dimension is added, and now they must think and draw in 3D, things get more or less complicated. My question is why this relationship isn’t maintained in this specific case of D2D -> D3D?

    It doesn’t even matter ( for me at least ) that they are made by MS, or that D2D is build on top of D3D, or that this new D2D still uses COM technology. What matters is the CONCEPT itself. The idea that 2D is simpler than 3D in real world geometry, and this concept must be fully respected when we speak about some APIs.

    I’m a programmer, but at least for now, I’m only doing graphical applications or small games as a hobby. However, I find OpenGL superior to this DirectX technologies. And when I say superior, I’m saying that it is *at least* more intuitive and more clean. I’m not God so please don’t take this as an assertion, it’s only an affirmation, my affirmation, build on own opinions /tastes.

    cheers for everyone!
    — Mihail

  39. second link is dead but just like the first one it is sourced from this episode of the Jeff and Casey show:

    Season 1
    Episode 50
    Original air date: January 26th, 2009
    A Camaro that Doesn’t Explode

  40. I just spent 50 hours trying to make Direct2D’s clipping implementation work like GDI’s and so I wanted to add some more analysis (based on that experience) to this discussion.

    It is completely absurd to have to create an overlay layer just to do clipping to an arbitrary path. What’s the big deal, you ask? Consider the following scenario:

    I have a partially transparent image that I want to render (clipped) to my drawing context and overwrite the existing contents (i.e. use copy blending mode). It’s impossible to do this with a layer because, when the layer is composed back into the main context, the transparent bits are ignored. That took me about half of the 50 hours to figure out. Why should I need to reverse engineer details like this just to do something very standard in 2D rendering (clipping)?

    I could go on about having find the secret knowledge where you can use QueryInterface() to convert an ID2D1RenderTarget to an ID2D1DeviceContext (to get access to D2D 1.1 blending modes). Or the fact that there are no less than 74 interfaces in the current version Direct2D! But I’ll leave it at the following statement:

    I’ve done 2D graphics programming in GDI/GDI+, Quartz2D, Cocoa, Qt, and Cairo and I have never experienced such a convoluted 2D API in my life.

Leave a Reply

Your email address will not be published. Required fields are marked *