 |
| Title | Applied .NET: Developing People-Oriented Software Using C# |
| Authors | Ronan Sorensen, George Shepherd, John Roberts and Russ Williams |
| Publisher | Addison-Wesley |
| Published | 2002 |
| 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:
- universalization,
- collaboration, and
- 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.
- 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.
- 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.
- Ronan Sorensen, Inside Microsoft Windows NT Internet Development, 10.
- Microsoft press release ("Microsoft Announces Reorganization,"
1999): http://www.microsoft.com/PressPass/features/1999/03-29reorg.asp.
