Sort of like wheel of fortune, pick an amino acid, and fill in the protein.

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.  The OpenGL portion was written in c++, the graphical user interface was written in python with widgets.  Communications between the processes takes place in corba.  This was not a python scripting application but a windows dialog application written in python. Princeton, NJ.  There have been dozens of people working on this project over the last ten years.  Of course, that can be said about most of the projects that I am privileged to work on.  Still it's nice to be able to see what is being described.

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

• Investigating mathematical singularities in the projective geometry

There were 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

SHURE, INC.  August 2005 – December 2006:  Consulting Programmer:

Technical Lead Windows Development: COM, COM, nothing but COM, Visual C++ 7.1 and 8.0, Niles, IL.

• 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:

I designed and wrote the ray / triangle intersection algorithm used to place a physical catheter in the same location as a virtual catheter.

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.  

Below: I built the active X controls and wrote the associated direct X 3D graphics code and I also wrote the code for the hematology panel in the middle left.

[ Home ] [ Up ]

Send mail to john@cosoftech.com with questions or comments about this web site.
Last modified: 07/27/09