I just created my first Deep Zoom Composer project. I added all of my Windows 7 install screenshots to a Deep Zoom project and then simply published them on Photo Zoom. This was surprisingly easy–no coding required. To zoom around in this set of images, click here.
I thought I’d do my part to flood the web with screenshots from the M3 preview of Windows 7 that was distributed at last week’s Professional Development Conference in LA.
The obvious place to start in Win 7 is with the installation process. I’ll put up more posts later with screenshots of various bits and pieces in Windows 7. But this first post will just contain: every damn Windows 7 installation screen.
Ok, admittedly, looking through install screens is about as exciting as watching bacon fat congeal. But really—there are people out there who will eat this stuff up. So it’s for them that I’ve suffered an endless series of screen captures. Enjoy.
The Environment
I installed my copy of Windows 7 to a VMWare virtual machine. The only “gotcha” was that VMWare creates a SCSCI virtual hard drive by default—which Windows 7 failed to recognize. Simple fix—just delete the default hard drive and create an IDE drive in VMWare.
The Screens
Ok, here we go.
You just get shivers as you start to install a new Microsoft OS for the first time, don’t you?
Then we switch from a DOS-looking progress bar to a cute Windows-looking progress bar:
Next we get the first Windows 7 install screen. This is the spot to insert the angelic music.
After picking an install language, you get to the main install kick-off window:
I once met a guy who actually read these EULAs. Can you believe it?
This next dialog is just as confusing in Windows 7 as it was in Vista.
In my first try, I went with the Upgrade option, which only got me this next confusing empty dialog. Nice.
Restarting everything and instead choosing Custom gets us where we want to go:
If you click on the link that reads “Drive options (advanced)”, you’ll see some options for managing hard disk partitions:
Finally, the actual installation begins.
At some point, near the end of the installation, Windows boots for the first time. It lives!
This was an interesting detail during the boot process:
All of the services apparently start firing up, as the boot process continues. (Hallelujah)!
And for some reason, we’re allowed to go back and look at this status dialog one more time.
And then back to the main boot screen. (Are you starting to feel as if you were really there)?
Oh, this is a nice little touch. No screen flickers or anything, but nice to know that it’s “checking” my video performance. (Whatever that means).
Now Windows is more or less running and we start doing some of the final configuration stuff. First, we specify a default username. This will be the Administrator user account. Seeing a PC name of “PC” also makes me think of John Hodgman and the Mac switcher ads.
And I enter my password:
And (of course) the product activation key. Wouldn’t it be cool if every key had a barcode and I could use a barcode scanner at this point? (My key did not have a barcode).
I also get to set my time and time zone.
This is an interesting one. Right out of the gate, I’m asked to specify whether my network is public or not. Like Vista, this dictates some default security settings.
I picked Home network and Windows 7 did some remaining network configuration work.
Ok, here’s one of the first really new things to show up. A “homegroup” is basically a relabeled “workgroup”—something short of a domain. I’m wondering if I’d chosen Work location in the earlier screen, if I’d now be joining a domain.
Finally, we are “welcomed” to Windows 7.
We’re so close, I can taste it.
And voila! The Windows 7 installation is complete and we’re sitting at the desktop screen. Note that I don’t have that cool new taskbar in the build that was handed out at PDC. More on that next time—the new taskbar is actually in the build and Rafael Rivera has found a hack to unlock it.
PDC 2008, Day #4, Session #4, 1 hr 15 mins
David Teitlebaum
Program Manager
WPF Team
My final session at PDC 2008 was a talk about the improvements in WPF graphics that are available in .NET Framework 3.5 SP1. David also touched briefly some possible future features (i.e. that would appear in .NET Framework 4.0).
David’s main topic was to walk through the details of the new Shader Effects model, which replaces the old Bitmap Effects feature.
What are Bitmap Effects?
These are effects that are applied to an individual UI element, like a button, to create some desired visual effect. This includes things like drop shadow, bevels and blur effects.
BitmapEffect
The BitmapEffect object was introduced in Framework 3.0 (the first WPF release). But there were some problems with it, that led to now replacing it with Shader Effects in 3.5SP1.
Problems with BitmapEffect:
New Shader Effects
Basic characteristics in the new Shader Effects include:
How Do You Do Shader Effects?
Here’s an outline of how you use the new Shader Effect model:
So what do pixel shaders really do? They basically take in a texture (bitmap) as input, do some processing on each point, and return a revised texture as an output.
Basically, you have a main function that accepts the coordinates of the current single pixel to be mapped. Your code then accesses the original input texture through a register, so it just uses the input parameter (X/Y coordinate) to index into the source texture. It then does some processing on the pixel in question and returns a color value. This resultant color value just represents—the resulting RGB color at the specified coordinate.
The final step is to create, in managed code, a class that derives from ShaderEffect and hook it up to the pixel shader code (e.g. xyz.ps file) that you wrote. You can then apply your shader to any WPF UIElement using XAML. (By setting the Effect property).
Direct3D Interop
David’s next topic was to talk a bit about interop’ing with Direct3D. This just means that your WPF application can easily host Direct3D content by using a new class called D3DImage.
This was pretty cool. David demoed displaying a Direct3D wireframe in the background (WPF 3D subsystem can’t do wireframes), with WPF GUI elements in the foreground, overlaying the background image.
The basic idea is that you create a Direct3D device in unmanaged code and then hook it to a new instance of a WPF D3DImage element, which you include in your visual hierarchy.
WPF Futures
Finally, David touched very briefly on some possible future features. These are things that may show up in WPF 4.0 (.NET Framework 4.0), or possibly beyond that.
Some of the features likely included in WPF 4.0 include:
And some of the possible post-4.0 features include:
References
You can get at David’s PDC08 slide deck for this talk here: http://mschnlnine.vo.llnwd.net/d1/pdc08/PPTX/PC07.pptx
And you can find full video from the session at: http://mschnlnine.vo.llnwd.net/d1/pdc08/WMV-HQ/PC07.wmv
PDC 2008, Day #4, Session #3, 1 hr 15 mins
Allison Klein
I jumped off the Azure track (starting to be a bit repetitive) and next went to a session focused on Direct3D.
Despite the title, this session really had nothing to do with Windows 7, other than the fact that it talked a lot about Direct3D 11, which will be included in Windows 7 and available for Windows Vista.
Direct3D 10
Direct3D 10 is the currently shipping version, and supported by most (all?) modern video cards, as well as integrated graphics chips. I’m not entirely sure, but I think that Direct3D 10 shipped out-of-the-box with Windows Vista. It is also available for Windows XP.
Allison spent about half of the talk going through things that are different in Direct3D 10, as compared with Direct3D 9.
I’m not inclined to rehash all of the details. (I’ll include a link to Allison’s slide deck when it is available).
The main takeaway was that it’s very much worth programming to the v10 API, as opposed to the v9 API. Some of the reasons for this include:
Direct3D 11
In the second half of her talk, Allison talked about the advances coming in Direct3D 11. She mentioned that D3D11 will ship with Windows 7 and also be available for Windows Vista.
Again, the details are probably more appropriate for a game developer. (See the slide deck). But the high level points are:
Futures
Finally, Allison touched briefly on some future directions that the Direct3D is thinking about.
The main topic that she talked about here was in potentially using the GPU to perform highly parallel general purpose compute intensive tasks. The developer would use HLSL to write a “compute shader”, which would then get sent to the GPU to do the work. As an example, she talked about using this mechanism for post-processing of an image.
PDC 2008, Day #4, Session #2, 1 hr 30 mins
Eugenio Pace
My second session on Thursday was a continuation of the cloud services symposium from the first session. There was a third part to the symposium, which I did not attend.
The presenter for this session, Eugenio, was not nearly as good a presenter as Gianpaolo from the previous session. So it was a bit less dynamic, and harder to stay interested.
The session basically consisted of a single demo, which illustrated some of the possible solutions to the Identity, Monitoring, and Integration challenges mentioned in the previous session.
Identity
Eugenio pointed out the problems involved in authentication/authorization. You don’t want to require the enterprise users to have a unique username/password combination for each service that they use. And pushing out the enterprise (e.g. Active Directory) credential information to the third party service is not secure and creates a management nightmare.
The proposed solution is to use a central (federated) identity system to do the authentication and authorization. This is the purpose of the Azure Access Control service.
Management
The next part of the demo showed how Azure supports remote management, on the part of IT staff at an individual customer site, of their instance of your application. The basic things that you can do remotely include:
The end result (and goal) is that you have the same scope of control over your application as you’d have if it were on premises.
Application Integration
Finally, Eugenio did some demos related to “process integration”—allowing your service to be called from a legacy service or system. This demo actually woke everyone up, because Eugenio brought an archaic green-screen AS400 system up in an emulator and proceeded to have it talk to his Azure service.
Takeaways
The conclusions were recommendations to both IT organizations and ISVs:
PDC 2008, Day #4, Session #1, 1 hr 30 mins
Gianpaolo Carraro
As the last day of PDC starts, I’m down to four sessions to go. I’ll continue doing a quick blog post on each session, where I share my notes, as well as some miscellaneous thoughts.
The Idea of a Symposium
Gianpaolo started out by explaining that they were finishing PDC by doing a pair of symposiums, each a series of three different sessions. One symposium focused on parallel computing and the other on cloud-based services. This particular session was the first in the set of three that addressed cloud services.
The idea of a symposium, explained Gianpaolo, is to take all of the various individual technologies and try to sort of fit the puzzle pieces together, providing a basic context.
The goal was also present some of the experience that Microsoft has gained in early usage of the Azure platform over the past 6-12 months. He said that he himself has spent the last 6-12 months using the new Services, so he had some thoughts to share.
This first session in the symposium focused on taking existing business applications and expanding them to “the cloud”. When should an ISV do this? Why? How?
Build vs. Buy and On-Premises vs. Cloud
Gianpaolo presented a nice matrix showing the two basic independent decisions that you face when looking for software to fulfill a need.
There are, of course, tradeoffs on both sides of each decision. These have been discussed ad infinitum elsewhere, but the basic tradeoffs are:
Here’s the graph that Gianpaolo presented, showing six different classes of software, based on how you answer these questions. Note that on the On-Premises vs. Cloud scale, there is a middle column that represents taking applications that you essentially control and moving them to co-located servers.
This is a nice way to look at things. It shows that, for each individual software function, it can live anywhere on this graph. In fact, Gianpaolo’s main point is that you can deploy different pieces of your solution at different spots on the graph.
So the idea is that while you might start off on-premises, you can push your solution out to either a co-located hosting server or to the cloud in general. This is true of both packaged apps as well as custom-developed software.
Challenges
The main challenge in moving things out of the enterprise is dealing with the various issues that show up now when your data needs to cross the corporate/internet boundary.
There are several separate types of challenges that show up:
Solutions to the Identity Problem
Gianpaolo proposed the following possible solutions to this problem of identity moving across the different boundaries:
The basic idea was that Microsoft has various assets that can help with this problem.
Solutions to the Monitoring and Management Problem
Next, the possible solutions to the monitoring and management problem included:
Solutions to the Application Integration Problem
Finally, some of the proposed solutions to the application integration problem included:
The ISV Perspective
The above issues were all from an IT perspective. But you can look at the same landscape from the perspective of an independent software vendor, trying to sell solutions to the enterprise.
To start with, there are two fundamentally different ways that the ISV can make use of “the cloud”:
When delivering your software as a service, you need to consider things like:
Some Patterns
Gianpaolo presented some miscellaneous design considerations and patterns that might apply to applications deployed in the cloud.
Cloudbursting
Worker / Queue / Blob Pattern
Let’s say that you have a task like encoding and publishing of video. You can push the data out to the cloud, where the encoding work happens. (Raw data places in a “blob” in cloud storage). You then add an entry to a queue, indicating that there is work to be done, and a separate worker process eventually does the encoding work.
This is a nice pattern for supporting flexible scaling—both the queues and the worker processes could be scaled out separately.
CAP: Pick 2 out of 3
Eventual Consistency (ACID – BASE)
The idea here is that we are all used to the ACID characteristics listed below. We need to guarantee that the data is consistent and correct—which means that performance likely will suffer. As an example, we have a process submit data synchronously because we need to guarantee that the data gets to its destination.
But Gianpaolo talked about the idea of “eventual consistency”. For most applications, while it’s important for your data to be correct and consistent, it’s not necessarily for it to be consistent right now. This leads to a model that he referred to as BASE, with the characteristics listed below.
Fundamental Lesson
Basically the main takeaway is:
Sean's Stuff 