Jini Technology: Impromptu Networking and its Impact on
`Telecommunications
`Lai Olstad, Javier Ramirez, Clint Brady, Bruce McHollan
`olstad@colorado.edu ramirejj@colorado.edu cdbrady@usa.net bmchollan@category5.net
`
`1. Introduction
`Impromptu Networking, as brought by Sun Microsystem’s Jini technology, is poised to radically
`change telecommunications. While it is too soon to tell if Jini technology will be the dominant
`means of implementing impromptu networking, the benefits of this new paradigm are
`unmistakable. Providing the ability to automatically interconnect devices into impromptu
`networks will make the lines between today’s numerous disparate networks disappear.
`This paper examines Jini technology and its ramifications on telecommunications, including both
`voice and data networks.
`
`2. The Vision of Jini
`According to Bill Joy, one of the founders of Sun Microsystems and the original creator of
`Berkeley UNIX: "The complexity of the systems today has exceeded the professional systems of
`twenty years ago. A better way of constructing new systems is needed, to reduce the frustration
`and better match the computing devices to human uses [1]". The main goal of Jini is to provide
`simpler, more flexible and robust networks to the telecommunications industry.
`
`2.1. Jini History
`A synopsis of Jini’s history will help explain how the vision of Jini evolved. The history of Jini
`is largely the history of Java. Jini fulfills the original Java vision of consumer-oriented groups of
`electronic devices interchanging data. Java evolved from a language called Oak. Oak was
`designed by Sun Microsystems in 1990 to serve as a portable way to write programs for
`embedded processors. In 1994 engineers Patrick Naughton and Jonathan Payne from Sun wrote
`a Web browser using Oak. This browser, named WebRunner, later became the foundation for
`the HotJava browser. HotJava had the unique ability to download executable programs from
`Web servers and execute them in a browser. These programs are called applets. Although Java
`got its start in consumer electronics, it was the ability to build applets that propelled it into the
`computing industry. Realizing that the original Java concept was still compelling, a group of
`Sun engineers recognized the need for continuing development. Although Java enables moving
`code from machine to machine, problems exist that hamper implementing constellations of easily
`administered devices. This requires mechanisms normally not associated with desktop
`computing. These mechanisms for such devices are as follows:
`• A robust software infrastructure.
`• The ability to dynamically configure additional devices and peripherals.
`• The ability to share components without reconfiguration.
`• The ability to form impromptu communities.
`Prior to 1998, Jini was being developed secretly at Sun until New York Times technology
`reporter John Markoff published a story on Jini. Jini was first introduced to the public on
`January 25, 1999. Accompanying the introduction was a host of licensed supporting
`
`1
`
`Ex.1028
`APPLE INC. / Page 1 of 12
`
`

`

