C++ - A general purpose programming language with a bias towards systems programming

C++ is currently my language of choice because is supports object oriented development and places very few limitations on my software development. Note: all of my multi-platform object frameworks were built with RogueWave Tools. I started using C++ in late 1996 after watching it for many years and waiting for it to mature when ANSI drafted the 'standard'. All the way back to 1984 I have been using C for a number of system level functionalities.

I have developed the following systems in C++:

• The company wanted to develop Java applications, but was worried about the performance of Java on certain process intensive sections of the system. I designed an n-tier applicatiion framework with duplicate APIs in C++ and Java, This allowed business logic developed in Java to be moved to C++ by passing it through a perl program that could strip the "new(s)" needed for the Java object declarations. The C++ objects were reference counted, so that they were functional equivalents of their garbage collected Java counterparts. Application level C++ code contained no memory management code and no pointers.
  • Framework used a factory product pattern to persist and transmit objects between the tiers and database.
  • Factory classes cached objects to reduce relocating objects from other tiers.
  • Attributes of objects were tracked for modification, allowing updates between tiers to be reduced to just changed data.
  • Database column names were detached from member names of classes. This allowed member data to have names far larger than the 10 character column name limit in DB2
• The comapny wanted to convert AS/400 specific programs to Open Platform environments. I had already converted the RPG source to C++ compatible syntax. I need an application framework that duplicated the services of the AS/400 Operating system and the RPG library and database functions. This allowed 3 million lines of RPG and CL code to be easily converted from the AS/400 for use on Windows, Solaris, AIX and HPUX.
  • Framework used a factory product pattern to persist objects in the Oracle and DB2 databases.
  • Framework provided template based data types that performed operations like the equivalent RPG and CL Types. Including fixed length and fixed decimal on numeric quantities.
  • Framework had a runtime configurable inter-process layer that could run additional processes on the same machine (virtual IO streams w/dynamic shared library calls) or on different machines (IP socket based IO streams).
• The company had millions of lines of AS/400 RPG, They wanted to beable to sell applications to Windows and UNIX platforms. I built an RPG to C++ cross compiler. RPG programs were converted into object oriented C++ code that worked with the above framework. This recursive descent parser would instantiate an object for each line of RPG source when a new block command was instantiated, the parser would recurs, unwinding the blocks as appropriate. The resultant code was normal fully readable C++ code, understandable by both C++ and RPG developers.
• I needed a way to move whole database structures from one database to another, DB/400 to Oracle, Oracle to DB/2, Oracle to SQL Server, etc. I built a generic table moving tool. This tool establishes simultaneous connections to two database managers and duplicates a list of tables from one to the other.
• The company was developing a combination C++ parser and class generator. C++ classes were parsed to determine what attributes need to be stored to persist object instance of that class, it would then generate a group of classes to persist objects of that class in a database. After the benchmarks below, I studied their design which was having major performance problems. I then designed and implemented a number of modifications that increased the performance of the object persistence by a factor of 30 (from about 240 object instances per minute to about 7,500) and the code generation by about 15 (from about 5 minutes to about 20 seconds)
• Rogue Wave was nearing release of a new product, they wanted to know how it compared to the competing products. I created benchmarks which compared object persistence performance of Rogue Wave DBTools, Rogue Wave Metro, Persistence PowerTier and an Object framework of my own construction. Tests included:
  • Single object retrieval by one query per object and by many objects from a single query.
  • Writing performance with some and all attributes changed.
  • Related object retrieval with and without caching.
• The company was porting applications between databases and programming languages. The easiest way to test the port was to run the same tasks on the two platforms and then compare the contents of the two databases to locate differences. Rather than read millions of fields and attempt to perform visual inspection, I wrote a program that would scan the sables and compare them column by column and return the results.
• The company wanted to completely port an AS/400 application to C++. During this prot they wanted to normalize the database. I designed an application framework, including object persistence and generic user interface tools. The application framework was similar to above frameworks relative to the back end. The generic front end was a user interface engine that used generic base classes and information stored in Oracle to construct the user interface on the fly. When the generic classes were insufficient a derived class was created in a separate DLL and could be loaded and referenced from the configuration data in the database. Private version of the UI could easily be created at system, department, group and user levels, allowing every user of the system to get a view of the system that made sense for their job.
• The company need 33 interfaces between a new HPUX system and the existing MVS host system. They had multiple programmers cutting and pasting from a template interface to create the interfaces. With 6 weeks until deadline and 27 interfaces to complete and test. I noticed that all of the interface specification documents were in an identical format. I created a generic TCP/IP interface for HPUX that parsed configuration documents and processed all 33 interfaces to the MVS mainframe and the HP. Internally this multithreaded program buffered the burst transmissions from the host system, and then fed the data to an Oracle database through object broker as fast as the database could accept it.

I have developed the following systems in C

• I was using an OO language that had a command line compiler, but no support for make. I created a wrapper program for the compiler that would read the compiler listings and keep the dependencies in the make file up to date. I later added the ability to execute mass compiles across the network, by running copies of the wrapper in 'host' mode you could stream hundreds of compiles into a queue and hosts would pull requests off of the queue and process them. Because this pcode language used identical 'executables' on DOS, Windows and UNIX, we could use the 'big' UNIX box as a background compiler for all of the 'small' PCs.
• We need to interface our application in an OO language, which had very limited access to the outside world, to a host system that used VT100 terminals. I built a background terminal emulator that communicated to the OO language by device driver level IO system routines. The OO program thought it was talking to a random access disk file. The terminal emulator would parse the requested data from the VT100 screens and return it to the OO program.
• We had an application in an OO 4GL that had one particular report that was taking about 10 hours to run. I recoded the report in C and reduced the runtime to about 20 minutes.
• I was working on an Energy management system (in Pascal) and needed to provide telephone response to tenants so that they could turn A/C and lights back on after the system had shut them down for the night or weekend. They would call a special phone number and schedule the time that they would like the services back on line. The programs that managed the phone system were written in C and used a special hardware card which allowed the computer to play sound files and process touch-tones.

Perl