TracerX: Connectivity Tools
for Systems Integration

Contents

• Introduction

• Challenges to systems integration

• Tracer design philosophy

• TracerX as an integration tool

• Conclusion

Introduction

Two major challenges exist.

First, to share information effectively, it is necessary to resolve the basic incompatibilities that exist among software programs, operating systems, hardware, and communication components. Industry standards provide some relief but often fall short as vendors try to differentiate themselves with new, "improved" technologies. Secondly, integration tools available within standard software packages do not always work, or are as easily implemented, as advertised.

Clearly, companies need a tool that can easily integrate and adapt software applications to meet unique business requirements. TracerX is such a tool.

TracerX provides a Windows-based development environment with simple, high-level tools for connecting software applications. The TracerX runtime executes user-specific procedures, reacting to events while gathering, transforming, and distributing data among multiple programs and devices.

TracerX provides three important advantages:

Add "features" to your existing application. TracerX is not simply middleware, it is "extensionware"; it extends the capabilities of standard software. Do you need to add a customized dialog box, database, or error-checking routines? Use TracerX. Do you need to perform mathematical calculations, logic functions, or send key strokes to other programs? Use TracerX. It sits in the middle of your applications and helps you work the way you need to work.

Add integration "hooks" to your existing application. Whether you need to exchange data with a DOS or Windows application, Web site, legacy host system, scale, or other device, as far as TracerX is concerned, integration can be achieved in a few simple steps. Because TracerX programs are small and easy to read, you can easily change procedures as your needs change.

Attach to popular software programs. Tracer has pre-established TracerX interfaces to many "best-of-class" software programs, including shipping, compliance labeling, forms processing, data collection, and EDI translation products.

TracerX picks up where industry standards leave off.

Challenges to systems integration

The real world contains new technology that, in many cases, has barely been tested, specifications that are incomplete, shifting user expectations, and legacy systems that refuse to go away. Integrating new technology with new technology is challenging enough. Integrating new technology with old technology is often impossible. The result is redundant data entry and overruns on cost-saving re-engineering initiatives.

To avoid integration issues, IT professionals try to find alternative solutions in all of the usual places:

Alternative 1: Find the Holy Grail - the software package that does it all Like the mainframe users of old, some companies try to find a single software product that meets all user requirements to avoid integration altogether. This truly is a challenge, given the unique characteristics of each user's work flow and business environment.

The single-source alternative presents a spectrum of choices. At one end of the spectrum are off-the-shelf software packages. Developers at this end, eager to capture a larger share of the market, try to build enough features into their software package to appeal to the needs of a mass audience. While this type of software is often lower priced because it is distributed more widely, it misses the mark in terms of delivering a solution narrow enough to address a specific user's needs.

At the other end of the spectrum is software that is more expensive because it is directed at meeting the unique requirements of a much narrower market, sometimes a single user. With this type of software there is a higher risk that the vendor will terminate support, having failed to generate enough interest in the market for a product oriented to one user.

Alternative 2: Find the most "flexible" software available Realizing that no single vendor can deliver the perfect solution, a user will frequently employ the 80/20 rule. They narrow their range of software choices to the products that can deliver 80 percent of the features they need. In anticipation of the final 20%, software developers provide configuration utilities that allow an end user to change the default characteristics of the system. Unfortunately, these utilities usually fall far short of meeting a user's needs.

This setup utility approach also introduces crucial tradeoffs. The more extensive the range of possible configurations, the more bloated the software program. Additional software overhead impacts reliability and performance. In the stability vs. flexibility tradeoff, the user almost always loses on both counts.

Alternative 3: Ask the software vendor for custom programming Setup utilities may narrow the choice of software to the final 10% of functionality. The competition among the remaining software vendors is even more fierce. Undeliverable promises are made. As the pressure to make the sale intensifies, software developers will often yield to pressure and customize their application. In doing so, the developer takes the software out of the mainstream, creating a one-off product with an extremely narrow market.

