Visual Programming Armoury

Multidimensional structure of desktop

That's the idea that software developer supervises a project in as much views simultaneously as he like. In the days of The Age of Explorers we can't pass the matter by without putting this concept into service. The construction singularity of VPA lies in multidimensional engine for navigation through code. IDE is a customary MDI application. User opens MDI window and splits up each MDI window into several areas. Every area is an autonomous view (or pane) of all projects loaded. You bename the whole VPA workspace, each MDI window and every autonomous view. The pane area is customized to keep a check on specific project part. Having partitioned workspace this way programmer can extricate himself from difficulties about large-scale systems working-out or about how to be familiarized with such systems when team work is in progress. Workspaces are profiled.

Ergonomic interface

Another side of the visual programming brainchild consists in the keyboard being charged to the full but not to the damage of the mouse. Either you hardly survive in 3D action game or you failed executing performing arts if your controls customize badly. We develop user interface allowing programmer to minimize mouse usage, except painting. All you need to navigate through desktop is to switch between MDI windows and to position by arrow keys over the target item. Pressing numpad-5 key you enter the editor appropriate for the item type. VPA is a really perfect tool for code walkthroughs.

Two programming languages

VPA supports C++ and Java. This list may be branched out due to idea of language plug-in. The plug-in of the specific language is a construction which embeds in project tree and manages semantic characteristics, generatees code, finds compiler errors, provides documentation, etc. You may work at several languages simultaneously. VPA is independent of compiler and facilitates the building process with a set of makefiles that are automatically managed. You customize command-line compiler output to identify error and warning line numbers. Thus bugged source code is highlighted.

Structured organization of source code

VPA provides a natural way of structuring complex projects by abstraction of the file-and-directory-based-view. It ensures a more logical and less implementation-dependent view of a software system. VPA manages the abstraction from a file level view to an intuitive and more natural hierarchical order of projects and sub-projects. A project in VPA comprises a set of files and, optionally, a set of sub-projects that can be shared among multiple or several projects. A project or sub-project can consist of files of any type like source code, binaries, makefiles, test cases, etc.

Each language plug-in set up in different ways due to distinct universals of its grammar. Common attribute of all plug-ins is that source code is structured and folders group project fragments according to your logic. View your code as a hierarchical tree organized into categories and subcategories. This folders may be nested as deeply as desired and provide a way to manage complex schemes. With familiar Windows Explorer-like views, look deep into a project or glance across its entire face.

The difference between language plug-ins consists in binding project items to physical files. Each desktop pane view shows the primary structure of all projects loaded in VPA. Project typically corresponds to C++ compiler target like prj.exe or prj.dll files or to Java targets. C++ project contains code in the form of functions, classes, macros, variables, type synonyms, etc. Classes further contain their own variables, functions, enumerations, types, and if necessary, raw C++ text. This items may be attached to C++ physical files, f.e. matched pairs of *.hpp and *.cpp, *.cxx, etc. You attach items or thier folders in terms of header and body, by the way header and body may differ. Java project contains no files. Java class agrees with its storage entity name.

Source code documentation

Quality software is not finished until it is documented. If documentation is done separately from coding, there arise inevitable discrepancies between the sources and their manuals. Too often, it is the documentation that is obsolete, inaccurate, ignored, or simply never created. VPA creates documentation directly from its repository, the same one that is used to generate the C++ or Java code itself. There is no possibility of the manuals being out of sync with the sources. Each element of the project may be documented via.commentary attached. For example you comment C++ public method by attaching protocol sentence to the header file and the detailed info of algorithm implementation to the body.

Trace utility WinOut

Simple trace utility called WinOut release developer from breakpoints. There are two WinOuts. One is a function of printf (for C++) or System.out.println (for Java) style linked to your project. Other is a simple application. On WinOut-function call your application try to interact through DDE with WinOut-application. Being loaded WinOut-application prints the message. Thus you can trace the flow of program or values of variables. There is no need for either log files or assertions.

Sophisticated syntax highlighting

Together with a standard keywords highlighting this facility affects function arguments, user special keywords, class members with inherited ones for C++ and Java. SQL script tokens is also supported.

Project repository

Physically each project is stored in a single file. Binary resources also stores in the repository - bitmaps, icons, cursors which you create with internal image editor. This storehouse of project forms a central location from which code can be controlled, generated, documented, and - best of all - reused. Versioning tasks and division of projects over the team are simplified by means of the repository. Repository is restrictable. Such feature is important for distribution purposes, in other words class protocols and other declarations remain in their native layout, private items and function bodies are truncated.