This page is the starting point for all information about the Z Directory. Below you will find a basic overview about it. Or see the Frequently Asked Questions page (sidebar). If you have downloaded it and are ready to use it for the first time, the user's guide section, or quick start guide would probably be of best use. Finally, for more detailed usage information, there is the reference manual.

All information and documentation currently is found in this web site. A simple, hopeully not-too-technical discussion for laymen not familiar with the process of writing software is presented in the "real simple" page. If you are interested in face-to-face learning, you will need to contact us .

THE Z DIRECTORY: INTRODUCTION

Overview.



The Z Directory is a general-purpose, commercial toolkit / library for C++ software. Programmers use its objects and functions, linking to the Z Directory libraries during compilation. An assortment of real-world components are provided in order to reduce the amount of code put into the application. This library makes it significantly easier to develop a wide variety of software programs. The Z directory is not a typical engineering system, since it was not custom-built for a specific purpose. It is intended to be completely context-free, so that you don't need a specific run-type environment or particular software to run it on.

The Z Directory provides many objects, in the context of computer software object-oriented programming. They are pre-written and are provided in binary form, found inside a set of library archive files. The objects may be accessed by writing software code that accesses them. When programs are created, the compiler (itself simply a software program) will figure out how to link the code that accesses these objects to the objects themselves (found in the libraries that Vettrasoft provides).

An analogy: imagine a computer program to be a car. Then, the Z Directory would provide car builders with components: carburators, camshafts, drivelines, wheel bearings, calipers, disk brakes. It is o-o "compoent-ware" for programmers. Furthermore, all these components are integrated: no worry about connecting a carb measured in (English) inches to a manifold measured in (Metric) centimeters. The Z Directory provides seamless and uniform interfaces.

The Z Directory objects are not limited to a specific domain. In this way, the Z Directory differs from most other software API-libraries. For instance:
  • STL (Standard Template Library): provides software containers (arrays, linked lists, maps) only.


  • Adaptive Communication Environment, or "ACE": code for real-time programs, dealing with interprocess communication, event handling, and concurrency.


  • Rogue Wave: various objects - in this way they are closest akin to the general-purposee aspect of the Z Directory. However, the two systems are quite different.


  • several libraries for networks, especially sockets: GOBLIN, Komodia, OpenLDAP, Marshallsoft, Network Library Directory, Net.h++ (by Rogue Wave), SNMP C++ Library, SocketCC, RockSaw, C++ class socket library, etc.


  • A plethora of GUI and graphics toolkits: Fast Light Toolkit, or "FLTK" (C++ GUI toolkit for UNIX); GTK+; wxWidgets (for Microsoft Windows); Qt and Wt (web-oriented UI); etc.




What the Z Directory is not:

The Z Directory is designed to work in many types of software applications. The intent is to be context-free of any GUI, operating system, database, or network protocol. It can work as an adjunct to a web server but is not limited to web material. It does not require DOM, or AJAX, or a specific database. It is not limited to MFC or linux or X Windows. You don't need to tie it to an LDAP server. It is not limited to mySQL, and is independent of gnu. It is almost completely self-contained (however you do need to specify an SQL database). Also, the Z Directory is not an IDE. It is not a program that gives you a cocoon to write code. We write the code; you assemble the components that you need to use in the creation of your program (and you would probably use an IDE to do that).


