POSITION

Application Software Consultant

PERSONAL DATA

Address:	Omitted for Privacy Reasons Greater St. Louis Area (Metro East)	Date of Birth:	Omitted for Privacy Reasons
Phone:	Omitted for Privacy Reasons	Email:	inquire@wiiBridges.com

EDUCATION

School:	University of Missouri - Rolla now known as the Missouri University of Science and Technology
Degree:	BS Computer Science 1979
GPA:	3.5/4.0
Honors:	Magna Cum Laude Computer Science Honorary - Upsilon Pi Epsilon (President)

HARDWARE/SOFTWARE

Hardware:	Linux, Unix (HP700, SunSPARC, RS/6000, AT&T63xx), Mac OS X, INTEL(Windows 10/7/XP/NT/98/95/3.x, MSDOS), VAX(VMS), IBM(MVS/VM)
Languages:	JavaScript (es6, both functional and OO), Java (EJB/Applications/Servlets/Struts/Applets/RMI/JNI), JSON, Groovy, C++, C, html, XML/XSLT, Velocity, Perl, CGI, PASCAL, PL/I, FORTRAN, BASIC, COBOL, Assembler
Graphics:	Swing (Java), Google Maps API, AWT (Java), OSF/Motif (UIL), UIMX, X-Windows, DECwindows, html, PS, GKS, MDC-GSR, GM-CGS
Frameworks:	React, redux, redux-logic, feature-u, Angular 1, Servlets/Struts (Tomcat), Web Services (Axis), AJAX (JSON), EJB (JBoss, WebLogic, XDoclet), Spring, CORBA (JacOrb, VisiBroker, Dais, Orbix, XShell), RMI, RPC
Analysis/Design:	UML (Unified Modeling Language), TogetherJ, OMT (Object Modeling Technique)
Database:	JDBC, ORACLE, PostgreSQL, SqlServer, DB2, MySql, JDO, Hibernate, IMS/DB(DL/I, DLT0), VSAM, DB2, DBASE, Btrieve, FOCUS
TP:	Tuxedo (Jolt), IMS/DC(MPP, ADF, BTS, BMP)
Expert Systems:	Clips, Jess (Java Expert System Shell)
IDE:	eclipse, emacs, intelliJ/idea, ant
Support:	NODE.js ... npm UNIX ... Shell Scripts (Perl, C, K, Bourne), make, cygwin, git, cvs, sccs, dbx, xdb VAX/VMS ... Symbolic Debugger, EVE, WPS+, Standard Runoff IBM/MVS ... TSO, SPF, DMS, CLIST, JCL, ACF2, RACF, SDSF, Panasophic IBM/VM ... CMS, EXEC, PROFS, Telegraph

EMPLOYMENT HISTORY

4/2015 - Present	Retired	Retired Life
8/2004 - 4/2015	Consultant	RGA-TP
7/2007 - 4/2008	Consultant	Q-up Mobile Systems
10/2003 - 8/2004	Consultant	Monsanto
11/2001 - 9/2003	Consultant	Express Scripts International
12/1999 - 10/2001	Consultant	AG Edwards
1/1996 - 11/1999	Consultant	Edward Jones
7/1995 - 12/1995	Consultant	MasterCard International
10/1994 - 6/1995	Consultant	Southwestern Bell Technology Resources
3/1994 - 9/1994	Member of Technical Staff	Ascom Timeplex
5/1987 - 2/1994	Senior Technical Specialist	McDonnell Douglas Corporation
3/1985 - 4/1987	Technical Specialist	Electronic Data Systems
6/1979 - 2/1985	Project Leader	Delco Electronics - Division of GM
5/1977 - 9/1977 (Summer Employment)	Programmer	McDonnell Douglas Automation

CAREER OBJECTIVE

Through consulting, I am able to continue in the technical career path that I have chosen. My emphasis has been in application level software development. I have expertise in Object Oriented Technologies, Distributed Object Management, Client/Server Computing, Web Development, GUI/Windows Development, and Engineering Applications. I am very pragmatic, and production oriented, and I enjoy working in all aspects of the software development life cycle.

DETAILED WORK EXPERIENCE

Retired Life

Retired

4/2015 - Present

Now retired, my wife and I travel, and very much enjoy being grandparents.

