The computer desktop today is what the television was to people in the 1980s. It's the single most important channel for consumer entertainment and information. The computer desktop - as was the case with newspapers before there was radio and radio before there was television - has become the high ground from which empires are built.

The programming language dictates how developers can describe data structures, interfaces, and algorithms. The libraries provide an extensive array of advanced services to the program such as data access, communications, and graphical user interface. The language and libraries are called the platform. The platform sets the rules and makes the system possible. However, over the course of a system's lifespan, the platform can and will change: languages and libraries inevitably evolve and are replaced by next-generation technologies. Usually, the changes are gradual with an appropriate measure of backward compatibility, so we can adapt through standard maintenance activities. Sometimes, however, the changes are more radical and disruptive, so a more focused effort, called a migration project, is called for.

The mouse was the original idea of Doug Engelbart who was the head of the Augmentation Research Center (ARC) at Stanford Research Institute. Engelbart's philosophy is best embodied, in my opinion, in the design of another device that he invented, the five-finger keyboard - with keys like a piano, used by one hand. The problem was, Engelbart's five-finger keyboard and mouse combination was very difficult to learn.

In this article we're going to take a database and create our own mini version of an 'Amazon-like' item lookup. That is to say, any .NET or .NET-compatible client will be able to look up items in our database via the Web by simply providing a UPC. This article will show you how. To complete this project, you'll need a few items...

Maybe some of you remember a time when we created a sprite on a piece of graph paper and afterwards hacked zeroes and ones in so we could see something eventually move on a TV screen. I have to admit that those days have been gone for a long time and a lot of things have happened in IT since I developed simple games on my C64. And one of these new things is XNA Game Studio (the current version is 2.0).

db4o, an open source object database system with broad industry applicability, belongs to a popular database management systems that has close to 2 million downloads to date. Here we'll illustrate the features and application areas of such a database and compare db4o against relational DBMS/object relational (OR) mappers.

Like many world-changing technologies before it, SharePoint has caught IS organizations off-guard. Early adopters within the business established SharePoint environments on their own. These users assumed they could manage these environments independently without IS's knowledge or perhaps with tacit consent. SharePoint environments began proliferating throughout many organizations. Quickly, these environments needed maintenance at a level these business users couldn't handle, and that's when things got interesting.

Roughly two years ago, when I was writing an article on 'New Features for Device Developers in Visual Studio 2005' that was published in the August 2005 issues of this magazine, our program management team was already busy shaping the next release of the product, which is soon to be released as Visual Studio 2008. We spent a lot of time talking to our major customers and reviewing the feedback we got on blogs and questions on forums on newsgroups to identify what enhancements/features would be most useful to our device developers. One thing that surfaced was that device developers needed more help when it came to testing their applications efficiently. Whether that meant testing on multiple devices or under varying conditions or simply being able to write unit tests, they clearly needed help getting applications to market faster by reducing the testing time.

The Microsoft Windows Presentation Foundation (WPF) provides the foundation for building applications and high-fidelity experiences in Windows Vista, blending together application UI, documents, and media content. WPF contains two data sources for XML and objects. To enhance productivity and include WPF applications in lines of business, you need to employ best practices and guidelines in reusing existing internal frameworks through WPF data binding capabilities. That way enterprises will benefit from advanced accessibility, data-driven UIs, and the highly stylized data visualization inherent to the WPF platform.

In Visual Studio 2003 and earlier, the build process for Visual Basic and C# projects was hard-coded, and built into Visual Studio itself. The only build scripting tool that Microsoft offered was nmake, and a companion tool called build.exe that provided some support for concurrent builds. Visual Studio users whose build systems were based on makefiles had to maintain project files in parallel. For Visual Studio 2005, we thought it would be great if it was possible to completely customize the build process, and to build Visual Studio projects on machines that didn't even have Visual Studio installed, exactly the same as they built inside Visual Studio. We also wanted to be able to plug in reuseable build loggers and build steps.

C# 3.0 represents a radical new approach to .NET development. The new language features were added primarily to support Language Integrated Query (LINQ), allowing you to query data using the same constructs regardless of where the data is currently stored. However, you'll find that there are many things you can do with these new features outside of queries. There's a learning curve for these new features, but by adopting them you'll find that you can be much more productive than you ever were in earlier versions of C#. In this article, I'll give you a whirlwind tour of C# 3.0 language features, and how you can leverage them in your work.

To take advantage of the OpenSocial implementation in Orkut sandbox, you have to create a Google Gadget with the OpenSocial feature, post the gadget on the Internet, and then add the URL of the gadget as an application. As I looked into the Google gadget API to build this, I found something interesting, the Google Gadget framework exposes the function _IG_FetchContent() that can be used to asynchronously fetch the text at any URL.

