Click here to Skip to main content
Click here to Skip to main content

Applied .NET: Developing People-Oriented Software Using C#

, 3 Nov 2001
Rate this:
Please Sign up or sign in to vote.
Applied.NET illustrates development of several .NET applications using C#.
<!-- Article image -->
Sample Image
TitleApplied .NET: Developing People-Oriented Software Using C#
AuthorsRonan Sorensen, George Shepherd, John Roberts and Russ Williams
PublisherAddison-Wesley
Published2002
ISBN 0201738287
Price US 44.99
Pages 416

People-Oriented Software

The Internet has brought software to the people. For the first time in history, ordinary people all over the world are using software to connect to each other. This trend will surely continue as Internet connectivity enters the realms of television, radio, telephone, personal digital assistant (PDA) technology, and the automobile. In addition, people's lives are becoming the primary focus of software-either directly through human interaction via Web-user interfaces or indirectly through business-to-business (B2B) communication targeted at serving human needs. The increasing connectivity of the populace through software combined with software's more specialized focus on people is revolutionizing software design.

The software of the past focused on modeling the operation of things, which gave rise to the object-oriented movement. Although today people could be viewed as just another collection of objects in an object-oriented world, this approach would be impractical and likely fail. There is simply no plausible way to model the dynamic interactions and forces within our society using object-oriented design. Social interaction involves issues such as the use of freedom, multicultural preferences, mobility, unpredictability, and geographical location, just to name a few. Simply put, society cannot be adequately represented using the abstraction of an object model. The real world of people is radically different from the world of things, as philosopher Karl Wojtyla (better known as Pope John Paul II) pointed out years ago:

The world in which we live is composed of many objects . . . As an object, a man is "somebody"-and this sets him apart from every other entity in the visible world, which as an object is always only "something." Implicit in this simple, elementary distinction is the great gulf which separates the world of persons from the world of things.1

Because people are singularly exceptional types of objects and their activities are becoming the central focus of software development, a new programming vision is emerging that targets people's complex dynamic interactivity in a more specialized way.

The .NET platform is an early embodiment of this new programming vision that is oriented toward people. It is necessary to understand the elements of this programming vision to fully leverage the capabilities of .NET. In the days when people were migrating from the C language's procedural-oriented programming to the object-oriented programming of the C++ language, it was easy to make the mistake of trying to adopt the new tool without understanding the paradigm shift that it was designed to address. Some mistakenly viewed C++ as just a better version of C instead of as a radically new way to write software. Similarly, today's .NET could mistakenly be viewed as just a better way to build a Web site instead of as an enabling technology for the next generation of the Internet. To prevent this kind of misunderstanding, the rest of this chapter will examine the people-oriented programming paradigm for building the next generations of the Internet and how the paradigm can be implemented with the .NET platform.

What is the Internet evolving into, and how will .NET help? The success of the Internet is tied to the fact that people are social beings. We quickly embrace innovations that facilitate communication, as the success of the printing press, radio, and television demonstrate. The primary need being addressed by the Internet is people's desire to be involved in a community-an online community that is global in scope. The global online community is naturally subdivided into a vast multitude of smaller communities that target specific groups in more personalized ways. The next generation of the Internet, which will evolve using technologies such as .NET, will more completely and seamlessly connect people through economic, social, and cultural interactions.

Building an online community that adequately represents society is a complicated undertaking. Although dramatic improvements in speed and wireless connectivity will be necessary to allow a truly ubiquitous Internet, the greatest challenge engineers face is overcoming inadequate software methodologies. More sophisticated and powerful software tools and techniques are needed to meet the daunting engineering tasks that exist. Once the appropriate methodologies and tools become available, a global online community can emerge out of the somewhat independent initiatives of millions of people. Without the right tools, standards, and methodologies, progress will be very slow, and we will make many wrong turns.

The People-oriented Paradigm