I have also started biking. My son and daughter-in-law (a seasoned triathlete) inspired me to get more exercise.

From a technical perspective, I am keeping current! I have become proficient in es6 (JavaScript) and React. My preferred front-end stack is react, redux, redux-logic, and feature-u. I have also been contributing to open source, and have published several libraries (see https://github.com/KevinAst/).

RGA-TP
St. Louis, MO

Consultant (Technology Partners)

8/2004 - 4/2015

My most recent activity has been 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 have been 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). 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.

• Aura's Web 2.0 compliant AJAX-based User Interface (Ui2)

  Ui2 is Aura's next generation script GUI - promoting Aura's dynamic reflexive question/answer session. Internally, Ui2 is layered on top of Aura's WebService. The object-oriented nature of this API provides a very clean model to build upon.

  The GUI was completely re-vamped using a modern up-to-date look and feel. User inputs are specified through a more intuitive "form entry" style, with fill-in-the-blank semantics.

  The philosophy of this GUI is to maintain the User's current state, whenever a service request is implicitly required, providing a very intuitive "user experience", even when Aura's sub-reflexive structure dynamically injects a sub-question mid-stream. This provides the best of both worlds - the power of Aura's dynamic reflexive structure, with an intuitive GUI presentation.

  Question types were enhanced to promote more-streamlined entry. Examples of this include the date calendar popups, auto-complete impairment search, streamlined contacts, implicit treatment of optional questions, advanced treatment of question notes and help, non-intrusive spell-check popups, etc.

  Higher level presentation directives were made available. For example, the new grid directive supports a concise rendering of repeated disclosures within a grid (via Aura's wrapup).

  Ui2 is Web 2.0 compliment. This means that it does NOT take control of the entire browser window. As a result, an Aura Script can be embedded within the larger context of the client's application page (say through a sub-section of the page, or even a Dhtml popup).

  A hallmark of Ui2 is to provide modular extension points that support customization at either a deployment or customer level. This "extension" philosophy applies to both style (CSS) and logic (JavaScript). This is accomplished without functionally modifying core, allowing the customization points to more easily migrate to subsequent Aura releases.

• ATF (Aura Testing Framework)

  I designed and implemented an advanced testing tool used by AURA users to validate their rules. This utility is a "System Testing" tool, as it exercises fully deployed AURA functionality. An innovative approach was used where test data (both complex input and expected results) could be maintained in spreadsheets, interactively driving the test suite (through internal macros).

• Aura's Next Generation Disclosure Engine (DE)

  The last achievement of my RGA tenure was part of a team that re-wrote RGA's long standing AURA rules engine. A new design was implemented that promoted a next-generation Disclosure Engine. I was instrumental in the design process, and lead the team that developed the Disclosure Engine User Interface - using the Angular 1 framework (very new at the time).

• Various additional Aura components were architected, including:
  • Underwriting Work Queue
  • MIB Code Reporter
  • Correspondence Send Processor
  • Multi-Lingual Refactor

Q-up Mobile Systems
St. Louis, MO

Consultant

7/2007 - 4/2008

This position was a collaboration with Q-up Mobile Systems (a local startup company) to develop a series of mobile applications. This work occurred in the midst of my RGA work (see above).

While somewhat confidential (at this point), the apps were based on a J2ME architecture (Java Micro Edition), and were 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.

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:
  1. Improve throughput performance, as the transaction volume scaled up over 10 times (30,000 to 300,000 orders per month).
  2. 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:

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. 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:
  1. The ability to Short-Circuit Responses that have no bearing on the end result.
  2. The ability to provide Explanations of how the results were produced -- specifically for Needs-More-Information, and Denials.
  3. 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:

  1. Comparable development effort
  2. Concurrency -- no longer restricted to a single threaded model (we can evaluate multiple concurrent requests)
  3. Licensing issue resolved -- Jess license is no longer needed
  4. More flexible in tailoring exact desired results
  5. Faster performance
  6. Less resource utilization (both memory footprint and throughput)
  7. 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:
  
  1. Supports both Corba-based client/server requests, and unix command line requests.
  2. Supports an unlimited number of report formats, that are selectable at run-time (for example: text, html, xml, csv, etc.).
  3. 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.
  4. 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).
  5. 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.