This chapter is about existing and upcoming client–server paradigms in communications, the distribution of computing power, and effective programming with reusable code that can be run on both sides of the client–server pair.

The past decade of client–server development turned to the server part of this happily married couple. The biggest software giants are in a hurry to translate desktop applications into Web services leased or sold on a pay-per-use basis.

This work, begun several years ago, was based on several assumptions:

1. Client networks will improve/upgrade faster and more cheaply than client computers.

2. HTTP-based Web technology will be able to provide all or most of the requested services.

3. Centralized data and services will benefit clients and service providers.

Unfortunately, not all of these assumptions happen to be true.

1. Computers and PDAs are much more capable and cheap today than they were several years ago, whereas digital subscriber line (DSL) and cable modems are still the same price, with no miracles to show for it.

2. One of the biggest requests for Internet services, streaming data, requires protocols other than HTTP and lies outside of Web technology. (This is just one example; applications with asynchronous natures are also not comfortable with HTTP limitations.)

3. Groups of clients are unhappy with the centralized service concept. For security reasons, they prefer peer-to-peer or similar communications.

4. […]

Ontology is a controlled, hierarchical vocabulary for describing a knowledge system or knowledge-handling methods.

This chapter is an introduction to a development paradigm in which software and knowledge engineering are integrated. As always happens on the other side of an economic crisis, a new set of skills will be required. A growing number of developers will actively use the knowledge technologies reviewed in this chapter.

The chapter starts by talking about fundamental standards that currently bridge ontology and engineering: the Resource Description Framework (RDF), the Semantic Web language DAML+OIL (DARPA Agent Markup Language + Ontology Inference Layer), Topic Maps concepts, and their XML Topic Maps (XTM) standard knowledge exchange format.

We'll continue with a brief overview of data-mining methods with coming Java support and eventually discuss the challenging topic of generic knowledge, not just knowledge of a specific business domain, expressed in natural language. The final part of the chapter describes OpenCyc, probably the most exciting knowledge instrument today, and provides examples of using the CycL language and OpenCyc engine in distributed knowledge systems.

I hope this chapter does not take you, my reader, by surprise. Integration-ready systems and collaborative engineering need and help create knowledge technologies, which create a very healthy cycle.

A customer with a computer and computer skills is still the main target for computerized services today.

Even when searching Google.com for a specific topic, you need to know the specific terms of the industry this topic belongs to.

This chapter introduces Wireless Markup Language (WML) and provides examples of programming wireless applications using presentation factories.

Wireless Application Protocol (WAP) devices include WML browsers that can display some content described in WML and WMLScript, which is part of the WAP specification. WMLScript can be used to add programming support to the client. It is similar to JavaScript and can be used in a similar manner. You can use WMLScript to validate user input, but most importantly, you can use it to generate messages and dialogs locally, so error messages and confirmations can be viewed faster.

It is also possible to access facilities of the user agent; for example, WMLScript allows the programmer to make phone calls, access the SIM (subscriber identity module) card, or configure the user agent after it has been deployed. (Keep in mind that data and voice are separate.)

Memory and CPU resources are limited and often prohibit the use of WMLScript, although WMLScript may be necessary to program proprietary telephony features for specific devices. For example, some devices allow your program to:

• Send DTMF (Dual Tone Multi-Frequency. The technical term describing Touch Tone dialing with combination of two tones, one low frequency and one high frequency.) tones

• Modify the device's phone book

• Use the phone book to start voice call or reject a call

Note that such programs would hardly work for a variety of models. The compatibility problem is one of the serious problems WAP developers face.

This chapter is a brief overview of the basic principles and standards driving the world of wireless applications.

