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
- 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.
- 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.