Custom software requires a unique support structure, documentation procedure, and upgrade path. In practice, vendors seldom accommodate customized software. Customized software become "special" support cases. Ultimately, any issue that arises with custom software is suspect. As a result, custom systems are often bypassed when new software upgrades are made available.

Alternative 4: Build in-house applications from the ground up Instead of paying expensive customization costs, many users turn to in-house programmers to build an application from the ground up. The temptation to take this path is strong due to the availability of rapid application development tools and the existence of in-house personnel who have a better understanding of the business purposes an end-user is hoping to achieve. Unfortunately, this path presents difficulties and costs that are often greater than outsourcing custom development.

In-house development expertise and the technical resources are at an all time premium. IS departments are under siege, called upon by every segment of the company to maximize (and justify) the return on technology investments. Development priorities are often set by the "squeaky wheel", starting from the CEO down. Meeting individualized programming needs are low on the list of IS priorities.

Microsoft's Visual Basic and other development tools lessen the cost and time required to create new applications, but it is often difficult to build a production-quality application complete with all of the features that are readily available in time-tested, off-the-shelf packages. Long-term support and maintenance of 4GL applications is a problem. The original developer may leave the company. Modifying underlying 4GL code is difficult to support due to poor documentation. In many cases it is easier to re-create the application from scratch than attempt revisions.

Alternative 5: Aggregate features in the Windows environment Users ultimately come to accept the fact that no one software package can provide all of the features necessary to meet all needs. Most software packages are strong in some areas and weak in others. The Microsoft Windows environment has gained popularity because it provides a platform where multiple software programs can run at the same time.

While Windows provides users with the opportunity to run applications concurrently, it is hardly a "seamless" process. Moving from one application to another may require numerous keystrokes and still information may not be easily "shared".

Alternative 6: Use industry-standard interfaces The computer industry has promoted the idea that as long as software complies with industry standard interfaces, software integration is relatively straightforward. Anyone who has ever tried to make two software programs (not developed by Microsoft) talk to each other knows it is not easy. Even if a software program complies with DDE, OLE2, ODBC, and other integration standards, implementation requires a fairly high level of technical expertise and support by the software vendor. Have you called a help desk recently?

Integration standards can't guarantee a tight fit because software developers don't know exactly how their products will actually be used with other products. "Plug and play" standards may work well when integration involves a fairly predictable environment, but it is less realistic to expect trouble-free compatibility among components in more complex systems.

To make matters worse, no two developers implement industry standard facilities in exactly the same way. Software revisions, device drivers, and operating system versions must remain in synch just to make sure that the connections will work. Even if you can get all the players to the table consistently talking the same language, it doesn't guarantee they can carry on uninterrupted conversations.

Constant shifts in technology, changes in business direction, and management's desire for completing the return on investments for legacy systems only make matters worse. Finger pointing abounds.

Tracer design philosophy

One of Tracer's design principles is that reusable code (programming that contains the business rules and procedures that are central to a software package's central purpose and operation) should be separate from user-specific code ("customized" programming that changes from user to user).

Separating reusable code from user-specific code insulates applications from the destabilizing influences of customized code. The ultimate design objective is to deliver the user-specific feature as an independent procedure that can be modified and supported without affecting the reusable code. Tracer believes that many of the issues associated with customization and systems integration arise when reusable code is modified.

For example, shipping system software is designed primarily to comply with carrier rating, labeling, and documentation requirements. Many companies need to generate customized labels to meet specific customer compliance requirements. TracerX can add customized labels tasks to shipping system software without impacting the mission-critical operation of the reusable code.

TracerX as an integration tool

TracerX provides software developers with the benefits of the reusable/user-specific code design philosophy. The TracerX environment allows systems integrators to develop, compile, and run user-specific TracerX programs that augment, but are separate from, the base application. In effect, TracerX "grafts" custom features on to standard software.