What is the appropriate software methodology needed to transform the World Wide Web into a more globally connected community? Part I of Inside Microsoft Windows NT Internet Development2 introduced a people-oriented programming paradigm to address this question. The people-oriented paradigm focuses on connecting people in more immediate ways through the Internet and on embedding software within the operations of society so that an online community can emerge. Unlike the other paradigm shifts that have already transformed the software industry, such as procedural- and object-oriented programming, people-oriented programming does not focus on the creation of a new programming language, such as Java. Rather, people-oriented programming focuses on leveraging the rich services provided by modern operating systems such as Windows server.

The Internet revolution represents a dramatic shift in the way society conducts itself, and so it necessarily represents a dramatic shift in the purpose of software-a paradigm shift-from technologies focused on individual computing tasks to technologies focused on social interaction, cultural expression, and information exchange. Essentially, software designed for the Internet will be responsible for building a global community. It will focus on improving the ordinary circumstances of living, enabling people to more effectively accomplish day-to-day activities. Thus you could aptly call this new paradigm people-oriented programming . . . While both ActiveX and Java make valuable contributions to Internet development, they are insufficient by themselves to meet the needs of the Internet era. To rapidly build reliable, scalable, distributed software solutions, we need to take ActiveX and Java and embed them in Internet-enabling systems. This is what the Windows NT server platform technologies provide. Windows NT and Microsoft Windows Distributed interNet Applications Architecture (Windows DNA) provide the tools for implementing people-oriented programming.3

This guiding principle, which had its initial implementation in Windows DNA, has achieved more comprehensive expression in Microsoft's next-generation .NET platform. The .NET platform subsumes the rich system services of Windows DNA and extends them to allow for the creation of people-oriented Web services that can be used in an elaborate and personalized way over the Internet. Although Windows DNA focused on satisfying foundational requirements such as Internet connectivity, transactions, asynchronous programming, fault tolerance, security, and scalability, the .NET platform addresses the need for people-oriented Web services. These Web services will allow people to integrate software more seamlessly into their lives. For example, people will be able to view other people's appointment calendars in a standardized way or integrate their business processes between their customers and suppliers. The focus on people has become increasingly important in the software industry during the last few years, and it predates the .NET platform. On March 29, 1999, Microsoft announced that its company had been reinvented. Microsoft intended to encompass a new, broader vision of the empowerment of people through great software-at any time, in any place, and on any device. Bill Gates, Microsoft's Chairman and Chief Software Architect, explained the company's more people-oriented perspective:

Our original vision of "a computer on every desk and in every home" is still extremely relevant. Looking to the future, our vision is much more expansive. We see a world where people can use any computing device to do whatever they want to do anytime, anywhere. The PC will continue to have a central role in this future, but it will be joined by an incredibly rich variety of digital devices accessing the power of the Internet. We want to give people the power, connectivity, and ability to choose how they want to use computing in their lives.4

The .NET platform will facilitate the creation of software that is much more people oriented because it directly enables the implementation of the three concepts embodied within the people-oriented programming paradigm: 

  1. universalization,
  2. collaboration, and 
  3. translation.

Universalization

Universalization is a model of development which leverages the capabilities of sophisticated universal runtimes that implement universally accepted Internet standards.

The universalization model relies on the runtime to provide system services that are widely applicable to addressing complex software engineering tasks. Although programming languages such as C or C++ have powerful capabilities and also have runtime libraries, the runtimes proposed for people-oriented programming are many orders of magnitude richer in their capabilities. Instead of concentrating on programming techniques such as encapsulation, polymorphism, or inheritance to write reusable code, people-oriented programming concentrates on reusing the services of ubiquitous runtimes so that code creation can be minimized and the coding effort can be increasingly directed toward developing people-oriented Web services for building an online community.

The focus of programming shifts from the inherent capabilities of a programming language to the inherent capabilities of a runtime. Windows Server is an example of a runtime that implements universal Internet standards and provides very rich features within its component object model (COM+) services layer. The PocketPC is also an example of a runtime that implements universal Internet standards but has scaled down services more suitable for the devices on which it runs. The .NET runtime more eloquently expresses this model, as we will explain later in the chapter.

Collaboration

Collaboration is a model of synergy in which people-oriented Web services cooperate to provide enhanced services.