The Z Directory (as of 2010) currently deals with the following subject matter:
  • object - database storage. You can store and retrieve objects, so their state can extend beyond the lifetime of a program's run. This is not the same as an o-o database. The Z Directory provides a simple mechanism for writing objects to a database, but it does not supply the database.


  • data representation. "Data bags" are a way to store data in text stings. The data may be put into lists or a matrix and can recurse. The format is defined by a meta-data schema. This may sound suspiciously like XML. Once again, the data bag concept pre-dated XML, having existed in the early- to mid-1990's. Whereas XML focuses on HTML and web applications, data bags are to be used by programs written in C++.


  • message transport. The problem of moving a block of bytes from one place to another is a major topic in software engineering usually assigned to the category of networks. the Z Directory has code to do it with the following defining characteristics: (1) an address class set is provided to address the topic of defining a location. There are many types of addresses: internet, web, computer memory, e-mail, postal, etc. (2) the interface for moving a block of data over a circuit (a path between an originating and destination address) has no reference to the implementation. Typically the mechanism is sockets, but with the Z Directory, this can also be via shared memory (if within the same host computer), TLI (if within a system V unix environment), or other transport system.


  • containers. The Z Directory provides template-based containers to store your data: linked lists, arrays, stacks, and [coming soon] trees. You will probably immediately think STL. the Z Directory's container interface is a bit different, and you might find, simpler. The same member function names are used irregardless of the implementation. Peering into your data in a debugger is much easier than with STL. There are other differences.


  • string and text processing. One common complaint opponents of C++ use is the lack of tools for managing strings. The Z Directory attacks and destroys this argument. String operations include regular expression searches; extracting words, sentences, and quoted text sub-strings; trimming lines; string to type conversion; monetary formatting; concatenation; white-space processing; and much more.


  • encryption. Most of the well-known ciphers (ie encryption and decryption) algorithms are included, such as DES, blowfish, Rijndael (AES), and RSA.


  • postal addresses. Strings containing addresses can be easily parsed. Currently only American addresses are fully handled. We expect to grow this to encompass all addressing formats used world-wide.


  • mathematics. Several math functions are provided, including factoring, modulus, GLB and LUB, summation of a series, random number generation, linear regresion, mean averages, standard deviations, angle math and conversion (degree - radian), etc.


  • time and date. If you ever need to get the current time/date, and then add or subtract a span of time to/from it, the Z Directory provides unparalled ease for that. You can add say 1 week 3 days and 15 hours to any given date and get the result with only a couple lines of code.


  • threads and semaphores. In a Microsoft environment, you would need to use functions such as CreateMutex(), WaitForSingleObject(), and ReleaseMutex(). In some unix environments, the corresponding calls would be pthread_mutex_init(), pthread_mutex_lock(), and pthread_mutex_unlock(). Or, you can use the Z Directory and use a single function call, instead of learning the specifics for each operating system to intend to port to.


  • clients and servers. There are a set of classes dealing providing client-server architecture. A dispatch mechanism forwards a message to your message processing code when it arrives to a server.


  • error processing, logging, tracing and debugging. An elaborate but general-purpose group of classes help you manage what to do in case of an error, above and beyond the simple mechanics embedded in c++. You can create event logs and control when a message is to be generated. You can control when a message is created, and to where it is to go.


  • Files and directories. In Microsoft, directories are called folders. Once again, by using the Z Directory you need not concern yourself with the specifics of any particular operating system. How to read the contents or traverse them is handled by a simple set of classes and routines in the Z Directory. Creating, removing, renaming, opening and closing a file or directory are handled in a portable fashion. You can do things like add text to a file, get a line of text or a specific number of characters.


  • more, including: e-mail management; exam questions and answers; money operations; packetization; HTML operations; and classes for worldy items such as people, businesses, and telephones.


One fact: Z Directory is devoid of graphics utilities. Writing tools for GUI programming is a specialized, big, never-ending work sink. We have decided to focus on more 'framework' issues. Also, there are plenty of libraries out there dealing with GUIs and graphics.


One primary goal is to simply provide object for real-world constructs, so that you need not write it yourself. Another goal is to provide a single uniform base of code - you won't need to link to several libraries provicded by multiple vendors, then deal with the resultant problems. You should be able to use it along with other libraries.

Our approach is to provide an 'all-in-one' solution. This mitigates the complexity of dealing with multiple sources. If you are an automobile manufacturer, you may prefer to deal with a vendor that supplies a complete engine with drive train, rather than purchase carburators, transmissions, and engine parts from separate sources, then putting it all together. The downside is the limitation of choices. You may want to mate your engine with either or both of say Stromberg or Holly carburators, or put in a camshaft with a different lift from that provided by your one-stop shopping vendor.