`manufacturers. In May 1999, the first Jini Community Summit was held in Aspen, Colorado.
`During the summit, Bill Joy and Jim Waldo, Sun’s chief Jini architect, explained further how Jini
`fundamentally changes the architecture of computing systems [2].
`
`2.2. Two Emerging Trends
`Two emerging trends, the proliferation of small embedded devices and high speed networks will
`point to a future in which more devices will be enhanced with embedded microprocessors and
`interconnected via networks. Embedded devices are appliances or devices with an embedded
`microprocessor that has a relatively focused functionality. Examples of embedded devices
`include cell phones, microwave ovens, VCRs, pagers, clocks, and printers. It is important to
`note that although a PC contains an embedded microprocessor, it is not usually considered an
`embedded device because it does not have a focused functionality. Rather, a PC is a general
`platform suitable for many different software applications. The proliferation of embedded
`devices is being driven by the decreasing costs of adding processing power to devices. This is a
`result of increasing the functionality of the microprocessor chips. As both the cost and size of
`computers continue to decrease, it becomes cost-effective to include processors in a wide variety
`of products. Manufacturers are adding embedded processors to their products to increase the
`functionality and value. This trend will yield an explosion of embedded devices in the coming
`years.
`Another trend underway is the proliferation of high-speed networks. Companies like Qwest,
`Level 3 and Global Crossing, to name a few, are rushing to build high-speed backbones. High-
`bandwidth pipes are being sent into homes. Wireless networks are being developed. The
`network will be increasingly fast and accessible by all. Jini will take advantages of these two
`trends and make networking simple and flexible.
`
`2.3. Disappearing Computer
`"Forget the desktop" bellowed Joy at the Summit. With that, he predicted the demise of desktop
`computers and the emerging network-centric environment. Joy went on to describe a flat-panel
`display currently being manufactured that can be folded or rolled like paper. He said that in the
`future when he needed to do some work, he would set down his “handset” and roll out his flat-
`panel display. The handset would have a wireless connection to the Internet and a wireless
`connection to the display. The flat-panel display or “smart paper” is an example of how
`computers will disappear into application specific devices we will use everyday [3].
`
`2.4. Jini Scenarios
`Jini technology gives users a unique, more convenient option for accessing services in their
`neighborhood and the world at large. Examples of possibilities that Jini technology enables
`include: You walk into a conference room or a colleague’s office and instantly your laptop
`computer is connected to a full array of services. Rather than drive to your local instant-copy
`store, you might simply access their services application from your home computer. You tell
`them what you want copied, where to deliver the job, and they take care of the rest. Or, imagine
`appliances that maintain themselves through remote diagnostics and repair procedures; Water
`heaters that adjust temperature and water pressure to compensate for someone turning on the
`dishwasher while the shower is running. All these are possible due to the vision of Jini
`technology within the impromptu community.
`
`2
`
`Ex.1028
`APPLE INC. / Page 2 of 12
`
`

`

`Since the Internet is an extremely dynamic network, composed of fiber, wire, cable,
`wireless, satellite, cellular and other communications media an adaptive technology like Jini
`makes sense. Being able to seamlessly access resources provided by the network based on
`proximity and / or authority is becoming much more valuable. A printer that is unavailable
`today, should not appear as an option. Yet today’s network operating systems implementations
`are quite static in this regard and this is exactly how and un-useable printer is handled. If a new,
`previously unknown resource becomes available, no one should need to tell the user about it so
`they can configure their computer to take advantage of the resource. With Jini, utilizing this new
`resource may not even involve a conscious (human) decision. For example, the user may want to
`print color photos when a color printer becomes available at some unknown future time.
`
`Any technology that experiences exponential growth, will encounter limiting factors that
`have to be addressed through fundamental shifts in paradigms or the explosive growth self-
`limits. For example, it is estimated that had it not been for the development of automated
`switching in the telephone network, the number of operators that would be required today would
`exceed the population of the planet. Automated switching removed a barrier that would have
`impeded the further advancement of technology.
`
`3. The Jini System Components
`Jini is a small set of rules that enables clients and services to interact; Jini is an extension of Java,
`Sun’s cross-platform programming language. Jini's purpose is to enable the creation of simpler,
`more flexible networks. Jini will provide a way for entities (machines, applications, or devices)
`to automatically "discover" and share resources called "services" which can be of any type
`(hardware, software, communication channels, users) [4]. Jini is based on the Java programming
`language and it requires a Java Virtual Machine (JVM) definition. Java is an interpreted
`language and is independent from the platform on which it is run. This is in contrast to the JVM,
`which is platform dependent and must be implemented accordingly [5]. (Figure 1)
`
`Applications
`
`Services
`
`Jini Technology
`Java Technology
`Operating System
`Network Transport
`
`Figure 1. Jini Stack
`
`Jini technology provides simple mechanisms, which enables devices to plug together to form
`an impromptu community. Each device provides services that other entities in the community
`may use. Devices provide their own interfaces, which ensures reliability and compatibility. In
`Jini a group of services is called a community; all services in a community are aware of and able
`to use each other. Federation is the ability for Jini communities to be linked together into large
`groups making it very scalable. Ideally the size for a single Jini community is about the size of a
`workgroup (10 to 100 people) [1].
`
`3
`
`Ex.1028
`APPLE INC. / Page 3 of 12
`
`

