|
SoftBase Systems -
SK Web Construction -
Miscellaneous -
Skills
Scott McMahan is a professional software developer since 1994, and
a part-time writer. This resume highlights some of the solutions to
business and customer needs which have been implemented over the
years.
While I have been at SoftBase over ten years, I have been
constantly growing into new responsibilities. I began as a C coder,
and have created the company's Internet and web presence; and finally,
began mainframe systems programming and software development.
Product delivery system for the web. I
created an automated process which replaced a manual one that was
becoming burdensome (and time-consuming) as the company grew. The
system packaged the components of a product release (binaries,
manuals, readme files, etc) from various sources (including the
mainframe) and put them into the web site. The program (written in
Java) used an XML project file (loaded from a mainframe project
library so mainframe-only developers could access it) to describe the
project. The program would take the actions in the file (download
files from the mainframe, copy files from a file server, etc), package
the release, and put it on the web site. Later the ability to set
variables in a MySQL table (used by the web site) was added, so the
web pages would be automatically updated with current information
about release dates and file versions. The system has been in use for
several years, and has proven to be adaptable to unforeseen needs.
Secure web site. Using industry best
practices, I created a portal site for customers to log on securely
and download products, download manuals, and send technical support
requests. This replaced an ad-hoc system which used
.htaccess files for resource-level access. Our tech
support is not centrally located, and frequently on the road, so the
portal had administrative access to view site activity. The site
logged much information about what was going on. The site was written
in PHP, using a MySQL database. The site has become a platform for
developing new features requested by technical support and sales (such
as e-mailing certain people when customers download the product,
integrating with distributors, etc).
Automated product packing and unpacking
system. Using an existing in-house design for shipping products
to customers with the mainframe standard XMI file format,
I developed an automated version of the packing and unpacking code
(which had been a manual process). Afterwards, I added an ISPF panel
interface to unpacking the code. The end result was based on extensive
customer feedback and field tech support experiences using our
original approach, so we could make customer installs of our products
as seamless as possible. The packing code was also integrated into the
web site, so users could submit jobs from there to pack a distribution
(for logging).
Complete company backup system. The first
component was a complete mainframe backup system, which wrote backup
to "fake tape" files (disk files treated as tapes) and compressed them
with bzip2 to make the files as small as possible. A full backup was
taken each weekend, and then incremental backups of changed files were
taken each weeknight. A naming convention kept track of the tapes and
job output for each backup. The second component was a set of
procedures to back up various servers to a central location, and
create a master backup. Once a week, the master backup was downloaded
off-site. Also, this weekly backup was written to DVD-RW. Monthly, an
archive copy of the backup files was written to a DVD-R. Low cost and
extremely flexible solution compared to alternatives.
FlexES emulator systems programming.
Learned and took over the care and feeding of a Flex-ES mainframe,
including installing CKD disk packs to UNIX disk slices (using an
automated method to improve accuracy and turnaround), mapping UNIX
devices to mainframe channel units, bringing up a new mainframe,
etc. Also day-to-day maintenance such as installing new version of
Flex-ES, using the emulator, etc.
Mainframe (MVS, OS/390, z/OS) systems
programming. A variety of tasks, including: IPLs. System
parameter (PARMLIB) customization and tailoring. Started task
setup. ISPF profiles. Catalog management. User and RACF
management. REXX and OMVS Perl programs for system management and
reporting. Bringing up IMS DB region and using sample programs and
DFSDDLT0 for testing. Setting up job streams for DBD and PSB
generations and compile/link/run for IMS DB programs. Test programs in
COBOL and assembler for using IMS, VSAM files. Coding JCL for VSAM AMS
(IDCAMS). Conversion and analysis of various dump formats sent to us
by customers (including Perl programming to display EBCDIC dump
records directly on the Linux FTP server, so we would know how to
transfer them to the mainframe).
Mainframe development and testing.
Developed a set of programs in multiple languages which tested a tool
for setting the clock backwards and forwards while programs ran. Did
various debugging and sending dumps back to the developers of the
tool. Modified started tasks to run with this tool.
Data masking tool. Based on a customer
request, I began work on implementing a mainframe product for data
masking in Java so it could be run against distributed databases (Oracle, SQL Server, etc) on multiple platforms. The original product
was so completely tied to the mainframe that no feasible way could be
found to port it, so I got to design the distributed systems version
from scratch. The result was one of the most complete and powerful
systems I've ever designed. The core product was a set of objects
which performed the various functions of extraction, masking, and
saving data. Around that was built a scripting language interface (for
Jython), and a graphical shell (in Swing), so the product could be
used through the GUI (especially important for demos) and scripted (by
advanced users). The project was cancelled about halfway through the
initial implementation.
Internet presence setup and
administration. I've been actively involved in installing and
upgrading software packages used in the Internet presence, which
included many remote users. Areas I worked on include but are not
limited to: DHCP, Samba, sendmail, apache, imap/pop3 (plus
Squirrelmail), secure instant messaging (Jive and Psi), ntp, security
(of the company servers, and secure access for remote users), etc.
Web monitor for checkpoint-restart tool.
Designed and implemented web-based monitor for administration and
dynamic changing of restartable programs. Built API for C and Java for
use by restart tool and client programs, and implemented a
browser-based administration interface using Java Server Pages.
Real-time data management tool.
Co-designer and implementer of a tool which harvests data from
real-time enterprise sources (databases, call center switches, etc.)
and caches for delivery to user desktops. Most of these sources have
"thin pipes" which allow only one data connection, and the source
can't handle thousands of desktop requests for data; also the data
harvested from these sources requires processing and reformatting to
be usable, including the kind of summary, aggregation, and logic that
only a programming language could provide. The solution to this
problem was a fully object-oriented system with interfaces for writing
harvesting components, processing data with a scripting language,
caching data, and presenting it to the user (such as in HTML, JSP,
XML, etc). Most important was the harvesting API, since each data
source (particularly call center hardware, where each vendor had its
own API) needed a custom-written harvester. The initial implementation
was for Win32 in C++, and used Perl as its embedded scripting
language. After real-world use, the feedback from this
proof-of-concept led to a redesign of the software, which included
many improvements to the core design and also a requirement that the
software be scalable to high-end servers, which triggered a decision
to rewrite in Java. I began much of the R&D for the rewrite, including
implementation of a revamped and much more feature-rich core of APIs
and interfaces, a full cron-like job scheduling subsystem, and a
pluggable architecture for adding interpreted scripting languages
whose interpreters were written in Java (initially including
JavaScript and Python). After I had gotten the software to a point,
the project was so large that several developers were hired to take
over different components such as the core product, the creation of
harvesting components, scripting and customization for customers,
etc. Since this point, the core product has been enhanced, as well as
extended in new ways using the various APIs. The flexibility afforded
by the modular, OO design has allowed the product to be extended in
ways originally unimagined.
Java checkpoint-restart tool. Designed and
implemented the first checkpoint/restart tool ever written in
Java. Using the basic paradigm of checkpoint/restart, I implemented a
system for creating restartable Java programs and restoring objects
which participate in a logical unit of work. The initial
implementation was quite early, when JDBC had first been introduced,
and the core code was later retrofitted to take advantage of new Java
technologies such as BLOB support in JDBC, as well as object
serialization.
Implementation of mainframe checkpoint-restart
API in cross-platform C. Using the published API of the
mainframe checkpoint/restart tool, I implemented a version in C with
an emphasis on portability to different platforms. The software was
beta-tested by a company who was porting a COBOL application which
used the mainframe tool, and expected the new portable version to be a
complete clone. Many undocumented and imprecise aspects of the
mainframe implementation were brought to light and introduced for
compatibility into the portable version. At one time or another, this
code has been ported to Windows, OS/2, HP-UX, AIX, Solaris, and Linux;
has worked with both DB2 and Oracle databases; and has worked with
many third-generation languages such as C and MicroFocus COBOL. Over
the years, this code base has undergone much change and improvement,
including the addition of the online monitor, an XML-based
configuration file, and support for 64-bit computers.
In-house web site synchronization with customer
management package. The package kept data in an Microsoft SQL
Server database, and technical support wanted to access information
about customers (only, not leads) as part of the administrative portal
on the secure web site. I built a program in Java which (from Linux,
using a type-4 JDBC driver to access the SQL Server instance via the
network) read the database, extracted records, and combined the data
tech support wanted in a single MySQL table. This ran nightly to keep
the MySQL in sync with the master database.
In-house phone report tool. Report for
management which aggregated data from a long-distance phone company
report file with our PBX's logs. Imported data into MySQL for easier
processing, and used the Java poi classes to generate a
spreadsheet. The most interesting aspect of this program was the fact
that both phone logs had no common key, and the two files had to be
matched by the timestamp of the calls. The implementation was
surprisingly good at guessing the matches.
In-house license application. Original
DOS-based license key program was re-written for Windows workstations
in a networked LAN environment, to allow technical support to easily
give out keys without running mainframe jobs. Involved creating
multiple DLLs for algorithms (including a C implementation of an
algorithm reverse-engineered from mainframe assembler, a mainframe
COBOL module recompiled on the PC, and others) and building a
graphical control panel (using Delphi) to generate keys with the
algorithms. Logging was added for the LAN, as well as the ability to
import the log into an Excel spreadsheet.
Quote automation system. Designed and
implemented an automated quote system for a client. The system
responded to quote requests generated by web site visitors. The
package looked up item SKUs in the corporate database, calculated
shipping based on item categorization (using an expert-system style
ruleset derived from a manual process), and e-mailed a quote. (The
database was kept on a PC using a desktop database system, and had to
be imported into PostgreSQL in order to be available on the hosting
service's BSD-based system.) Significantly, this software was planned
for a beta test in late October before being rolled out for the
client's busy Christmas season. By that time, they were already so
overwhelmed by manually responding to quote requests that they asked
us to turn the system on without the full testing period. The system
ran flawlessly from the beginning despite transaction volumes being an
order of magnitude above the client's best volume estimates, and has
continued to run to this day with no significant bugs or
downtime. (The only changes I ever made to it were in the rules for
shipping calculations.)
Online used car search engine. Under a
tight time frame, implemented a prototype of a used car search engine
for a car dealership client. This project was a proof-of-concept
mockup to show management that the system was feasible. The intent was
to provide a working demo for a certain presentation at a certain
date, at which time the go-ahead would be given to develop the real
system. The prototype I built was so feasible that, as often happens,
it was rolled out as the production system for several years as a
replacement was budgeted and developed. The most significant flaw was
that time constraints meant the system was not as extensible as a
production version needed to be, and more changes had to be made than
the smoke-and-mirrors code would allow, or otherwise they'd probably
still be running it.
User validation module. Using the
ColdFusion MX web development platform, I implemented a user
authentication module for web sites which allowed for the dynamic
creation, approval, and administration of user accounts. Originally
developed with Oracle, it was later "downgraded" to work with MS
Access. (This was an early precursor to a full customer login system.)
Unix administration. In my years of
working with UNIX, I've done everything to a UNIX system from
constructing bare-metal machines out of the crate to maintaining
Internet servers. Tasks I've done have included installing necessary
software (GNU Emacs, compilers and interpreters, shells, etc.),
running a sendmail-based e-mail server, maintaining virtual hosts for
an Apache web server, installing PHP for hosted web sites, configuring
databases like PostgreSQL and DB2, and configuring SSH access to
machines for off-site users. I also have written many administration
tools in Perl, such as a web site backup package, system and security
monitor tools, etc. I think I've done almost everything there is to do
in UNIX. I have written several small security applications to monitor
a Linux box: the goal being that since standard Linux distributions
are vulnerable to having rootkits installed which affect standard
utilities, non-standard ones would survive and alert me that something
was wrong. One application was written in Python and used a MySQL
database to keep a sample population of which users were logged in to
the system from which Internet hosts. The format made it easy to spot
unusual logins quickly. Other applications were written in Perl to
scan log files and active processes and report on current activity. By
e-mailing these reports to me, I had a real-time indication of system
activity so if anything bad happened, I could spot when and how it
occurred.
Automating Windows With Perl. R&D
Books, 1999. (A critically acclaimed but commercially unsuccessful
book on an obscure topic.)
My first job was writing reports for
Medical Manager a doctor's office practice management package (which
is still around) sold by a local VAR company that would buy the PC and
custom hardware, and install and configure the software. At the time,
before widespread small-office computer networking, the computer was a
386 with serial-port attached Wyse terminals. They hired me because
doctors were constantly getting new forms from Medicare and insurance
companies, and MM had to be programmed to generate reports on the new
forms. The report generator was amazingly primitive: each field to be
printed on the form had to be specified by entering the (row, column)
position as an integer: there was no visual layout at all. I quickly
wrote a C program to translate a visual representation of the fields
in a file (which looked a lot like Perl's format strings) into the MM
report file format so I would not have to count the hundreds of row,
column positions for fields every time I did a form. This productivity
tool was not marketed, because the company went out of business. This
job also saw me moving a client's database from a SCO Xenix instance
of MM to a very primitive 4GL database package on DOS the client
wanted; the punch line is that they moved back to UNIX instantly after
seeing just how awful the DOS package was!
Improvement. One area of interest for
me is applying the self-improvement technologies of Anthony Robbins to
software development. Many concepts such as the problem-solving
questions, CANI! (constant and never-ending improvement), etc
translate well to software development. I've found this makes the
development process more effective.
Summary. Basically I've done
everything you can do to a computer at one point or another. My
primary career emphasis has been software development. I mostly work
with object-oriented designs and lower level C coding.
Languages. C, C++, Java, Perl, COBOL;
also Python, shell programming, REXX, Emacs LISP, Scheme, anything
else you can think of.
Databases. DB2, Oracle, PostgreSQL,
MySQL; also JDBC, ANSI SQL.
Environments. Solaris, Red Hat Linux,
AIX, HP-UX, BSD, MVS (OS/390, z/OS), Win32, even OS/2 (no, really!)
and SCO UnixWare's two predecessors, Novell UnixWare and SCO UNIX (I
am not making this up!).
Tools. GNU Emacs, gcc, Borland C++,
Delphi, Visual C++.
Web Related. HTML coding, Java Server
Pages, PHP, XML.
Additionally, I have done a lot of mixed-language programming, an
area not many people have experience in.
Education
University of North Carolina At Asheville, 1994: Bachelor of
Science degree in computer science. UNCA is unique because it is a
public university which provides a liberal arts education to all
students.
Research emphasis: At UNCA, my primary area of research interest
was with studying the transmission and processing of e-mail. My senior
project was the implementation and production use of a Majordomo-like
mailing list automation package written in Perl.
|