John Brian Coke
Office: 817.283.4465 e-mail: johnbcoke@hotmail.com
Cell: 817.319.2910 e-mail:
john@cosoftech.com
Although
I’m not a web developer, building this site was a lot of fun and I think it’s
really a much more informative presentation than a traditional resume.
Check it out => www.co-soft-tek.com/index.htm
EDUCATION: BSEE, Southern
Some additional course work after graduation
PROFESSIONAL
ORGANIZATIONS: IEEE Computer Society, Association for
Computing Machinery, and Independent Computer Consultants of
SUMMARY: Graphical User Interface / Windows XP / Scientific, Engineering, and Financial Systems.
LANGUAGES: C, C++, C#, Python, Pascal, Assembler, Shader Assembler, bit-slice microcode
ENVIRONMENTS: OpenGL, DirectX, Windows .NET / XP / 2000 / NT, .NET controls, ActiveX, ATL, MFC, OWL, Rose XDE, UML, OOA, OOD, DOS, UNIX, VMS
DATABASES:
Access, Paradox, Empress, DBASE IV, Informix – ISAM, Code
Base, C-Tree, Oracle 7, SQL-Server
AWARDS: Wylie / Electronic Engineering Times National Design Competition 1995: Motorola Award
HIGHLIGHTS:
I
have 30+ years of software engineering experience including 15+ years C++
development experience in the Microsoft Windows environment. Currently I am working in OpenGL -
applications or drivers. I also build
graphical user interfaces for large client /server systems. I am
experienced with all types of methodologies: OOA, OOD, OOP, SA, SP; half a
dozen databases; mathematical functions: splines, exponentials, polynomials,
linear algebra; medical, electrical, and aerospace software standards; languages: assembler, Pascal, Python, C, C++,
C#, templates<>, and debuggers. I
have full life cycle experience: specification, design, coding and test. I’ve done scheduling with Microsoft project,
testing with Silk Test, configuration management with Source Safe, Star Team, Clear
Case, and CVS, and deployment with Install Shield and MSI.
Living
Software, Inc. April – now: C, C++,
OpenGL, OSG, GLUT, Shaders, Linux
Linux:
I would like to be able to do anything in Linux that I can do in Windows, but
I’m just starting on that adventure. The last time that I
used UNIX professionally was almost 20 years ago. In the late 80’s I used BSD 4.2, XENIX
(Microsoft), and Ultrix (DEC). Since
then my experiences with installing both BSD 6.2 as well as Red Hat Linux on
the PC were something of a disappointment.
However, a couple of weeks ago I installed UBUNTU on 4 different
machines here at my office. The installation
went smoothly, even for my Wi-Fi connection, although I may need to drop in the
latest drivers for that. As of today I have Mono and Eclipse working, so I am
very pleased with the results. I intend
to rebuild a complete development environment including Boost, Nant, Widgets,
Python, etc. I want to duplicate my windows working environment as closely as
possible. Apparently Python was already
installed with the Debian release. I
need to hook that into Eclipse. I’d like
to see if I can get Corba running as well.
As of today I have Mono and Eclipse running. I’ve added the Python language. I need to add Widgets and some sort of
Framework.
OSG:
This is an open source version of a scene graph program. I am experimenting with it as an exercise. It
utilizes the cmake build utility. I’ve
rebuilt TIFF, JIFF (GIF), PNG and JPEG source code from Source Forge Website. I could not get the original downloaded
binaries to link in debug mode to the Open Scene Graph source code. At first it was an exercise in frustration,
but gradually I began to get some insight into how to put things together. The last library to build was cURL. It required modifications to the cmake files
to correctly provide all of the #defines.
I probably should turn in the corrections to the cURL site and let the
OSG people know that the above debug versions don’t link.
I also built a 1 angstrom to 1 unit model of a water
molecule and a methane molecule using the OSG. I need to find out if there are
acyclic graph versions of Protein molecules available online anywhere. I can
get the DNA / FASTA format that’s not the problem. If I could visualize the map between the DNA
and protein by formula then reconstruct the protein in 3D and add some bending
/ folding tools that would be very interesting.
From 1DNQ.pdb data set drawn with OSG, Yes, there are no
hydrogen atoms in the model. Below both 1DNQ and 1DNR are drawn using
only selected amino acids. [MFC and OpenGL not OSG] notice disulfide bonds:
Methane and Water in OSG
GLSL
shaders:
GLSL just is not that complicated. Of course having said that it’s true I have
not yet built a pair of shaders that will pass the OpenGL conformance test.
However, I have managed to apply a (image 1)color array from a
vertex object, (image 2) and (image 3) a square texture, and (4) the “brick”
shader to a mobius strip using vertex buffer objects and a texture object.
I’ve been running the 3DLabs GLSL sample codes. I compared their GLSL blend shader to the
blend shader I wrote for BARCO in 3DLabs shader assembler. They are very, very similar. Even their notes say to be sure and pass the
alpha value down to the fragment shader; I did add some shader codes to my
mobius strip. I may put up a side by side comparison between the assembly
language and GLSL for alpha blend codes.
Image 1) A
brick shader, Rost, etc., is drawn onto Mobius strip, using x and y from the
position. Image 2) the standard brick shader is modified to use tex_coords from
above instead of x and y from the gl_Vertex shader attribute.
Image 4
through 8) the seam is visible where the Mobius strip starts over. Below a
Mandelbrot set adhered to the Mobius strip
.
U-SYSTEMS,
Inc. , February 2009 – March 2009: C,
C++, C#, and OpenGL, Consulting Programmer
Development
of OpenGL programs in a managed code environment. VC 9.0,
Short
contract to support virtual biopsy capability: Build classes to render vertex
buffer objects and store buffer data to 3DS format file.
The
client has a 3D bio-med application to use ultra-sound imaging of the human
breast for diagnostic purposes.
- Purpose
Create 3-dimentional
data export capability from vertex buffer objects into a standard format: 3DS.
- Development
Process: Rapid Prototype.
Built a small single
dialog MFC application with simple draw capability and then rewrote that
program using windows forms and the customer’s proprietary class library. [This was to insure a reliable baseline from
which to start.]
Wrote sample coding
using vertex buffer objects. Built a simple cube with lines base on the
“red book” vertex array cube and created a drawing example of both a vertex VBO
and an index VBO. I rendered the cube to
the screen using both glDrawArray and glDrawElement.
Chose the “little
bird” demo program from the deep exploration 3D tool and exported it as a (non-managed)
cpp file. Put the data arrays into the
name space of a new managed c++ class, then moved the functions over as both
managed c++ and global c functions. [The
little bird application uses a single vertex mesh, a single normal mesh, an
array of materials, and a funny little algorithm for calculating when to change
materials.] Modified the begin/end paradigm
to use vertex arrays. Set up some lights
and did some rotations and translations to make it look good. Duplicated the code and created a new class
derived from the customer’s vertex buffer object class to create and populate
the buffer objects. See results below:
Little Bird in a
managed code environment
- Verification
Process
Wrote software to
export a 3DS format file using a publically licensed c library called 3dsLib. Downloaded a 3dsviewer [called
ab3d.reader3ds.viewer3DS.exe] from the net to verify the 3DS file so produced. Resulting 3DS version of little bird:
Little Bird displayed
in 3DS file viewer
- Enhancements:
Adding texture coordinates to 3DS
Stored texture
coordinates into the 3ds file along with the vertices and then created a vertex
buffer object (VBO) for rendering to the screen. Rendered the checker board with vertex
arrays, creating the texture coordinate with: glTexCoordPointer
instead of glTexCoord2f. Rendered a textured cube from a 3DS file. Rendered the
vertex and
Texture
coordinates stored in 3DS file format.
SARNOFF,
Inc., July 2008 – Jan 2009 C, C++, Python, Corba, OpenGL, Consulting Programmer
Make
enhancements to a global mapping system capable of showing terrain and live
data. This is the Standard Ground
Station for the
The
c++ code was built using Visual Studio 2005 (VC 8.0). The python code was built using Ganymede
Eclipse with SlickEdit for code writing and python 2.5 drop in editor for Eclipse;
wxPython versions were 2.6 and 2.8
- Create new Corba
Remote Procedure Calls between a c++ executable and a python executable.
Modified the IDL and
let the Corba tools rebuild the interfaces.
Added handlers on both sides of the Corba interface. Cut / paste / and edit new IPC
functions. The GUI was written in Python,
the OpenGL was done in C/C++.
- Investigated
mathematical singularities in the projective geometry
Investigated point singularities
in the projective geometry over the poles.
I had been reading a math book about adding bad points back into the
finite group one at a time. My instinct is that it is typical to solve a
problem in the real number system and then work out the code using floats,
doubles and integers not realizing that the algebraic properties [abstract
algebra: groups, rings, fields] for these subsets are quite different. In fact I think that with a proper algebraic
treatment these finite sets might be quite a bit more malleable than the real
number system. I created proper inverses
for the points and patched around the floating point errors. Still there were a number of special cases
throughout the code. The technique for
bad points is to treat each point separately and give it “group” properties. This problem remained an open investigation.
- Execute the Coverity
Prevent Defect Checker and correct defects.
Ran the Coverity
prevent checker which detected about 750 potential defects and corrected about
250 defects. Approximately 250 of those flagged were false positives. Another
200 or so were a result of automatic code generation by various tools. An
excerpt from my notes on the Coverity Prevent Defect Checker:
1.
BUFFER_SIZE_WARNING 3/3
2.
CHECKED RETURN 13/13, but I’m not altering
the flow of control based on the result, not yet.
3.
DEAD_CODE 0/6 I have not decided what
to do about these. I may just #if 0
around the dead code and see the effect, I am cautious about chopping out code,
since we don’t do dynamic coverage. The
real error could be that the logic to skip over the dead code is in error.
4.
FORWARD_NULL 35/35 but I’m not changing
any of the generated Corba code, obviously.
5.
MISSING_LOCK 4/4, but one of these,
required no lock. I discovered this the
hard way, when the renderer suddenly stopped working, I hadn’t done a build in
a few hours and it took a while to find what broke.
6.
SECURE_CODING 150? Corrected string functions to prevent possible buffer overflow
[all of the deprecated sprintf type functions]
- Created
asynchronous function call capability in Python: Threads, queues, and
locks
Utilized python’s
built in thread, queue, and lock functions to provide asynchronous client side
function calls. [Python allows very
smooth integration of various types. In
this case, what would be called a function pointer in c was placed on a
queue. New threads are simply created in
python. Worker threads can access the
queue removing the “function pointer”, which in this case is simply an
identifier with no special characteristics other than being of type
executable. Execution of the function
was simply by name. The l-value derives
its type from the r-value. No special code was required for declaring function
pointers or delegates or any c, c++, c#, type mechanisms.]
- Perform code
maintenance
Create various minor
code enhancements at customer’s request [US ARMY].
BARCO,
INC. December 2006 – June 2008, c, c++, OpenGL, Consulting Programmer
Develop
an OpenGL graphics driver.
- Client Side
Display Lists
Designed and wrote an implementation of a safety
critical version of the OpenGL display lists capability. The native Display List functionality for our
graphics card utilizes list architecture with memory management on the server
side [GPU]. This functionality is not
allowed for our avionics application. I
have rewritten this code to use finite arrays OpenGL client side.
- Segment Swapping
Algorithm
Designed and wrote
code implementing an algorithm to change the order of execution for segments of
code within a display list. The
algorithm slices the code into segments, creates a tree representing the
segment structure, and traverses the tree according to a set of reversal
operations.
- Saved Display
Lists, Decoding and Encoding, OpenGL does not provide for the saving of
Compiled display lists. A customer
enhancement of a previous driver captured the compiled display lists and
saved them to a file.
Designed and wrote
code implementing an algorithm to parse the binary of a compiled and saved
display list. The display list had been
compiled for a different graphics card, so it was necessary to regenerate the
OpenGL commands and recompile them for the new graphics card.
- Vertex Arrays
The tricky part was
making it work with display lists. I
expanded my test frame to test functions against the ATI driver and the Barco
Driver.
(The upper left openGL
display is a vector font library stored as a series of vertex arrays stored in
a saved precompiled display list; a customer openGL extension provides saving
precompiled display lists)
Vertex
arrays at work
- Read Pixel
Wrote read pixel
code, this task involves locating memory mapped chip address in local address
space and converting chip format data to standard GL types
Figure out what the
actual addresses are for the frame buffer memory. Enable the pipeline bypass to do direct
memory reads.
- Test frame for
conformance testing
Designed and wrote a
graphical test framework for running the OpenGL EC-SC conformance tests. See picture
on the left above.
- Test frame and
performance testing.
Designed and wrote a
set of OpenGL performance tests, an accounting structure, and a test frame for
running the tests.
- Blend
Wrote blend
code. This is pixel unit micro code. I Modified anti-aliasing codes to improve
speed.
- Alpha Test
This is fragment
shader code, not GLSL, this chip does have GLSL. The language is “c-like”. It translates assembler
to horizontal micro code which drives the programmable units on the graphics
chip.
- Push / Pop
Attribute, Push / Pop Client Attribute, Push / Pop Matrix.
I built various
reworks, fixes and new code for the above.
- Multi-partition
code separation.
I re-split OpenGL
into client / server model. I then connected
via sockets to simulate the 653 partition boundary.
- Modifications to
pass EC-SC conformance tests, reworking depth processing.
- Rewrote graphics
context initialization sequence and state flush code
- Code clean-up
MISRA rules, etc.
SHURE,
INC. August 2005 – December 2006: Consulting Programmer:
Technical
Lead Windows Development: COM, COM, nothing but COM, Visual C++ 7.1 and 8.0,
- Simulation and
test. Developed the
messages for communication to the hardware. Wrapped an existing hardware
communications simulator in an MFC GUI and added the capability to
represent various devices and frequency configurations. Built a simulator client which
duplicated the functionality of existing and new hardware. This software looks just like a device
and behaves the same way. The simulator and its client are fully
functional models at the external messaging level. This is to support testing
the communication protocols prior to delivery of the hardware. The new components, from project #2,
recognize the new device, but still retain much of the behavior of the
original components. The simulator
client can also talk to existing hardware and can be used for automated
test of the hardware if required.
- Enhancements. Wrote a requirements document and an
interface control document [ICD]. I
built twelve new COM modules, but this was not new code, I was simply
cloning the existing modules and refitting them for the new hardware. I reverse engineered the COM modules to
produce the ICD. Built a top level COM drawing containing the software
connections for the new system. Wrote a project development plan for the
GUI component of this project. Developed
a Microsoft project schedule for the GUI software development. The new COM modules are running and the
simulator below shows up in the application as a valid and communicating
device. Picture of COM diagram and
little simulator front end.
- Maintenance. Performed Software cost estimates for
all defects. I used an exponential grid philosophy to produce the
estimates. Wrote a software
documentation specification, that is, a document to describe what does and
does not need to be documented in their software. Performed bug fixes and new development
in C++ and performed install shield builds. After doing estimates for all of the
defects and enhancements, I created a software development plan containing
a schedule of development. We created a phased software release and have
made all releases, so far, on schedule.
I wrote most of the code for the first two milestones. Lately, I have been more involved in
managing since we have more activities to coordinate and we are
integrating a number of parts and pieces.
STEREOTAXIS,
INC.: July 2004 – June 2005: Consulting Programmer:
Modified
and enhanced existing code base: OpenGL / Windows XP / VCC 7.0, St. Louis, MO.
- Designed
and Developed an OpenGL
enhancement providing touch sensitivity to an OpenGL 3-dimensional model
of the heart. This capability
allows a catheter to be directed through the heart via touching the
location on the OpenGL model and hence modifying a magnetic field which
directs the catheter. The model can
be rotated and scaled. Preset locations
can be stored graphically on the model.
This project was mostly mathematical in nature. Most of us are accustomed to being able
to select objects with-in game programs, etc. However in those cases, the z location of
the object is known to the program and hence to the user. Since the medical models are derived, scaling,
orientation and most of all, the z component of a given point on the
surface is unknown to the user or the program. Therefore the z – component
must be derived from the un-projected and un-rotated model. My initial
algorithm used a sphere moving down a line (ray) to discover points within
the model within a certain epsilon of the intersection point. Later I developed an exact solution for intersecting
a ray and triangle in space using point – vector descriptions for both the
ray and vertex triangle from the model.
Surrounding this algorithm is the linear algebra necessary to
calculate positions and directions for the ray trace, locations of various
other superimposed models, such as the catheter and preset locations, and
calling library functions for the physics and the graphics. I used both the supplied Linear Algebra
language and well as my own math functions. Most of the OpenGL work was
fairly ordinary: lighting, rotations, colors, and projections. One thing of interest to me was a creating
a clip plane which allowed the user to see into the atria by making the
top half mostly transparent and the back half opaque. As the object was rotated the clip plane
remained at (0, 0, 1) parallel to the view as the object was rotated. The mathematics could then select
surfaces inside of the object. The algorithm was designed so that the clip
plane could be moved through the object with the next exposed surface
selected for catheter targeting.
That capability is not yet added.
Another interesting piece of mathematics is the registration of the
model to the patient x-ray. The
concept is single point registration or pinning of the model to the
patient data. This assumes known
rotational variation and scaling variation. Below: My work is the open GL in upper
center of screen:
EFW,
Inc.: Jun 2004 – December 2004: Consulting Programmer:
Developed
code Windows XP / Visual C# / Integrity Real-time / C
- Developed
test software for a new flight computer for the Apache helicopter. Wrote the system specification and the
software specification for the maintenance interface. [The maintenance interface is a set of
cabling that allows access to the computer in a closed box maintenance
mode.] Developed real-time embedded
c code under the Integrity operating system to
respond to the commands sent from a graphical user interface written in C# running on a standard PC
running windows XP. Developed a
graphical display which showed all of the components of the new computer
and all of the internal communication pathways. Designed and built a test description in
XML which could be sent over a
socket to the real time software running on the box. I designed a set of data flow diagrams
for all of the top level tests for the box. The test scenarios were displayable on
the top level interface for the graphical user interface. In other words, the test description is
presented graphically to the user and presented as XML to the test box. The
following describes my object oriented methodology: I read through the system specification
for the new computer and began to add objects to a Visio drawing for each
software entity or data source. I started
out with UML but the drawing began to be extremely cluttered without even the
beginnings of an idea about classification of objects or their
relationships. I switched over to just block diagrams where I could show
each board in the system and each processor on each board. After I had identified all of the
components and subcomponents, I iteratively rearranged the drawing for
symmetry and simplicity. At this
point I was able to assign software functionality so that each quad board
and each dual processor board worked in a similar fashion. If processor B on board 1 handled the
OpenGL chip, then processor B on boards 2 – 4 did the same. A similar assignment was made for
internet processing, graphics merge, etc.
Then I visually connected up all of the boards to distribute
communications evenly across all of the data paths. To be clear: this is a test program
design exercise. I was building
this program fro testing a computer system that is still in the early
phases of design. The systems
engineering group was performing a similar analysis from an electrical and
processing standpoint. The final
design topologies ended up almost identical. The boards were being programmed in c
and were not object oriented, but it seemed like the test task would be
extremely redundant so an object oriented approach would be viable for the
test software running on the PC. I
created data flow diagrams for each top level test scenario from the
system block diagram created above.
The previous paragraph
describes a c# program running under windows talking to a c program
running under integrity communicating via XML. The window IP stack does
successfully talk to the IP stack on the real time board.
LIVING
SOFTWARE, INC.: January 2004 – May 2004:
Research
on version 7.0 compilers: MICROSOFT WINDOWS / VCC 7.0 / .NET / C# / VB:
- Testing
.NET functionality across all .NET languages: Built an XML web service in c# and a
consumer. Used ADO.NET to access an
SQL database. Built a number of
form based programs in visual basic and c#, accessing c++ ActiveX controls
wrapped as NET controls, as well as c++ methods within a DLL. Exception handling is the same across
all languages and it is possible to throw an exception in one CRL language
and catch it in another. Created
delegates as a generic typedef for wiring function pointers into events. Created setup project to build an
installation program for a VB.NET app.
Building managed DirectX applications in C#.
ABBOTT
LABORATORIES: JANUARY 1998 – DECEMBER 2003:
Consulting
Programmer: WINDOWS / C++ / VCC 6.0 / MFC / ATL / WIN32 API / DIRECTX / OPENGL
/ GDI / ACTIVEX
- 1998 Assembled new, fully
functional, clinical chemistry system analyzer combining Abbott’s
Immunoassay software and Toshiba’s Clinical Chemistry hardware and it
worked! Prototyped clinical
chemistry “in vitro” analysis system: Printed out all Dos based screens
and rigorously compared to product line windows code. Reverse Engineered product line code using
Rational Rose a Win32 / C++ program. ( A medium sized application @ 1.5 M
lines of code ) Developed bridge software between existing structures and
classes and new database schema. Rebuilt or created new screens for the
new prototype. Built new OpenGL and
GDI ActiveX controls to display chemical reaction across time and
frequency and the display of calibration curves. Integrated and rigorously tested the
prototype system. Created an
“Install Shield”. Published the prototype software on CD almost
daily. Produced 233 builds on CD of
this system over an 18-month period.
Team lead graphical user interface.
- 2000 Performed system level
Integration combining the above prototyped c8000 clinical chemistry
analyzer with a production immunoassay analyzer. Modified my OpenGL
ActiveX control for displaying multiple functions: spline, exponential,
logit4, logit5, for both Cartesian and semi-log displays. Wrote a working debugger, to be called
in place of “Dr. Watson”, which captured unhandled exceptions using the
primary windows debug loop:
Generated call stack, symbol tables, etc. from either dbg files or
a pdb files.
- 2002 Prototyped graphical user
interface for new CDNEXT hematology analyzer. This is essentially building
new screens, controls, etc. and testing against an existing dataset. Wrote
a COM server for graphically displaying complex multidimensional
scientific data using Microsoft’s DirectX game technology API. One can actually distinguish various
cell populations visually!
- 2003 Re-factored software
system: Changed all of the friend classes to subclasses of the translated
code. Modified the internal design
pattern from friend to child.
- 2003 Automated test project
using silk test. Attempted to
borrow V&V’s test scripts for reuse by the development group. Code
coverage analysis. Mixed success.
- 2003 Developed software test
rig for performing built in test on ActiveX controls using generic COM
container software. Constructed tests
as generic C++ template functions.
Wrote function templates which walk the dispatch functionality,
then dynamically invoke constructed test functions, with the proxy / stub CWnd
for the COM server as the <T> parameter. Added
error code events for the ActiveX controls. Created connection point to an ATL
control.
- 2003 Converted Client side
application to UNICODE. (Note: This was an ongoing team effort.) Displayed Kanji characters to the screen
using code page 1200 and MS_SHELL_DLG font.
Siemens DEMATIC
AG (Electrocom AUTOMATION): December 1995 - November 1997:
Consulting Programmer: WINDOWS / VCC
5.0 / C++ / MFC / ACTIVEX
· Development of an automation system for control and data presentation of a nationwide postal sorting system. New design, coding and test of Windows NT graphical user interface. MFC development with document / view architecture. Extensive use of new VC++ controls: Property sheets, Tree controls, List controls, Custom toolbars, etc. Constructed viewers and database engines for four real-time memory image databases. Windows MFC Printing. Inter-process communications via custom message classes and global sections. Software for direct modification of the registry. Complex class serialization. FTP client retrieves configuration data remotely, updates the registry and loads global section for other processes. Documented project using Rational Rose analyzer: reverse engineering system to Mil spec 2167 design document.
MISCELLANEOUS
COMMERCIAL SOFTWARE DEVELOPMENT EXPERIENCE: 1991 – 1995 VCC / MFC / OWL / SDK /
ACTIVEX
· Performed object oriented design of distributed and remote objects in Rose C++. Object oriented consulting and mentoring for first object oriented project at the company. Utilized collaborator / responsibility (CRC) and Booch (UML). Facilitated C++ class design, developing objects at both the class level and the component level. Designed distributed configuration database server utilizing classes described above for persistent storage of a configuration profile class.
· Performed alpha test and defect removal for an upgraded C++ GUI based credit reporting system.
· Designed new 32 bit object oriented C++ software application. Performed data modeling and verification utilizing the Access database. Developed multi-process / multi- threaded solution. Utilized anonymous pipes for interprocess / inter-thread communication. Developed add on classes for adding this communications model to the existing system. Tested interprocess and inter-thread communications.
· Designed message routing and translation function of a real-time Object Oriented paging system controller under Windows NT server. Utilized various well-known methodologies for this Multi-threaded / multi-process application, utilizing pipes for inter-process message buffering and sockets for TCP / IP client-server connectivity to transmitter sites over X.25 land lines. Coded console applications and message translation classes. Utilized Access / ODBC to simulate the client / server processes. Constructed GUI test program for directing message traffic.
· Developed a number of new ActiveX controls: toolbars, menu, status bars and application base classes. Designed and constructed a data conversion program for translating data from an existing ISAM database into an Oracle database. Created a new schema and detailed one to one map between all elements of each database. This involves approximately 1000 elements and 100+ megabytes of data per system. Designed an algorithm for automatically generating an SQL schema based on the data unique to each site. Some of the data is stored in free text format. An algorithm for parsing free text data into a relational format was designed and coded.
·
Performed Beta test, code enhancements,
and corrected defects of a C++ windows application. Developed and taught a
course curriculum in Object Oriented
Analysis. Based on
Coad’s view of OOA.
· Developed new software using Windows SDK and Microsoft’s C7 compiler for an intelligent tax system. Developed new C code to enhance the existing C-tree database applications. Debugged a large - 500,000+ loc piece of C code which was not formally documented. Enhanced a prototyped OLE annotation system and modified the C-tree interface to correctly represent the requirements. This application involved custom message traffic between the Frame, the Client and the MDI children. Wrote a Visual C++ index key converter for the C-tree database.
· Designed and developed graphical user interface and Object Oriented software for replaying prerecorded or synthesized digital audio frequency data (prerecorded or synthesized fault data) through high performance test equipment amplifiers. Provided multi-channel translation, automatic scaling, synthetic pre-fault sine wave data, division by Potential Transformer and Current Transformer ratios, and the editing and storage of permanent test plans based on the selected data channels. Developed an Objected Oriented Design for a new electrical meter test system. Developed a database system for tracking requirements throughout the product life cycle.
· AEROSPACE SOFTWARE DEVELOPMENT EXPERIENCE: 1978 – 1990
· Developed several financial database applications for Litton.
·
Managed software development team of
five engineers during initial phase of development of an embedded real-time
Infrared Imaging Airborne System. Initiated DOD 2167a software development.
Used Boehm's Software Engineering Economics COCOMO intermediate model to
project costs of both this project and a conversion of existing c code to
· Developed test plans and procedures to validate Mode-S (transponder) radar ground station.
·
Reviewed research and development
projects: Artificial Intelligence,
· Designed and developed precision stage controller board firmware for the hardware graphics pipeline. Wrote IEEE 488 communications, image-recognition, initialization and control logic. Debugged new digital boards. Wrote portions of MS-DOS BIOS embedded driver for new token ring LAN board in Pascal. Used structured analysis and design to map requirements to transport / network layer protocols. Developed artificial intelligence algorithms for automatically generating test vectors for VLSI chips as part of Automatic Test Equipment expert system.
· Developed CASE tool (T-Parse / VMS) which automatically read and documented the internal structure of existing undocumented code.
· Team Leader software integration and test. Developed integration test software (VMS/ Pascal/ Macro 11 assembler) and performance studies for a new multiprocessor satellite data system. Discovered and corrected critical miscalculation in data flow design assumptions.
· Designed Direct Memory Access and Central Processing Unit Interrupt I/O cards for networking a VAX 11/780 to an IBM 360 channel controller. Managed the integration and test of MIPS SD ground radar display station of a fire control system. Wrote two papers on the computational requirements of deep space probes: "The Future of Deep Space Fight Navigation" and "Three Axis vs. Spun Spacecraft Navigation". Performed research and development in the area of deep space flight computers, especially multi-processing, task switching, and load balancing architectures. Member of flight computer architecture team for Venus Orbital Imaging Radar Spacecraft.
COMMERCIAL
SOFTWARE CLIENTEL:
SHURE, STEREOTAXIS, ABBOTT LABS, SIEMENS AUTOMATION, STERLING
COMMERCE, AMR, COMPUTER LANGUAGE RESEARCH, TRW (EXPERIAN), MOTOROLA, ALCON, AVO
MULTIAMP, U-SYSTEMS
AEROSPACE
SOFTWARE CLIENTEL:
LITTON DATA SYSTEMS, GENERAL DYNAMICS, UNISYS,