`

`3.1. Important Considerations
`Jini addresses how services connect to one another, not what those services are, what they do or
`how they work. Jini is not a Name Server even though it has similar functionality. Jini is not
`RMI (Remote Method Invocation). While Jini uses RMI facilities for mobile code, Jini is a set
`of services and conventions built on top of RMI. Jini is not a Distributed Operating System; Jini
`is only aware of services and has the facilities for finding those services. Jini is not middleware.
`Consequently, it does not create communication links between common commercial databases.
`In the current Jini implementation and specifications there is no authentication performed on
`either the discovery requests or responses [1].
`All of the components for Jini are implemented as a set of software libraries and conventions
`that are used by the code that participates in Jini communities. Jini has five key components:
`Discovery, Lookup, Leasing, Remote Events, and Transactions [6].
`
`3.2. Discovery
`The Discovery component is the process used to find/join communities on the network.
`Discovery is responsible for the spontaneous community-building properties of the system.
`Once a community is found, the Jini-aware entity can step through a series of conventions to
`become part of the community and publish services to the community. The Multicast Request
`Protocol is used when an application or service first becomes active and needs to find a nearby
`lookup service. The Multicast Announcement Protocol is used by lookup services to announce
`their presence. The Unicast Discovery Protocol is used when an application or service already
`knows the particular lookup service required. The process of publishing a service to make it
`available to others in the community is called joining [6].
`Currently Jini has been implemented only on IP networks. Based on the Discovery/Join
`specification from Sun, IP addresses may be statically assigned to some hosts and other
`components may be dynamically assigned. Any Jini-aware entity must have a properly
`configured network stack capable of UDP multicast and TCP unicast messages. (Figure 2)
`Service
`
`1. The discovering entity
`performs a multicast request in
`order to find lookup services.
`
`2. Lookup servers listen for
`multicast request from
`discovering entities.
`Lookup
`Service
`
`3. The lookup server sends a unicast
`response to provide a reference to itself.
`
`Service
`
`4. Entity joins the community
`and publishes its “proxy object.”
`
`Lookup
`Service
`
`Figure 2. Discovery Component
`3.3. Lookup
`The Lookup component is responsible for distributing code to participants requesting a service.
`Lookup fulfills the role of a directory service within each Jini community. It provides facilities
`
`4
`
`Ex.1028
`APPLE INC. / Page 4 of 12
`
`

`

`for searching and finding services that are known within a community. Lookup tracks all active
`services and listens for join requests. Lookup also provides detail information about the services
`running.
`Each active service contains a Java object called “proxy object1 ”. Other participants in the
`community can download the proxy object to use the service. When an entity needs another
`service, it will query the Lookup Service by a unique identifier or attribute. Once the service is
`found, the proxy object is downloaded to their JVM and the entity will make calls on it to use the
`service. This idea of downloadable proxy objects gives Jini its ability to use services and devices
`without doing any explicit driver or software installation [6]. (Figure 3)
`
`Lookup
`Service
`
`Service
`
`1. Client downloads
`“Proxy Object.”
`
`Client
`
`2. Client communicates with
`service via proxy
`
`Figure 3. Lookup Component
`
`3.4. Leasing
`The Leasing component is a technique that provides Jini’s self-healing nature. Leasing is based
`on the idea of leasing resources for a fixed period of time rather than granting access to a
`resource for an unlimited amount of time. Leases expire after a predetermined amount of time
`unless they are renewed. Leases are always defined in terms of time duration instead of a
`specific time in the future [6]. If a service becomes unavailable, either intentionally or
`unintentionally without cleaning its components, its lease will eventually expire.
`
`3.5. Remote Events
`Remote Events allow services to notify each other of changes in their state. Jini services, like
`many software components in a system, need to be notified when some interesting change
`occurs. Asynchronous notification messages are sent directly to a software component instead of
`polling for changes. Asynchronous notifications can often simplify the programming of
`components. Jini, like most of Java, uses events to do asynchronous notifications. An event is
`an object that contains information about some external state change that a software component
`may be interested in. RMI is an event notification built into Java, which allows objects to move
`across the network to be executed. The Lookup service can use remote events to notify
`interested parties when the set of services, available to a community, changes [6].
`
`
`1 A “Proxy Object” is a list of attributes that are used to describe the service. This object contains all the
`information to use and configure the service.
`
`5
`
`Ex.1028
`APPLE INC. / Page 5 of 12
`
`

`

