- Are Windows Forms old school?
- How badly do you want a MacBook Air?
- Visual Studio 2008 SP1: To beta, or not to beta?
- Imote2 .Builder Kit makes creating wireless sensor networks a snap
- TDD with Silverlight
- LINQ webinar video and forum
- LINQPad Webinar 2/20
- Yet Another Computer Language
- Cobra is an interesting work in progress
- Debugging into the .NET Library Source
June 09, 2008 | Comments: (0)
Over on the Advice Line blog, a reader who signs himself "Need help from Bill Gates" asked Bob Lewis about an upgrade project from a Windows application using MDI to the .Net Framework. The architects he talked to pooh-poohed Windows Forms as "old school" and pushed Web applications, Windows Presentation Framework, and Silverlight. Bob said "it depends" and suggested another conversation with the architects about fashion vs. style.
Here's my answer:
Dear Need-Bill ...
You need to talk to different architects, ones who will listen to what you want and analyze what you need instead of pushing the latest technology because it's glitzy.
Web applications have an advantage over desktop applications when it comes to installation and accessibility, but they aren't as responsive as desktop applications at this point. Windows Forms (WinForms) is the right technology if you want to build a Windows desktop application with the .Net Framework that will provide maximum productivity to people who use the application heavily, especially if they enter lots of data.
Windows Presentation Framework (WPF) offers additional graphical capabilities for desktop applications, but requires more in the way of hardware than WinForms to run well. I'm not sure your customers need or could benefit from the advanced graphics, and they might not want to upgrade their computers to run it.
Silverlight is a rich Internet application technology. It implements a subset of WPF as a Web browser plug-in.
Beautiful things can be done with Silverlight rich Internet applications, but you'd need Silverlight 2.0 if you wanted to build one that would be useful for line-of-business or data entry: Silverlight 1.0 doesn't even have a native text input control. Silverlight 2.0 has not yet been released: it is still being beta tested, and beta 2 was just released on Friday.
Posted by Martin Heller on June 9, 2008 08:03 AM
May 14, 2008 | Comments: (0)
How badly do you want a MacBook Air?
At least partially in response to my coverage of TopCoder last week, I have been getting a spate of programming contest and community announcements. ZocDoc is an API for doctor appointments. Appistry Enterprise Application Fabric (EAF) is a grid-based application platform for the development and deployment of scalable applications in Java, Spring, .NET or C++.
Notice what these two have in common:
Tuesday, May 13, 2008
ZocDoc Announces Developer Contest - Win a MacBook Air!
Today, ZocDoc kicked off a contest for software developers to create new applications that help patients book doctor appointments anywhere on the web. ZocDoc users have frequently requested integrations into popular applications and devices such as Facebook and iPhones, among others.
The contest, which runs from now until August 1, 2008, challenges developers to build the application that will most benefit patients looking for a doctor. A new API allows developers to pull data from ZocDoc such as doctor and dentist information, practice locations, pictures, URLs and available appointment times, which can be integrated into custom mashups and applications. The developer of the application that benefits the most users (as measured by appointments made) wins a brand new MacBook Air!
If you are a developer, visit the ZocDoc Developer Center to register for the API.
Join Appistry's Peer2Peer Developer Community and you could win a MacBook Air
Appistry Enterprise Application Fabric (EAF) dramatically simplifies the process of developing, deploying, and managing highly scalable and reliable Java and Spring applications.
Now, with Appistry EAF Community Edition, anyone can experience the benefits of Appistry EAF for FREE. Your Peer2Peer membership allows you to:
- Download Appistry EAF Community Edition at no cost
- Utilize it on up to 5 servers or 10 CPU cores for an unlimited amount of time (no expiration)
- Use it for development, testing, even production deployment of applications
It's easy to get started - join the Peer2Peer Developer Community today to download the free software and access developer resources such as tutorials, on-line documentation and support forums.
You could win a MacBook Air when you join Peer2Peer
Hmm. This is the computer that my high-school classmate Steve Levy (or possibly his wife) accidentally threw out with the newspapers.
Posted by Martin Heller on May 14, 2008 11:11 AM
May 13, 2008 | Comments: (0)
Visual Studio 2008 SP1: To beta, or not to beta?
As I mentioned in An old Visual Studio problem rears its ugly head back in February, I've been looking forward to SP1 for Visual Studio 2008 and NET Framework 3.5. Why? These are supposed to fix most of the problems I've been having with Visual Studio, and restore most of the functionality that was cut from the initial 2008 release.
SP1 is out, but only as a first beta-test version. As is true with most beta-test products, there are risks to running it, ranging from a high likelihood of encountering new bugs to a low likelihood of trashing your system to the point where your most effective option is to reinstall Windows from scratch on a newly formatted partition, also known by the woodworking analogy of scraping your drive down to the bare bits.
The list of improvements in this version is impressive. Both Scott Guthrie and Brad Abrams have discussed these in their blogs. Brad does a great job of covering new features; Scott does too, in a slightly different way, and also highlights the known incompatibilities.
Here are the "gotchas", copied from Scott's blog:
1) If you are running Windows Vista you should make sure you have Vista SP1 installed before trying to install .NET 3.5 SP1 Beta. There are some setup issues with .NET 3.5 SP1 when running on the Vista RTM release. These issues will be fixed for the final .NET 3.5 SP1 release - until then please make sure to have Vista SP1 installed before trying to install .NET 3.5 SP1 beta.
2) If you have installed the VS 2008 Tools for Silverlight 2 Beta1 package on your machine, you must uninstall it - as well as uninstall the KB949325 update for VS 2008 - before installing VS 2008 SP1 Beta (otherwise you will get a setup failure). You can find more details on the exact steps to follow here (note: you must uninstall two separate things). It is fine to have the Silverlight 2 runtime on your machine with .NET 3.5 SP1 - the component that needs to be uninstalled is the VS 2008 Tools for Silverlight 2 package. We will release an updated VS 2008 Tools for Silverlight package in a few weeks that works with the VS 2008 SP1 beta.
3) There is a change in behavior in the .NET 3.5 SP1 beta that causes a problem with the shipping versions of Expression Blend. This behavior change is being reverted for the final .NET 3.5 SP1 release, at which time all versions of Blend will have no problems running. Until then, you need to download this recently updated version of Blend 2.5 to work around this issue.
I wouldn't install this version on my primary development system, but I might install it on a secondary development system after doing a full back-up.
To beta, or not to beta? Maybe both.
Posted by Martin Heller on May 13, 2008 11:37 AM
April 25, 2008 | Comments: (0)
Imote2 .Builder Kit makes creating wireless sensor networks a snap
I spent several hours today exploring the Crossbow Imote2 .Builder Kit, a "complete development environment for high performance wireless sensor networking (WSN) applications leveraging the Microsoft .NET Framework," as the company describes it.
(I'd never say "leveraging" and "Microsoft" in the same sentence myself if I could avoid it, because of Microsoft's rather checkered legal history of "leveraging" its near-monopoly -- but oops, I did it again. Back to Crossbow.)
The Imote2 .Builder Kit sells for $990 in the U.S. in small quantities. It includes three Imote2 processor boards, two Imote2 sensor boards, two battery boards, batteries, a USB cable, and software on CD-ROM. Obviously, individual boards are cheaper, especially in quantity.
Why so many boards? The processor boards also have radios, and can talk to each other using the 802.15.4 protocol. The Imote2 has an XScale CPU @ [13–416] MHz and a DSP, 256kB SRAM, 32 MB of SDRAM and 32 MB of FLASH, and baker's dozen of I/O ports of various stripes in addition to the radio and antenna. It has two pairs of connectors for sensor boards, a set for a "basic sensor board" on one side and an "advanced sensor board" on the other side. The flash image includes the .NET Micro Framework.
The sensor boards that come with the kit are of the basic variety, but I guess that refers to the connector they use: they actually have a 3d Accelerometer, an advanced temp/humidity sensor, a light sensor and 4 channel A/D.
The Imote2 software is an add-on to Microsoft Visual Studio 2005 (yes, 2005, not 2008) and .NET Micro Framework 2.0 (yes, 2.0, not 2.5). A 90-day trial version of Visual Studio 2005 Professional is provided with the kit.
I found the programming model for the Imote2 easy to understand, as I was already fluent in C# and familiar with Visual Studio 2005 and the .NET Micro Framework. I think I could build wireless sensor network applications with this kit very quickly: in days to weeks, depending on the complexity of the application.
The processors seem plenty fast. Debugging is trivially easy. The only trouble I had with the kit was a minor but annoying deployment issue: sometimes a board would stop taking downloads, and code deployment from Visual Studio would fail. I was always able to recover from this by stopping all the software on the PC that talked to the board, disconnecting the board from the USB bus, reconnecting and resetting the board, and restarting the software.
According to the company, this is most likely a problem with the Microsoft USBSPOT driver. Once I had a board programmed, it would be fine.
The picture at the top of this article is the hardware configuration for the most advanced demo in the kit, a star network in which two battery-powered CPU/sensor stacks transmit accelerometer data, one CPU board receives the signals and sends them over the USB cable, and the PC plots the live output, as shown at left.
Overall, this is a very impressive kit. There's more information at the Crossbow site.
Posted by Martin Heller on April 25, 2008 12:10 PM
March 28, 2008 | Comments: (0)
Microsoft has not only released the source code for the Silverlight controls, they have released almost 2,000 of their own unit tests -- and a unit testing framework that works with Silverlight.
More on Brad Abrams' blog...
I think this is seriously cool. What do you think?
Posted by Martin Heller on March 28, 2008 02:25 PM
March 05, 2008 | Comments: (0)
I mentioned the 2/20 LINQ webinar given by Joseph Albahari in advance of its live presentation, but some of you didn't hear about it until the weekly newsletter went out on 2/21. (That's what the RSS feed is for, folks.) A few of you even asked for me to arrange a reprise or a video. Of course, I have nothing whatsoever to do with this, but the good folks at O'Reilly have obliged. The hype is theirs, not mine:
If you missed out on the recent O'Reilly Webinar, "Writing LINQ Queries with LINQPad," you can still learn the ins-and-outs of using LINQPad directly from author Joseph Albahari. LINQPad is the querying tool that's sweeping the .NET world. This is a must-view webinar for anyone working in C# 3.0 and Framework 3.5.
Download and watch the webinar video (43 minutes, .mov file, 50 MB) here:
http://downloads.oreilly.com/oreilly/videos/oreilly-linq-webinar.mov
You can also join authors Joseph and Ben Albahari in our C# 3.0 in a Nutshell Forum to continue the conversation.
Recent posts include:
- Table Of Contents In Pdf
- Linqpad Customization
- Linqpad Open Source?
- Sql Optimization
- Intellisense
- Linqpad Case Sensitivity
Join the discussion here:
Enjoy.
Posted by Martin Heller on March 5, 2008 08:27 AM
February 17, 2008 | Comments: (0)
Readers of this blog might be interested in an upcoming O'Reilly Webinar on LINQPad. From the official announcement:
"Writing LINQ Queries with LINQPad — Happening Wednesday, February 20th at 2:00pm PST. In this webinar, Joseph Albahari, author of C# 3.0 in a Nutshell, the LINQ Pocket Reference, and the upcoming C# 3.0 Pocket Reference, provides an introduction and brief tutorial to LINQPad, the querying tool that's sweeping the .NET world. This is a must-attend webinar for anyone working in C# 3.0 and .NET Framework 3.5. Learn more."
Posted by Martin Heller on February 17, 2008 02:41 PM
February 12, 2008 | Comments: (0)
You can't know how much it excites me to hear that Microsoft is designing yet another computer language. Why, what a novel idea! It isn't like there were hundreds of new computer languages designed every year. If that were the case, there would be conferences about the subject. Oh, wait: that's how we first heard about this one, at the Lang .NET conference on the Redmond campus.
But it's a declarative language! Ah, yes: that eliminates maybe half of the languages proposed every year. "Declarative" is an awfully broad term, with multiple meanings. Standard ML is considered declarative, and so are its derivatives OCAML and F#.
Prolog and rule-based AI systems are considered declarative. You declare the rules: the logic engine decides how to run them. SQL queries are declarative: you describe the data you want to see, and the query optimizer figures out how to get it out of the database.
Haskell is considered declarative as well as functional, not to mention that it has monads. Don't ask me to explain monads in the context of functional programming: it's not a short answer. The "Summarizing Proust" contest isn't on today, thank you very much.
Back to declarative languages. XAML is a declarative language for the domain of graphics. It was designed as an extension of XML. It's such an expressive language that Charlie Petzold, arguably one of XAMLs most vocal proponents, built himself a alternative to Microsoft's XAMLPad called XAML Cruncher, so that he could "interactively type XAML code and see the object it creates." In Visual Studio 2008, Microsoft included a bidirectional, split-screen XAML designer, so that you can create XAML by dragging and dropping objects and by typing XAML code, with the ability to freely switch back and forth between the two methods. I freely admit to needing these tools; I can almost never write XAML that will display correctly on the first try.
Watching the Connected Systems Division (CSD) at Microsoft over the years, it has been clear that they have been on a code-reduction path. Why? SOAP was invented by Don Box and others to be an XML-based lingua franca for communication among disparate computer applications and systems. The functional deficiencies of SOAP were addressed by the WS-* series of standards, to give it security, authentication, reliability, and so on.
All of those standards made it harder to write conformant client and server code, raising the complexity by orders of magnitude. CSD engaged in a series of efforts to counter this by raising the level of abstraction for programmers developing connected systems. Web Services Enhancements (WSE) for Microsoft .NET cut the amount of code you needed to write drastically, but not enough for mere mortals.
Windows Communication Foundation (WCF) brought the amount of code down by another order of magnitude or so, partly by using attributes in code and by depending on XML-based configuration files. Attributes are of course one approach to making a language more declarative, and configuration files are another.
Looking at WCF in Visual Studio 2008, it seems like the classes and attributes and design tools are fairly mature, but are still built on top of the general-purpose C# language and the .NET Framework. I wouldn't be at all surprised to hear that the CSD architects decided to try starting over from scratch with a new language that would raise the level of abstraction and reduce the amount of code that needed to be written for a connected application by another order of magnitude. But it's not like nobody else has ever tried that: there's a robust research community working on that kind of problem.
I can guess about the process they're going through, but I can't guess what the outcome will be. It's an emergent experiment, and there are a dozen ways it could go. Nevertheless the criteria are kind of obvious:
High level of abstraction? Check.
Regularity of syntax? Check.
Easy to write? Check.
Easy to read and understand? Check.
Suitable for connection to disparate systems over multiple protocols? Check.
Posted by Martin Heller on February 12, 2008 07:35 AM
February 09, 2008 | Comments: (0)
Cobra is an interesting work in progress
I'm grateful to Savio for mentioning the Cobra language in his Open Sources blog. I had a look at Cobra this weekend, and found it rather interesting.
Microsoft has always touted the .NET Framework as being language-agnostic. In the early days of the Framework, that sounded more like coordinated PR than a real technical characteristic of the Framework. As it turns out, though, it was true.
C# may be the premier .NET language, because that's the language in which most of the class libraries are written, and Visual Basic .NET may be a close runner-up. But there are dozens of other languages written for the .NET Framework, with a range of styles and amenities. Some of these are from third-party language developers -- Eiffel comes immediately to mind -- and some are from internal Microsoft groups, like the ML-derived F# language from Microsoft Research. Still others are or were open source efforts: a classic example is Jim Hugunin's IronPython, which is now sponsored by Microsoft.
In some ways, Cobra reads like a blend of Python and Eiffel. It uses indentation like Python, and supports contracts like Eiffel. It has additional influences, listed here.
When I talk about a new programming language, I usually start with its "Hello, World!" program.
"""
This is the infamous "Hello, world." example.
And this text you are reading right now is the "doc string" for the whole
program. You can also put doc strings underneath classes, class variables,
methods and properties.
"""
class Hello
def main is shared
print 'Hello, world.'
That little sample doesn't do justice to the language, however. This page explains some of the key features. The Wordcount sample illustrates Cobra's inline tests and object-oriented programming in a reasonably sized program that actually does something.
It's worth downloading Cobra and trying it yourself. You'll need .NET 2.0 or Mono. Don't expect Visual Studio integration, Windows Forms support, debugging support, or even a syntax-aware editor. Do expect an interesting language for console applications that's on the verge of becoming useful.
Posted by Martin Heller on February 9, 2008 08:08 PM
February 04, 2008 | Comments: (0)
Debugging into the .NET Library Source
I was hesitant to add any preview plug-ins or apply any patches to Visual Studio 2008 until I'd finished my review, but now that it's done I've gone a little wild. I have installed the ASP.NET 3.5 Extensions, the ADO.NET Entity Framework Tools Dec 07 Preview, the Silverlight Tools, Volta, and the patches needed for the EF Tools and for debugging into the .NET Library source code.
The instructions for enabling Visual Studio 2008 to debug into the .NET Library source code are on Shawn Burke's blog. The only part that gave me any trouble was installing the Hotfix, and even that didn't take long.
The EULA that comes up the first time you try to view Library source code is a little more specific than what was originally announced: it does not give you a license to view the source if you're building a competing product for a non-Microsoft OS. That addresses the "patent troll" issue that Dave Rosenberg raised last October, and which I discussed at the time.
It's worth understanding which assemblies are currently available for symbol/source loading. Shawn lists them in his blog entry:
- Mscorlib.DLL
- System.DLL
- System.Data.DLL
- System.Drawing.DLL
- System.Web.DLL
- System.Web.Extensions.DLL
- System.Windows.Forms.DLL
- System.XML.DLL
- WPF (UIAutomation*.dll, System.Windows.DLL, System.Printing.DLL, System.Speech.DLL, WindowsBase.DLL, WindowsFormsIntegration.DLL, Presentation*.dll, some others)
- Microsoft.VisualBasic.DLL
More assemblies will be added in the future.
There's a new MSDN forum to discuss the Reference Source Server. There are already 27 questions, but I'm sorry to say that many of them are just rehashes of FAQs that were already answered in Shawn's blog.
Posted by Martin Heller on February 4, 2008 08:11 AM
January 04, 2008 | Comments: (0)
As I was testing the LINQ to SQL functionality in Visual Studio 2008, I found myself missing the SQL Query Builder. For the relatively simple three-table inner join SELECT queries I needed, I was able to write correct LINQ syntax myself with only a database diagram, IntelliSense and online help for guidance. Writing more complicated LINQ queries freehand felt like it would challenge my nascent LINQ skills.
Do we really have to generate the SQL with SQL Server Management Studio and then translate it into LINQ?
I asked Microsoft, and it turns out that we don't. Joseph and Ben Albahari, the authors of C# 3.0 in a Nutshell, have released a free LINQ query builder (written by Joe), LINQPad.
It requires .NET Framework 3.5. If you have Visual Studio 2008 or Visual C# 2008 Express, then Framework 3.5 will already be installed. LINQPad supports SQL Express, SQL 2000, SQL 2005, and (with some limitations) SQL 2008.
Posted by Martin Heller on January 4, 2008 11:36 AM
December 06, 2007 | Comments: (0)
I downloaded the Microsoft Volta preview bits yesterday after writing up my initial take on the announcement, only to discover that my Visual Studio 2008 Beta 2 Virtual PC had expired, meaning that I couldn't actually try Volta out myself.
Meanwhile, I looked into how Volta works. As documented here, Volta basically works as a recompiler for .NET 3.5 applications. As a developer, you build the whole application as though it will run entirely on the client, and then you mark parts of it to belong to the server tier. Compile it. Volta then looks at the generated MSIL in your assemblies, and rewrites it "into any number of target languages, including, today JavaScript and MSIL itself."
According to Microsoft, the three techniques used are "refactoring, retargeting, and remodulating. Refactoring converts single-tier code into distributed, concurrent code as directed by user-supplied annotations. Retargeting converts MSIL code into code for other virtual machines. Remodulating tailors a single piece of code for multiple browsers."
The fact that Volta can retarget .NET applications for JavaScript means that you can write plain old .NET code to generate Ajax applications, much in the same way as GWT lets you write plain old Java code to generate Ajax applications. That opens up a number of interesting scenarios.
It also opens up a number of interesting questions. How well will all of this work? Will it make developers' lives easier, or add yet another layer of junk between us and our goals, and introduce hard-to-debug, hard-to-profile black boxes into our applications? Will it turn out to be the powerful, liberating tool that Microsoft's write-up suggests, or will it turn out to primarily be a way to lock developers into writing for the .NET Framework?
What do you think? Have you been able to try Volta yourself?
Posted by Martin Heller on December 6, 2007 11:48 AM
December 05, 2007 | Comments: (0)
Volta: Web Development by Tier-Splitting
Microsoft Volta was just posted as a technology preview at Microsoft Live Labs. The short summary is that Volta is a new methodology for creating Web applications. Instead of deciding on your architecture at the beginning, building the tiers and tying them together, you start by building a .NET client application, then designate components to run on the server and client tiers later in the cycle, and let the tool generate the plumbing for you.
The tag line is "Web development using only the materials in the room." Why do I keep looking around for Heidi Klum and Tim Gunn?
Here's the full introduction from the Volta home page:
The Volta technology preview is a developer toolset that enables you to build multi-tier web applications by applying familiar techniques and patterns. First, design and build your application as a .NET client application, then assign the portions of the application to run on the server and the client tiers late in the development process. The compiler creates cross-browser JavaScript for the client tier, web services for the server tier, and communication, serialization, synchronization, security, and other boilerplate code to tie the tiers together.
Developers can target either web browsers or the CLR as clients and Volta handles the complexities of tier-splitting for you. Volta comprises tools such as end-to-end profiling to make architectural refactoring and optimization simple and quick. In effect, Volta offers a best-effort experience in multiple environments without any changes to the application.
Read Paul Krill's news article about Volta here, including discussions with the architects and product managers.
Posted by Martin Heller on December 5, 2007 11:13 AM
November 27, 2007 | Comments: (0)
What happened to my Visual Studio 2005 News Feed?
Today the news feed on my Visual Studio 2005 start page stopped working. I don't know why.
I was able to fix it, though. I went to Tools | Options | Environment | Startup and copied the existing news channel URL. I pasted that into my browser, and it redirected to http://www.microsoft.com/feeds/msdn/en-us/vstudio/rss.xml. I copied that URL back into the Startup form, pressed OK, and the news feed came back.
I'm looking forward to Visual Studio 2008, but I suspect I'll wait for the DVD to arrive instead of downloading it.
Posted by Martin Heller on November 27, 2007 12:30 PM
October 18, 2007 | Comments: (0)
Creating and Using a Data Access Layer with Visual Studio 2005
Every time I do this I have to figure it out again. (Sometimes I empathize with HAL, when he is being dismantled at the end of 2001: "My mind is going, Dave. I can feel it.") I'm blogging this as much for myself as for anyone else it might help.
Here is the magic spell you need:
- Create a Class Library project in your solution in the supported language of your choice. I like C#, but Visual Basic .NET also works. I usually end the project name with DAL so that I can remember what it is.
- Delete the Class1.cs (or .vb) source file that is created automatically.
- Right-click on the project and add a new DataSet item. The design surface for an XSD file will open.
- Open a data connection to the database you're wrapping.
- Select each table you want to use and drag it to the design surface.
- Build the data access layer project.
- Add a reference to the data access layer project to your UI project. It doesn't really matter whether the UI project is a Windows Forms application, an ASP.NET application, a console application, or a Windows Presentation Foundation application.
- Add a using (or Imports) statement for the table adapters of the data access layer to your UI project. IntelliSense will help out if you added the reference properly.
Now you can instantiate the table adapters in your code and call the appropriate pre-generated methods for whatever CRUD operations you need. If you need other operations, you can go back to the DAL and add them: right click at the bottom of the table in the DataSet diagram and add a query.
Posted by Martin Heller on October 18, 2007 08:06 AM
October 05, 2007 | Comments: (0)
.NET Library source welcome, but not earth-shattering
With all due respect to the esteemed Senator from MuleSource, I wonder what Dave Rosenberg has been smoking. In this blog posting, Dave says that Microsoft's release of the source code to the .NET Libraries is "a patent trolling dream."
I've dealt with my share of patent trolls (I was an expert witness defending against a big one), but I'm also an experienced developer who is familiar with Microsoft development tools.
Microsoft has shipped the source code to its C/C++ runtime libraries with Visual Studio for many years. The practice of publishing copyrighted source code is hardly new: it goes back at least to DEC and IBM. For example, I used to read Dave Cutler's source code for RSX-11M in the 1980s, and I read IBM VM-370 system routines in the 1970s.
If I look in my C:\Program Files\Microsoft Visual Studio 8\VC\crt\src directory or my C:\Program Files\Microsoft Visual Studio 8\VC\atlmfc\src directory, I can view the source code for any of the C/C++ runtime library, MFC, and ATL routines. Sure, the source code starts with a Microsoft copyright claim, but frankly I don't care:
/***
*abs.c - find absolute value
*
* Copyright (c) Microsoft Corporation. All rights reserved.
*
*Purpose:
* defines abs() - find the absolute value of an int.
*
*******************************************************************************/#include <cruntime.h>
#include <stdlib.h>#pragma function(abs, _abs64)
...
What's important to me is that I can debug into the library routines if and when they are implicated in programming problems. abs() is a bad example, because it's not something I'd misuse, but there have been plenty of times when being able to debug down into the library has shown me where I've gone astray.
What about the .NET Framework libraries? Well, for one thing, for the basic libraries I can refer to the .NET Framework Standard Library Annotated Reference (Addison-Wesley, 2004 and 2005), of which I was an editor, and find out not only how whole classes and specific members work, but what the designers were thinking. For another, I can use Lutz Roeder's .NET Reflector and see the source code reconstructed from the compiled code, along with the documentation.
Why does that work? Mostly, because the .NET Framework compiles to an intermediate language (IL), not native code. The IL gets JIT-compiled at runtime (or at installation time for the libraries), but that doesn't interfere with the IL and metacode information in the assembly.
In addition, Microsoft chose not to scramble or obfuscate the .NET library code. They have always wanted developers to understand how the library works.
So what's new? Three things: more libraries are being released as source than are covered by the ECMA/ISO standards; we'll be able to debug directly into the library source; and we'll be able to see the internal comments. If history is any guide, the internal comments will be rife with misspellings:
*Exit:
* returns the aboslute value of number
Brad Abrams has a posting about the source release here. He in turn links to a posting by Scott Guthrie and a podcast by Scott Hanselman and Shawn Burke.
Posted by Martin Heller on October 5, 2007 08:18 AM
August 24, 2007 | Comments: (0)
Charlie Petzold was one of the pioneer Windows development writers, along with Paul Yao and a few others. I didn't write my first Windows development book until 1992, and by then Charlie's books were so well-established that I consciously positioned Advanced Windows Programming as the book to read after you had already grokked Petzold's Programming Windows.
Charlie's latest book is 3D Programming for Windows (Microsoft Press, 2007, 448 pp., $39.99, ISBN 9780735623941). It's no surprise at all to me that the book is a beauty of clear explication, filled with illuminating examples, and backed by a Media3D library that implements many of Charlie's techniques.
If you like 3D programming, aren't averse to XAML, and have access to Windows Vista or Windows XP, go buy this book. If you're in any doubt, try reading Charlie's blog, where he has been discussing the library and other material from this book for the past few weeks.
Posted by Martin Heller on August 24, 2007 02:47 PM
August 01, 2007 | Comments: (0)
.png "Visual Studio 2008")
Microsoft has released a lot of stuff for developers to look in the last week. I had downloads going most of the day last Friday, even though I have an 8 Mbit/s business cable connection to the Internet. I still haven't installed everything I've downloaded, much less looked at it in any detail.
Visual Studio users will want to see beta 2 of Visual Studio 2008. The master public download page for that is here; I personally downloaded the Visual Studio Team System 2008 - Team Suite & Team Foundation Server Beta 2 VPC, but that's only one of about eight options. If you're feeling adventurous and are not behind a corporate firewall, try the Microsoft Secure Content Downloader (MSCD), a peer-to-peer download channel now being tested for Visual Studio 2008 beta 2.
If you have an MSDN subscription, you can get Studio 2008 beta 2 as a Subscriber Download, in one of five flavors. For some reason, the combined VSTS/TFS VPC is not available as a Subscriber Download: don't ask me why. I got perfectly good performance using the public download site on Friday, but it does sometimes get overloaded; when it does, the Subscriber Download site usually provides a better download experience.
Many other new downloads that you are you likely to want have to do with Silverlight, Microsoft's new RIA environment:
- Silverlight 1.0 Release Candidate (runtime only)
- Silverlight 1.0 RC SDK (for developers)
- Silverlight 1.1 Alpha Refresh (runtime only)
- Silverlight 1.1 Alpha Refresh SDK (for developers)
- Expression Blend 2 August 2008 Preview (supports Silverlight 1.1 Alpha Refresh)
- Microsoft Silverlight Alpha Tools for Visual Studio 2008 Beta
You might also want to download the Acropolis CTP and samples, which were posted earlier in July. Acropolis is basically a new "set of components and tools that make it easier for developers to build and manage modular, business focused, client .NET applications."
Posted by Martin Heller on August 1, 2007 01:44 PM
July 24, 2007 | Comments: (0)
The Microsoft team building Ruby for the .NET Framework has released the first source code for IronRuby. See John Lam on Software: A first look at IronRuby for the announcement. The IronRuby source code was released under the Microsoft Permissive License.
According to Lam, they are accepting contributions to the libraries, and planning to get IronRuby onto Rubyforge by the end of August. Why Rubyforge and not CodePlex? So that we can access it from Subversion instead of TFS.
Cool.
Posted by Martin Heller on July 24, 2007 08:25 AM
July 12, 2007 | Comments: (0)
Embedded Fusion is in the process of making the accelerometer board I mentioned here available for purchase on their site. In the mean time, they can be purchased by contacting sales@embeddedfusion.com. There isn’t a specific name for it, so "accelerometer board for Tahoe" is what customers should request. They will be making the source to the Ball-in-Maze application available for free download with the upcoming SDK release next week.
Posted by Martin Heller on July 12, 2007 12:34 PM
June 30, 2007 | Comments: (0)
When I wrote about free Ruby on Rails IDEs last Wednesday, I drew a comment from "teki321:"
"I would never put 'Ruby in Steel' in the context of free. It's an extension for a commercial application, which is not free."
That's currently true, but I wasn't really thinking in those terms. It's free for people who already have Visual Studio 2005 Standard or above.
The Ruby in Steel folks have mentioned to me their wish that their product worked as an add-on to one or more of the free Visual Studio Express products. They're certainly not the only VSIP partner to feel that way.
A little later this year, all of these partners can have their wish, if they build their product with the Visual Studio 2008 Shell.
"If you create software development tools, you'll want to consider building on the Visual Studio 2008 Shell. A streamlined Visual Studio development environment, the Visual Studio Shell provides the core foundation so you can focus on building your application's unique features. Flexible customization options help you deliver optimized experiences for specific markets."
How does this help? The Visual Studio Shell will be free, and also royalty-free. When does this miracle happen?
The Visual Studio Shell will be available to Visual Studio Industry Partners (VSIP) partners with Visual Studio 2008 beta 2 and will be available to the broader development community with the release of Visual Studio 2008. The Visual Studio Shell will be available by web download alongside the Visual Studio SDK.
There will be two modes of the Visual Studio Shell, integrated and isolated. The former is for languages, and the latter is for applications.
So there you have it. Who says that the only thing worse than being a Microsoft competitor is being a Microsoft partner?
Posted by Martin Heller on June 30, 2007 03:13 PM
June 28, 2007 | Comments: (0)
.NET Micro Framework: Tahoe Development Kit
Last week I told you about a conversation I had with Colin Miller, the manager of the Microsoft SPOT group, about the .NET Micro Framework. Since then, I have installed the .NET Micro Framework SDK, along with the EmbeddedFusion Tahoe Development Kit. That goes along with an EmbeddedFusion Tahoe board that Microsoft's PR firm sent me; they also sent an accelerometer daughter board, a "ball in maze" sample application, and a lab manual for the sample. The accelerometer and sample application are not part of the standard Tahoe kit.
The Tahoe board uses a Meridian CPU module, which combines a 32-bit Freescale i.MXS (ARM920T core) processor running at 100 MHz, RAM, FLASH, an LCD display, some buttons, and the Microsoft .NET Micro Framework. As you can see from the illustrations, the LCD display and the buttons are on top of the board, and the Meridian CPU module is on the bottom. The Meridian CPU supports many low power peripheral devices via the serial, i2 C, and SPI interfaces. It isn't obvious from the illustration, but for development the Tahoe board draws power from a miniUSB connection at the top left.
Compared to the 8-bit, 12 MHz, Intel 8051-based embedded controllers that I grew up on, the 32-bit, 100 MHz ARM 9 is a speed demon. By the time you factor in the overhead of the interpreted .NET Micro Framework runtime, however, the performance doesn't feel all that spectacular. Maybe I've been spoiled by 3,200 MHz desktop CPUs with multiple cores.
Anyway, I'm finding playing with the .NET Micro Framework SDK and the Tahoe SDK luxurious fun, in my geeky, retro way. I remember writing assembly code to flip I/O bits on wire-wrapped breadboards for embedded controllers 20-odd years ago, and here I am writing C# code to flip I/O bits on a packaged printed circuit breadboard. The more things change...
Posted by Martin Heller on June 28, 2007 02:33 PM
June 21, 2007 | Comments: (0)
.jpg)
Today I had a briefing from Colin Miller of Microsoft about the .NET Micro Framework, a very small footprint version of the .NET Framework targeted for the embedded development space. The official description goes like this:
The Microsoft .NET Micro Framework is an environment that extends the advantages of Microsoft .NET and the toolset in the Microsoft Visual Studio development system into a class of smaller, less expensive, and more resource-constrained devices than previously possible with other Microsoft embedded offerings.
According to Miller, the Micro Framework is not as compatible with the desktop as the .NET Compact Framework, because compatibility wasn't the primary goal. For example, they didn't implement the Forms namespace, because the Forms footprint is too big: interestingly enough, they used part of the Windows Presentation Framework object model instead.
The Micro Framework does support most of the .NET System namespace, but none of the Data namespace. Basically, they built the .NET Micro Framework up from scratch based on the needs of the embedded devices they and partners key customers were building.
Note that the .NET Micro Framework is not suitable for hard real-time. While they have a JIT compiler on the shelf, it requires too much of a memory footprint, so the Micro Framework runtime is still interpreted. It's also not as feature-rich as Windows CE or Windows XP Embedded.
According to Miller, embedded development hasn't changed much since 1970s, despite all the changes in desktop programming. There are fewer 8-bit devices being used: in the 1970s and early 1980s, when I did most of my embedded system development, a lot of embedded systems were built around 6502s and Z80s. There are still many 16-bit processors in use, but newer 32-bit processors are coming down in power and becoming appropriate for embedded systems, for example the ARM Cortex.
When Miller's group started talking about embedded programming with some version of the .NET Framework, they got a great response from embedded developers, and not the die-hard push-back you might have expected. They started cherry-picking things from desktop, and they are still doing it: one of the future releases will include web services for devices.
Colin had a lot more to say to me, but perhaps it would be better if you heard it directly from him. This video shows Colin, Mike Hall, Craig Mundie and others talking about the .NET Micro Framework, its applications, and the reasons for it. Basically, if you know how to write C# for the desktop, you should be able to write for embedded devices with the .NET Micro Framework.
Download the .NET Micro Framework SDK from here if you already have Visual Studio 2005. A white paper is here, and the official book site is here.
Posted by Martin Heller on June 21, 2007 02:12 PM
May 01, 2007 | Comments: (0)
At Microsoft's MIX07 conference, the keynote was mostly about Silverlight. What is Silverlight, and why should we care about it?
Officially, Silverlight "is a cross-browser, cross-platform plug-in for delivering the next generation of .NET based media experiences and rich interactive applications for the Web." In other words, it's a browser plug-in that enables a subset of the capabilities of the Windows Presentation Foundation over the Web. It was previously called WPF/E.
From the user's viewpoint, to enable Silverlight, you download and install a 1.4 MB plugin, and then you can view Silverlight content in IE, Firefox or Safari. From a developer's viewpoint, once you have the tools installed, you instantiate Silverlight by including some JavaScript helper files from your HTML, and then you can display and script XAML files in your Web pages.
Microsoft cites four key benefits of Silverlight:
1. Compelling cross-platform user experiences
2. Flexible Programming Model with Collaboration Tools
3. High-quality media, low-cost delivery
4. Connected to data, servers, and services
Two versions of Silverlight were announced Monday: the V1.0 beta, and the V1.1 Alpha. What's the difference? The diagram below summarizes what's in each release:
.png)
Again, why should we care? If you're a cynic, Silverlight just looks like Microsoft's answer to Flash. But if you like the idea of XAML-based display, or the idea of programming in managed code, then Silverlight offers a compelling model for programming the Web client.
Posted by Martin Heller on May 1, 2007 12:38 PM
April 16, 2007 | Comments: (0)
Windows PowerShell: An Introduction
One of the hazards that Microsoft groups face when they launch their products is competition for attention from other Microsoft groups with bigger marketing budgets. Think about the poor Windows PowerShell team, who basically launched at about the same time as Windows Vista and Office 2007. It was no contest.
If you haven't already heard about Windows PowerShell by that name, you may have heard of it by its rather pretentious code name, Monad, or its temporary name Microsoft Shell, abbreviated MSH. I'm sure that Jeffrey Snover and the PowerShell team wanted "Monad" to convey the unified interface they were building.
Then why do I think Monad was a pretentious choice? It's the other meanings of the term. In philosophy, the term Monad, meaning the "ultimate, indivisible unit" goes back to Pythagoras, and was used by Plato, Aristotle, the neo-Platonists, Liebniz, and the Theosophists to describe some rather lofty concepts, often verging on the divine. In mathematics, a monad is a type of functor in category theory. In functional programming languages, for example Haskell, a monad is a rather complicated implementation of sequential functors.
So, what is Windows PowerShell? It's a command line shell, a programming language, and a unified interface; it's not your father's command line shell. From the Windows PowerShell Getting Started Guide:
Windows PowerShell is a new Windows command-line shell designed especially for system administrators. The shell includes an interactive prompt and a scripting environment that can be used independently or in combination.
Unlike most shells, which accept and return text, Windows PowerShell is built on top of the .NET common language runtime (CLR) and the .NET Framework, and accepts and returns .NET objects. This fundamental change in the environment brings entirely new tools and methods to the management and configuration of Windows.
Windows PowerShell introduces the concept of a cmdlet (pronounced "command-let"), a simple, single-function command-line tool built into the shell. You can use each cmdlet separately, but their power is realized when you use these simple tools in combination to perform complex tasks. Windows PowerShell includes more than one hundred basic core cmdlets, and you can write your own cmdlets and share them with other users.
Like many shells, Windows PowerShell gives you access to the file system on the computer. In addition, Windows PowerShell providers enable you to access other data stores, such as the registry and the digital signature certificate stores, as easily as you access the file system.
I have found PowerShell to be extremely useful for exploring the operating system. One of the data stores it supports is WMI, Windows Management Instrumentation, which is a wrapper for many system structures, so you can use PowerShell to dig into the guts of things like Win32 processes, add-remove program lists, and system hardware. It also supports COM, so you can use it to script all sorts of applications and controls that expose COM interfaces.
I was under the mistaken impression that PowerShell would ship with Windows Vista. In fact, you need to download and install PowerShell separately; make sure that you get the right version for your operating system (Vista, XP, Windows Server 2003, or Longhorn Server) and locale, and that you have .NET Framework 2.0 installed before you install PowerShell.
The documentation that comes with the Windows PowerShell download will get you started. However, I have found Windows PowerShell in Action, by Bruce Payette (Manning, 2007, 576 pp, ISBN 1-932394-90-7, $44.99) to be an excellent supplement. Payette is a co-designer of the PowerShell language and the principal author of the language implementation. His book not only tells you all the secrets of PowerShell, it tells you what the team was thinking when they designed and implemented the language.
Posted by Martin Heller on April 16, 2007 06:00 AM
March 12, 2007 | Comments: (0)
Free Lessons for Beginning .NET Programmers
When the free Express editions of Visual Studio were first announced, the Microsoft .NET Development Series got quite a few proposals for books aimed at amateur and novice programmers. As Series Editor, I always had to ask how much money someone would pay to learn how to use a free development environment. My gut feeling was "nothing:" the free IDEs would need free training, meaning that the business opportunity for Express-specific books was practically non-existent.
It has been a long time coming, but Microsoft now has a site for this, the Beginner Developer Learning Center. At first examination, I'm quite impressed.
The site is divided into two major tracks, one for Web development and one for Windows development. Within each track, there are lessons in each of three tiers. Tier 1 lessons assume no prior software development knowledge; tier 1 lessons assume that you understand the foundations of .NET development. Tier 3 lessons "expand your knowledge of Windows and Web development with more advanced concepts such as data access and debugging." (Pay no attention to the man behind the curtain rolling his eyes at this last statement.)
In addition, the Learning Center has a Kid's Corner with cartoony introductions to C#, VB, and Web development. I found these corny myself, but I haven't yet tried them out on my middle-school-aged kids.
For reference, the site has video "how-to" guides to Windows Forms and Web Forms controls in C# and Visual Basic, and a video "how-do-I" series about ASP.NET. Finally, it has a "Tips and Tricks" series of assorted video and PDF guides, for things like creating templates and deploying applications with ClickOnce.
These short video guides are very much in the same spirit as the short videos we produce here on InfoWorld.com. As with our videos, the production values might not be anything to write home about, but the information presented is right on the money.
Posted by Martin Heller on March 12, 2007 06:00 AM
March 07, 2007 | Comments: (0)
Unscrambling the March Orcas CTP Downloads
Microsoft, in its infinite wisdom, has released what was supposed to be the February Visual Studio "Orcas" CTP as the March Orcas CTP. They released it late on February 28th, which is typical for something they promised in February; I couldn't actually download it until late on March 1st because of server congestion, which is also typical of a new download-only release. In addition to more of Orcas, this drop includes most of .NET Framework 3.5.
There are four download options here, but picking the right one(s) for your needs might be tricky. I have downloaded 2 of the 4, and run them briefly. Let me give you enough information to help you decide what you want for yourself.
All of the downloads are broken into pieces compressed in RAR format. The first piece is an EXE that unpacks itself and all the other pieces. The Virtual PC downloads require a version of Microsoft Virtual PC to be installed, along with the Orcas Base Image.
Let me start with the ones I haven't downloaded.
This download adds an Orcas VS installation to a real computer. It has 7 parts to download, six of 700 MB each and one 433 MB. It isn't recommended for installation on production machines. It requires either Windows Server 2003 or Windows XP, and 1 GB of physical RAM.
This download adds an Orcas TFS installation to a real computer. It has 2 parts to download, one 700 MB and one 160 MB. It isn't recommended for installation on production machines. It requires Windows Server 2003 and 1.5 GB of available physical RAM.
And now the ones I have downloaded. Both are Virtual PC images, and both will force you to change the administrator password when they start up. Both will try to update themselves; I allowed this.
This download creates a Virtual PC image that contains Orcas VS, Orcas TFS, Visual Studio 2005, MSDN Library for Orcas, .NET Framework SDK 2.0, and both SQL Server 2005 and SQL Server 2005 Express running on Windows Server 2003. It has 9 parts to download, eight 700 MB and one 656 MB. It requires Windows Server 2003, Windows Vista, or Windows XP, and says it needs 1 GB of available physical RAM; experimentally, it needs a little more than that. This virtual PC image comes set to use 1 GB of virtual RAM and has its undo disks enabled.
While this has the same title as the previous download, it is a different link. This download creates a Virtual PC image that contains Orcas VS, MSDN Library for Orcas, .NET Framework SDK 2.0, and SQL Server 2005 Express running on Windows Server 2003. It has 7 parts to download, six 700 MB and one 256 MB. It requires Windows Server 2003, Windows Vista, or Windows XP, and says it needs 1 GB of available physical RAM; experimentally, it only needs 512 MB of available physical RAM. This virtual PC image comes set to use 384 MB of virtual RAM and has its undo disks disabled.
I'll have more to say about my experience with the many new features released with the March Orcas CTP in future postings.
Posted by Martin Heller on March 7, 2007 06:00 AM
March 02, 2007 | Comments: (0)
Periodically, I encounter an annoying but not fatal problem with Microsoft Visual Studio: the help takes a long time to display the first time I launch it in a session. Sometimes I expect this to happen, because of having recently installed an add-on to Visual Studio that needs to merge its help contents. Other times, it is unexpected behavior.
Recently, it started happening again every day, and I found myself avoiding launching help from Visual Studio: if I remembered, I would launch the MSDN help browser or help for a specific product from the Windows Start menu. If I forgot and pressed F1 or Ctrl-Alt-F1 in Visual Studio, I'd moan aloud and go refill my tea mug.
Finally, I got fed up and asked for assistance from the folks who helped me fix the slow Visual Studio (VS) loading problem I told you about on January 15th. They didn't know how to fix this, but they passed the problem along to the program manager responsible for what they call Document Explorer.
What I told him to narrow the problem down was this:
Is this VS 2005 SP1? Yes.
What keyword are you searching for? Contents, the simplest case, still seems long.
Do you have internal or external help configured? External.
Are you loading help locally or off the web? Local first, then online.
How long exactly is it taking? 45 seconds. I expect it to be more like 5 seconds, based on the load time for MSDN from Windows.
Do you get the 45 second delay every time you press Ctrl-Alt-F1, or just the first time Document Explorer loads? Just the first time.
Does it continue to take this long if you configure help for online first?
That turned out to be the money question. I did the experiment of switching help to "online first." I closed VS, then reloaded it, and Document Explorer loaded in under 5 seconds.
Then I tried switching back to "local first." I closed VS, then reloaded it, and Document Explorer still loaded in under 5 seconds. Brilliant!
Our theory is that Document Explorer was doing a merge with the new add-on content every time, erroneously, and that the flag to merge the new content wasn't gettting cleared. Whatever the problem was, switching to "online first" made it go away and stay away. I don't know if that'll be useful to anyone else, but it helped me.
Posted by Martin Heller on March 2, 2007 06:00 AM
February 09, 2007 | Comments: (0)
I mentioned my affinity for Python on my first Weblog entry, at the end of last year. I had intended to tell you about the Iron Python for ASP.NET CTP in my second entry, but it mysteriously stopped working for me before I could write about it. It turns out that disabling Iron Python for ASP.NET was an unintended side effect of the Visual Studio SP1 installation, which also caused other mayhem on my Visual Studio 2005 instance. By the time I had fixed all that and reinstalled Iron Python for ASP.NET I was distracted by the AJAX subversion exploit.
I recently went back and looked at the Iron Python for ASP.NET CTP, and was impressed with what has actually been accomplished with that project. It's not just that you can code server-side ASP.NET Web logic very simply in Python, as in this Global.py from the Iron Python Personal Web site starter site:
from System import * from System.Web import * from System.Web.Security import * def Application_Start(): SiteMap.SiteMapResolve += AppendQueryString if not Roles.RoleExists('Administrators'): Roles.CreateRole('Administrators') if not Roles.RoleExists('Friends'): Roles.CreateRole('Friends') def AppendQueryString(sender, e): node = SiteMap.CurrentNode if node is not None: node = node.Clone(True) qs = e.Context.Request.QUERY_STRING if len(qs) > 0: node.Url += '?' + qs if node.ParentNode is not None: node.ParentNode.Url += '?' + qs return node
It's also not just that you can write code behind standard-looking ASP.NET pages in Python, and that much of what you already know about Python and ASP.NET just carries over.
No, it's even more impressive than that. What this team has done is to extend the ASP.NET model from static compiled languages to dynamic languages, as explained in David Ebbo's white paper on the subject. They basically scrapped the CodeDOM model used for static compiled languages, and extended the idea of no-compile pages. It sounds like a paradox, but they've created no-compile pages that support scripting languages with a change to the PageParserFilter API, which gives external code a hook into the parser. They have also added a custom HTTP module, and a custom base class for scripting pages.
One thing they haven't done is to support Web services. That turned out to be hard, and it's not clear when or even whether they'll come up with a solution. Another thing that they haven't done in the CTP, but which I hope to see in a future drop, is to write full Visual Studio IntelliSense support for Python. Stay tuned.
Posted by Martin Heller on February 9, 2007 06:00 AM
February 02, 2007 | Comments: (0)
Small Differences in Vista Can Break Applications
It's a truism that applications have to be retested on every new operating system. We expect that.
On the other hand, we've come to expect that the .NET Framework will buffer applications for operating system differences. We've been spoiled, I'm afraid, and it's not something we can count on.
Take the recently released Ruby in Steel, a Ruby programming environment for Microsoft Visual Studio 2005. The first release build was specifically supported only on Windows XP and not Windows Vista, which was a clue for me that there might be known issues, but naturally people tried it on Windows Vista anyway, and did encounter problems.
I was surprised by the resolution of this particular problem: it turns out that the .NET function Encoding.UTF8.GetBytes returns a different array of bytes under Vista than XP. Who would have "thunk" it?
Posted by Martin Heller on February 2, 2007 06:00 AM
January 31, 2007 | Comments: (0)
Orcas CTP: I Probably Should Have Waited
After buying and installing another gigabyte of RAM for my Windows development box, downloading about 6 gigabytes of compressed virtual PC images, and putting my computer to work for several hours decompressing and assembling the images, I finally have a working copy of the Microsoft Visual Studio Code Name "Orcas" January 2007 CTP as a virtual PC.
It does work. It doesn't mess up my Visual Studio 2005 installation. On the whole, running this drop as a VPC is a better idea than applying the preview bits to a production system.
It probably wasn't worth the effort this time around, however. I probably should have gone with my initial instinct and waited for the February CTP drop, which as I understand it is scheduled to have full LINQ support, a design surface for Windows Presentation Foundation, the new Web design surface that Scott Guthrie blogged about
here, y mucho mas.
On the other hand, setting this up was a learning experience. I now know that the Virtual PC 2007 beta works just fine with the January "Orcas" image. I also know that the image was built for 384 MB of RAM to be available to the Windows Server 2003 system it contains. Adding in the RAM needed for video in the image and for Virtual PC to run comes out to a need for less than 512 MB of available RAM in the host computer, not the 1 GB that was documented. My Task Manager readout confirms that: with the VPC image running, I have over 1 GB of available RAM remaining to the host system.
In other words, I could have skipped buying the extra GB of RAM. On the other hand, it doesn't hurt to have it, and I might actually be happy that I do at some future date.
Another interesting conclusion: since the January "Orcas" image works with the Virtual PC 2007 beta, and the Virtual PC 2007 beta runs under Windows Vista, it should actually be possible to run the "Orcas" Virtual PC images under Windows Vista, even though this is not supported by Microsoft.
Posted by Martin Heller on January 31, 2007 06:00 AM
January 22, 2007 | Comments: (0)