So you want to build an intranet?

The Heisenberg Principle states that it is impossible to know both the velocity and position of an atomic particle. In the microcosm of the subatomic world, making things visible adds energy to the system and alters everything. Looking at something inevitably changes it.

In the macrocosm of the Internet and intranet, celestial bodies move at the speed of light. Things move so rapidly that it seems impossible to know either the velocity or position of anything. Technologies frequently come into existence, only to be swept away by newer ones. Products are cool today and gone tomorrow. Standards are obviated by standards and standards themselves become a meaningless concept.

“God does not play dice with the universe,” said Albert Einstein. But the corporate developer declares, “My whole life is a crapshoot.”

In many corporations, the intranet is becoming the latest realization of client/server computing. A recent study by IDC for InfoWorld magazine indicates 76 percent of corporations currently have or are planning an intranet. Of these, nearly all will use their intranets to facilitate enterprise-wide communications, while more than 65 percent will use it as a platform for distributed computing.

Sadly, many intranets are evolving with no clear objective, seemingly through a process of random mutation. Take this, add that, shave a little off the sides. An implicit goal of most intranets is to realize the promise of client/server computing: cheap, scalable, easily maintained software for the enterprise. For intranets to succeed they must achieve a real business purpose, have an overall design, and be built with a set of measurable objectives in mind. According to InfoWorld, only 40 percent of IS managers currently consider client/server computing “a worthwhile investment.” Without some intelligent thought now, no IS managers will consider their intranet to be a worthwhile investment in the future.

Intranets in 6 easy steps

It’s amazing how little design has gone into most corporate intranets. If there is any architecture at all it seems to be of the Rube Goldberg variety: a haphazard assembly of amusing components. Intranets of any size are ultimately software projects, and frequently mission-critical ones. The same design rules that concern any sophisticated software application apply to intranets, with a few enhancements. At the highest level, there are six key design characteristics:

1. Define the mission
2. Select the standards
3. Think big, start small
4. Develop skeptically
5. Measure everything
6. Build on what works

Define the mission

Surprisingly enough, the most ignored aspect of intranet design seems to be elementary questions about its mission or purpose. What business objective does the intranet serve? Is it to be used as a mechanism for information sharing? Is it the company’s primary interface to customers? Will it be used to connect to all employees? To vendors? To customers? Will operational systems be built on top of the intranet infrastructure?

While these questions may seem simple, there are some major architectural decisions that derive automatically from them. If the intranet is to be used primarily for communications and information retrieval, it is really an electronic publishing system composed of linked HTML pages. If it is used for operational systems, then it is a platform for distributed computing composed of both programs and documents. If it is used primarily for employees then one security and caching scheme will apply. With Internet access, another strategy works best.

Perhaps the most overlooked aspect of intranet design is security. In most corporations there is a legacy of client/server thinking where applications are difficult and expensive to scale to large volumes of users. In the intranet scalability is less a concern than security. Where information is widely available, who will not have access is as important as who will?

Select the standards

Selecting a set of standards upon which to build an intranet is always a mix of science and divination. Where the intranet is used for information retrieval, the issue comes down to selecting a set of supported browsers, content types, address schemes and server APIs. Where it is used for distributed computing, there are a number of bets that must be placed. The most important is the application protocol that will be used to connect programs and resources. There are at least four competing visions here. One is the Netscape Internet Inter-ORB Protocol (IIOP) for programmatic access to servers using a lightweight Common Object Request Broker Architecture (CORBA) interface. The second is Microsoft’s Distributed Component Object Model (DCOM). The third is extended HTTP (HyperText Transport Protocol). The final one is CGI (Common Gateway Interface). Each of these has strengths and weaknesses. The same is true for database access, where choices must be made among Microsoft’s Open Database Connectivity (ODBC), JavaSoft’s Java Database Connection (JDBC), and more proprietary interfaces like Microsoft’s Data Access Objects (DAO) and Remote Data Objects (RDO).

Standardizing on browsers, servers and an HTML specification is becoming simpler as product features and APIs converge. Subtle differences remain, however, even in browser support for generic HTML features like tables and frames. Standards will continue to evolve rapidly; choose carefully if not conservatively.

Think big, start small

Ultimately your corporate intranet will be everything to everyone. It will bring new levels of productivity to the enterprise, and link your employees, vendors and customers in a quality embrace. It will create a new standard for the World Wide Web. It will make you richer than Oprah.

But not in its first release. The inherent flexibility of popular Internet technologies such as Java, URLs, HTML, and HTTP is that they let you easily evolve, enhance, and relocate the system.

There are two important thoughts for those who wish to embark on building an intranet. First, it is better to have something that works and has measurable benefits now than a good design that is never implemented. Second, think about the long-term, even in the smallest project. The chance is good that it will be reused as a component in a larger system, and that it will eventually execute as part of system that is available outside of the corporation.

Build small components. Aggregate the components into larger systems. Assume that what is built for the Intraprise today will execute in the Extraprise tomorrow.

Develop skeptically

Be agnostic. Netscape, Microsoft, Oracle, and others have grand strategies for world dominance. Assume that no single vision will prevail in its entirety. Where you can choose technologies or standards that span visions, invest in them. Where you cannot, tread lightly. Even in corporations where the intranet infrastructure is well-known and well-managed, you must assume that it will change and ultimately will be integrated with external systems whose characteristics are unknown.

Of all the technologies that make up your intranet, Java has the best long-term potential. Choosing it now for critical component building may be a speculative investment, but it is a wise one.

Stay close to standards. Beware of enhancements, plug-ins, and other deviations from the safe path. Choosing a vanilla implementation may not give you the same satisfaction as choosing a more exotic flavor, but it is and always will be the smart choice.

Measure everything

Evaluating the success of your project involves many metrics. How many hits does it get, and where are the hits clustered? How fast was the site developed? How much money has been saved? How much has productivity been improved? Some of these measurements are hard to obtain, but all of them are worth exploring. Ultimately, the success of your intranet will be judged not on how cool it looks but on the degree to which it helps the company achieve its business objectives. If this cannot be measured accurately, or is does not appear positive, then it’s time to rethink your design.

Build on what works

An object-oriented approach to building intranets is best. Build small components and reuse them to build bigger systems. Fortunately, languages like Java (and even HTML) help make this approach viable. This is particularly true of JavaBeans. Building software as beans helps insure that it is reusable.

One of the best ways to build intranets is to focus on constructing “Intelligent” components, ones that are computed on the fly for individual users. This approach eliminates the need to develop an infinite amount of documents to serve the user base. Developing intelligent pages means that HTML fragments are computed from one or more data sources (databases, user profiles) and dynamically created for individual users depending on who they are or what they do.

Building intelligent content into your intranet eliminates the need to maintain large quantities of pages and links.