For The Developers! : Programming

TxF Managed Wrapper on Code Gallery

jolson — Wed, 23 Apr 2008 07:40:59 GMT

Hello, everybody, I have released the first version of a rudimentary managed wrapper around Transactional NTFS to Code Gallery on MSDN: http://code.msdn.microsoft.com/txfmanaged.

The wrapper in its current form is very basic but should give developers a good idea on how simple it is to use Transactional NTFS from managed code. Feel free to go grab it, play around with it (there are some sample screencasts using the wrapper on the Developer Meet Server Show), and feel free to use it any way you wish.

Enjoy!

WS08 Feature of the Week #14 - Sub-queues in MSMQ 4.0

jolson — Wed, 30 Jan 2008 00:19:03 GMT

What are sub-queues? Subqueues are implicitly created local queues that are logical partitions of a physical queue. Applications can use subqueues to group messages. Subqueues are implicitly created when opened, are deleted when empty, and have no open handles. Messages cannot be sent to a subqueue. Messages can be received from subqueues, moved between the main queue and its subqueue, or moved between a pair of sibling subqueues.

Subqueues do not have their own properties or state, but share the properties and state of their parent queue. For example, a subqueue does not have its own quota, access control list (ACL), or transactional type. Subqueues share the quota of the main queues. Messages in the subqueues consume the quota of the main queue. Subqueues cannot be created under journal and other system queues, or other subqueues. If journaling is enabled, copies of messages that are removed from a subqueue are sent to the journal queue of the main queue.

So why sub-queues? MSMQ-based applications often require messages to be grouped based on some criteria. Previously, the only way to do this was to create several queues and when a message arrived in the main queue, move the message into a specific queue based on some selection criteria.

Here’s the thing: moving messages between physical queues is a resource-intensive process. If you are wanting to build a high performance application, it is best to try to avoid this resource-intensive process. But if you were building an application based on MSMQ 3.0, this was not very feasible. Now, the new sub-queues feature enables you to logically group messages within a single queue without the need of creating another physical queue.

- MSDN Documentation

- WCF Examples

WS08 Feature Of The Week #12 - IIS7 Administration API

jolson — Fri, 11 Jan 2008 23:28:39 GMT

Hello everyone, and welcome back after our winter break hiatus. We have a lot of cool features to cover in the coming weeks that will especially show off the power of Windows Server 2008 as an application server. So, this week we will kick off the new year by taking a short little peek at the new management API coming in IIS7.

What is new in IIS7 Administration? IIS7 provides a comprehensive managed-code API that allows complete manipulation of the XML configuration files and convenience access to server objects. IIS7 includes Microsoft.Web.Administration, which is a new management API for the web server that enables editing configuration through complete manipulation of the XML configuration files and also provides convenience objects to manage the server, its properties and state. The configuration editing aspect of the API provides programmatic access to read and write configuration properties in the IIS configuration file hierarchy and specific configuration files. The object management aspect of this API provides a series of top-level administration objects for direct management of the server (i.e. sites, application pools, worker processes, etc.).

The management classes reside in the Microsoft.Web.Administration namespace. The classes provide a weakly-typed interface to access configuration sections and convenience objects with properties and methods representing attributes of the configuration (like the path of a virtual directory) or actions to take on the object (like recycling an application pool).

Resources

How To Use Microsoft.Web.Administration

The launch of marshal-as.net

jolson — Fri, 23 Nov 2007 02:03:05 GMT

In my previous post, I talked about why I personally love C++/CLI as a solution for managed and native interop. With the launch of Visual Studio 2008, and the include of the new marshalling library, there is on part of the equation missing, I believe. On the C# side of the interop equation, you have http://www.pinvoke.net. When I'm wanting to interop with a given Windows API, there is a very (very) good chance that the wrappers have already been posted onto pinvoke.net.

While the marshal_as<> construct of the marshalling library in VC++ 2008 is quite extensible through the use of templates, there is no community site for me to go to in order to retrieve an existing piece of the interop puzzle. That is, until now.

