2007-Present: For a small software company, designed and wrote a
Web application for sale to large regulated corporations (pharmaceutical,
cosmetics, auto parts, medical devices, fertilizers, etc.) to taglessly
track products for detection of counterfeits and distribution chain violations:
- Architected (see diagram), designed, implemented, tested, documented, and demoed
the Web app, using MySQL, Tomcat, Java, JDBC,
- Installed, configured and hosted the Tomcat app servers and MySQL
DB servers on Linux and Windows.
- "Filthy rich" client interface: liquid
interface with draggable self-calibrating dynamically constrained
move, etc. but requiring no client install.
- Multi-window master-detail drill-down user interface,
running in any browser.
- Data validation and access control performed at all
levels (UI, App server, DB), but only specified once.
- Portable across all operating systems, DB servers, App
servers, and browsers.
- Ajax transactions used for global validations, keep-alives,
- Full audit trail in a parallel set of DB tables.
- Fine-grained, attribute-based, hierarchical, cached access
control allows owner users to grant and deny other users the
rights to view, update, delete, and own objects.
- Comprehensive multi-level hierarchical logging of all
user actions and internal operations with automatic begin/end
matching, durations, indented layout for visual scan by a person
as well as timestamps, memory size, thread id, IP address,
username, browser name, etc. for use by log analysis tools.
- Entirely data-driven: constraints, rules, units, access
- Robust file upload and download w/access control, configurable
limits on file type and size, dynamic image scaling, etc.
- Custom connection pooling, monitoring, managing, and
- Admin tools for adding users, specifying initial access
control rights, etc.
- Self-reloading XML config file specifies all limits,
delays, timeouts, levels, scale factors, connection info,
locations, etc., so no server restart is ever needed.
- Comment posted by client to my LinkedIn page:
"Fred has done amazing work, far beyond merely turning our ideas into software.
He thinks about the whole problem, its context, its implications, and its future, and builds for the long term.
He meticulously documents the options overruled, and why, as well as the path taken, so nobody wastes time revisiting settled issues.
It's a pleasure working with him.
When I first hired Fred, his references were highly enthusiastic, and now I understand why:
his work is so polished, it's as if we got 2.0 instead of 1.0."
2005-2006: For an on-line bank, supported and enhanced Web
applications, Web services, and underlying architectural components, using Oracle
9i, WebLogic, Apache HTTP Server, JSP, Struts, EJB, JMS, log4j, JUnit.
- Enhanced login to use "Multi-Factor Authentication" images
and phrases obtained via SOAP calls to the Passmark Web Service.
- Converted Web site from HTTP to HTTPS.
- Implemented various new features and bug fixes.
- Created Wiki for use by developers containing:
- Comprehensive installation/setup/configuration guide for
- How-to guide for implementing new features, debugging problems,
searching logs, etc.
2004-2005: For a small dot-com company, helped develop a JavaServer Faces
(JSF) engine and set of components. Specific contributions included:
- JSF Engine Development
- Developed several pieces of the JSF engine, including
bean discovery, value bindings, method bindings, component
bindings, and event generation.
- Re-wrote several pieces to make them compliant with the emerging
- Re-factored the Java class tree for improved code sharing and
- JSF Component Development
- Developed Integer and Date JSF components to support user
entry of integer and date (month/day/year) values with
internationalization. Wrote the Java classes for the
code to do client-side validation in all major browsers (IE,
Netscape, Mozilla Firefox, Opera, etc.)
- Demos, Documentation, Training
- Developed demos and user/programmer guides for use at the product
- Taught team members advanced Java topics, like thread
- Taught team members how to use JetBrains IntelliJ IDEA, Microsoft
Script Debugger, CVS, and other development tools.
- Configuration Management
- Introduced the team and the company owner to the concept of
- Installed and administered CVS.
- Used Ant to automate builds, regression tests, and releases
as JAR, WAR, and EAR files.
- Unix System Admin
- Configured Unix firewall to safely support remote access by
- Automated backups via cron and tar. Debugged and resolved
network hardware issues.
1999-2004: For a large multi-national
pharmaceuticals company, developed a 3-tier Web application architecture
- Presentation Tier
The presentation tier consists of DHTML, XSL, CSS,
Tomcat web server, and displayed and executed by the IE Web browser.
They use the MSXML component to implement Ajax-style
loading, sorting and filtering of XML, and generation
of HTML via XSLT transformations.
- Business Tier
The business tier consists of Java components. Access from the
presentation tier is via Java servlets implementing REST
Web Services. Access to the data tier is
via JDBC using a shared pool of connections. The Xerces
XML parser and Xalan XSLT/XPath
processor format XML to send to the presentation tier.
- Data Tier
The data tier consists of an Oracle 9i database. All data is
retrieved via database views and updated via PL/SQL stored
procedures. Foreign keys provide referential integrity, with
triggers maintaining audit tables and additional referential integrity. Packages
add structure to the stored procedures.
The client estimates savings of 15
million dollars per year, increasing each year as it uses the
application to manage more clinical trials.
Previously for the same client, prototyped the following, demonstrating successful integration across tiers
using each combination:
- Alternative Technologies for Presentation Tier:
Java applets running in a web browser, using Xerces to
manipulate XML and generate HTML.
Visual Basic, using MSXML to manipulate XML.
- Alternative Technology for Business Tier:
Perl CGI scripts using DBI to access the database.
Previously for the same client, developed Web and database applications (which I later ported
architecture above) including:
- Inventory Tracking
Enhanced an existing application using VB, RDO, and Oracle
7.3 to track the inventory and distribution of drugs used in clinical
trials. Defined tables and views, and wrote stored procedures and triggers.
Wrote VB code using RDO to access the database and call stored procedures. Optimized
performance to maintain good response time despite a heavily loaded database server across
- Web Reporting
Designed and coded a Web-based reporting system. HTML pages are
generated by Perl 5 using DBI to access an Oracle
7.3 database. The user interacts with the pages specifying selection and
sort criteria for the reports, views reports as HTML tables, and downloads them as
comma-separated (CSV) files. All interaction is funneled through a common Perl
script to log interactions and dispatch specific requests to secondary Perl scripts.
Previously for the same client, developed a Generalized Database Front End.
Designed and coded a VB application to access Oracle 8
and Oracle 7.3 databases. The application presents the user with a
list of available plugins (stored procedures and SQL*Plus scripts), executes the selected
plugin with the specified parameters, and displays the results to the user. The
application is structured as 3 layers of cooperating components:
- Database Layer
Oracle packages provide a
stored procedure API for running plugins, scheduling runs to occur in the future, viewing
the output of previous runs, etc.
- Business Object Layer
COM components encapsulate all knowledge of plugins, runs, etc, including all database access (via the
database layer), validation, execution, etc.
- User Interface Layer (see
ActiveX Controls (OCXs) encapsulate all user interaction, including data access (via the business object
layer), presentation, undo, dirty flag, etc. These OCXs can be embedded in a variety
of host environments, including Visual Basic, Excel, Word, or Internet Explorer,
displaying their output in VB controls, Excel spreadsheets and charts, Word documents, or
1996-Present: Webmaster and Linux System Admin
for the Bristle
Software Web site (http://bristle.com).
- Installed and administer the Linux server running Apache Web
server, Tomcat, SMTP, DNS, etc.
- Author the Web pages to house my collection of thousands of tips and techniques
on topics including Java, XML,
Windows, Unix, VB, ASP, C++,
SQL, X, Perl, HTML, Lotus
Notes, and VAX/VMS.
- Maintain a mailing list for
each topic and mail the tips to subscribers as I add them to the Web pages.
- Wrote my own mailer to do the list mailings, most recently in Javamail,
previously in VB directly using the SMTP protocol.
- Currently, re-writing tips pages in XHTML and processing them
with XSLT transforms to generate RSS and Atom
1996-Present: Developing and supporting open source Java
- Applications: Image scaler, URL downloader
- Web Applications: Slideshow, MemoryMeter, ConnectionMeter,
- Packages/Subsystems: Logging, Database connection pooling,
Attributed-based access control, File and directory operations, Command line parsing, JPEG manipulation,
JSP helpers, Data dictionary, Multi-tier metadata and
- Classes: FTP, HTTP, HTML, SQL, XML, XSL, JDBC, Enhanced Java data types
(strings, exceptions, maps, arrays, lists), etc.
Source code: http://bristle.com/opensource/
1999-2000: Developed and taught an advanced VB 6.0 ActiveX
Component Development class for corporate clients. Covered all aspects of component development with
VB, including: designing and building ActiveX DLLs, EXEs and OCXs, data access via
ADO, debugging techniques, enterprise-scale support and scaleability considerations, etc.
1999-Present: Tutoring professional programmers in Java, XML,
VB, ASP, Unix and Windows.
1999: Prototyped a component application architecture. The
Java components can be configured in a variety of ways, including:
|N-tier Web application
running in a Web Browser. Web pages are generated by ASP using VBScript
on the IIS Server. ASP pages exchange data via XML with application
objects written in Java. Application objects communicate with a MS
SQL Server 7.0 database via ADO 2.0.
|J++ WFC Client/Server application
||Client is a J++ WFC application, which communicates with
the same Java application objects, and through them to the database.
|Java AWT Client/Server application
||Client is a Java AWT application, which communicates with
the same Java application objects, and through them to the database.
|Java Swing Client/Server application
||Client is a Java Swing application, which communicates
with the same Java application objects, and through them to the database.
1998-1999: For a small medical technology watchdog company, developed database
applications and portions of a government sponsored, database driven Web site containing
information about medical devices and procedures. Specific contributions included:
- Database (SQL Server 6.5 and 7.0)
Administered the databases and database server, defining tables, views, users, logins,
etc, and writing stored procedures and triggers. Ported the databases from SQL
Server 6.5 to 7.0.
- Data Entry Programs (VB 6.0)
Enhanced an existing Visual Basic ADO data entry program.
Re-architected from a "fat client" (the user interface code was intermixed with
the database access code) to an object-oriented 3-tier application with
thin client, application objects and database layer. Added the ability to add and
delete database records (the previous version only supported update of existing
records). Converted the internal HTML editor from a text-based editor (the user was
required to type in the HTML tags as text) to a WYSIWYG editor similar to
Microsoft Front Page or Word (the user can directly edit the rendered HTML).
- Web Site (IIS 5.0)
Helped write and administer the ASP scripts that pulled data from the
database and generated Web pages. Such pages are used by the internal users to
review data and generate reports for the government client, and by external users to
search for information on medical devices and procedures.
1996-1998: For a major financial services and mutual funds company, functioned as
a consultant to the Technical Architecture and Core Infrastructure team, which is
responsible for defining the software architecture for all corporate applications on Windows
NT and producing reusable software components. Specific contributions and
- User Interface Framework (UIF).
Designed, developed, documented, and promoted
the UIF (a 1998 predecessor to the RCP -- Rich Client Platform --
concept that gained popularity in 2007). It is a user interface framework written in VB 5.0,
that supports the
ability to "snap in" binary components at runtime. Application developers
produce screens as ActiveX controls (OCXs) in VB, and configure the UIF
to load each screen as the header or footer region of a window or as a tab of a tabbed
notebook. The UIF is completely data driven. It reads configuration data
at runtime to determine which OCXs to load and to dynamically build its menu, toolbar,
status bar, etc. To the user, the resulting application looks like a typical
well-integrated Windows application, but behind the scenes it is a collection of
cooperating components running in one or more processes, coordinated by
the UIF. Advantages of this approach include:
- Snap in additional screens without re-building or re-installing the entire application.
- A bug in one component cant crash the entire application.
- Dynamic loading of components for fast startup.
- Dynamic reconfiguration based on security.
- Consistent look and feel.
- High degree of reuse.
Used a RAD (Rapid Application Development) approach to design and
develop the UIF. Worked with an application group for 2 weeks to produce a working
prototype to demonstrate the concept and refine the requirements. Over the next 2 years,
added more and more function, always maintaining backwards compatibility. Also wrote
the tutorials, developers guide, and reference manual, and gave dozens of demos to
management teams and application groups. The UIF has been adopted for use by all in-house
client/server applications on Windows NT.
- Software Architecture for Windows NT
When I joined the team, all applications
were running on OS/2 in a variety of languages (C, Smalltalk, SQL Windows, Application
Manager). Worked with the lead architect to design a layered architecture
on Windows NT including user interface services, business services and data services. We
proved the feasibility of the architecture with a series of prototypes using progressively
more of the layers. For client/server applications, the user interface runs in VB
on Windows NT (using the UIF described above). For Web applications, the
user interface is HTML and Java in a Web Browser. The
data services, written in VB and C provide portable
access to legacy data sources (SQL databases, VSAM files and CICS programs) without
requiring changes to the legacy code. One division of the corporation has successfully
moved to this architecture and the other three are now following.
- Core Infrastructure Team
When I joined the team, it was an ad-hoc group of
developers with no documentation, no process, and no plan. The team was constantly
interrupted with support calls and the users were dissatisfied. One developer complained
that the hardest part of producing the next version of the software was to find the latest
source code from the previous version. Only one division of the company used the Core
Due in part to my influence, the team now produces regular quarterly releases of software
to all four divisions of the company, with a full regression test suite, complete
documentation (developers guides, tutorials, reference manuals, release notes and
Help files), an automated build process to reproduce old software versions from source
code archives, an automated bug-tracking utility, automated install/uninstall scripts, and
a Lotus Notes database for communication with users (announcements, tips/techniques,
questions/answers). Users communicate with the developers and each other via the Notes
database. Support calls are down, and the users are much happier.
- NT Developers Guide
Wrote a Developers Guide, containing standards,
tips, and techniques for use by all Windows NT developers. Created this as a "groupware"
application, using Lotus Notes, rather than a simple document, so that
all developers could review and publicly comment on the Guide as I wrote it. This approach
achieved dramatic "buy-in" from the developers because they could participate in
- Software Distribution
Learned and documented WinInstall, used
with Systems Management Server to silently "push" application
installs to thousands of PCs overnight. Taught application developers how to use it. Wrote
standards to avoid collisions between unrelated installs and to guarantee the ability to
uninstall safely. Wrote a utility program in C++ to check install scripts