For anyone familiar with dbgsrv, it is similar in purpose and function to msvsmon, the visual studio remote debugging monitor. Both applications are “process servers” for their respective debugging environment. Running dbgsrv on a remote machine allows developers to attach to any process on that machine, or launch processes under the debugger.

Using dbgsrv is slightly mysterious, as the UI for using it is a bit cryptic in WinDbg. I’m going to run through a few examples to show how useful dbgsrv can be.

To start, we need to get dbgsrv running on the machine you want to debug. Usually, this will be a test computer that you want to debug from your development computer. If you want to follow along the examples, you can use a single machine, although this scenario isn’t very useful for real world debugging. To start dbgsrv, run it from the command line giving it parameters to pick a transport to use. Usually, tcp is the easiest when not working with domain-joined machines:

dbgsrv -t tcp:port=31337

If there are no errors, dbgsrv will start silently and start listening for connections. (You may see a firewall dialog at this point). To use the process server from windbg, use the “Connect to Remote Stub…” menu item from the File menu:

The connection string should match what you’ve started dbgsrv with. For instance, if dbgsrv is running on my computer named “timtst”, I would connect to “tcp:port=31337,server=timtst”. After accepting the connection string in this dialog, there will be no indication of failure or success until you actually try to use it. Once the connection string is entered, you can try to attach to a process using File->Attach to Process, or using F6. If the connection was successful, you will see a list of processes on your test computer, or an error if the connection was not successful.

To use the same functionality in cdb/ntsd, you can use the “premote” command line argument. For instance, to use the same dbgsrv instance as in the previous example to attach to process ID 4000, you can use the following command with ntsd:

ntsd -premote tcp:port=31337,server=timtst -p 4000

Using ntsd also lets you start a process under the debugger through a process server:

ntsd -premote tcp:port=31337,server=timtst C:\MyTestApp.exe

Note that the path given refers to a path on the remote machine running dbgsrv, not the machine running ntsd. This functionality is not available in windbg.

There is an excellent write-up with more information about dbgsrv at nynaeve.net

If you’ve found this interesting, I highly recommend the book Advanced Windows Debugging
by Daniel Pravat. As one of the most informative books about the Windows Debugging toolset, it has a host of information about dbgsrv and the rest of the tools.

Not necessarily. A recent slate article examines the discrepancy between black and white spending on “visible goods” (like fancy clothes, luxury car, etc). The proposed explanation is that black people tend to live in neighborhoods of other black people of relatively similar income levels (compared to that of white people). The increased spending on visible goods has nothing to do with race, but simply a result of increased tendency for “signaling”. The net result of “signaling” is that more money is spent on “visible goods” and less is spent on health care and education.

Does this mean that equality is bad? Probably not, however it certainly means there are significant unintended consequences that are highly unintuitive.

Bill Gates is my personal hero, which should come as no surprise to those who know me as a Kool-Aid drinking fanboy. However, the reason I admire Bill Gates has little to do with Microsoft itself. He exemplifies personal qualities that I admire, including technical breadth, ambition, and commitment to effective philanthropy. I’m sure Bill has made some mistakes over the years, as many would like to point out, but the way I see it, the best way to judge character is to see if a person really puts his money where his mouth is. Bill delivers, though I suppose that makes his mouth pretty big.

Adios, billg! So long, and thanks for all the fish/DOS/qbasic/etc.

-Tim

IE8 passes ACID2!

Everyone is excited about the newest generation of consoles. Microsoft is going all out with XBox 360, and Playstation 3 will doubtless be amazing. The underdog, in this generation of consoles, will be the Nintendo Revolution. Or will it?

XBox 360 costs $399 (The core system doesnt exist, so dont talk to me about that). Rumor has it that PS3 will cost upwards of $499 (Although I think a price point of $399 will make it much more competitive with XBox). And how much does the Revolution cost? Probably around $150. It’s no secret that Nintendo doesn’t want to compete with Sony or Microsoft. Who can blame them? Nintendo follows no one’s rules but their own. Nintendo is not getting sucked into the console arm’s race for the most spectacular graphics. It’s fairly likely that the Nintendo Revolution will have graphics only marginally better than the original XBox.

I still put my money on Nintendo. In fact, I don’t know for sure whether PS3 will win over 360, or vice versa, but I do know that Nintendo Revolution will do just fine, regardless of what happens to the other consoles.

Nintendo has always been an innovator. This has been the key to their success, and has also been the cause of many laughable failures. They have a philsophy that seems to be willing to try anything. Products such as Virtual Boy, Nintendo DS

I can’t decide if I was psychic, good at picking up industry activity, or if this was obvious. To this day, it’s hard to find a Wii because every console is sold out.

For what it’s worth, my money is on Silverlight. When Microsoft announced that Silverlight applications will use CLR, and that CLR will be available on OSX, my jaw dropped. The ability to write a rich internet application using the amazing power of C# and the Common Language Runtime is amazing, and the fact that this will work on OSX shows that MS is serious about making this a viable platform. On top of this, I’m sure that there is going to be an extremely intuitive RPC mechanism to interact with ASP.Net webservices (and PHP/Ruby/etc. webservices). The boost in developer productivity is going to have a direct impact on the quality of applications that will be developed in the next few years.