With the help of Kate Gregory, there is now a new website for those C++/CLI users out there: http://www.marshal-as.net. If that link doesn't work for you, give it a day or two as this is a new website and DNS is still propagating for it.

I have already sent Kate a couple of samples that I had done for my own interop work with Visual C++ 2008 (have I mentioned yet how easy my life is now that I'm using C++/CLI in Visual C++ 2008?). You should pop over and check it out. If you have your own samples that you want to submit, feel free to use the contact form (the email icon) at the website and email your sample to the website.

Enjoy!

What's Mandatory Integrity Control?

jolson — Tue, 13 Nov 2007 02:00:37 GMT

Mandatory Integrity Control (MIC) is a cool new security feature built in to Windows Vista and Windows Server 2008. It adds another "layer" of security to Windows resources (files, processes, etc.) over the usual DACL (Discretionary Access Control Lists) that we have in Windows XP and Windows Server 2003.

Essentially, Mandatory Integrity Control adds an "Integrity Level" to resources present in the Windows operating system. There are four possible integrity levels. They are (from most privileged to least privileged): System IL, High IL, Medium IL, and Low IL. System Services run at System IL, Administrative Processes run at High IL, and all resources in Windows with an explicitly set integrity level exist at Medium IL by default. When one resource wants access to another resource, the first resource's integrity level must be greater than or equal to the integrity level of the requested resource. This integrity level check takes place before we even check the DACLs on each resource.

Processes, for instance, can access files that have an integrity level lower than or equal to their own integrity level. So let's say I have Notepad running under my own local account (not an administrative account). By default, Notepad.exe is launched with an integrity level of Medium. As long as I am trying to write to a file that has an integrity level of Medium or below, then the operation will success just fine.

However, if I have a file that is sitting there with an integrity level of High, the write operation from Notepad will fail because Notepad doesn't have the proper integrity rights to access and to write to that resource.

Let's go ahead and take a look at this in action (you can work through this "demo" if you are currently running Windows Vista or Windows Server 2008).

Demo

You _must_ be running Vista and Windows Server 2008 for this demo to work

1) Launch Notepad

2) Enter some text and save the file as “test.txt” on your desktop. Now we have a text file with the default Medium IL.

3) Launch a command prompt as Administrator (from the shortcut, right click and choose “Run As Administrator”)

4) Navigate to your desktop (“cd C:\Users\USER_NAME\Desktop” in the command line for a default Vista installation).

5) Issue this command to set the created file’s integrity level to a High IL: “icacls test.txt /setintegritylevel H”. Now that the file has a high integrity level a default notepad process won’t be able to save the file.

6) Launch Notepad again (make sure it isn’t launched as Administrator since Administrator permissions will make it have an integrity level of High, voiding this experiment).

7) Open test.txt from your desktop

8) Change the file and try to save it. Notepad will fail while trying to save (Notepad gives a “user-friendly” error, but the underlying error is actually “Access Is Denies”).

There you have it, Mandatory Integrity Control in action! However, that's not the end to the story!

Did You Know? Internet Explorer “Protected Mode” actually uses Mandatory Integrity Levels under the hood to achieve its goals. Since IE Protected Mode runs with a low integrity level, and all files on the file system (and running processes) are a medium integrity level by default, an attempt to write to those files or processes fails.

Listing Running Transactions In A Resource Manager

jolson — Fri, 20 Jul 2007 00:34:00 GMT