`3.6. Transactions
`Transactions provide the mechanism used by Jini to allow computations that may involve
`multiple services to reach a safe state. Jini’s transaction model helps guard against problems
`produced by partial failures in a distributed system. Transactions are how a series of related
`operations are grouped so that the outcome of the transaction is either a failure or a success. In
`either case the system will handle the outcome correctly. It will continue with the process if the
`transaction succeeds or try again later if the transaction fails. The protocol commonly used by
`such systems is called two-phase commit [6].
`
`4. The Competition
`In this section we searched the market place to find products that could offer competition to Jini.
`Since Jini is a new concept and technology, exact matches as in searching for PC operating
`systems, were difficult to find. We did find three possible competitors, Microsoft Millennium
`and Universal Plug and Play, Lucent’s Inferno, and IBM’s T-Spaces. These products were
`selected based on their ability to provide automation and new services in telecommunications.
`Automation is further defined as the combination of impromptu networking capabilities and
`fewer administration duties. Once these products were identified we investigated the
`technologies of each and the possibilities these technologies enabled. We then ranked the
`products according to services, configuration, maintenance, scalability, and portability. Services
`are defined as those currently offered and the potential for new or other services. Configuration
`refers to the amount of effort required for installation configuration. The maintenance ranking
`reflects ongoing configuration and administration. Scalability is the ability to grow or shrink as
`needed. Portability is the ability to run in different environments.
`To summarize the Jini System Components section, Jini has a small footprint, it is robust and
`able to dynamically connect any array of devices or appliances and provide services only limited
`by the imagination. The configuration and maintenance is minimal but Jini has the flexibility to
`configure very specific uses. Naturally, this would increase configuration and maintenance
`efforts. Scalability is dynamic based on the Discovery, Lookup, and Leasing features of Jini.
`Portability is also excellent, needing only a Java enabled device or platform. This is all reflected
`in Sun’s stated goal of Jini: “. . . to make a network flexible, easy to administer, and provide
`dynamic use of its resources to humans of computational clients.” [7].
`
`4.1. Millennium and Universal Plug and Play (UPnP)
`Microsoft is currently researching and developing two projects that may provide competition for
`Jini. The two projects are named Millennium and Universal Plug and Play. “The goal of
`Millennium is to erase the distinction between distributed and local computing by turning a
`network of computerized devices into one giant computer that resembles the human brain,
`allocating resources efficiently to accomplish each task” [8]. “The goal of UPnP is to make a
`network easy and convenient for the average consumer” [9]. With UPnP, Microsoft supports
`seamless connection of household appliances to a network. Therefore, bringing UPnP closer to
`the Jini vision. Both Microsoft projects compare themselves to Jini and each other. It will be the
`melding of these two projects that would bring competition to Jini.
`Millennium research is broken into two areas with supporting prototypes. The first is a high-
`level application runtime environment that raises the level of abstraction to simplify the
`presentation to programmers. The second is a low-level infrastructure and distributed services
`
`6
`
`Ex.1028
`APPLE INC. / Page 6 of 12
`
`

