Allen Holub's Sporadic Newsletter

A l l e n H o l u b

Programmer

Allen is one of the country's foremost software designer-builders. He's
an expert-level programmer, specializing in Swift, Java and Web 2.0
(AJAX/Cloud/Microservice) applications, typically deployed to cloud
platforms. He can build highly dynamic web
sites (along the lines of GMail) from front to back: both the front end
(JavaScript-JQuery-Angular-HTML5-CSS3) code that runs in the browser and the
back end (Java, PHP, MySQL, Ruby, Mongo, C++, AppEngine, EC2) code that runs
either on your server or in the cloud.

Allen is a highly-regarded trainer and much-sought-after speaker.
(See a video of a recent keynote at on the
Videos page.
Speaking topics range from Agile culture and architecture, and process,
to Swift, OO-Design, UML, Java, C++, and computer security.
He works with both startups and
Fortune-N companies, and can train both small teams and entire
departments if required. His
Agile OO-Design Workshop
and
Agile Architecture
class are unique in the industry.

Allen's
long-running columns
for Dr. Dobb's Journal (C Chest),
JavaWorld (Java Toolbox),
SD Times (JavaWatch),
and others have been highly influential in the industry.
His open-source Java threading library predated the java.util.concurrent
system, and the associated book (Taming Java Threads) was
one of Apress's all-time best sellers. He's written a total of
ten books
on programming topics.

Allen regularly speaks at major technical conferences,
both in the US and internationally,
and served on the SD (Software Development) Conference advisory board.

Coach

Allen specializes in helping you take your idea through to fruition.
His CTO, Agile-process, and architect experience, when combined with his
practical programming expertise,
puts him a unique position to guide you through the quagmire of
software development. He approaches agile in a non-tribal way, focusing
on what will work best for your company,
as compared to the dogmatic focus on a specific process (e.g. Scrum)
pursued my many.

Allen can help you assemble an implementation team,
and lead that team to a successful outcome.
If you have an existing company, he can assess and improve
both your software and your software-development organization and process.

He provides Agile coaching and design-review services,
and can train individual teams and entire departments on
Design, Agile process, and OO languages.

LinkedIn (with recommendations)

I'm using my LinkedIn page as a resume.
Since non-LinkedIn members can't see recommendations, here's a (probably out of date)
.pdf version of my listing.

A Few Recent Projects
Show all (or click arrow next to title to show that project).

Pearl.com (2012)

Principal Architect and Agile-Process consultant.
Designed APIs, implemented API protypes, guided software development generally.
Moved the organization from a dysfunctional Scrum shop to one that was considerably more Agile
(worked with the teams, worked with individuals).
Taught a series of classes and hands-on workships with topics ranging from Agile Process and Architecture, to Design Patterns,
to programming (e.g.: C# multithreading).
Mentored upper management, programmers, product owners, scrum masters.

Digital Ocean (2011)

Characteristic of very-short term coaching engagements, helped define processes used by a very
small software-development organization, walked the team through the design/development process, and
helped with initial design work.

timezer.com (2010-present)

A cloud-based invoicing service. This project is not yet deployed.

Designed and constructed a full prototype system:
Google Web Toolkit (GWT), JavaScript, and JQuery on the (AJAX) client side;
The Google subset of J2EE on the server side: JDO, Servlets, JavaMail, Memcache, OAuth authentication, and Google Multitenancy.
System is deployed to the Google App Engine,
and integrates tightly with various Google and Amazon
cloud services using both Google's GData APIs and Amazon's Web-Service (AWS) APIs.
Integrates with Paypal payment processing.

Designed the user interface and underlying system, applying OO principles throughout, and was
instrumental in the fund raising process, writing all technical aspects of the business plan and performing
a competitive analysis.

A full featured Web 2.0 AJAX application that implements impressive
desktop-like capabilities. The browser-based AJAX user interface
communicates with a Java-based server back end (J2EE, MYSQL, JDBC,
Servlets).

.
iExperiment is a full-featured laboratory notebook, allowing for the
capture, display, and publication of experimental data (laboratory
reports). The data is "structured" in that it can be represented in XML
that expresses the semantics of the data, to facility The application
can function both as a public, web-based service and also as an in-house
system. The user interface is unique to the application, and
incorporates many custom "widgets" that improve usability.

Allen was initially brought in as a "hired-gun CTO," helping the
principal through the product-definition and design phase. Working
closely with the client, Allen developed the architecture of the system,
set up and led the (distributed) development team, and implemented the
AJAX user interface using both the Google Web Toolkit (GWT) and as raw
HTML/CSS and JavaScript. The back end was developed using Java and MySQL
under Apache/Tomcat. The bulk of the work on this project occurred in
2009.

To see a report in read-only mode, click on the "Repository" link on the
main page.
You'll have to create and accont and log in to see the full editing UI.

An AJAX implementation of a to-do list. (If you go to the page by
clicking the foregoing link, you can play with the list at the bottom of
the main page—it's fully functional, but doesn't save your
changes).

This application demonstrates advanced AJAX features. The front end is
written using the Google Web Toolkit (GWT) under Eclipse. The draggable
tab bar, trash, and tool bar are all custom GWT-extension widgets
developed by Allen, not part of GWT itself. The server side is written
using JDO (J2EE) over MYSQL to allow eventual deployment to the Google
App Engine. This application also demonstrates a secure plug-in login
implementation developed by Allen. Login is implemented in straight
JavaScript/HTML4/CSS with a Java-servlet back end so that it can easily
be plugged into non-GWT applications. The Login system includes an
easy-to-use GWT-integration layer, however.

Technical Background

Allen has worked in the computer field since 1979—as an independent
consultant since 1983. He started out as a hardware engineer, developing
robotics control systems—his first software projects were device
drivers for his own boards—but the software eventually preempted the
hardware. He moved into software by developing compilers and operating
systems, and is now an acknowledged expert in OO Design and Process, as well
as systems and application development. His software projects have
included:

Various Java libraries, including a threading library that predated java.util.concurrent.

Various client-side application programs.

Open-source markup-language processors.

Several operating systems (one real-time system and one disk OS).

Various compilers for proprietary languages. (His C compiler is documented in his book
Compiler Design in C).

An UNIX-style C shell for Microsoft operating systems.

Compilers and compiler-construction utilities.

Various custom device drivers.

Allen has been an active participant in the open-source community,
publishing large amounts of useful source code in books and in the various
magazines to which he's contributed over the years. Much of his published
code has found its way into commercial products such as the Rogue Wave C++
tool kit and the libraries accompanying the Borland C and C++ compilers.

Allen was an early adopter of Java—programming
in it since 1995 (the language was released by SUN in March of that year).
He also works regularly in PHP, SQL, (X)HTML/CSS, and JavaScript.
Before that, Allen worked primarily in C++ (since 1991), C (since 1980), and various
other obscure and now-irrelevant languages
(Smalltalk; FORTRAN; PL/M; PL/1; Pascal; Modula;
8080, 8085, 68000, and TI 9900 assembler; and the like.)

Allen is one of the country's foremost experts in Object-oriented Design techniques.
He has been a strong public advocate of Agile design processes, in both his
public writings and in his teaching work.
Over the years, he's helped thousands of programmers work
more effectively by showing them "how it's done."
An important part of his practice involves
training, mentoring, and guidance to companies
who wish to apply Object-Oriented design techniques
and processes to computer-software development. These sort of
technology-support services range from on-site
instruction to regular design and code review.

Allen has provided consulting and educational services
to many companies, both
in the San Francisco Bay Area, across the country, and internationally.

Teaching

Allen is a highly regarded educator. He regularly teaches in-house classes for
individual companies, and has taught
for the University of California, Berkeley, Extension since 1982.
He's taught various topics, including
Object-Oriented Analysis and Design, Java,
C++, C, Compiler Design, Win32 Systems Programming,
and Microsoft Foundation Class Programming.
He regularly receives accolades from his students,
who represent most of the major software companies in the Bay Area.

Allen is a regular presenter at both national and international conferences,
including Bear Park's Software Architecture Conference,
the Software Development (SD) conferences,
Sun's JavaOne conference. He recently spoke at JAX/San-Jose.
He served as the Security-track chair for SD.
His Software-Development presentations include security talks
(including a nontechnical introduction to software security),
various design talks (including Design Patterns and Architecture),
and discussions of specific libraries
(including the Google Web Toolkit (GWT)—an AJAX development platform).

Writing

Allen was a Contributing Editor for the on-line magazines
JavaWorld (Java Toolbox)
and SD Times (Java Watch).
He wrote the OO Design Process column
for IBM DeveloperWorks
and has moderated several public forums
(including the ITworld Programming Theory & Practice Forum).
His articles
have championed the OO-design process, and have opened many readers eyes to what
the term "object oriented" really means.
Allen was a contributing editor for Dr. Dobb's Journal,
Dr. Dobb's Sourcebook,
and Programmer's Journal.
His popular "C Chest" column, which appeared monthly in
Dr. Dobb's Journal from 1983 to 1987, provided many
people with their first introduction to C.
Allen has also written for
Microsoft Systems Journal,
Programmers Journal,
BYTE.
Windows Tech Journal,
Mac Tech Journal,
C Gazette
and others.

Holub on Patterns: Learning Design Patterns by Looking at Code
(Apress, 2004).
This book is unique in the industry in that it presents the complete source code for
two nontrivial programs (a SQL interpreter and a Game-of-Life implementation) and analyzes them
in depth in terms of the design patterns used in the implementation.
It is the only that shows you how the design patterns actually appear in real code.

Taming Java Threads.
(Apress, 2000).
This book anthologizes his popular nine-part
Java-threading series, originally published in JavaWorld,
adding considerable material to the original articles.
It covers all the threading traps and pitfalls found in Java,
including the platform-dependence issues, and presents a production-quality
threading package that you can use to solve those problem.
Object-oriented threading architectures are also discussed.

Enough Rope to Shoot Yourself in the Foot
(McGraw-Hill, 1995): A collection of rules of thumb for C++
programming. Following these rules helps the reader both
write better code and head off programming errors before
they happen. The rules are based on practical programming
experience in C++.

C+C++: Programming With Objects in C and C++
(McGraw-Hill, 1992): An introduction to C++ for professional
C programmers, this book takes the unique approach of
presenting object-oriented concepts in the context of C
before introducing C++. Covers pitfalls of the language
and presents more practical-programming advice than most
books of this sort.

Compiler Design in C (Prentice Hall, 1990):
Considered by many to be the definitive practical introduction
to compiler design, this book covers all the relevant theory,
but in the context of real programs: fully functional versions
of the UNIX lex and yacc utilities are presented, as is the
complete source code for a C compiler. This book is still a
strong seller, six years after it’s first printing.

The C Companion (Prentice Hall, 1987): Each
chapter covers a different subject, both interesting and
useful to the C programmer, but not covered in most books on
C programming.

The C Chest and other C Treasures
(M&T Books, 1987):
reprints 21 of the C-Chest columns that Allen wrote for
Dr. Dobb's Journal.

On Command: Writing a UNIX-like Shell for MS-DOS
(M&T Books, 1986):
The complete source code for a UNIX
C-Shell implementation (which is much more powerful than
Microsoft’s COMMAND.COM) that ran under MS-DOS. One of the
first books to show how to implement useful UNIX utilities
in the MS-DOS environment.

Dr. Dobb's Toolbook of C
(M&T Books, 1986):
contains reprints of two of Allen's early articles for
Dr. Dobb's Journal:
"Getargs: A Command-Line Argument Processor"
and
"Grep.c: A Generalized Regular-Expression Parser in C."

Many of his books appear in Japanese, German, and Russian translation.

Education, Etc.

Allen hold a double degree from he University of California, Berkeley,
in Computer Science and Medieval-European History
(or "mid-evil" history, as his
D&B rating used to say).
He is an
accomplished composer and musician.
He's also an artist, and an avid pilot
(Airplane SEL, instrument-rated, commercial).