The more I work with TxF, the more I realize that our (Microsoft's) coverage of certain KTM topics is sorely lacking. One of those areas is around documentation and samples of managing resource managers (important if you are wanting to investigate programatically the running status of a resource manager).

Sometimes, being an evangelist can be quite fun (or frustrating) because the documentation leaves something to be desired and you can't run to the internet because the only results you get back or to the documentation on MSDN. And of course, since you're on the cutting searching for the control codes online provides you with two results, both pointing back to MSDN. It becomes doubly "interesting" if you are a managed developer because a large number of management-oriented information for KTM is all done through DeviceIoControl (an API that is NOT fun to try to P/Invoke into, especially using certain control codes).

Anyways, that's all beside the point... moving right along.

If you are writing an application to monitor TxF (or even building it into your own application), there are some core "things" that you need to do. One of the first ones (and the one I will cover in this post) is to get a list of transactions in a given resource manager. This is done using the FSCTL_TXFS_LIST_TRANSACTIONS control code.

What structure is DeviceIoControl passing back to us in this instance? A TXFS_LIST_TRANSACTIONS structure. Looking at this structure, we see two fields: NumberOfTransactions and BufferSizeRequired.
That's nice and all, but where is the information about those transactions? The information is stored in a TXFS_LIST_TRANSACTIONS_ENTRY structure.

The trick is that the TXFS_LIST_TRANSACTIONS_ENTRY structure is mentioned nowhere in the documentation for FSCTL_TXFS_LIST_TRANSACTIONS. So how do you get to it? An array of TXFS_LIST_TRANSACTIONS_ENTRY structures are stored in memory after your TXFS_LIST_TRANSACTIONS structure. So assuming you have two running transactions in the given resource manager, you would pass in a pointer to the TXFS_LIST_TRANSACTIONS structure, and here is what the memory would actually look like coming back from DeviceIoControl:

The impact of this is that you need to allocate enough memory for not only your TXFS_LIST_TRANSACTIONS structure, but the array of TXFS_LIST_TRANSACTIONS_ENTRY structures as well. You might notice a little bit of a "chicken and egg" problem here. If I'm using FSCTL_TXFS_LIST_TRANSACTIONS to retrieve the transactions, how could I know how many entry structures to allocate when I don't know how many transactions there are yet?

Well, assuming there are one or more running transactions in the resource manager, you have to call DeviceIoControl with FSCTL_TXFS_LIST_TRANSACTIONS at least twice: once to find out how big of a buffer you need to allocate (read: to calculate how many ENTRY structures to accomodate for), and then another time after allocating the extra memory to have it fill the actual ENTRY structures.

Why do I say "at least" twice? Because, between the time we make our first call and the time we make our second call, more transactions could have appeared and we will have to allocate even more memory. A little bit of a "cat and mouse game," I must say.

If you are a managed developer, this may sound a bit scary. Don't be scared though, it's not too bad (and I know I at least have fun writing this kind of lower-level code :P).

So let's dive right in and look at the code to make this work!

In pseudo-code, this is what we have to do:

------------------------
while (true)
{
// Deallocate memory from last loop through this

// Allocate memory for transaction list buffer

// Call DeviceIoControl with FSCTL_TXFS_LIST_TRANSACTIONS

// If DeviceIoControl Succeeded

// Get list of transaction entries after TXFS_LIST_TRANSACTIONS structure
}

// Deallocate any remaining memory
------------------------

Not that bad really. So here it is implemented in native code:

#include 
#include 
#include 
#include "Winioctl.h"

int _tmain(int argc, LPTSTR argv)
{
    DWORD lastError, bytesReturned;
    HANDLE rmDirectory;
    TXFS_LIST_TRANSACTIONS *txList = NULL;

    // Get handle to directory where resource manager resides
    rmDirectory = CreateFile(TEXT("C:\\"), 
        GENERIC_READ,
        FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
        NULL,
        OPEN_EXISTING,
        FILE_FLAG_BACKUP_SEMANTICS,
        NULL);

    if (rmDirectory != INVALID_HANDLE_VALUE)
    {
        // Get a list of transactions within the given
        // resource manager
        DWORD neededBufferSize = sizeof(TXFS_LIST_TRANSACTIONS);
        while (true)
        {
            // Deallocate previously allocated memory if we are back
            // here after getting back ERROR_MORE_DATA
            if (NULL != txList)
            {
                delete[] (char*)txList;
                txList = NULL;
            }

            // Get the list of running transactions in the RM
            txList = (TXFS_LIST_TRANSACTIONS*)new char[neededBufferSize];
            if (!DeviceIoControl(rmDirectory,
                FSCTL_TXFS_LIST_TRANSACTIONS,
                NULL,
                0,
                txList,
                neededBufferSize,
                &bytesReturned,
                NULL))
            {
                // How did we fail?
                lastError = GetLastError();
                if (lastError == ERROR_MORE_DATA)
                {
                    // We need to enlarge the buffer and try again
                    neededBufferSize = txList->BufferSizeRequired;
                    continue;
                }
                else
                {
                    _tprintf(TEXT("Unhandled exception: %u\n"), lastError);
                    break;
                }
            }
            else
            {
                _tprintf(TEXT("Transaction Count: %u\n\n"), txList->NumberOfTransactions);

                // List Tx details
                TXFS_LIST_TRANSACTIONS_ENTRY *txEntry;
                txEntry = (TXFS_LIST_TRANSACTIONS_ENTRY *)((char *)txList 
                        + sizeof(TXFS_LIST_TRANSACTIONS));
                for (DWORD i = 0; i < txList->NumberOfTransactions; i++)
                {
                    txEntry++;

                    // Get GUID string
                    WCHAR szGuid[40];
                    StringFromGUID2(txEntry->TransactionId, (WCHAR *)&szGuid, 40);

                    // Print Tx info
                    _tprintf(TEXT("TX %s: %u\n"), 
                        szGuid,
                        txEntry->TransactionState);
                }

                break;
            }
        }

        // Any memory left to deallocate?
        if (NULL != txList)
        {
            delete[] (char*)txList;
            txList = NULL;
        }
    }
    else
    {
        _tprintf(TEXT("Unable to get valid handle to Resource Manager\n"));
        return 1;
    }

    _tprintf(TEXT("\nPress any key to exit...\n"));
    getchar();

    return 0;
}

And that's how you do it. It's not the most fun getting in to DeviceIoControl (unless you're a geek like me and enjoying this kind of stuff), but hopefully with this post out there to help it will be easier to find out how to do this since there is a lack of documentation around this area.

In closing, there is some work that needs to be done around making management of kernel-level transactions a lot easier than it is now. In some ways, it is pretty clear that this is still a "1.0" technology. So while you could use the KTM directly for your transaction coordination, I would highly recommend sticking with using DTC for your transaction coordination as it is much more mature from a management perspective (and there are quite a few enhancements with DTC in Vista and Windows Server 2008).

Windows Server 2008 Developer Training Kit

jolson — Fri, 20 Jul 2007 00:03:51 GMT

James Conard announces over on his blog that our team has just released the Windows Server 2008 Developer Training Kit for Beta 3. Mosey on over and check it out. You can find resources on everything from WCF, to Cardspace, to WF, to Windows Eventing, to PowerShell, to IIS 7, to Transactional NTFS.

So if you are a developer interested in checking out Windows Server 2008, make sure to grab it.

Windows Server "Longhorn" - Beta 3 Has Arrived!

jolson — Thu, 26 Apr 2007 04:08:32 GMT

Well, it's official. Beta 3 of Windows Server "Longhorn" has launched. With it, I finally get to release some of the work I've been working on lately.

If you are a developer, I encourage to take a look at "The Top Ways To Light Up Your Apps On Windows Server 'Longhorn'" that was just launched today. It outlines key ways that you, the developer, can leverage all the new and improved enhancements to the Server platform to really make your applications shine in a whole new light.

I encourage any of you with access to Beta 3 to try it out. Windows Server "Longhorn" is quickly shaping up to be the best Server release from Microsoft ever.

Top Ways To Light Up Your Apps On Windows Server "Longhorn"

jolson — Thu, 26 Apr 2007 03:41:00 GMT

Whether you are a developer building web applications, to a developer writing core server based system services, Windows Server “Longhorn” provides many new features that you can leverage to build more secure, flexible, and innovative applications.

1) Build More Flexible Web Applications

For developers wanting to build flexible web applications, IIS7 provides a very powerful platform in which to build upon. With IIS7, you can take control of the web server footprint to increase security and decrease patching, more quickly resolve faulty applications, go to market faster and reduce support costs with simplified deployment and application configuration, as well as rapidly leverage new technologies with IIS7’s extensible framework. IIS7 is also more efficient to manage with the introduction of new management APIs, a powerful new UI, a suite of command line tools, as well as the capability to manage IIS7 directly from Windows PowerShell.

More Information:

· The .NET Show: Bill Staples and Scott Guthrie on IIS7

· End-To-End Extensibility Example

· Downloads on IIS.net

2) Build Connected Systems

