NeatTools

About NeatTools

Past

NeatTools is an object-oriented, visual programming environment, coded in C++ (with a Java-like thin-layer API). NeatTools, examples, and documentation may be downloaded from this web site at no cost. The language and its toolkit are extensible and expandable. NeatTools modules (visual objects) are selected and dragged into the workspace from toolbox collections. Modules possess properties, parameters, and various data inputs and outputs. Inputs, outputs, and parameters are connected to other modules by links (lines) drawn by the programmer.

Special objects and tools allow NeatTools to access a PC’s basic peripheral hardware: keyboard, mouse, joystick, serial port(s), parallel (printer) port(s), sound card, etc. Other modules have been developed to interface with a family of devices we refer to as TNGs. NeatTools is dynamic. Visual editing and program execution take place concurrently, so there is no need to alternate between editing and execution modes, as in other visual environments. NeatTools is also network-ready, robust, secure, architecture-neutral, and portable.

The built-in, or internal, modules (over 200 in number, not counting individual keys), arranged in seven toolbars, include device-support modules, switch and slider modules, calibrator module, internet sockets, state-machine module, timers, graphical displays, arithmetic (integer and real, including transcendental) and logic operations, character generation, multimedia sound, Musical Instrument Device Interface (MIDI) controls, and visual relational database modules with multimedia functions.

There are also external modules. External modules are separately compiled visual objects, analogous to those in the main toolbars, loaded at runtime. In the Windows environment, these are implemented as dynamic link libraries (DLLs).

The NeatTools programming model has its roots in the formal input/output automaton model. In NeatTools, module abstraction is offered as a set of class methods for intermodule communication. Functional components (implemented as class objects) of a concurrent system are written as encapsulated modules that act upon local data structures or objects inside object class, some of which may be broadcast for external use. Relationships among modules are specified by logical connections among their broadcast data structures. Whenever a module has updated data and wishes to broadcast the change and make it visible to other connected modules, it should implicitly call an output service function that will broadcast the target data structure according to configuration of logical connections. Upon receiving the message event, the connected modules execute its action engine according the remote data structure. Thus, output is essentially a byproduct of computation, and input is handled passively, treated as an instigator of computation. This approach simplifies module programming by cleanly separating computation from communication. Software modules written using module abstraction do not establish or effect communication, but instead are concerned only with the details of the local computation. Communication is declared separately as logical relationships among the state components of different modules.

The base code and internal modules of NeatTools constitute about 54,000 lines of C++ code. The author, Yuh-Jye Chang, did this for his Ph.D. dissertation in computer science at Syracuse University, working in close collaboration with David Warner who conceived the conceptual architecture based on previous generations developed by Warner independently.

Present

NeatTool has proved to be remarkably resilient. Originally written under Windows '95, NeatTools still works with Windows VISTA. Somewhat dormant in recent years, NeatTools is witnessing a new resurgence.

Future

The future is bright! An open source project has started at SourceForge.net. Stay tuned for exciting developments. Also, start looking for a new, updated TNG! The new TNG will feature more analog resolution, USB communications, faster data acquisition rates, bidirectional data communications, larger power budget, new connectivity options, and support for SPI-based peripherals.