The collaboration model facilitates much more sophisticated software integration across organizational boundaries. A people-oriented Web service is any application exposing a programmable interface over the Internet, as opposed to a graphical user interface, with the purpose of enabling developers to build an online community. Examples of these Web services in the retail industry include catalogues of products and accessories, billing and payment processing services, and shipping and delivery services. By programmatically binding these Web services together, software developers all over the globe can collaborate to create marketplaces in which the needs of millions of businesses and consumers are identified and matched.

The software engineering challenges of accomplishing this feat are formidable. Directories are needed to identify the available Web services and to describe how developers can integrate other services with them. People need to form a consensus on Web service description contracts for similar types of services to avoid excessive complexity in integrating multiple service providers. Testing and troubleshooting will require easy ways for programmers to collaborate with multiple Web service providers during the development and operational phases.

Translation

Translation is a model of interoperability that addresses conversion of functionality between heterogeneous platforms and between diverse service description contracts.

The translation model provides an approach to creating a virtual uniformity in an environment that is aggressively diverse. Building an online community requires a seamless way for thousands of Web services to talk to each other. This is not an easy task because there are millions of software developers independently building these types of services using diverse technologies. The Internet is a network of heterogeneous infrastructures that run many different operating systems and use incompatible component protocols like distributed component object model (DCOM), Common Object Request Broker Architecture (CORBA), and remote method invocation (RMI).

It is not feasible to migrate all these systems into a common technology. Instead, people-oriented programming concentrates on translation techniques that allow disparate systems to communicate over ubiquitous Internet standards such as the Hypertext Transfer Protocol (HTTP) and the eXtensible Markup Language (XML). People-oriented Web services can be built with any programming language and on any platform. Internally the service may use proprietary protocols to achieve maximum scalability and an external interface can translate back and forth between the proprietary interface and the ubiquitous Internet standard. The translation model has another equally important objective. It is likely that multiple Web service providers will provide the same type of service but use different description contracts that indicate how to programmatically integrate with that type of service. It will be a considerably complex task for the software developer to try to accommodate all these different service description contracts. The model of translation requires tools and techniques to facilitate a way to map all the description contracts into a common format that the consuming system understands.

A .NET Approach

The first version of the .NET platform goes a long way to help software engineers build people-oriented systems that facilitate universalization, collaboration, and translation. Although other competing technologies such as Sun ONE could be used instead of .NET to implement these principles-and other new technologies are likely to appear in the future-the purpose of the following analysis is to give a sampling of how .NET facilitates the development of people-oriented software. The rest of this book provides a more comprehensive analysis.

.NET and Universalization

The Internet of the future will be far more ubiquitous and powerful than the Internet of today, with people interacting through natural interfaces. The Internet will be a high-bandwidth, global network transmitting data, voice, and video and connecting billions of computers, telephones, radios, televisions, PDAs, and automobiles all over the globe.

Wireless connectivity will be fast and affordable, potentially displacing landlines as the most predominant means of Internet access. Many new Internet devices will emerge that will hook up home items like refrigerators, doors, windows, air conditioning units, and security systems. Disposable Internet devices will be commonplace, and people will be able to wear them, mail them, and easily replace them. Data will be universally accessible and will usually not be tied to an Internet device. Although security will be enhanced with biometrics, security and privacy will always be difficult issues. Financial transactions using Internet cards will be widespread, and the line between buying online and buying in person will become blurred because the primary distinction between the two will be delivery or pickup. There will be newer, more natural ways of communicating over the Internet. Handwriting recognition, voice recognition, and visual recognition through cameras will allow people to forget that a sophisticated technical infrastructure is enabling them to communicate easily over the Web. Hopefully, software developers will also be able to forget these complexities through the services of universal runtimes and universally accepted Internet standards.

The .NET platform furthers this end through the universal runtime called the Common Language Runtime. This runtime operates on top of the operating system to manage the execution of code and provides services to simplify the development process. Source code that is targeted for the runtime is called managed code; the compiler translates it into a Microsoft intermediate language (MSIL) that is independent of the central processing unit (CPU). As the code is being executed, a just-in-time (JIT) compiler converts this MSIL to the CPU-specific code required by the device on which it is running. In theory, this means that software developers can write code for the runtime without having to target each CPU architecture on which it may run. This will become an issue of increasing importance as new Internet devices are built on inexpensive commodity CPUs. Although the .NET runtime will be available for each variation of the Windows operating system, it is also possible that .NET may be ported to other operating systems such as Linux. To enable easier interoperability with alternative universal runtimes on different platforms, the .NET runtime implements intermachine communication services using universal Internet standards such as HTTP, HTTPS, XML, and the Simple Object Access Protocol (SOAP).