You can argue that the Z Directory provides the same or similar functionality found in other systems. STL is an obvious example. The Z Directory started its containers about 1990. STL got more advertising, hence it is more well known. We think ours is easier to use and has a better interface. In the case of message transport, there are other library-toolkits out there. The Z Directory interface is easy to use, and is independent of the implementation (a common trait in the Z Directory). Since point-to-point (eg circuit-based, or stream) message transport requires knowing the source and destination, a class of objects for specifying the address was created. This has turned out to be very useful. The concept of address exists in many contexts: internet (IP), e-mail, socket, computer memory location, even postal addresses. With our scheme allows for universal messageing: a message can be delivered across contexts, in many cases (we haven't yet found a software solution for sending a byte stream to a postal address, though).

Architectural considerations: often many design decisions are done that locks in place a system behaviours, implementation, or architecture. Changes to a system become more difficult as the system is developed. Since the Z Directory's different approach provides a toolkit, care is done to avoid locking into a specific approach.

Example: an alert and monitoring system. The concept of an alert can be implemented as an object. It relates closely with monitoring. One can monitor hardware in a computer network, telephones in a building, a heating system in a skyscraper, or a vehicle tracked via a GPRS system. A component in a system would generate an alert. Monitoring is often done by an operator at a computer console display. The status of object monitored can be represented as a color. If a system is built to represent an object's status with a color, that system is useless on a black and white terminal, or on a telephone with no display. The mistake was to assume that color should be tied to an object's status. Also, the alert needs to get to the point where it is to be monitored. Building a specific transport method would invalidate its use on a different method. Eg, an SNMP-based alert message would be useless for a telephone-based notification if a house was being broken into. In fact, the transport mechanism is a completely separate object and should in no way be tied to the alert mechanism.

The Z Directory is a large, comprehensive, and mature system. If you are involved in software development, programming, or computer science in any way, and are unfamiliar with the Z Directory, it would be worth your while to spend at least a little time exploring it.




History and evolution: past, present, future.



In the 1980's, the Z Directory was called the X Directory. It was renamed to the Z Directory after the X-Windows system came out. The 'Z' is an indication that this is the final system. In the beginning, it ran on Sun unix operating systems. After 2000, the focus was on a port to Microsoft OS's, which is the current offering.

Although the Z Directory was started in the mid 80's, it has a long journey ahead. There are many exciting plans for it on several levels. Some objects will improve both in internal implemenation and additional functionality. More layers will come. New subject matter domains will be incorporated. More platforms and environments (such as operating systems and databases) will be added. Some immediate improvements envisioned will be the ability for you to create your own objects that can be stored and retrieved in a database ("orthodox objects"); parsing of non-American addresses; and conversion between data bag and XML formats should be forthcoming soon.

As your software grows and improves, so does the Z Directory. Instead of what-you-see is what-you-get, you will get more with each version. This doesn't mean you will need to rework your software with each new revision. Since the Z Directory is mature, its interfaces are secure. However, in almost all software systems there comes a time when an overhaul is necessary. If so, all efforts will be made to minimize the impact on you and ease the transition. This shouldn't happen for quite a while.

In the more distant future, the hopes are to include AI-oriented subject matter, such as neural nets, expert systems. Also anticipated would be more mathematics. Vettrasoft encourages feedback from the user community, so that we can see the trends for what important areas of improvement are best needed.




Using the Z Directory.



Currently (mid-2010), you will need a Microsoft operating system with Visual Studio installed to use the Z Directory. There is an installer program, but library and include paths still need to be set up in Visual Studio. Please see the "quick start" or "user guide" pages for step-by-step instructions on configuring your machine for the Z Directory. A fast way to get up to speed is to peruse the case studies for building various application programs. That should give a good over-all sense how to use the Z Directory.




Education: becoming a Z Directory expert.



At present, all documentation is on this web site. The near-term plans include documentation in book format and adding forums and discussion groups here. If there is sufficient interest (write us), we will arrange for group classes. All comments and suggestions are welcome.




*** FATAL ERROR in "add_webhit()":