In my opinion, this view can be equally applied to software. People are motivated to create software through the incentives they get through having control of the intellectual property of the software they create. The incentives are obvious for companies like Google, IBM, and Microsoft. For open source software, however, the incentives are less clear, but are present nonetheless. The Free Software Foundation, for instance, vehemently defends the GPL. For them, the incentives may be less financially driven, but the underlying enabler is the ability they have (through US copyright law) to control the distribution and use of their work. I find it interesting that an organization which so strongly defends its own right to control its work is so vehemently against the rights of musicians and authors from protecting their own work. On their sites badvista.fsf.org and defectivebydesign.org, they explain how DRM is an evil technology that prevents you from using your computer. DRM is a technology which allows content producers to specify how they want their work to be used and distributed (and thus protect their rights under US copyright law).

So this begs the question, is the campaign against DRM a technology issue or an ideological struggle? This is plausibly a technology issue, since DRM technology in its current incarnations pretty much sucks. Then shouldn’t there be a push to do DRM technology in a technologically sound way? With all the smart people out their working on Linux and related technologies, can’t we come up with a way to ensure that copyright holders can maintain control of their work in a technologically sound way? But what if this is an ideological struggle? Then it certainly seems as if the FSF is somewhat hypocritical, since it seems to believe it has the right to control its work, but musicians and artists do not.

My two cents.

Logically, there are three positions you can have on open source and closed source software. If you have an opinion on the issue at all, it must be that 1) All software should be open, 2) Some software should be open, and some should be closed, or 3) All software should be closed. However, I have never met a programmer who believes that all software should be closed. Even at Microsoft, the supposed bastion of closed-source software, the developers regularly release open source code, in the form of documentation, utilities, samples, and a multitude of projects on codeplex. So in reality, this is a war between the belief that all software should be open source, and the belief that some software should be open source.

The belief that all software should be open source is championed by Richard M Stallman. He asserts that proprietary closed-source software is unethical and immoral, and this sentiment is reflected in the terms of the GPL. Specifically, the GPL specifies that all derivative works must also be released under the GPL. This means that if I release any software that is based on GPL software, I must also release my software under a GPL compatible license. The GPL spreads to every work that it touches, irrevocably and irreversibly. Sound familiar? That’s because my description could just have easily been that of a virus. The GPL is a virus that attempts to enforce its view of the world on everyone it touches. When I worked for IBM (one of those supposed champions of open source), we were not even allowed to look at GPL code for fear of our own code becoming tainted.

Is software really free if I can’t even look at it for fear of legal repercussions? Stallmanites would likely argue that IBM is morally obligated to release their software under an open source license anyway, so why is it such a problem? The problem is that without an economic incentive, the software would never get developed, and the only business model that has been shown to be viable with open source software is the “support model.” Under this model, companies release their software for essentially no charge, but then charge their customers for support contracts. Unfortunately, this business model is completely unviable for a huge range of software industries. As an easy example, look at the video game industry. What gamer would pay for a support contract? And there are plenty of other examples where the support model obviously doesn’t work, especially in the domain of consumer oriented software.

Anyone who thinks I’m an “open-source hater” should check out my website; all of my code is released under a public domain license (the only truly Free license). But I need to work for a living, which is why I work for Microsoft. I have a feeling that most people are in the same boat as me. We need to work for a living, and companies need to make money to survive and keep paying us. Not all of us have the ability to support ourselves from speakers’ fees and prize money. So while we contribute where we can to support the community, we still plug away at our day jobs. Stop disrespecting us Stallman.

Fast forward about a decade to Windows Vista. Security is (and will forever be) a huge concern in operating system design. Running as administrator is no longer a viable option. However, backward compatibility is just as important as ever before. The solution, in the form of UAC, is to prompt the user every time administrator privileges are required. This allows users to continue to run as administrators, but selectively elevate their privilege level when needed in order to perform administrative tasks (such as installing programs). Every time elevation is required, the screen grays out, forcing the user to select whether they want to approve or deny.

From a user interface perspective, this really kind of stinks. Apple derides UAC in their Mac vs. PC advertisements (which is interesting, since OSX has a similar elevation mechanism I’m told). The problem is that admin privileges are simply needed too often. You need admin privileges to install applications, change system settings, but also 90% of legacy applications require admin privileges to run properly. Vista alleviates some of this to a certain extent by virtualization of the filesystem and the registry to give legacy applications the illusion of running as Administrator. However, there are plenty of programs that this doesn’t work for.

Fortunately, this is really a temporary problem. Any application written after the introduction of Vista, even if written to run on XP, will be written with the assumption that “I am not running as administrator”. This is fantastic, because new programs will be written to play nice on a limited account, and so will never need to request elevation. In other words, no more UAC prompts!

UAC is like fine wine, it only gets better with age.