If you are writing enterprise grade distributed applications, Windows Server Codename “Longhorn” is the best platform you can target. Every aspect of the application life cycle enjoys state of the art support: service development, hosting, process modeling, manageability, performance, interoperability out of the box, extensibility, protection of the current investments… all those facets of distributed software development and management are natively implemented by Windows Server codename “Longhorn” features. Many of these features are provided through the Application Server role and the integration of the .NET Framework 3.0 within Windows Server Codename “Longhorn”.

Even if you are simply porting your Windows DNA based application, you will enjoy the great benefits brought by various key enhancements in the core services such as a completely redesigned TCP stack, enhanced transaction capabilities, MSMQ evolutions, and much more.

More Information:

· .NET Framework Developer Center

· Microsoft .NET Framework 3.0 Community

· Introducing the .NET Framework 3.0

3) Develop Federation-Aware Applications

As the business need for ubiquitous user access has evolved, the demand upon Web applications is to no longer only support users inside the firewall. Potentially, these same applications, or portions of them, need to now be accessed by vendors, partners or customers as well. How do you provide access for these constituencies to applications built around the domain-based identity model? At the minimum, it infers additional user account management. Each constituent must have a domain-based identity inside the firewall as well. If this is hundreds or potentially thousands of additional user accounts, it’s a further burden on IT and help desk staff to manage provisioning/de-provisioning of accounts and password resets for those loosely affiliated with the organization.