The .NET runtime exposes a unified programming model for many services that are available today through disparate application program interfaces. There are general-purpose libraries, such as the WIN32 application programming interface (API), the Microsoft Foundation Classes (MFC), the Active Template Library (ATL), and WinInet; more specialized libraries, such as DirectX, the Microsoft Telephony application programming interface (TAPI), CrypoAPI; and a whole set of COM interfaces for component services such as transaction processing, queued components, or object pooling that must be learned to develop sophisticated software. The software developer has to absorb many APIs from many sources-some duplicating the same functionality and some targeting different programming languages-to effectively leverage architectures like Windows DNA. The .NET runtime consolidates most of these APIs under a simpler unified model that abstracts many of the details, especially the interoperable COM underpinnings. In the future, the software developer will be able to focus mostly on the .NET runtime regardless of which programming language is being used. For example, the message queue component in .NET allows easy incorporation of message-based communication into applications to do tasks such as sending and receiving messages, exploring existing queues, or creating and deleting queues. The runtime implementation of HTTP 1.1 frees the developer from complex tasks such as pipelining, chunking, encryption, proxy use, and certificates and authentication mechanisms such as Basic, Kerberos, or Windows NT Challenge/Response (NTLM).

Many powerful new features that simplify the development process have been incorporated into the .NET runtime. These include cross-language integration through a common type system (CTS), simplified versioning and deployment through the use of assemblies, self-describing components through extensible metadata, easier lifetime management through automatic garbage collection, a simplified model for component interaction, and improved debugging and profiling services.

The .NET runtime introduces a new entity called an AppDomain that can greatly facilitate scalability design, a major issue when connecting billions of devices. Normally there is a tug of war between scalability and fault tolerance in the design of high-performance systems. New components are partitioned into different process spaces within an application so that undiscovered bugs do not bring down the entire system through something like a memory access violation. However, cross-process communication can significantly reduce the scalability of an application because of the additional code execution required and the serialization of processors that occurs from memory allocations on the heap during marshalling. In the .NET architecture, managed code is protected from causing many typical faults in the runtime. Any negative consequences that may result can also be confined to the offending AppDomain. This allows the software architect to partition code execution into multiple AppDomains within the same process space to avoid expensive cross-process communication. The end result is a much more scalable system that also achieves fault tolerance.

Security is another critical factor determining the evolution of the Internet into a sophisticated online community. People will not connect sensitive business operations to the Web unless they are confident that their transactions will be secure. The .NET runtime provides a code access capability to help address some of these concerns. Mobile code is a big danger because it can come from many sources such as in e-mail attachments or in documents that are downloaded from the Internet. Exploiting known vulnerabilities such as buffer overflows in Internet software applications is another common method of attack. Code access security helps protect computer systems from these kinds of attacks because it allows code to be trusted in varying degrees depending on where the code originates and on its intended purpose. This mechanism does not prevent all mobile code from executing but rather limits what the code is capable of doing. The degree to which this occurs may depend on whether the code has been digitally signed by a trusted source. Code access security can also reduce the risk that other legitimate software can be misused by malicious code using buffer overflows or other exploits. This is accomplished by specifying the set of operations the legitimate code is allowed to perform as well as the set of operations it should never be allowed to perform.

The .NET runtime is an evolving platform that will continue to be enhanced as the needs of the emerging online community expand. One can expect the incorporation of additional features such as natural interfaces in later releases of the universal runtime. These new features will be exposed through the same unified programming model.

.NET and Collaboration