`

`that are self-configuring and self-tuning. Millennium accomplishes the first area by something
`called Coign. Coign automatically distributes non-distributed (local) Common Object Model
`applications. Coign has four components, which work together to profile applications. The
`components are Run Time, Binary Re-writer, Analysis Profiler, and Network Profiler. These
`components work together to analyze and profile applications for the best distribution scheme to
`be used on future runs of the application [10]. To effectively enable Coign to distribute an
`application, it takes multiple iterations of analyzing and profiling the application. These profiles
`must be conducted again as new releases of the application, operating system, service packs, and
`service releases are installed. This makes configuration, maintenance, and scalability very labor
`intensive. Coign is very dependent on the success of Falcon and Component Operating System
`Proxy (COP), two current research projects from Microsoft. If either of these prove unable to
`perform, the whole concept could be rendered useless.
`COP and Falcon accomplish the second area of Millennium. COP, a Win32 application
`program interface, coupled with Falcon, a highly optimized version of Distributed Common
`Object Model, allows computers to share attached devices. Devices and peripherals can be
`shared across different PCs regardless of location. This creates what Microsoft calls the
`disaggregated PC. This process is bandwidth and media dependent. And, it only applies to a
`pure Microsoft environment. Clearly, Millennium could offer only a couple of services. The
`configuration efforts would be enormous. With labor-intensive configuration and maintenance,
`scalability becomes impractical. In regards to portability, it is not possible because Millennium
`is PC, Microsoft application, and Microsoft OS centric.
`UPnP is based on the existing standards for Plug and Play [11]. This technology and
`standard is already proven and supported by numerous manufactures. The protocols are network
`and media independent. The intent is to cover all types of networked and traditional peripheral
`devices. UPnP supports Discovery and Configuration using Extensible Markup Language and
`standard URL addresses. This provides an avenue for devices to negotiate a common protocol to
`communicate. This is different from Jini, which provides a translation service between
`heterogeneous devices. UPnP offers a number of services like Simple Service Discovery
`Protocol, Dynamic Host Configuration Protocol - Auto Configuration and Multicast-enabled
`DNS. These services basically support the needs of UPnP to function. The configuration and
`maintenance for UPnP is relatively light, it basically happens when a device is loaded with
`software. A mechanism for device driver updates would have to be developed or would require
`manual updates. Scalability is dynamic due to the Discovery and Configuration support.
`Portability is dependent on manufactures accepting and supporting UPnP and Internet protocols.
`However, it will take the melding of all the Microsoft efforts previously discussed to provide real
`competition for Jini.
`
`4.2. Inferno
`Lucent has created a product called Inferno. Lucent’s goal is for Inferno “to become the
`operating system for the net-centric era”[12]. Inferno is marketed and supported by Vita Nuova
`from York, England. It is network and media independent. The biggest benefit of Inferno is the
`500 Kb kernel. It will run as an Operating System (OS) on a device or emulated on another
`operating system. It currently runs on NT, Windows95/98, Linux, and Sun Solaris [13]. Inferno
`is designed to be a robust OS on the smallest of environments while providing a host for a wide
`variety of applications. The Inferno kernel and one of its applications will run in just under 1
`MB. Inferno uses Limbo as the programming language whose architecture and functions are
`
`7
`
`Ex.1028
`APPLE INC. / Page 7 of 12
`
`