With Windows Server “Longhorn”, technologies like Active Directory Federation Services (ADFS), Active Directory Lightweight Directory Services (AD LDS), and Windows Authorization Manager (AzMan) provide you, the developer, with the capabilities to develop “Single Sign-On”, Federation-Aware applications.

More Information:

· .NET Developers Guide To Identity

· Active Directory Federation Services (ADFS) Resources

· Identity and Access Management Developer Center

4) Design Highly-Manageable Applications

In today’s rapidly changing IT environment, it is critical that application errors be diagnosed and solved quickly by IT Operations, without the need for costly escalation. This requires datacenters and applications to be designed to be highly-manageable. Microsoft’s strategy for enabling these highly-manageable systems is called the Dynamic Systems Initiative.

The Dynamic Systems Initiative (DSI) is Microsoft's technology strategy for products and solutions that help businesses enhance the dynamic capability of its people, process, and IT infrastructure using technology. To enable applications to be managed within the DSI world, they must be “designed for operations”.

With technologies like Windows Eventing 6.0, Windows Installer 4.0, Windows PowerShell, Microsoft Management Console 3.0 (MMC 3.0), and Task Scheduler 2.0, Windows Server “Longhorn” enables you to develop highly-manageable applications.

More Information:

· Windows PowerShell

· Design for Operations

· Dynamic Systems Initiative

5) Develop More Reliable Applications

Building truly reliable applications that can handle everything thrown at them, including everything from power outages to hardware failures, has always been notoriously difficult. With the addition of several new technologies in Windows Server “Longhorn”, building reliable applications has become easier than before.

By leveraging the new Application Recovery and Restart APIs, Restart Manager, Transactional NTFS, Transactional Registry, or even the new Kernel Transaction Manager, you can let the platform handle a large number of details and build more reliable applications at the same time.

More Information:

· About Transactional NTFS

· Transaction Resources List

· Kernel Transaction Manager and Friends

6) Build for Scalability

Windows Server Codename “Longhorn” provides new scalability enhancements that enable you to build, deploy, host, and manage even the most demanding applications. The businesses of today and tomorrow Windows Server Codename “Longhorn” provides new scalability enhancements that enable you to build, deploy, host, and manage even the most demanding applications. The businesses of today and tomorrow demand more scalability from their servers, and Windows Server Codename “Longhorn” delivers by providing developers new ways to control the concurrent processing behaviors of their applications.