Building a globally connected online community can be a lot easier in theory than in practice. The level of collaboration required is very difficult to achieve, especially given the competing forces active within the different industries that will be involved. However, the existence of the Internet today in its present form demonstrates that it is possible to get a consensus when the opportunities generated through collaboration outweigh the advantages of protecting proprietary gains. What types of desirable applications will be possible in future generations of the Internet?

This is a huge topic, so we will focus only on an e-commerce example. Assume that every product and service has a globally unique identifier. Everything you buy at a shopping mall or supermarket has this identifier encoded on it and it can be scanned through readily available scanners in your home, car, or PDA, all of which are connected to the Internet. Also assume that there are people-oriented Web services that understand your identity and provide you with personal storage. Anytime you buy anything, the item is scanned and your personal inventory is updated. Anytime you consume an item, you scan it and your personal inventory is depleted. After you set the personal preferences for your inventory, automated software agents will be checking periodically on your data to ensure that your house supplies are always replenished. If you are running low on beer, the automated software agent will order more from your local store, which you can pick up next time you drop in. Alternatively the automated agent could search the current prices of this item using its unique identifier and order additional supplies from a less expensive store, which will deliver it to you. Each month your automated agent will produce a report of items it has purchased for you, providing comparative analyses of alternative buying patterns that may be to your advantage. For example, your agent may tell you that if you buy brand X instead of brand Y, you will save a certain amount, or if you stock a two-month supply of product X, you will save money through bulk purchasing. Every month the automated agent will present you with a financial summary of your account and ask for your approval to automatically pay your bills.

Every supplier of products could also have automated agents working on its behalf. By analyzing previous buying patterns, suppliers could predict more accurately the desired inventory levels required for their goods. These could be used to automatically order additional supplies from manufacturers who in turn could rely on automated agents to stock raw materials appropriately. Anytime there are unforeseen events that break traditional buying patterns, adjustments could be quickly made in production, and excess supply could be offered to the automated agents at a discount. The end result is a finely tuned system that minimizes waste and effectively matches supply to demand.

How can .NET help software developers build these kinds of systems? Building these systems is only possible if there are ways to programmatically collaborate the services of multiple companies over the Web. Vast arrays of Web services need to be developed that expose business functionality in well-defined ways. The .NET platform greatly simplifies the creation of these Web services using universally accepted standards. The runtime provides all the necessary plumbing, and development tools-such as Visual Studio.NET-provide wizards that create skeleton Web service applications, which can be enhanced with specific functionality. The .NET platform exposes its functionality through a number of namespaces, a few of which we mention here.

The System.Web.Services namespace consists of the classes that enable the user to build and use Web services. Using this functionality can be very easy. For example, to make a method of a public class running inside ASP.NET accessible over the Internet, the user simply adds the WebMethod attribute to its definition. The System.Web.Services.Protocols namespace consists of the classes that define the protocols used to transmit data across the wire during the communication between Web service clients and the Web service itself. It exposes methods such as HttpClientRequest and HttpServerResponse and provides the implementation for communicating with a SOAP Web service over HTTP.

The System.Web.Services.Description namespace consists of the classes that enable you to publicly describe a Web service via a service description language. Service description contracts are automatically generated when a Web service is created in Visual Studio. A consumer of the Web service uses this contract to learn how to communicate with it-that is, the methods it can call, the input parameters, and the exact format of the potential responses returned. The Web services description language (WSDL) has become the de facto XML Internet standard for describing Web services in this fashion. The System.Web.Services.Discovery namespace consists of the classes that allow consumers to locate available Web services. Web service discovery is the process of learning about the existence of available Web services and interrogating them for their description contracts so that users can properly interact with them.