Enterprises frequently have to deal with part of their infrastructure that doesn't have the privilege of uninterrupted connectivity. Such system environments designed using Service Oriented Architecture (SOA) need a way to manage uncertain connectivity. SOA as an architectural paradigm depends on a set of services providing business functionality. These services may be distributed over different domains or geographical boundaries. SOA, characterized by independent and self-sufficient services primarily needs to handle the issue of data inconsistency that may result from a disconnect in such environments.

.NET lets us easily serialize an object into XML and deserialize XML into its corresponding object. This functionality has been available since .NET 1.0. The introduction of new data type called XML in SQL Server 2005 gives us even more advantages that come in handy with Stored Procedures that attempt to insert/update records in multiple but related tables.

You might be tempted to say that once you enter the .NET world, you'll never look back. Nothing seems too easy for you at this moment, what with the brand-new .NET 3.0 that's just out, high tech and still unexplored in its entirety.

At this point, we should think about the permissions our component needs. We're creating our own code group and permission set, so we start from scratch: this means that we'll have no permissions at all to start with. So, in addition to the permission to call unmanaged code (which we need to solve the event-handling problem that got us into this mess), we also need to include the permission for our assembly to execute. If we forget to include 'execute permission,' our component will simply refuse to load.

Most of the applications we software developers build need to interact somehow with data from a database. The .NET Framework defined by Microsoft provides a rich set of objects to manage database interaction; these classes are collectively referred to as ADO.NET and the latest versions of DataWindow .NET (which is now version 2.01).

As both a .NET programmer and ColdFusion developer, I always wondered how I could leverage the world of .NET in ColdFusion. Both platforms come with powerful features and using them together might be a wonderful friendship, if one could only make them cooperate. There are two worlds out there and none of them is an island.

We're living in an information age. Our daily life involves absorbing useful information and filtering out garbage. Information (data) plays an important role in our daily life. People, especially businesses, need to organize large amounts of disparate information. The information needs to be organized in such a way that you can easily access desired data quickly. The first step is to design a database, which balances normalization with data integrity and performance requirements. But that's just the first step. It's just as important to be able to programmatically access the data from the database in an intuitive and consistent way. That's where ODBC comes into play.

When building WCF services you'll eventually need to integrate common logic that may be applied across a number of services, contracts, endpoints, or operations. Examples include logging, security, error handling, and message or parameter manipulation. Since this kind of logic cuts across all of these concerns and must often be executed somewhere between the submission of a message from a client to the service, we are presented with an interesting design and programming challenge. Fortunately, WCF provides a feature called Custom Behaviors that lets us inject common and 'cross-cutting' logic into the WCF runtime either at the proxy (i.e., the client) or dispatcher (i.e., the service) to achieve such ends.

Windows Vista Sidebar gadgets are a great way to add value by addressing targeted and focused user scenarios. Think souped-up system tray - always-on applications typically used for monitoring something that often drives, based on notification, to a broader range of related scenarios. The nice thing about Sidebar is that it gives you more space and freedom to work with in designing your notification-based applications; rather than being limited to an icon and toast pop-ups, you can take advantage of resident UI space.

To solve problems DHTML, JavaScript and XML can't handle, you sometimes need so-called 'rich' client components for your Web applications. Traditionally, this is the realm of Java (applets) or ActiveX controls.

The significance of blogging is not the word 'blog' whether used as a verb or a noun, but its role as a harbinger of the game-changing Web-as-platform revolution. In particular, the migration of blogging from the individual toward the enterprise...

Predicate is a new feature introduced in .NET 2.0 in conjunction with Generic collections. Generics are also new in .NET 2.0; Generic collections are by nature strong-typed. What that means is that if we declare a generic list of Address objects, we can only insert an Address type of object. If you try to insert an object that's not an Address type of object or a derived class of it, you'd get a compilation error. So using Generic collections ensures type-safety. In .NET 1.1, we'd have to use an ArrayList (which is a list of 'object'-type items).

At the end of each year, when SYS-CON informally polls its globe-girdling network of software developers, industry executives, commentators, investors, writers, and editors, our question is always the same: where's the industry going next year?

We are on the cusp of the next giant step in software applications. It's a new frontier that is there for the bold of mind to embrace. This new caliber of applications will be hugely beneficial to mankind, the quality of our lives, and the safety and security of our nation. These applications will be pervasive and impact every aspect of our lives?how we work, learn, communicate, get medical care, travel, shop, and play.

The capabilities and advantages of using the Microsoft .NET Framework are undeniable. It provides the ability to rapidly build, deploy, manage, and use connected, security-enhanced solutions with Web Services, enabling businesses to integrate their systems more rapidly and agilely and helping them realize the promise of information anytime, anywhere, on any device.