With the new Thread Pool API enhancements, developers have more control over how worker threads execute asynchronous callbacks within their application. By efficiently managing these callbacks and the creation of new threads, these enhancements provide a means to reduce the number of application threads needed by an application. The Thread Ordering Service in Windows Server Codename “Longhorn” controls the execution of one or more client threads. It ensures that each client thread runs once during the specified period and in relative order. Even enhancements to debugging these scalable application have been made with technologies like Wait Chain Traversal, enabling debuggers to diagnose application hangs and deadlocks.

More Information:

· Thread Pooling

· Using Wait Chain Traversal

7) Go Virtual

Virtualization is a very powerful technology that enables consolidation of existing servers, business continuance through flexible data recovery capabilities, lowers the requirements (and total cost of ownership) of testing and development environments, as well as providing unique capabilities to make the management of branch offices easier than before.

Windows Server Virtualization is Microsoft’s new hypervisor-based Virtualization product for Windows Server “Longhorn”. There are many virtualization enhancements coming with Windows Server Virtualization, like:

· 32-bit and 64-bit support for hosts and guests

· Leverages new hardware-based virtualization technologies

· Capable of supporting large memory (>4 GB)

· Supports “memory over-commit” (assigning more virtual memory to a virtual machine than physical memory on the server)

· Symmetric Multi-Processing capabilities for virtual machines (up to 8way)

· Pass-through disk access for virtual machines

· New Virtual Service Provider / Virtual Service Client architecture (allowing requests to shared hardware like disk devices, networking devices, etc.)

· Runs on Server Core installation, minimizing footprint and increasing security of host

More Information:

· Microsoft Virtualization Home

· Windows Server Virtualization - An Overview

Developer, Meet Server - Transactional NTFS and WCF

jolson — Thu, 05 Apr 2007 03:18:35 GMT

I recently posted the second screencast in my new "Developer, Meet Server" screencast series. This latest screencast covers using Transactional NTFS in a service-oriented environment via WCF.

Enjoy!

Transactional NTFS and Free Disk Space

jolson — Thu, 05 Apr 2007 03:14:50 GMT

Andrew recently watched my screencasts and had some great questions that came up around how Transactional NTFS behaves with the file system. So, I figured I would answer them here. So, if you want to see the context around his questions, check out his post.

Here's the paragraph with the questions:

I wonder what happens to files that never get committed - ala a long running transaction. They have to be taking up file space. Jason says not even Windows Explorer knows about them, but they have to exist somewhere. What if they overflow? Is there a way to clean house? If the poop is invisible, does it still stink?

Great observations and questions Andrew! In the case of a long running, open transaction, the files will exist on the disk. Hence, they are certainly taking up space on the disk. If you have 256 MB of free space on your disk, and try to write 257 MB of data to the disk within a transaction, you will get an "out of space" error like you would outside of a transaction.

Is there a way to clean house? Yes, rollback or commit the transaction. On rollback, any changes made within the transaction are rolled back, and then consequently removed form the disk.

