John J. Xenakis - Resume Addendum - DOC and Text Formats

Descriptions of Selected Projects

Click here for: Resume Addendum in DOC format (updated November 2018).

Click here for: Resume

Click here for: Xenakis Professional Debt Calculator -- an Android app that analyzes debts in conformance to federal regulations

Click here for: Xenakis MathGame -- an Android app to test math aptitude of students


100 Memorial Drive #8-13A
Cambridge, MA  02142

Latest DOC/Word file:


** ABILITY NETWORK CORP. (04/2013-10/2014)

Ease is a real-time Medicare payment system.  Users log into Ease and
enter data to make a Medicare claim.  Ease stores the claim data into
the database, and then logs into the remote IBM mainframe that runs
the Medicare software.  The Medicare application assumes that anyone
logging in is using an IBM 3270 terminal, which was originally
designed in the 1960s.  The 3270 communicates with the mainframe using
3270DS (3270 data streams), which encode data in tightly packed
strings of bytes, using the EBCDIC character encoding.

Ease's code simulates a 3270 terminal by receiving and transmitting
3270DS strings via Telnet, but the 3270DS code is very arcane, and
hadn't been looked at in years.  Problems with it were ignored or
worked around.  As a sub-project, I took control of the 3270DS/Telnet
subsystem, and identified and fixed problems that had been around for

** NECTAR CORPORATION (03/2012 - 02/2013)