There are three main benefits that differentiate TracerX from other languages:

1. TracerX is simple, fast, and easy to use.
2. TracerX is designed to be used in the field.
3. TracerX code is easy to support and maintain.

TracerX features a Windows-based development system, a full-function language, compiler, and runtime engine. Unlike many high-level development systems, running TracerX is highly efficient and transportable. It does not require installation of the entire development system to run. The run-time executable can be loaded from a single diskette. The entire development system consists of a single executable file.

TracerX's graphical development environment guides even the most inexperienced developer through projects that would otherwise take an experienced programmer weeks to achieve using another language.

TracerX is not "better" than other languages. TracerX was not developed to build software products. It is designed to achieve a much narrower purpose: to add incremental functionality and connectivity to existing software applications.

Traditionally, production quality integration is achieved with low level programming in a language like C/C++. Development is often slow and tedious. TracerX's high level language exerts low level control over a wide variety of industry standard integration tools, operating systems handles, and communication functions. TracerX provides diverse connectivity options Whether you are mapping data from a host system terminal session, serial device, ODBC, Internet web page, DDE server, or ASCII file, TracerX reduces complex integration tasks to two simple functions: Getfrom and Sendto. TracerX shields the developer and treats all data sources as "hosts". TracerX provides a common interface that can map "anything to anything".

TracerX manages the exchange of data among multiple applications

TracerX's powerful connectivity functions allow you to transform, condition, and transport data to and from up to 9 concurrent "host" applications. For example, suppose a user needs to transfer consignee name and address from an AS/400 order inquiry screen to a PC-based shipment processing application. TracerX can launch a 5250 terminal emulation session using an interface to Rumba, automatically capture data from the AS/400 screen, and send the data to Clippership, Tracer's multi-carrier shipping system software. TracerX can then capture carrier rate information from Clippership and send it back to the AS/400 screen through Rumba.

Using the example described above, in addition to "screen scraping" between Rumba and Clippership, TracerX could easily integrate compliance labeling to the shipment system application by launching a third host session to a labeling application, such as Loftware's LLM-WIN software. Additional host sessions could activate EDI transmissions, shipment confirmations over the Internet, or transmit serial data to a conveyor controller. To the end-user, the integration is seamless and transparent. To the IS professional, it's one less thing to worry about.

How do TracerX programs run? TracerX programs can be launched independently or directly from a software application. TracerX can also run in an automated fashion, monitoring and reacting to events on either a desktop or server.

Many software vendors have created interfaces within their products that contain TracerX 'triggers', calling TracerX programs at strategic points in the operation of the software. When TracerX programs are launched, it appears to the user as though the core software application executed the program itself.

In the above example, TracerX could be configured to initiate the procedure by several means: the shipping system could call TracerX directly, the TracerX program could run when a designated event occurs, or the operator could use a function key to call TracerX.

TracerX works best in environments with the following characteristics:

• Need to augment desktop application with user-specific features and functionality.
• Need to augment desktop application with connectivity.
• Desktop application is transaction oriented.
• Desktop application exists in mission-critical environment.
• Desktop users need national systems integration/implementation resource.

TracerX development system TracerX includes a development system specifically designed for use by field level personnel. Issues related to long-term support and maintenance are minimized because TracerX programs tend to be very small and easy to read. Integration tasks that would otherwise require thousands of lines of low-level code can be accomplished in a few lines of TracerX code. The result is integration can be easily supported and modified, without getting lost in indecipherable source code. For example, accessing an address line from an IBM AS/400 5250 emulation screen requires only a single line of code:

ADDRESS1 = GETFROM( 'HOST1', 10, 20, 30 )

The above example calls for the 30 character string that is mapped from row 10, column 20, on an AS/400 terminal screen to be assigned to the variable ADDRESS1.

Adding a dialog box to request user input is only a single line of TracerX code:

POPEDIT( 'User Name Dialog', 'Name:', 'XVAR' )

In the above example, 'User Name Dialog" is the title bar, 'Name' is the data entry prompt, and 'XVAR' is the variable to which the user entry string will be assigned. Once the variable contents are captured, TracerX's full-function language can transform and then transport the data to another application, file, or device.

The TracerX development system includes the following features:

• Development tools

  • Editor includes familiar, easy to use interface
  • Graphical wizards and tools to simplify and speed up development process
  • Pull down menus, scroll lists, keyboard shortcuts, and standard Windows functions like Copy, Cut, & Paste
  • Xbase-style syntax
  • Functions
  • String manipulation
  • Logical comparisons
  • Variable assignments
  • Create rules, including "while" loops, "if/else" logic, "and", & "or" constructs
  • Error-checking
  • Help system
  • Compiler
  • Access system date and time
  • DBF database engine
  • Build customized Windows user interfaces, including dialog boxes complete with buttons, text, data entry fields, frames, etc.

• Generic integration tools

  • Access operating system facilities including DDE, DLL, and ODBC to build interfaces to other applications
  • Implement communication procedures to a wide range of devices and systems using serial port, parallel port, and TCP/IP socket level controls
  • Automate keyboard entry in multiple Windows applications with macro scripts
  • Read and write data to ASCII or Windows INI files
  • Control Windows clipboard facilities
  • Capture data from DOS program screens running in Windows sessions

• Application interfaces

  • Internet browsers - use pre-built interfaces to Netscape and other internet-compatible programs to map data to and from HTML pages
  • Terminal emulators - scrape mini & mainframe computer screens with a single line of code. Send data to and from 5250, VT220, and other terminal screens
  • EDI translator - map data into EDI X-12 compatible formats procedures
  • Shipping & mailing systems - exchange data with programs designed to weigh, rate, and generate carrier documentation
  • Label designer & generator - feed data into labeling systems to automate compliant labeling tasks
  • Weighing & counting systems - capture weight and piece count information directly from electronic scale platforms and integrate that information into your desktop application
  • International forms management - eliminate manual international forms generation with pre-defined interface
  • Tracking systems - implement automated material and mail tracking systems with transaction processing system "hooks"

Tracer's track record of success

Conclusion

Product developer benefits

• Reduce customization costs and support.
• Improve stability of software by insulating software from customized programs.
• Improve supportability and backward compatibility of standard software products.
• Improve performance by minimizing setup utility overhead.
• Improve development schedule by eliminating "one-off" customization requests.
• Improve productivity of development staff by shifting custom programming and implementation to field level.
• Improve customer satisfaction by providing field personnel with high-level TracerX tools to address integration and customization requirements.
• Broaden market for standard software and improve competitive position by extending capabilities and feature set.
• Reduce attrition of installed base by continuously adapting to changes in end-user environments.

Systems integrator benefits

• Reduce customization project costs and support time.
• Reduce integration of multiple platforms to one simple, high-level language.
• Improve performance with fast TracerX runtime engine.
• Improve long-term support with small and readable TracerX programs.
• Improve productivity of field personnel by using TracerX to quickly get in and out of complex integration and automation projects.
• Leverage existing knowledge by using industry-standard programming conventions.
• Reduce learning curve with complete help system and sample programs.
• Reduce reliance on software vendor by maintaining localized control of custom code.
• Reduce development time by reusing code.
• Reduce errors with syntax-checking compiler.

End-user benefits

• Reduce customization costs and support.
• Improve productivity by integrating new applications with corporate legacy systems.
• Improve productivity by adding new features to standard applications.
• Improve productivity by automating keyboard control across multiple applications.
• Improve productivity with fast, trouble-free execution.
• Improve reliability by leaving standard software applications intact.
• Reduce errors by adding TracerX's IF, ELSE, and WHILE logic to business functions.
• Reduce the risk of losing long-term support of standard systems.