`

`similar to C and Java. It is compiled into byte code, which is run within a virtual machine (DIS)
`making it portable. Inferno uses the Styx protocol for communicating to other Inferno devices.
`Styx uses a uniform interface and runs on any reliable data stream protocol.
`Inferno provides many services and the possibility for many more. Current services include
`PKI, POP3, SMTP, HTML, Ethernet, infrared, cable, satellite, sound card, and video card
`support. Scalability is excellent since the kernel size is 500 Kb. Configuration would be heavy
`since drivers for new devices will have to be written. Maintenance would also be heavy as
`devices change. However, with the development of an automated service to handle many of
`these tasks, Inferno would probably jump to the front of the competition list. From a technology
`standpoint Inferno is positioned to be a major player against Jini. In Lucent’s recent alliance
`with Vita Nuova, Lucent will continue to develop enhancements jointly while allowing Vita
`Nuova exclusive marketing and support [14]. This new alliance is a step in the right direction to
`gain popularity of this product in the market place.
`
`4.3. T-Spaces
`T-Spaces, developed by IBM, is being portrayed as a network communication buffer with
`database capabilities. T-Spaces is considered network middleware. Due to the lack of a stated
`goal it is better described as an enabler of communications between applications and devices in
`a network of heterogeneous computers and operating systems. T-Spaces provides group
`communication, database, URL-based file transfer, event notification, print, e-mail, pager,
`remote control services, transactions, indexing, and simple queries [15]. The possible services
`that T-Spaces can provide are endless as long as the devices support Java. T-Spaces is
`implemented in the Java programming language and thus it automatically possesses network
`ubiquity through platform independence, as well as a standard type representation for all data
`types. Portability, like Jini, is restricted to Java supported devices and environments but may be
`limited due to space requirements. Scalability is questionable due to the needed coding for
`services. Therefore, configuration and maintenance for T-Spaces would be enormous.
`T-Spaces started off in the right direction. They built the technology on a sound foundation
`but they lacked the vision to carry the possibilities into the future. It will communicate with any
`Java enabled device but they do not suggest or provide any visionary examples. Therefore, it is
`up to the creativity of the users to decide how to use the product.
`The table below summarizes the measurements for all the products. With our vision of these
`products providing or
`their ability
`to provide automation and new services
`in
`telecommunications all metrics are weighted equally.
`
`METRICS
`Services
`Possible Services
`Configuration
`Maintenance
`Scalability
`Portability
`TOTAL
`
`Jini
`• • • •
`• • • • •
`• • • •
`• • • •
`• • • •
`• • • •
`26
`
`Millennium
`• •
`-
`•
`•
`•
`-
`5
`
`UPnP
`• •
`• •
`• • •
`• • •
`• • • • •
`• • •
`18
`
`Inferno
`• • • • •
`• • • • •
`• •
`• •
`• • • • •
`• • • • •
`24
`
`T Spaces
`• • • •
`• • • •
`•
`•
` Unknown
`• • •
`14
`
`Table 1. Product Comparison
`When choosing a product it is unlikely one will find a single product to meet all the desired
`needs and criteria. Looking at all the products and projects investigated, Jini meets the criteria
`
`8
`
`Ex.1028
`APPLE INC. / Page 8 of 12
`
`

`