Designed and implemented new features and capabilities for Nectar's
Converged Management Platform (CMP), a heavily networked/threaded Java
system capable of simultaneously monitoring thousands of voice over IP
(VoIP) and network devices, including such measures as quality of
server (QoS) across an enterprise's entire phone system, including the

  * Took control of the entire Reporter subsystem. Developed a
    "Visio-like" graphical interface to the report generator.  A user
    can "drag and drop" various chart and table types onto pages,
    position them on the pages and resize them.  Then, when the report
    runs, the report manager draws data and data feeds from the server
    data base and creates a PDF with all the charts and tables as
    specified by the user.  The implementation requires heavy use of
    Java Swing, and the Drag & Drop API, as well as the JFreeChart
    charting library.

  * Designed and implemented a new system API (known as the "Domain
    Object API") to replace all the ad-hoc accesses to server data
    with a consistent API for obtaining data and data feeds from the
    server data base in a non-hackable secure manner.  This was
    designed so that an XML layer on top of the API would allow
    external tools to access the user data, for the first time.


Summary: Developed enhancements to the FAA's national Traffic Flow
Management (TFM) system, related to automated rerouting of plane
flights as required by weather or overcrowded skies.  Worked on the
Traffic Situation Display (TSD), a program that displays all flights
in real time on a large map, allowing-down into specific details for
particular flights, routes, or particular regions.  TSD is written in
C++ STL and uses Motif for all dialogs and displays.  In addition,
used third party products XRT/Table, XRT/Gear and XRT/Field from IST
Limited to create special purpose widgets.

TSD is a large complex program that's been under development since the
1980s.  Arrived on the project at a time when TSD was turning into a
sophisticated real time system with numerous different types of
network messages and dozens of new Motif dialog boxes.

As an adjunct to the development work, developed an AutoTest tool that
greatly improved productivity.  This tool had these features:

  * Run tests with the Motif GUI under script control.
  * Execute scripts involving any of TSD's 200 dialog boxes and menu
  * Execute scripts with variables, expression evaluation and
  * Trace incoming and outgoing network messages to identify problems.
  * Track memory usage, so that memory leaks can be detected.

This quality assurance tool is described in detail in:

These tools permitted identification of bugs that otherwise would have
taken much longer to find. Also wrote a number of other tools: Unix
shell script tools for Red Hat Linux, and Emacs lisp macros for

Won an award from CSC for the paper, "International Business
Forcasting Using System Dynamics with Generational Flows"

** BOSTON TECHNOLOGIES INC. (10/2007 – 02/2008)

Summary: Designed and implemented a major enhancement to the company's
standalone "bridge" product line to allow components to be distributed
over networks.  Used Java J2EE with Swing and RMI.  The application
was an online Forex currency trading system integrated with
MetaQuotes' MetaTrader4 trading platform.

The company markets a collection of "Bridge" products that permit
anyone to become a Forex (foreign exchange) broker.  You run this
product and customers can buy and sell currencies through your system.
You take 1-2% off the top of each trade, so you make money no matter
what happens.

The configuration is this:
Customer <-> MetaQuotes' MetaTrader4 <-> Bridge <-> Banks/data feeds

The data feeds from banks are presented to the customer as real-time
currency quotes.  The customer can initiate a buy or sell order
through MT4.  The order is sent through the bridge to the bank, which
accepts or rejects the trade.

The Bridge runs as a desktop application, and communicates with only
one bank at a time.  The client wanted the program modified so that it
could communicate with multiple banks and data sources simultaneously,
and to include a trading algorithm that selected the best bank for any
given transaction, depending on the values in the data feeds.

The implementation required a complete redesign and refactoring of the
Bridge Java code; a process that could be described as "untangling
spaghetti." All the code for the different features was tangled
together.  Completely redesigned the class structure for the program,
untangled the code and moved it around within the new class structure.
The resulting Bridge product could then configure itself at run time
communicate with MT4 or with a bank/data feed.  Thus, a Forex broker
could have 5 copies of the Bridge application running, one of which
communicated with MT4, and the others communicating with four
different banks.  The application copies communicated with each other
via Java's RMI (Remote Method Invocation) capabilities.

The architecture of the result was designed to be as flexible as
possible, by isolating all major functions in separate classes, and
tying them together through well-defined interfaces.  This had the
added benefit of providing a framework for intensive testing; each
component (UI, MT4, bank, selection algorithm, data feed) could be
replaced by a test module that generated thousands of test cases
programmatically.  The application was heavily threaded, so that
different processes could run independently and communicate with one
another through synchronized message queues. Eclipse was used as the
editing and debugging tool.

** DIGIMARC CORP. (03/2007 – 08/2007)

Summary: Designed and implemented .NET/C# system, including database
access (SQL and Pervasive/Btrieve), message queuing, integrated error
and exception handling, with function calling to and from existing C
DLLs.  Includes an IIS Web Service (ASMX).

The company sells a "secure id" service, and is responsible for the
manufacture of drivers licenses and other ids for a number of states
and countries.  Massachusetts drivers licenses are manufactured by

The company's existing manufacturing software was antedeluvian.  It
was written in C, using a Btrieve back end, with SQL capabilities
provided by a Pervasive layer.  All database table formats were wired
into the C code.

The State of Texas and State of Virginia specifications used new
manufacturing devices that would require significant additions to and
expansions of the existing data base records.  In order to meet these
requirements, a major upgrade would have to be made to the company's
core software.  Sole resource in completing this project, as the
entire software group had recently resigned and the supervisor was
taking a long sabbatical.

Implemented in 2 stages:

In the first stage, modified the C core system code so that it could
handle more database table records.  This was very messy, because the
data base fields were deeply wired into the code.  Redefined the basic
table record structures in the C code so that they contained all the
needed fields in all required records.  (Think of this as the "logical
union" of all the fields in all the required record formats.)  All the
C functions then used these expanded definitions, so most existing
code continued to work without change.  Subsequently modified the
low-level routines that read and write data base records to copy the
data in the enlarged record formats to and from the customer-specific
record formats.

The 2nd stage required a C#/.NET implementation in order to support
new manufacturing devices.  Wrote about 12,000 lines of C# code for a
re-implementation of the entire C core system in .NET.  The new core
system handled SQL database access, including generalized table record
formats, message queuing, integrated error and exception handling,
configuration support and log file support.

In conjunction, implemented the driver for the manufacturing device
that sprayed tactile data onto the drivers license.  Communication
with the device was through an RS-232 port, and the user interface
used WinForms.

Integrating all the legacy code with the new code required function
calling among managed and unmanaged DLLs in C and C#.  This was one of
those instances where only ten lines of code are required, but it
requires research to figure out what those ten lines are.  Also
integrated a small test Website, including an IIS Web Service (ASMX).

** US AIR FORCE (CAC INTERNATIONAL) (08/2004 – 06/2006)

Summary: Participated in design and implementation of CITS Block 30, a
high-security networked system to be deployed throughout the US Air
Force, using, IIS, C#, Apache, Netcool, Active Directory (AD),
Directory Name Services (DNS), and related security tools.

Instrumental in a large Air Force project involving dozens of hardware
and software engineers.  Charged with a wide variety of
responsibilities, including setting up IIS and Apache Web servers and
Websites, testing and implementing SNMP network management systems
(Micromuse Netcool, EMC Smarts and others), evaluating content
management systems and providing designs for various components.

As an example, Micromuse Netcool is a very sophisticated SNMP-based
network management tool able to monitor thousands of network devices
simultaneously.  It's a multi-component tool, a combination of many
other tools that were acquired from other companies.  As a result,
learned 6 different scripting languages to handle it.

Conducted an evaluation of the leading industry content management
systems, and became familiar with all of their features and
functionality.  (The 2 leading content management systems are EMC's
Documentum and IBM's Document Management System.)

** 401KLOANS.COM (11/2003 – 03/2004)

Summary: Effectively implemented a C# and ASP.NET application
supporting the Federal Reserve Truth in Lending Law (Regulation Z,
Appendix J).

The regulations for computing the APR are contained in the Federal
Reserve Truth in Lending Law (Regulation Z,
Appendix J).

Implementation of "Reg Z" is fairly straightforward when you have a
simple case -- a simple loan or credit card, for example.

But implementing the entire regulation is very complex, because it
handles all the complications (multiple advances with different
interest rates, multiple fees, multiple prepaid fees, multiple
irregular payment schedules, etc., all occurring at different times).

At this time, conducted an internet search and could not find anyone
who had done a complete implementation of Reg Z.  It's undoubtedly
been done in some banks' back rooms, but nothing was publicly
available at the time. Successful in completing one of the few full
implementations. The implementation of the "loan calculation engine"
(not including the UI) was 6000 lines of C# code.

** COMPENDIUM RESEARCH (06/2000 – 08/2000 AND 03/2002 – 09/2002)

Summary: In 2000, wrote mortgage calculators in JavaScript.  In 2002,
took control of large, badly slipping C++ development project and
brought it back on schedule.  Designed and developed Windows/Linux C++
software to parse and process 60 GB of data, loading it via Oracle's
SQL*Loader into a 34-table, optimized Oracle database.  JavaScript :
mortgage financial mathematical computations.

The project involved reading the print images of telephone bills and
storing the data into a database.  It was like a "screen-scraping"
program, except that it was for print images.  There were several
different formats, depending on the phone district, and each had
different pricing options and features.

The program had different front ends for the different formats, and
the front ends were table-driven as much as possible.  The back end of
the program did internal quality assurance by reproducing all the bill
computations and verified that everything added up correctly.

Implementation required designing a database structure involving over
30 tables.  During the development process, to be able to change the
table definitions quickly, coded the database design as a series of
"#define's" in a ".h" file.  The ".h" file was used in various coding
sequences in the program to provide for table-driven coding.  Enabled
change of the database design and most of the code adjusted
automatically to the new design.  Also wrote a separate program that
used the ".h" file to create file with "delete table" and "create
table" SQL statements, so that the database structure could be quickly
re-created within Oracle.  This created a great deal of flexibility
during the development process, so the tables could be changed quickly
for iterative development.


Summary: Took control of major behind-schedule Java development
project enhancing the American Express Financial Library Website and
the Merrill Lynch Investor Education Center Website, and brought it
back on schedule.

  * Site development required integration and implementation of
    numerous technologies, including Java Server Pages (JSP), Java,
    JavaScript, HTML and Perl.

  * iPlanet Web server accessing a Sun/Solaris-based Oracle database,
    using homegrown Content Management System (CMS).

Asked to resolve the performance of the administrative screens.  You
could select several options for a report and click "Submit," and it
would take several minutes for a response. Determined that the
existing code was making multiple SQL requests to the Oracle back end,
and they were taking a lot of time.  For example, if someone requested
a weekly report from January to June, then the JSP would submit one or
two SQL requests (depending on the filtering options) for each week.
Rewrote the software so that it took the time series request (daily,
weekly, monthly) and the various filtering options and assembled a
single SQL statement to retrieve the entire table.  The SQL might be
very long – sometimes several hundred lines long, containing numerous
sub-tables and joins -- but Oracle handles such things very well.
This fixed the performance problems, and the administrative screens
now got almost instantaneous response.


Summary: Modified middleware interface to support XML/SAX transactions
for AlertDirect, a host-to-host transaction-based management/alerting
system for financial services firms.

This was a brief C++ project that required integrating XML/SAX
functionality into existing software.

** STATE STREET BANK (05 /1999 – 11/1999 AND 02/2000 – 02/2001)

Summary: Developed front-end (Windows COM, ActiveX, MFC), middleware
and back-end (UNIX) development of large multi-national financial

  * Application was written in cross-platform C++, linked to multiple
    databases (Oracle, SQL Server, Sybase, Informix, ODBC, ADO), and
    communicated (TCP/IP) over multiple UNIX and Windows servers.

  * Installed virtual private network (VPN) applying DES and AES
    (Rijndael) encryption. Implemented Unicode data flows and
    international character sets (Japanese Kanji and other Asian sets)
    using IBM's ICU.

This was a heavily threaded application that was used by customers
around the world.  The user interface was a highly complex MFC Windows
application, using just about every MFC capability available.

The middleware and back end might have to run on various platforms,
depending on the customer.  Supported platforms included Windows and
several versions of Unix, along with any SQL database.  So the C++
code had to be "cross-platform," meaning that the middleware could run
on any supported platform.

The database interface was implemented as a database layer that
provided a standard API that was used by all the middleware
applications.  There were drivers written in C++ for the
database-specific APIs for each of Oracle, SQL Server and Sybase, as
well as drivers for ODBC and ADO.  Most memorable was the Sybase API,
which included a complex internal crazy making "transaction transition
model," and required a 2000+page manual to document.

** STAPLES (12/1999 – 02/2000)

Summary: Created VB tools to support applications on
site. Automated real-time Website monitoring with service interruption
alarms.  Other applications targeted IIS and SQL Server.

Requested to develop a collection of Visual Basic (VB6) applications
to perform various administrative tasks.  The largest was a program
that tested the Staples Website.  It would bring up the home page,
click through to a product page, click through to a specific product
page, select specific options and click through, and so forth.  There
were typically about 8 pages in the sequence, finishing with the
selected product in the cart, and the program requesting a credit card
number.  If the test failed twice in half an hour, then the program
would automatically notify people -- via e-mail and via beepers.  This
allowed Staples to guarantee uptime.  The program was highly
configurable, with interfaces that allowed the easy addition of page
sequences, modification of the list of people being notified and the
notification methods.

One particular performance problem is worth noting.  The program would
work fine for several hours at a time, but then would slow down
considerably.  Diagnosed this as a memory management problem -- memory
was getting fragmented over time.  The program worked by bringing up a
Web page, decomposing it using the DOM (document object model) API and
creating a tree within VB using internally allocated node objects.
There might be hundreds of these node objects for each page, and then
they were all freed when the Web page analysis was done.  The fix to
this problem was to avoid freeing the node objects by maintaining a
free chain of unused node objects, and allocating new objects from the
free chain.  This modification completely solved the performance


Summary: As Senior Analyst, accountable for Development and Quality
Assurance. Charged with the complete object-oriented design and
development of several Windows-based application programs, including
the following:

  * Upgraded a large Windows 3.1 program written in C to C++ using MFC
    (Microsoft Foundation Classes) and Win32, to take advantage of the
    graphical features of Windows 95 and Windows NT.

  * Designed and developed C++ implementation of multi-tasked,
    multi-threaded Quality Assurance test program running on Windows
    NT for testing the company's network communications product.

  * Gave a five-day course to the company's employees on "C++ and
    object-oriented development for C programmers," in order to
    upgrade the employees' skills capabilities


Summary: As Senior Consultant and Project Leader, developed several
embedded operating systems on various microcomputer CPUs, including
device drivers and simulators. Also built several tools for
development of embedded systems and supported groups of developers
using Assembler, FORTRAN, Jovial and Ada.

  * Developed dozens of system administration tools in VAX DCL;
    created floating point and instruction-level hardware simulators
    in VAX assembler language and C.


Summary: As a Consultant, designed and developed a full-language PL/I
compiler on DEC's mainframe computers, using Assembler language.


InformationWeek Magazine, Boston Bureau Chief / Technology Editor, 1990-91
CFO Magazine, Technology Editor and Columnist, 1992-2001 (part time)


Java Programming through Northeastern, EMC, 2001
Java Programming through Northeastern, Sybase, 2000
C++ Course, Process Software, 1994
C Course, Grumman, 1985
IBM Mainframe Assembler, Boston University, 1980-81
IBM Mainframe PL/I, Boston University, 1979