The Universal Discovery, Description, and Integration (UDDI) Project (http://www.uddi.org) was created to provide a framework for Web service integration through a distributed directory of Web services. This directory allows the user to locate available Web services within an industry or a particular company. Programmatic registration and discovery of Web services using an assortment of predefined SOAP messages is supported by the .NET platform. The UDDI and WSDL standards emerged out of collaboration between IBM, Microsoft, and Ariba, and more than 30 other software companies also endorse them.

Many Web services will be built through binding and extending other Web services. Some foundationally people-oriented Web services will likely emerge as commodities. A data store Web service could allow people to safely store their information in a universally accessible location. The methods to access this data will have to take into account the speed of the user's Internet connection and allow for offline updates that can be synchronized later. Although the data may be stored as XML, the user should be able to use Microsoft Office applications to view and modify it. An identity Web service will be needed to allow for a single log-on to multiple Internet services. The Microsoft Passport service provides this kind of functionality today. More sophisticated features such as biometrics may be added later. Users will need notification and messaging Web services that push information to people or their software agents, such as stock price updates or news headlines. Online calendar services will also be needed to enable people or agents to collaboratively schedule appointments and meetings. The calendar service should enable users to set permissions that authorize or prohibit access. For example, a user might give access to important clients and deny access for uninvited sales meeting requests. The .NET platform and associated Web services are evolving systems that will always be updating and improving. A dynamic delivery service will likely emerge that will allow users to automatically receive improvements when they occur.

Binding Web services together will present interesting challenges to the software development community. The software development process will need to evolve to encompass the particularities of collaborative development. How do developers test and debug applications that incorporate multiple live systems that they do not control? How is it possible to instrument them with diagnostic information and manage them effectively? How is a denial-of-service scenario that is caused by unexpected circumstances, such as a consumer repeatedly calling a Web service in a tight loop, prevented? How are transactions spanned across multiple Web services so that changes are automatically rolled back if an error occurs? Although the .NET platform is a great first step to facilitating collaborative development, numerous issues still need to be addressed.

.NET and Translation

As of August 2001, the .NET platform was still in the beta version. Although the Internet has connected millions of computers all over the globe, less than a tiny fraction of one percent is running the .NET software. The level of communication between computers on the Web is minimal and is confined mostly to presentation of information and point-and-click buying and selling. Even though standards such as XML, SOAP, WSDL, and UDDI have emerged to facilitate collaborative B2B communication, not many system implementations are currently available.

Today the dominant binding glue of the Internet is still HTML, which has been applied to nonpresentation tasks such as e-commerce. HTML has been a tremendous success because it is easy to implement and acts as a common translation language for the many different types of systems that exist in the wildly heterogeneous Internet environment. Although practically every computer connected to the Internet understands the Internet protocols such as Transmission Control Protocol/Internet Protocol (TCP/IP) and HTTP, these protocols limit the level of communication and collaboration that can occur between them.

One approach to solving this problem would be to get everyone to adopt a common technology or new programming language such as C# that could provide better services. However, this is not realistic given the competing forces active within the software industry, nor is it desirable because it would stifle innovation in the future. A translation approach would allow greater flexibility and freedom of expression.

If the Web is to evolve into a more globally connected online community, new mechanisms of translation are needed that enable richer and more sophisticated software interaction between people. It is not enough to have universally accepted protocols; users also need platforms and tools that simplify their implementation. The .NET platform will help address the translation needs of the online community in two major ways: system interoperability and service contract transformation.

System Interoperability

Although Internet communication is still quite rudimentary, many sophisticated business processes have been computerized. There is already a tremendous amount of software engineering in place that can be used to construct an online community. Most of it is locked within corporations because of the use of proprietary and disparate software protocols. The .NET platform can help companies unlock these rich resources and expose them on the Web. Software developers can build intermediary Web services as translation layers to existing systems and also port some legacy code to .NET. The CTS within the .NET platform facilitates easier code porting through its handling of incompatible generic data types used by different languages, cross-language integration capabilities, and standardized ways of dealing with events, dynamic behaviors, persistence, properties, and exceptions. The .NET implementation of Web services is XML based and can be accessed by any language, component model, or operating system because it is not tied to a particular component technology or object-calling convention. This means that many different companies can independently build Web services that will be able to interoperate without first having to agree on system-level implementation details. If users already have a CORBA- or COM-based system, they can build a .NET Web translation service that wraps its functionality and exposes it on the Web. The .NET architecture uses the simple and extensible SOAP protocol for exchanging information within the heterogeneity of the Internet. SOAP is an XML-based protocol that does not define any application or implementation semantics and can be used in a large variety of systems from asynchronous messaging to remote procedure calls.

Web forms within the .NET platform also simplify the generation of HTML, which serves as a translation mechanism for presentation information. Using Web forms, a user can create Web pages by dragging and dropping rich user interface controls onto a designer and then add code to programmatically bind these components to business layers using any programming language. The .NET platform will translate the desired presentation into pure HTML, which can be understood by browsers on any device and operating system.

Contract Transformation

One of the biggest challenges facing companies who would like to use collaboration to conduct business on the Web will be getting a consensus about industry-specific Web service description contracts. There will be many contracts that serve the same purpose but differ slightly in their format. For example, there could be hundreds of purchase order contract types; without the appropriate translation techniques, programmers could face the nightmarish task of trying to cater to every purchase order contract variation. To simplify these intricacies, users need an easy way to translate disparate Web service contracts into a common format that is expected by the consuming Web service. Fortunately the extensible style language transformation (XSLT) specification addresses this problem in a standardized way. XSLT is a language that transforms XML document types into other XML document types. A transformation expressed in XSLT describes rules for transforming a source tree into a result tree and is achieved by associating patterns with templates. The .NET platform implements the XML document object model (DOM) through classes supported in the System.Xml namespace, which also unifies the XML DOM with the data access services provided by ADO.NET. The .NET System.Xml.Xsl namespace implements the World Wide Web Consortium (W3C) XSLT specification. The XslTransform class can load an XSL style sheet using an XmlReader and transform the input data using an XmlNavigator.

The capability of the .NET platform to provide easy translation mechanisms for system interoperability and service contract transformation is a huge step forward in the evolution of the Web into a sophisticated online community. We can expect that these capabilities will also emerge in other technologies and platforms so that all Internet systems will be more easily integrated in more powerful ways.

Conclusion

The Internet has changed the rules of software development and spurred on the emergence of the people-oriented software paradigm, which aims to transform the Internet into an online community that adequately represents society. Universalization, collaboration, and translation are the three principles proposed in the people-oriented paradigm. The transformation of the Web into a sophisticated online community has begun, and many developers are already building software that engenders the people-oriented characteristic outlined in this chapter. However, today developers are engineering all the plumbing work by hand and are implementing Internet standards on a case-by-case basis. The .NET framework will put in place the tools needed to make software universalization, collaboration, and translation much easier to deliver, thus more effectively transforming the Web into a true, worldwide online community.

  1. Karol Wojtyla (Pope John Paul II). Love and Responsibility, trans. H.T. Willetts (New York: William Collins Sons, London, and Farrar, Straus and Giroux, 1981), 21. The ethical principles established in Love and Responsibility could be applied to the social aspects of the Internet's impact on society at large.
  2. Ronan Sorensen. Inside Microsoft Windows NT Internet Development (Redmond, WA: Microsoft Press, 1998), 5. Used with permission.
    In December 1999, Pearson PTR, Slashdot.org, Netscape's DevEdge Online, and Doctor Dobb's Journal asked readers to nominate the books that have had the biggest impact on computer technologies to date-the books that stand dog-eared next to computers and are ready to tackle the next challenge-the books that stand the test of time and whose value extend into the years to come. Inside Microsoft Windows NT Internet Development was ranked fourth in this Best Computer Books of the Twentieth Century contest.
  3. Ronan Sorensen, Inside Microsoft Windows NT Internet Development, 10.
  4. Microsoft press release ("Microsoft Announces Reorganization," 1999): http://www.microsoft.com/PressPass/features/1999/03-29reorg.asp.

License

This article has no explicit license attached to it but may contain usage terms in the article text or the download files themselves. If in doubt please contact the author via the discussion board below.

A list of licenses authors might use can be found here

Share

About the Author

Chanda Leary-Coutu
Marketing
United States United States
No Biography provided

Comments and Discussions

 
General[Message Deleted] Pinmemberit.ragester28-Mar-09 6:39 
[Message Deleted]

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

| Advertise | Privacy | Terms of Use | Mobile
Web04 | 2.8.1411022.1 | Last Updated 4 Nov 2001
Article Copyright 2001 by Chanda Leary-Coutu
Everything else Copyright © CodeProject, 1999-2014
Layout: fixed | fluid