`and provides the best ranking on measurements. Inferno is close to what Jini stands to offer.
`However, it needs to continue maturing and offer more out of the box services. This will reduce
`the configuration and maintenance efforts. Microsoft also stands a chance of competing with
`Jini. They will need to reduce the complexity in Coign and COP, and combined UPnP and
`Millennium to offer services closer to that of Jini. The fact that Microsoft holds the majority of
`the market share for deployed technology gives them an almost unfair advantage. Which
`product will fare the best? Speaking from a technology standpoint, Jini and Inferno are very
`close. However, we all know that just because a product is technologically sound, it is not
`always the choice of the industry. Marketing, current market share, and ease of accessibility
`have often pushed a product to the top in terms of market share.
`
`5. Jini Technology and Its Ramifications on Business
`During a time of unprecedented outsourcing and downsizing activity, unemployment in the
`United States is at record low levels. The explanation for this is quite simple: companies are
`shrinking. In fact, the U.S. department of Labor predicts that by 2005 the largest employer in the
`country will be “self”[16]. This underscores the reality of the shrinking size of U.S. firms. But
`people in the U.S. workforce are not becoming unemployed. Rather, they are moving from
`larger firms to smaller ones. The driving force behind this trend is digital technology. While
`driving firm size down, the need for digital technology is fueling an unprecedented need for
`technology expertise. Impromptu networking, such as that made possible by Jini technology,
`will help sustain and accelerate this trend.
`MasterCard is an instructive example of this trend. Of the 1000 employees at MasterCard,
`800 work in data processing. This is noteworthy on two counts. First, it is a testament to
`productivity enhancing benefits of digital technology; that a company handling millions of
`transactions daily has only 1000 employees. Second is that 80% of this companies employees
`work to support digital technology [16]. Information Technology (IT) has increased twice as fast
`as the economy on a whole. IT investment as a percentage of all equipment purchased by
`companies is forty five percent [17]. These facts suggest that as firms shrink, a larger percentage
`of resources must be devoted to implement and support digital technology increases. Indeed, the
`percentage of expenditure for firms on IT related support and software has greatly increased
`since the first personal computers came to market. This can impose a lower limit or “floor” on
`how much firms can shrink or how efficient they can become.
`
`5.1. Hitting the Floor
`Today, implementing and supporting PC networking requires specialized expertise. The need for
`such expertise is demonstrated by the growing requirement of many companies that technology
`workers be “certified”. This certification comes at a price2. The dominant network operating
`system businesses use is Windows NT. This operating system is of a magnitude that rivals
`“mainframe” class platforms. Windows NT 4.0 consists of 16.5 million lines of code. The next
`version of Windows will have over 45 million lines of code and will be a complete re-write of
`the operating system. There is no expectation or intention that this program will ever be fully
`debugged. Sun’s Bill Joy recently commented: “We know Moore's Law will run out sometime
`around 2010. It's probably not going to be a crash into the wall. Things will just start slowing
`
`
`2 Microsoft’s System Engineer Certification (MCSE) and the even more rigorous and valuable Microsoft
`Professional + Internet Certification (MCP+I) results in an annual salary increase of approximately $4,600 [18].
`
`9
`
`Ex.1028
`APPLE INC. / Page 9 of 12
`
`

`

`down. We've been getting a free ride with Moore's Law. We can write worse and worse
`software, and the machines just get faster and faster and cheaper and cheaper -- and they cover
`our tracks.” Despite Microsoft’s claims that the Windows network operating system is
`“intuitive”, implementing and supporting networking on this platform requires specialized
`expertise. The need for, and value of, such expertise is demonstrated by the growing
`requirement by many companies that technology workers be “certified3” through formalized
`testing as a requirement of employment or advancement. This expertise comes at a price (On
`average, Microsoft certification results in an annual salary increase of approximately $4,6004).
`While the smallest firms (those with ten or fewer employees) often utilize PCs using
`Windows on a stand-alone basis, few implement networking5. The impact of impromptu
`networking will be the greatest for small businesses, where the benefits of networking have been
`largely missed. Jini will greatly reduce the need for specialized technology expertise by making
`computing, networking, and telephony virtually effortless. Historically, the reasons small
`companies have been slow to deploy networking have included:
`1. A Lack of Vision: In the past, small companies have not appreciated the benefits that
`networking can afford them. The popularization of the Internet has largely changed this
`today.
`2. Infrastructure Issues: Wiring existing buildings with networking cable has been an
`expensive and disruptive process. This has been addressed through the proliferation of
`products on the market today that allow small firms to implement networking over their
`existing telephone wiring, power wiring or completely wirelessly. The availability and
`affordable pricing of these solutions have just come about recently.
`3. Complexity and Expense: Complexity and cost are the remaining impediments to
`smaller firms
`implementing networking.
` Jini
`technology (and possibly other
`technologies that simplify networking) is poised to address this issue.
`While the idea of truly effortless networking may seem alien, the telephone network today is
`a good example of how transparent networking can be. Telephones are the ultimate “plug-and-
`play” device. Jini provides what you can think of as “JavaTone”, the equivalent of what happens
`when you pick up a telephone. Since the services that Jini links can be hardware, software,
`communication channels, or users, the utility of “JavaTone” is enormous.
`
`5.2. The Cost of Doing B