Anyone who develops applications for devices can vouch for the importance of having a powerful emulator that can help accelerate the overall development and debugging process. This articles talks about the new Microsoft Device Emulator and how you can exploit some of its capabilities and make yourself a more productive Windows Mobile and Embedded developer.

In the February issue of .NET Developers Journal, I described how implicit operations such as the boxing of value types can dramatically increase the amount of memory your .NET Compact Framework application uses. At the time, the tools available to help you get a picture of how your application uses memory were very limited. While version 2 of the Compact Framework did report performance statistics, it did so only when your application closed. The static nature of these counters made it very hard to locate memory usage trends in your application.

Visual Studio project templates and item templates are reusable and customizable stubs that can simplify the development process. They provide pre-defined starting points for the project or the project items, thus removing the need to create new projects and items from scratch every time.

Microsoft Visual Studio Team System (VSTS) provides tools and features that can be used in almost all areas of software development. As Microsoft VSTS has a broad spectrum of features and target areas, some of its core feature areas are still not well understood by many people working with the product. One of these feature areas is the methodology management system for software development lifecycles, which is built into the VSTS platform.

You have probably seen applications that control their size and positions with greater fluidity than you can get with normal .NET Forms, such as maintaining an aspect ratio while resizing, or docking to the side of a screen. Thankfully there are ways of gaining access to the more powerful aspects of Windows, but they are a bit ugly. In this article, I want to help you write a subclass of Form, which has greater power over its position - namely, I would like to keep the form from ever leaving the screen, not even a part of the side. In the process, we will explore ways to find out about the messages that Windows sends to forms, and how to retrieve their extra data and process those messages in custom ways.

In the past, using open source databases meant running UNIX (or Linux) servers and open source development environments. Today however, the two most popular open source database packages - MySQL and PostgreSQL - have full featured Windows installations, and can be run on most Windows platforms. This allows Windows developers to easily utilize open source databases in their applications.

Developer testing done early in the software's lifecycle is known to have a high positive impact on application quality, since this is the phase where finding and fixing bugs is cheapest, easiest, and fastest. Ideally, coding standard checking and unit testing would be done on every piece of code before it was added to a team's code base. However, this is not always practical. Many organizations don't give developers the time and resources needed for this testing. Moreover, most organizations don't develop applications 'from scratch' by writing new code for all required functionality. Rather, they typically make incremental enhancements to a large amount of functioning legacy code, or add their own code to extend third-party or Open Source packages.

How often have you wanted to reuse some code you previously wrote but it didn't quite fit in your current project? Code reuse is an oft-touted benefit of modern object-oriented programming. With the advent of generic support in the C# language appearing in the .NET Framework 2.0 developers have new leverage for writing code that can be reused without compromising type safety.

Over the last few years the Web has been going through another round of changes. Not only has the consumer Web sprung up with the Web 2.0 phenomenon, driven by new technologies such as AJAX and the philosophy of participation, but enterprise Web initiatives have also morphed. The information that businesses are publishing online is no longer limited to marketing collateral. Brochure-ware sites are quickly changing from static to dynamic and internal applications are being incorporated into corporate sites. As the Web touches every department from product development to finance, it has become an essential part of doing business for any organization.

Forms Authentication for ASP.NET is extremely powerful in that it lets you quickly add a layer of security to your Web site. While the simplicity of setup and implementation makes this form of authentication extremely attractive, usability can sometimes be downright ugly. The core functionality of Forms Authentication relies on redirects - first redirecting anonymous requests to the login page, and then redirecting back to the originally requested resource. Constant redirects not only annoy users, they can disrupt your page logic. Mixing in some AJAX with your Forms Authentication will quickly eliminate the need for most redirects, and the associated negative effects.

Enterprise Rich Internet Applications (RIAs) are the next evolution of business application development. There are four different approaches to RIA development - AJAX, Java, Flash, and .NET - and many different RIA solutions available today. This article answers the following questions: What are enterprise RIAs? Which approach should you use? Which solutions are appropriate for you? And how are RIAs being adopted today?

Ever since the advent of the Internet, Web applications have lagged behind desktop applications in terms of interactivity and responsiveness. One of the biggest drawbacks in the conventional Web model has been the cycle of inactivity between the user request and the server response. Reducing this period of inactivity has been the point of focus for any developer who wants to improve the responsiveness of Web applications and raise the user experience to levels offered by desktop applications.

Managing calendars across multiple Microsoft Exchange servers has always been a problem for those of us in consulting or other professional service fields. Having to aggregate appointments across calendars maintained at multiple client sites, plus your calendar back at the home office - and potentially even an Exchange calendar at home - is particularly cumbersome. Manually consolidating your calendars is time-consuming and error-prone - it only takes a couple of missed or double-booked appointments before you realize that there has to be a better way.