Unmatched opportunities in the mobile and wireless areas are attracting the attention of business and development. Wireless markets, including personal area networks (WPAN), local area networks (WLAN), and wideband local-area networks (WWLAN), have an estimated value today of several billion dollars according to the Gartner Group (http://www.gartner.com/5 about/pressreleases/pr11mar2003a.jsp)

According to Gartner, increasing focus on teleworking and corporate mobility to improve enterprise performance, and trends such as the move toward the real-time enterprise, will not merely exploit mobility but will demand it. At the same time, the relentless push by vendors, virtually giving away wireless capabilities with significant price/performance improvements, is fueling demand for wireless technology in the corporate marketplace. United States federal regulators are expanding the radio spectrum for wireless internet users to help bring broadband connections to rural areas.

The number of wireless devices on the Internet is growing fast. The stock of IP addresses is now almost exhausted, so it is about time to extend the Internet with Internet 2, which replaces the current IPv4 protocol with the latest IPv6 protocol and drastically increases Internet capacity and improves Internet security.

A great competition for multiple markets, running different wireless technologies, has just begun. The winners will be those wireless Internet service providers (WISPs) and wireless application service providers (WASPs) that can offer connection and content services and optimize development solutions with a unified approach across multiple client devices.

Who Should Read This Book?

Integration-Ready Architecture and Design strives for a union of theory and practice. Teaching the latest wired and wireless software technologies, the book is probably the first entry into “the next big thing,” a new world of integrated knowledge and software engineering. Written by a software architect and experienced trainer, this book is for:

• Software architects, designers, and developers

• Internet and wireless service providers

• IT managers and other IT professionals, as well as amateurs

• Subject matter experts who will directly participate in a new development process of integrated software and knowledge engineering

• Students and educators, who will find up-to-date materials for the following courses:

1. Software Architecture,

2. Software Engineering,

3. Programming Concepts,

4. Information Technologies,

5. Smart Card and JavaCard Technologies,

6. Wireless Technologies,

7. J2ME and Wireless Messaging,

8. XML Technologies,

9. Speech Technologies,

10. Java Language and Technology,

11. C# and Net Technology,

12. Integration Technologies,

13. Business Communications and Collaborative Engineering,

14. Web Technologies,

15. Introduction of Ontology, and

16. Integrated Software and Knowledge Engineering (introduced in the book)

• Peers: students, instructors, consultants, and corporate team players who might start using a peer-to-peer educational tool offered in the book as their entrance to the distributed knowledge marketplace

• All of the above who want to know how things work, should work, and will work in the IT world.

Though derived from SGML (Standard Generalized Markup Language), Extensible Markup Language (XML) [1] quickly outgrew its initial purpose of enabling large-scale electronic publishing and became the main road of data exchange over the Internet and elsewhere. XML is simple and flexible. These qualities have made XML the perfect instrument for creating new languages in many areas.

For example, HTML is currently the most common language used to create Web pages according to orthodox Web technology, in which the client program is a Web (HTML) browser. However, HTML has its limitations: HTML tags are predefined and cannot be changed or extended.

XML EXTENDS THE WEB AND BUILDS A PLAYGROUND FOR ITS CHILDREN

XML, on the other hand, allows us to create our own elements, attributes, and structures to describe any kind of data. With such flexibility, XML provides the ideal solution for producing new languages to express the ever-increasing complexity of data exchange and other needs.

WAP (Wireless Application Protocol) is, in a way, a child of web technology; but WAP has slightly different requirements, which are not covered by HTML tags. A member of the XML family, WML (Wireless Markup Language) provides the necessary keywords to satisfy these requirements.

XML DESCRIBES BUSINESS RULES AND DATA STRUCTURES; XSLT AND X PATH DESCRIBE THEIR TRANSFORMATIONS

XML is becoming the main tuning tool to describe business rules, data structures, and their transformations.

Extensible Stylesheet Language (XSL) [2] is another member of the same big family of languages.

One of the challenges programmers face every day is creating reusable components with a minimum of overhead.

We will consider an example of a service component and a service container, as well as their design and code evolution from a specific to a very flexible solution.

This chapter starts with a single Java class, which then evolves into a visual component. Then, a service container takes the central place on the stage. The chapter teaches how to build a container that is reusable in a Java applet or an application (desktop) program. It provides a solution to one of the most difficult problems: how to make the service container extensible and ready for more services, including those unknown at this time.

This very first example demonstrates one of Java code's benefits. Imagine a small device, such as a wristwatch, with a built-in Java chip. A single text line in the middle of this small screen usually displays the current time. With wireless Internet connection we will enable this device to display weather, stock, traffic, news from friends and family, community or business information (delivered via Short Message Service), and turn it into a “news watch.” Figure 3.1 illustrates this device that can be viewed as an extended wireless pager or scaled down wireless messenger described in the Chapter 11 (J2ME).

DISTRIBUTED PROCESSING AND THE FLAT WORLD OF XML

I think there is a connection between these two topics. Let me explain what I mean.

XML is becoming the dominant messaging body for wired and wireless communications. We are going down to the flat world of XML from the hills of rich object structures.

The need for object brokers, serialization mechanisms, and intermediate translators between communication parties is decreasing more and more. Does that mean we have been getting rid of objects all along? Impossible! We still need formatted data. So, how would we send and understand unknown structured objects?

We probably shouldn't. We shouldn't send MS Excel or PDF files from a sender to a recipient. We shouldn't send service objects either. We might not need to continue collecting document handlers and service utilities at our machines. We might not need to increase the size of a hard drive ten times every two years.

What can we do instead? Here, distribution processing comes into play. Today, we live in a disconnected world where most of your computing happens on your computer. If a collection of software products on your PC does not include, for example, Adobe Acrobat Reader the system will complain that it has no program to open this file.

In the connected world, things will be different. Your machine will always be on the Internet, with millions of specialized services that are ready to help you.

A structure is a user-defined data type that allows a single variable to store more than one type of data. In Visual Basic 6, structures were actually called user-defined types. The structure object has been improved in VB.NET, however, because VB.NET structures can contain both data and subprocedures to operate on those data. Structures are very common in form to classes, though they have several limitations that restrict their use to solve object-oriented programming problems. Because they are similar in form to classes, structures provide an excellent introduction to the use of classes, which is why we spend an entire chapter discussing them.

USING STRUCTURES

In Chapter 2 you were introduced to the concept of the abstract data type. To implement an ADT in VB.NET, we need to use a special data type called a structure. A structure allows us to store multiple components of different data types in one logical unit. In some languages structures are known as records.

The atomic data types (Integer, Single, String) allow us to store only single data items in a variable, as does an array (well, not strictly, since an array can be of type Object). For example, when we store a number in an Integer variable, we can only store one number in the variable. With structures, we can store more than one piece of the data in the structure and the data can be of different types.

Object-oriented programming (OOP) is just one in a series of technologies that has been deemed as the savior of software. In the world of computing, software often gets a bad reputation because so many programs are delivered to the end user late, with significant bugs, and not designed to completely solve the problem the program was written to solve. Object-oriented programming provides a set of tools and techniques to help programmers manage program complexity.

OOP DEFINED

Object-oriented programming is a programming technique that involves structuring a program around special, user-defined data types called classes. Classes are used to break a problem up into a set of objects that interact with each other. A class consists of both the data that define an object and subprograms, called methods, which describe the object's behavior.

A language that is to be called a true OOP language must implement three concepts—encapsulation, polymorphism, and inheritance. Without all three of these features, a programming language can be considered object-based, as Visual Basic 6 is, but all three must be present for the language to be considered a true object-oriented language.

Encapsulation

In the traditional, third-generation programming language (such as earlier versions of Basic, C, and Fortran), all programs consist of two primary elements—program statements and data. The program statements are used to perform operations on the data, but the two elements are always considered to be separate parts of a computer program.

This chapter explains how to perform database programming in an object-oriented way. There are several techniques (patterns) we can use to make a VB.NET/ADO.NET program object-oriented. Many of these techniques were first discussed (though not necessarily first used) in Martin Fowler's book Patterns of Enterprise Application Architecture (Fowler 2003). This chapter will distill some of the patterns he presents into working code that a VB.NET programmer will recognize, especially a programmer who now understands OOP. First, though, we'll provide you with an overview of how to use ADO.NET to access data stored in a database.

AN OVERVIEW OF ADO.NET

ActiveX Data Objects.NET (ADO.NET) is an object-oriented database API that allows a programmer to use one set of classes to access many different types of databases.

ADO.NET Objects

ADO.NET consists of a set of classes that encapsulate the behavior of the different aspects of a database. These classes include objects that represent the database, individual tables, columns within tables, and rows in tables. There are also specialized objects for making database connections and database commands.

The following list highlights these objects

• DataSet represents a subset of a database and is a parent object to many of the other objects used in ADO.NET.

• DataTable is used to work with the contents of a single table.

• DataColumn is used to represent each column in a table.

• DataRow represents a row of data from a table. Row data are retrieved from the Rows collection of a DataTable object.

• DataAdapter is used as a bridge between a DataTable object and the physical data source, or database, the program is using.

• […]

Programs written in VB.NET utilize the Throw-Catch model of exception handling when dealing with errors. The classes found in the.NET Framework use this model for handling errors, but the classes you develop must generate their own exceptions for handling errors. In this chapter, we discuss how exception classes are created and how to use them. We start the chapter with a review of the Throw-Catch model, which includes the Try-Catch-Finally statement.

EXCEPTION HANDLING IN VB.NET

The term VB.NET uses for errors that occur in executing code is exception. Writing code that deals with errors in a program is called exception handling. Exception handling in VB.NET consists of writing code that watches for exceptions when they're thrown and writing code that causes an exception to be thrown when an error condition arises. A VB.NET programmer is not responsible for always writing exception-generating code since the.NET Framework classes throw their own exceptions.

For example, trying to open a file that doesn't exist throws an exception because there was no file to open. This object is called FileNotFoundException. In the next section we examine how to write code to catch built-in exception objects.

Writing Exception-Handling Code

As we've discussed, trying to open a nonexistent file throws an exception. For our program to recognize the exception, we have to use a special construct—the Try-Catch-Finally statement.

Data we create via object creation cannot be treated in the same way native data (integers, strings, etc.) are treated. When we are working with strings, for example, it is easy to compare two strings to see if they are equivalent. In contrast, when we are working with two class objects, where each object is a composite of multiple data types, how we report the result of comparing the two objects is not obvious. Visual Basic.NET provides a special interface, IComparable, to aid us in making these types of comparisons.

Class objects also present a problem when we want to store them in a data structure and retrieve them using a For Each loop. The VB.NET compiler cannot automatically return an enumerator for class objects stored in an ArrayList or some other data structure, so we must provide the enumeration code. The.NET Framework again helps us in this task by providing an interface, IEnumerable, that we can implement. In this chapter we'll discuss how to implement both interfaces and provide several examples to see exactly how they're used.

THE ICOMPARABLE INTERFACE

A class type usually represents a complex data type comprising components of one of the built-in data types (String, Integer, Boolean, etc.). For example, an Employee class might include data for an employee's name (including the first, middle, and last name), social security number, salary, the department in which he or she works, etc. If we want to compare two Employee objects to see if they are the same, how do we do it?