But what if my server crashes in the middle of a transaction. Would I have turds floating around the file system? No, you would not. When an NTFS-formatted volume is mounted in Vista or Windows Server "Longhorn", any transactions that are "in-doubt" (the transaction manager is no longer around and we have no clue on the status of the transaction) will be rolled back automatically, effectively removing all the changes from disk. So, in that sense, you would not have any file turds you have to clean up after a system crash (like you would have if you were doing a "temp file -> rename" type of methodology.

Now, as is usual in transaction systems, you have to be _very_ aware and _very_ cautious of long-running transactions as it could cause some long-term problems that you don't want to deal with. So, there certainly are scenarios where Transactional NTFS just is not a good fit. As tends to be the case with all technology, make sure you are using the right tool for the right job :).

Announcing: New "Developer, Meet Server" Screencast Series

jolson — Sat, 10 Mar 2007 01:27:41 GMT

Welcome everybody to the inaugural, first ever, grand opening, “opening the doors to the public” celebration day kick-off for the new “Developer, Meet Server” screencast series. I am your sincere, humble (as ever), gracious and wonderful host/chef/tour guide Jason Olson.

In this series of screencasts we will be diving through all the various cool developer-oriented enhancements on the Windows Server "Longhorn" platform that developers can leverage to build robust and powerful applications. Specifically, in this first screencast, we will take a quick peek at Transactional NTFS. In future screencasts, we will go into a more detailed look at Transactional NTFS, so think of this as a quick introduction.

The screencast can be found in one of the main tubes on the Intarw3b known as the ever-lovely Channel 9: http://channel9.msdn.com/Showpost.aspx?postid=289816.

So sit back, grab a cup of coffee/tea/InsertYourFavoriteLocalTastyBeverageHere, and enjoy this screencast.

MSR TechFest - See How Microsoft Research Shaping Is The Future

jolson — Tue, 06 Mar 2007 23:52:56 GMT

[Crosspost from Managed World]

Rory is doing some videos at Channel 9 on the Microsoft Research TechFest event happening at Microsoft this week. If you want to see how Microsoft's own version of Area 51 is shaping and changing the future of technology, you should ABSOLUTELY watch these videos.

The first video has just been released: http://channel9.msdn.com/ShowPost.aspx?PostID=288554.

There is a lot of cool stuff coming out of Microsoft Research. Even Google won't stand up to some of these technologies :). We shall prevail :P. It's important to realize that Microsoft is filled with geeks just like you. We want to create cool stuff that changes the world. And what better way to emphasize that than taking a dive into Microsoft Research :).

Enjoy the video. And feel absolutely free to send this link around. This is truly exciting stuff coming from Microsoft and most geeks should be able to find some type of excitement in it :).

Vista-Only Features for Managed Developers

jolson — Tue, 14 Nov 2006 04:06:41 GMT

[Crosspost from Managed World]

I recently came across a bunch of stuff done by Daniel Moth, a Developer Evangelist for Microsoft UK. If you are a managed developer and want to see the new stuff you can leverage on Vista, be sure to check out his stuff.

If you want to digest some of these new features in Screencast format, be sure to check out some of these screencasts that Daniel Moth has also done:

Enjoy! And thanks go to Daniel for all of these :).

LHS Feature Of The Week #2 - Remote Differential Compression

jolson — Sat, 23 Sep 2006 02:32:00 GMT

[Update: Added link to RDC Whitepaper and blurb about RDC dogfooding in DFS Replication (thanks cfsbloggers)]

Hello everyone, and welcome to the second installment of the “Feature Of The Week” newsletter. This week, we will take a short little peek at a feature coming in Vista and Longhorn Server called Remote Differential Compression.

So, sit back, relax, and enjoy the Longhorn Server Feature Of The Week!

What is Remote Differential Compression? Remote Differential Compression (RDC) allows applications to synchronize data between two computers in an efficient manner. The synchronization efficiency is made possible by using compression techniques to minimize the amount of data sent across the network.

What makes RDC different from other differencing mechanisms? RDC is different from patching-oriented differencing mechanisms, such as Binary Delta Compression (BDC), which are designed to operate only on known versions of a single file. RDC makes no assumptions about file similarity or versioning. Because differences between files are computed on the fly, RDC is ideally suited for synchronizing files that are different or have been updated independently.

What scenarios does this enable? RDC is suitable for applications that move data across a wide area network where the data transmission costs outweigh the CPU cost of signature computation. RDC can also be used on faster networks if the amount of data to be transferred is relatively large and the changes to the data are typically small.

Dogfooding RDC. It's important to note that we are actively dogfooding RDC internally. One of the current examples of that dogfooding is that RDC is actively being used for DFS Replication, available on Windows Server 2003 R2.

Resources

Documentation
Code
- If you have the latest Windows SDK installed, you can find a simple Client/Server example using RDC in the following directory: %INSTALL_DIR%\Samples\winbase\RDC

Enjoy!

[Crosspost from Managed World]