Applied Software Technologies
Glen Carbon, IL
| Product Development |
Ongoing |
This is my own consulting company that was established to provide
software development services by applying advanced technology in
production quality systems. The company's emphasis is in Object
Oriented Technologies, Distributed Object Management, Client/Server
Computing, and GUI/Windows Development. Training and Mentoring
services are also available.
In addition to consulting, I have worked on numerous freelance
development efforts. I am currently working on a Java project, called
SemanticJava, that I am considering submitting into open source.
SemanticJava is a general purpose class library that delivers an
in-memory semantic network by encapsulating bi-directional named
relationships between application-defined java objects, providing both
ease of use with powerful traversal mechanisms.
Q-up Mobile Systems
St. Louis, MO
| Consultant |
7/2007 - Present |
My most recent activity has been to work with Q-up Mobile Systems (a
local startup company) to develop a series of mobile applications.
The system is somewhat confidential (at this early stage). It employs
a J2ME (Java Micro Edition) architecture, and is deployed to
GPS-enabled cell phones and PDAs.
One aspect of this project involved the development of a sophisticated
web-based geographical mapping agent, utilizing the Google Maps API (a
programmatic API that provides the ability to interject
application-specific graphical overlays), employing an AJAX-based Web
2.0 architecture.
RGA-TP
St. Louis, MO
| Consultant (Technology Partners) |
9/2004 - 7/2007 |
This position was with RGA-TP (Reinsurance Group of America -
Technology Partners). RGA-TP markets a commercial J2EE application to
insurance companies - world wide. AURA (Automated Underwriting and
Risk Analysis), provides a suite of products that facilitate the
automation of the underwriting process. Notable components that
comprise AURA are:
- A Rules Engine that maintains client-configurable underwriting
rules to determine risk and eligibility status of insureds - based
on a question/answer session.
- An Underwriting Workbench that provides clients with the ability to
consolidate and track case details, such as: outstanding
requirements, outstanding work items, notes, final decisions,
reinsurance details, and manual decisions.
I was instrumental in developing a number of major system
enhancements, including the following:
- AURA Web Service
This effort provided a programmatic interface to the AURA
session, representing the first interactive Aura offering that does not
promote a GUI representation - rather program-to-program API (bound
through a web-service API). This component is used by clientele that
wish to take complete control of their GUI, and simply use Aura as a
"back-end service".
An extensive design effort was accomplished to promote a very
object-oriented model of the legacy rule engine.
- Decision and Risk Assessment
This component provides the mechanism by which underwriting decisions
can be formulated by assessing risks analyzed from multiple sources --
both automated (AURA scripts), and manually entered decisions (by a
human underwriter). This provides a "Clearing House" where by
multiple information sources can be controlled, summarized, and
maintained -- in a holistic way.
- New AJAX-based (Web 2.0 compliant) User Interface (Ui2)
Ui2 promotes an alternate GUI by which a user can interact with an
AURA script - using a completely new User Interface.
- Ui2 provides a lightweight Web 2.0 User Interface to an Aura
Script, that:
- Eliminates the traditional web-page refreshes, minimizing the
associated overhead (using AJAX technologies), and
- Is embeddable in a variety of web-page contexts
- Ui2 supports user input through a more intuitive "form entry"
style, where questions are editable at all times, and no explicit
user controls are required to edit/commit individual responses.
- Ui2 supports advanced "presentation" directives, providing a GUI
representation that is tailored to specific needs, for example a
"Grid" disclosure layout used in "Evidence Summary" and "Add Manual
Risk" scripts.
- Internally, Ui2 was layered on top of the Aura WebServices API
(WSAPI). While the WSAPI service layer and domain objects were
employed, the client/server binding is based on AJAX (replacing the
SOAP binding with AJAX). The object-oriented nature of the WSAPI
provided a very clean model to work from.
Monsanto
St. Louis, MO
| Consultant (Technology Partners) |
10/2003 - 8/2004 |
This position was with the Monsanto TCC Group (Technology
Computing Consortium), enhancing the biotech systems used by their
genomic molecular breeding scientists. The applications are Java
based, and utilize a variety of component architectures, including:
Corba, Servlets, Struts, Swing, Applets, and Java2D. The development
team utilizes an Agile-XP process, and employees test-first design
principles.
I was instrumental in re-factoring the underlying architecture to
utilize business-objects, capable of being marshaled over a
distributed boundary (through XML).
I designed and implemented a full-featured scheduling system,
supporting the automation of project work within the lab. The system
is very interactive, promoting a variety of flexible views, with
drag-and-drop capabilities.
I also architected a report query tool using an XML grammar. The XML
binding provided an expressive mechanism to represent complex and
extensive structures in an intuitive way. All queries were maintained
by our administrative users, and presented through a dynamic menu
hierarchy.
Express Scripts International
St. Louis, MO
| Consultant (Technology Partners) |
11/2001 - 9/2003 |
This position started as a short-term project where I was involved in
the rapid development and deployment of the Express Script Alternate
Funding System. Once this was complete I was transitioned into the
groups primary application, called SDS (Specialty Distribution
System).
In addition to my component development responsibilities, I have
promoted extensive use of high-level documentation (in an on-line
web-based form), both technical specifications (using UML class and
sequence diagrams), along with extensive javadoc. I have also
implemented several automated development processes, including a build
process using ant, and an automated test environment using JUnit.
| Specialty Distribution System |
3/2002 - 9/2003 |
This system is a high-volume order processing system, that distributes
"special needs" drugs, on behalf of a variety of different drug
suppliers and manufactures. The system utilizes Corba-based
client/server technology, and is implemented in Java, with an Oracle
data repository.
I joined this project subsequent to it's release in production. My
primary responsibility has been in the area of re-architecting various
critical-path components -- to provide better throughput, with more
flexibility, using sound Object Oriented design principles. My major
contributions include the following:
- Order Release Process
This process was completely re-architected, to accommodate the
following goals:
- Improve throughput performance, as the transaction volume scaled up
over 10 times (30,000 to 300,000 orders per month).
- Improve the maintainability of the validation rules, providing an
Object Oriented solution that addresses both re-usability and
flexibility (several checks are shared between client suppliers).
The end result of this re-design effort was very successful, improving
throughput performance by a factor of 10, even with the increased volume.
Equally important was the maintainability improvement of the release
checks themselves, through an extendable and open architecture.
The following aspects were implemented:
- Develop and utilize a broad-scoped caching object (SdsObjCache and
OrderBasedCache) that's life cycle is defined within the context of
a logical transaction. This significantly reduced the overhead
associated with redundant database retrievals made throughout the
code base.
- Develop and utilize a common java interface through which ALL
release checks conform. This provides a consistent API that can
be reasoned about at an abstract level. Because each rule is defined
in a consistent manor, the architecture is more expandable in an
open environment. In addition, because each rule is defined through
an object binding, it lends itself to being processed in concurrent
threads.
- Rewrote the "expert system" Jess eligibility rules (written in
clips) into java components, making them consistent with all other
components in the new architecture. Because of the variability between
rules across programs, the overhead of launching the rule
engine process (for each request) was eliminated.
- Utilized java threads to concurrently process the various
release checks that are appropriate for each program. All checks
occur concurrently, since there is no inter-dependency between
them. This was implemented using a newly introduced thread pool
manager, which maintains a free pool of Java Threads, that can be
re-used over and over again.
- Develop and utilize a more formal timing probe instrumentation and
analysis.
- Enrollment Expert System
A generic Expert System component was developed to support the needs
of the SDS Enrollment process. This component has the ability to reason
about client-supplied knowledge, replacing the Jess component that was used in
the AltFunding Means Tester. The SDS Enrollment project
had several additional requirements (over and above AltFunding) that
necessitated a re-architecture. These requirements were:
- The ability to Short-Circuit Responses that have no bearing on the
end result.
- The ability to provide Explanations of how the results were produced
-- specifically for Needs-More-Information, and Denials.
- An easier mechanism to establish user-defined constraining rules,
without the complexity of the low-level / high-level rule
segregation.
It was recognized early on that our previous architecture, modeling
knowledge through clips rules, would fundamentally not satisfy these
requirements. Supporting these advanced features require a
meta-reasoning capability, that is, the ability to reason about the
rules themselves. This provides features such as how, why, what if,
and the ability to identify missing input that could affect resultant
decisions, etc. Meta-reasoning dictates that the rules themselves be
treated as data. Fortunately in our case, the rules could be
represented as a network of and/or nodes and both the reasoning and
meta-reasoning functionality needed can be accomplished using rather
strait forward algorithms -- using any conventional language (such as
Java). The decision to replace the Jess component was a straightforward
for the following reasons:
- Comparable development effort
- Concurrency -- no longer restricted to a single threaded model (we
can evaluate multiple concurrent requests)
- Licensing issue resolved -- Jess license is no longer needed
- More flexible in tailoring exact desired results
- Faster performance
- Less resource utilization (both memory footprint and throughput)
- No longer need to maintain Jess skills in the group
- Correspondence
Re-factored the SDS Correspondence sub-system. This component was
unique in that it is never directly interacted with, rather
correspondence is generated as a result of select "secondary"
external activities. As an example, when an order is completed - one
type of correspondence is generated, or when an enrollment is made -
another type of correspondence is sent.
A delegation event model was employed, providing the proper
division of work. A "secondary" external activity emits the
appropriate application-defined events, while suitable correspondence
agents listen for selected events, generating the necessary
correspondence.
The correspondence listeners were implemented through a supplier-based
class hierarchy (using a factory pattern), which allowed
supplier-specific correspondence decisions to be applied at the
appropriate location (using polymorphism).
With the introduction of this event/listener model, it was crucial to
retrofit all logic to utilize this central point of control. Prior to
this effort, logic was spread out over a variety of places (as a
result it was unwieldy, difficult to maintain, and not very
expandable).
- Reporting Architecture
A reporting architecture was developed that is both open and
extendable. Some of the key highlights of the architecture were:
- Supports both Corba-based client/server requests, and unix command
line requests.
- Supports an unlimited number of report formats, that are
selectable at run-time (for example: text, html, xml, csv, etc.).
- The XML is open ... in that it is not required to conform to a
global set of characteristics defined for all reports. While common
XML characteristics are in fact defined (and used) by infrastructure
components, a report can still characterize XML to it's specific
need.
- The report rendering factory utilizes reflection, allowing the
repertoire of reports to be expanded without modification to the
underlying factory implementation (a key design principle of a well
designed system).
- The architecture is open, utilizing interface based contractual
agreements. As an example, the utilization of the velocity template
engine is optional ... it is available, but can be bypassed.
- Object Cache
A general-purpose SDS object cache was developed that had knowledge of
all SDS object types. SdsObjCache objects serve as a clearing house
for access to all SDS structures. Each accessor employs a lazy
initialization pattern, meaning that the overhead of initialization is
only incurred if the data is requested.
The cache duration is completely defined by the client's usage, tied
to the life-cycle of each SdsObjCache. A typical usage scenario would
be to use a cache instance only within the context of a logical
transaction. This allows each transaction to see the most current
database content while significantly reducing the number of redundant
database accesses within the scope of the transaction.
SdsObjCache is re-usable and generic in the sense that it can be used
by any SDS component. Derivations of SdsObjCache can provide
value-added semantics to a specific component/operation (for example,
a multi-threaded initialization process, seeded with key contextual
information).
SdsObjCache is thread safe. It guarantees that requests for the same
object key will return the same object instance (even in a
multi-threaded environment). In addition, parallel processing will
function in the most optimal fashion, synchronizing on the smallest
scope locking objects possible. This promotes the most optimal
throughput possible.
- SysResources
The configuration of the entire SDS system was re-architected to
utilize a central SysResources class. In essence this class fronts a
series of java properties. However, much more value is provided by
abstracting several complexities in regard to loading properties,
initializing sub-systems, and accessing higher level resources.
The SDS System run-time configuration is accomplished through a single
java property file. Multiple property files can be used, but in
general, are not needed. The details of this configuration have been
abstracted through the use of the SysResources java component. It is
possible to utilize a single (unmodified) property file for all
processes in all deployment environments.
As a result, this single resource can be version
controlled, and deployed as part of the packaging process of the build
procedure.
- ThreadPool
Developed a Java thread pool utility, maintaining a free pool of Java
Threads, that can be re-used over and over again, eliminating the
expensive overhead of thread startup.
The pool is created with an initial capacity of Threads. The number of
threads can dynamically increase beyond the initial capacity, as
required ... based on the maximum number of concurrent threads
requested.
| Alternate Funding System |
11/2001 - 2/2002 |
This system provides a customizable means test, matching patients with
a variety of third party programs that offer prescription drug
financial assistance. The system is a client/server web-based portal,
utilizing Java, Corba, and Oracle. It also employs an expert system
component, using Jess ... a Java based Clips derivative.
I was responsible for the design and implementation of the back-end
distributed Corba Java components, along with the expert system means
testing service.
A typical usage scenario would be an iterative process where an
advocate answers a series questions about a patient. At any time a
means test can be performed to determine what assistance programs they
are qualified for. If a program's eligibility cannot be determined
because additional information is required, those unanswered questions
are then presented.
The acceptance criteria, for the various third party assistance
programs, can be completely customized by an application
administrator. This criteria persists within an Oracle relational
database. The means testing component utilizes an expert system
knowledge base, which is derived from the Oracle representation,
transformed into a Jess Clips format.
AG Edwards
St. Louis, MO
| Consultant (Technology Partners) |
12/1999 - 10/2001 |
I was part of a team that developed AG Edwards' On-Line Investing
(OLI) system. This is a web-based application providing customer
access to on-line trading. This is one of the first customer-based
global internet applications at AG Edwards. The architecture is J2EE
compliant, employing Java Servlets, Enterprise Java Beans (EJB), and
XML, deployed under WebLogic 5.1.
A strong emphasis was placed on architecture, design, and
documentation. Standards, utilities, and procedures were established
that work in an open environment (spanning the gambit from NT
development workstations, to the production delivery Unix platforms).
My responsibilities included a full gamut of the various architectural
tiers, including servlet components, internationalization, view state,
state transition, business services (utilizing session EJBs), and the
business domain objects (used throughout each layer of the various
software tiers). I was also responsible for the design/implementation
of various infrastructure components, key to the architecture, along
with the development/build environment, and documentation standards
used by the entire team.
- Served as a mentor in both Java and OO technologies.
- Established coding/documentation standards, and performed code
reviews.
- Analyzed/Isolated/Corrected a major memory leak problem, related to
application thread usage within an EJB environment.
- Implemented a systematic testing strategy, utilizing JUnit. This
was incorporated into our build utility, enhancing ease-of-use, and
providing seamless integration into our nightly build process.
- Developed the internationalization architectural components used
within the application. This was based on Java's standard
ResourseBundle, and is utilized for both internationalized display
text, and user messages.
- Developed a base adapter architecture, encapsulating the common
characteristics of interfacing to enterprise level back-end
systems. The protocol used in these systems was based on XML.
- Developed a simulation service architecture that was utilized prior
to real service availability, and continues to be used during
back-end outages. This utility is configurable at run-time, and
integrated at a low-level infrastructure component, meaning that
all application code is exercised, and application logic is unaware
of the simulation status (in other words, no conditional logic is
required at the application level).
- Developed a service "HeartBeat" architecture, which can relay
statistics on any service bean (configurable through a run-time
resource). The major items of interest were 1) the TUX domain
names (which define the service location), 2) whether the back-end
is simulated or live, and 3) a real-time "ping" status (identifying
if the back-end service is alive or dead). Detailed information is
cataloged in regard to the "ping" request. This service is
visualized in a summary on-line table format, that is accessible
through a status servlet.
- Maintained application domain object oversight. Developed
architectural infrastructure in regard to domain objects.
- Primary party responsible for the integration effort from the
order-handler service bean (session EJB) to the back-end
order-processing service.
- Developed several XML parsing utilities, including a SAX Router,
which provided finer grained "delegation" event handling (over and
above the standard SAX protocol).
- Developed a Java thread pool utility with a virtual ThreadHandle,
allowing client logic to interact with a "logical thread".
- Developed a comprehensive application enablements utility. This
architecture consolidates all authorization policy rules in a
single control point, acting as a clearing house of application
specific "Can I Do This" questions. Enablement methods build on
one another, providing a comprehensive set of dependency rules,
improving integrity, simplifying usage patterns, and enhancing
maintainability. All underlying distributed security data access
was optimized, using threads where necessary, and cached over the
course of a transaction (eliminating redundant and expensive
distributed calls).
- Developed utilities to support application monitor probes,
gathering a variety of statistical information, including
performance, timing, request/response sizes, memory utilization,
load balancing, network performance, etc.
- Developed an external navigation utility, retaining state of any
un-processed request, allowing it to be resumed when user
re-enters.
- Developed a diagnostic logging tool (Diag) that is used heavily in
all of our production code.
- This utility provides a flexible mechanism by which diagnostic
probes can be conditionally logged through a filtering
mechanism. Messages are tagged to specific severity levels (such
as debugging, warning, error, etc.), and filtered appropriately
at run-time.
- A very flexible and efficient filtering mechanism is utilized
which supports a fine grained tuning of only the probes of
interest.
- Diag is highly optimized, so that when a message is filtered out,
virtually no run-time overhead is incurred. This means that
diagnostic probes can be left untouched, even for production
runs, by simply allowing the filter to default to a production
level.
- Developed a Jolt Session Pool Manager, which was a thin wrapper
around BEA's SessionPoolManager. The primary value of this utility
is related to run-time configuration.
- Developed a generic translator utility class that maintains a
bi-directional mapping, allowing objects of one domain to be
translated to objects of a different domain, and vice versa.
- Developed run-time configuration ability, using a property-based
configuration utility.
- Developed a generic error representation scheme, based on a
symbolic federated namespace. Notice collections were utilized to
support compound error notification to the end-user. A generic
search/filter ability was built into this utility.
- Developed a technique where all enumerated states for a specific
application context are encapsulated in a light-weight Java class.
This is similar to C/C++ enumerations. Each choice class is
machine-generated, from an XML source, using XSLT. This practice
incorporates the following benefits:
- They are type-safe, defining a complete set of options ... no
more, no less.
- They are self-documenting.
- These classes easily support expansion to additional choices in
the future.
- Support is automatically provided for both Invalid and Undefined
scenarios.
- Aliasing is also supported, allowing multiple symbolic names to
reference the same Choice.
Edward Jones
St. Louis, MO
| Consultant (Technology Partners) |
1/1996 - 11/1999 |
My position at Edward Jones, involved an extensive effort to convert
their legacy mainframe systems to a client/server architecture. The
initial conversion effort utilized C++, in a UNIX X-Windows Motif
environment, with a distributed ORACLE database at multiple branch
satellites.
Subsequent projects were web-based implementations, utilizing Java
Applets/Servlets, and JavaScript. A business tier middle-ware
component was employed (implemented in Java).
Several early prototypes were developed in CGI using Perl.
One of my project efforts also employed Java JNI (Java Native
Interface) tying into legacy libraries, and utilized Java RMI (Remote
Method Invocation) as a distributed service protocol.
An on-line documentation approach was developed that included both
project content (such as Architecture, Design, Object Models, and
Technical Specification) as well as process (such as methodologies
used, and administrative procedures).
I have also been utilized at Jones in establishing their internal
standards and tool selection, specifically in the area of Java and C++
development.
MasterCard International
St. Louis, MO
| Consultant (Technology Partners) |
7/1995 - 12/1995 |
In this position I was part of a team that delivered one of MasterCard's first
client/server applications. The application is an ORACLE based information
system, deployed on an AT&T UNIX server. The client portion was written in
Visual C++, targeting a 16 bit MS Windows platform. A batch transaction
processor was written in C++ on the UNIX server, replacing a legacy system.
Southwestern Bell Technology Resources
St. Louis, MO
| Consultant (Technology Partners) |
10/1994 - 6/1995 |
During this assignment a proof-of-concept prototype was developed which promoted
the benefits of combining Object Oriented Technology with Distributed Object
Management in the deployment of Network Management Applications. My
responsibility entailed the deployment of an architecture that externally
promoted a distributed API, while internally interfacing to the OSI Network
Manager. The distributed aspect of the project was based on the OMG's (Object
Management Group) CORBA specification (Common Object Request Broker
Architecture). The project was implemented using C++ and Orbix as the CORBA
compliant ORB (Object Request Broker). An informal evaluation was completed
that compared two CORBA products - XShell from Expersoft, and Orbix from Iona
Technologies.
Ascom Timeplex
St. Louis, MO
| Member of Technical Staff |
3/1994 - 9/1994 |
This position was in the tele-communication industry. Our office was developing
the signaling software for a commercial ATM switch (Asynchronous Transfer Mode).
I was part of a team that is developing the distributed processing
infrastructure used in the environment. The system employed object oriented
concepts, and was implemented with C++ on both Sun SPARCstations, and AMD29K
embedded processors under VxWorks.
McDonnell Douglas Corporation
St. Louis, MO
| Senior Technical Specialist |
2/1991 - 2/1994 |
This assignment involved the development of a hydro-mechanical/electrical design
engineering analysis tool. The major components of this system include
schematic capture, control law definition, and simulation. One of the key
aspects that made this project unique was it's ability to model a system's
digital control laws in the form of graphical decision trees that are
executable. The logic script is highly integrated with the schematic, and is
the driving force behind the simulation. A full featured symbolic debugger was
implemented to assist in performing logic validation.
The system adheres to a strict object oriented methodology, and was implemented
using C++, Motif, and X-Windows, on both Sun SPARC and HP700 work-stations.
It's user interface is very flexible and highly intuitive, patterned after the
dominant GUI's of today. The system utilizes pull-down and pop-up menus, and
electronic clipboards. Mouse wrappers allow graphical objects to be
mouse-selectable. Overlapping prioritized windows allow multiple concurrent
viewports to display the same or different models in the same or different
formats.
The system actually provides an automated design knowledge capture. The
acquired design information is to be used in subsequent tools to support
testability, embedded systems software, reliability and maintainability, thereby
promoting concurrent engineering and integrated product definition. This was a
very exciting project which obtained high level visibility within MDC.
The system is very production oriented. Even though it was a research project,
it is being actively used in the production design of several sub-systems on the
F/A-18 E/F, T45, and C17 aircraft.
I also prepared and taught a 5 day course entitled "Object-Oriented Programming
Using C++". The course emphasizes object-oriented concepts and techniques while
learning the C++ syntax.
| Senior Technical Specialist |
11/1988 - 2/1991 |
My assignment here involved the design and implementation of a detailed
scheduling system utilized by McDonnell's Machining Center. The first phase has
been implemented in production, and incorporates a highly graphical user
interface utilizing DECwindows (Digital's X-Windows layered product). The
system promotes object oriented concepts through the use of an internally
developed network data manager. Subsequent phases of this project will
introduce advanced AI search techniques, supporting the machine generation of
optimized detailed schedules.
| Technical Specialist |
5/1987 - 10/1988 |
This assignment involved the development of a structural analysis CAE package.
An extensive "User Interface Management System" was developed to streamline the
integration of future applications. The system is highly graphical and supports
an internally developed prioritized windowing scheme. My primary responsibility
was the development of the File Management subsystem, including both
File/Retrieve and Database Management. I have also been involved in the
development of the graphical plotting package.
Electronic Data Systems
Detroit, MI
| Senior Software Engineer |
3/1985 - 4/1987 |
My assignment involved the development of an Electrical CAD/CAM Engineering
Design tool. Specifications for this project came directly from the GM Car
divisions. The development effort was on an IBM Mainframe utilizing GM's
Corporate Graphic System (CGS).
In addition to the above responsibilities, I served in the capacity of the
Technical Assistant reporting directly to the Divisional Manager of the Computer
Aided Engineering Department.
Delco Electronics - Division of GM
Kokomo, IN
| Project Leader |
1/1984 - 2/1985 |
My assignment here consisted of the establishment of a Personal Computer Center
emphasizing support to "End User Computing". My responsibilities included
coordination in the following areas:
- marketing, training, and support to end users
- policy development & standardization of supported products
- connectivity integration
- software development on selected projects
| Systems Analyst |
6/1979 - 12/1983 |
My major responsibilities included the design, development, and modification of
computer systems interfacing with the Manufacturing Information System. This
involved an understanding of engineering and manufacturing processes and their
interfaces.
One major contribution was the development of a complete on-line Bill of
Material Maintenance system including a computer aided Part Number Assignment
Facility. The inquiry capabilities of the system developed into a highly
visible communication tool for Delco personnel across many functional areas. An
extensive Users Manual was developed and formal presentations made dealing with
the usage of this system.
McDonnell Douglas Automation
St. Louis, MO
| Programmer |
Summer Employment 5/1977 - 9/1977
|
This job gave me some good practical experience the summer after my sophomore
year in college. My primary responsibility was to write several statistical
programs which interfaced an "in-house developed" structural analysis package.