BauHaus is a package of Java classes that allows the user to simulate a network's configuration, adding levels of detail in a top-down manner. The output can be customized to a Customer's specifications and applied to software testing, electronic commerce, and training.

The present version is 0.9.5.

BauHaus makes network configuration look easy and frees the user from painstaking work: answering a few nontechnical questions is enough to fill and connect everything properly. There are four ways to view it:

Using a browser:

• If the browser supports most of the features in version 1.1 of the Java API, simply review the Tips given below and click here.
• If that does not work, then the browser may need the Java Plug-in to support version 1.1 of the Java API. Follow that hyperlink's installation instructions, review the Tips given below, and click here.

(To rerun the simulation, guide the browser back to this page and click on the appropriate hyperlink again.)

Using the JDK (Java Development Kit):

• The AppletViewer is the preferred way to try the package because it gives the most control. Its "Stop/Restart" capability is useful when running the simulations repeatedly. Review the Tips given below and enter "appletviewer http://www.abl.com/The_Wireless/BauHaus/hotJava.html" in a command-line window.
• The Java Interpreter can run the Java archive (JAR) file as a standalone application. However, this approach bypasses the built-in security of the applet approach. While BauHaus does not violate any security guidelines, we do not want to encourage any bad habits -- unless you insist. Review the Tips given below and enter "java -classpath bauhaus.jar BHcontrol" in a command-line window inside the download directory.

Tips

First, the BauHaus Console window will appear and then display some initialization messages. A BauHaus Survey window will appear each time (presently, five times) the system has a configuration question for the user. (Running as an applet, a warning message will appear in each window. This is a reminder that the security features are enabled.) While the size of the network can be arbitrarily large, it is limited by the user's patience. Note that the "data" network has a troubleshooting ("spy") network superimposed on it:

1. begin with the defaults to view a simple example of output (in the BauHaus Console);
2. then choose one Building and add a few more Subnets (3 or 4) to the Floors and see how this affects the connections in the Wiring Closets and the Basement;
3. then add a few more Floors to the Building and see how the Basement changes;
4. then add a few more Buildings, keeping defaults for the remainder, to see how the NOC (Network Operating Center) changes;
5. experiment.

The viewed behavior hints at the three-layer architecture of BauHaus: The initialization messages are in the "parameter" layer; the survey, which asks the user to inspect any ambiguous parameters, is part of the "configuration" layer; and the "output" layer handles the display of the network connections. The "configuration" layer manages the build-and-connect aspects of the simulation, and the "output" layer essentially unravels the resulting data structures.

This simple architecture will aid our future development of BauHaus. There is a lot of technology that can still go in the package -- we just need to find more applications that will benefit from a simulation which builds large enterprises/networks. The immediate benefits will primarily come from the "output" layer. For instance, we can customize the output to generate customer-specific configuration files (for demonstrating, testing, or setting up software) and "transactive content" for electronic commerce (such as a bill of materials).

These additions may, in turn, make demands on the other two layers, such as more sophisticated data structures in the "configuration" layer or user parameters in the form of "text/Tcl rules" or "palette objects". In any event, this working implementation of BauHaus will serve as the scaffolding for future development.

Relevant to "transactive content" for electronic commerce, one goal of BauHaus is to let the user simulate network-design alternatives and determine what they need to make their network better. BauHaus simplifies the process and helps minimize the "page-to-purchase" ratio. Currently, our network model adds increasing levels of detail in a top-down manner. We could extend this approach to guide the detailed, vendor-specific configuration of NetDevices. Thus, BauHaus could help configure built-to-order NetDevices with software options, interface modules, memory, power supply & cable, etc. -- all detailed on a bill of materials.

(For more on "transactive content", which blends transactions and interactivity, please read "Sizing Commerce Software".)

Moreover, as networks themselves become "intelligent fabrics", the user will need to extend BauHaus: emulating the function of certain NetDevices, allowing changes to topologies, and using emerging technologies could help to investigate their impact on network implementation strategies. The user could manipulate parameters in the form of "text/Tcl rules" or "palette objects": a Java Bean, the parameters of which can be inspected and edited graphically, would represent a "smart device".

Subsequently, as we implement more options, a Physical View (a level browser or tree) may furnish helpful, visual feedback during the more detailed surveys. A "hierarchical data editor" would be useful in a design that allows extensive editing of choices, branches, and other parameters.

In the "output" layer, a Connections Graph could provide a simple logical view of the network and serve as a graphical representation of a configuration file.

The project is named after the Bauhaus ("house building") school of design to reflect its function (network construction) and form (which we developed using the Fusion method of object-oriented analysis, design, and implementation). BauHaus frees the developer from extensive programming: the developer simply requests a "new PortBox" and then directs that PortBox to display itself. In Java, this looks like:

      enterprise = new PortBox(); //build the network
      enterprise.printNetwork(); //view the configuration

That is, BauHaus is a package of classes that uses the PortBox class as its "facade" or point of access. The Java archive (JAR) file for BauHaus contains the simulation package and a simple control class, with its source to show how to use the package.

Last modified: 2/10/2000