Engineer at Versant 1989-1999

Versant's flagship product was its Object Database (ODBMS). Coming straight out of Graduate School, I joined Versant in the first year of the startup, and eventually became Principal Engineer and Architect of the Programming Language bindings. I stayed 10½ years at Versant. Some highlights:

• 1990: Designed and implemented the "PObject" transparent persistent C++ object binding for the Versant ODBMS. This was a well-designed, properly layered interface, replacing an inferior binding.

• 1991: Designed and implemented Simulated Exceptions (with cpp macros) and Simulated Templates (with our own template preprocessor) (for cfront1.2) so Versant customers could use templated smart-pointers (e.g. Foo* Link<Foo>::operator->() ) for database object references, in advance of real compiler support (in cfront2.0) for templates and exceptions. This was very successful: customers later migrated to real templates with no trouble. Later this style of binding became the basis for the ODMG 2.0 Standard C++ Binding.

• 1991-1994: Versant's representative to the ANSI&ISO C++ Standards committee, on Extensions subcommittee with Bjarne & other gods.

• 1993: Designed and implemented Query Enhancements for Versant ODBMS Kernel, including disjunctions, String Matching, and Path Queries.

• 1993-1997: Versant's representative on and Board Member of ODMG, the standards committee for Object Database bindings.

• 1994: Designed and implemented Garbage Collector for Versant database (especially for the Smalltalk Binding).

• 1996: Design and core implementation of Versant's Java Binding: at first, a flat API; then a transparent persistent object binding.

• 1996-1997: Editor of Java portion of ODMG 2.0 Standard ( Publisher: Morgan Kaufmann, ISBN: 1558604634 ).

• 1997: Versant goes public!

• 1998: Designed backend to emulate the Versant Object & Storage Managers with an RDBMS as the physical storage, instead of (or in addition to) Versant's ODB kernel.

• 1999: Designed Versant's backwards-compatible ODBMS internationalization strategy, around optional UTF-8 representation and local transcoders.

[All these dates are to the best of my memory, plus or minus a year.]

More Recently

• 2000-2004: I was semi-retired since quitting Versant a week before The Millennium. I've been working on my own projects, e.g. a web & wiki server named Smilax (this résumé is served by Smilax!), and recently a small language called ParentheTcl for writing extensions to Tcl.
• I've also done a little opportunistic contracting when it came my way: I did patent research for Earthlink, and I wrote half of a course on databases (Postgresql on Linux) for Red Hat.
• I've spent a couple of months learning Croquet (a collaborative 3D environment in Squeak Smalltalk ) and wrote a simple collaborative game in it ( http://smilax.org/144 ).
• I've been writing little minimalist Virtual Machines (Unithorpe, Trithorpe, & Oglethorpe) for the fun of it. My newest experiment, Cinnabar, is a faster Smalltalk Virtual Machine designed to speed up the rendering bottleneck in Croquet.
• 2004-2005: Programmed with a small team on the product BugScan (a.k.a. "Logiscan") which does automated static analysis of binaries (Sparc, Mips, x86, and Java) looking for security vulnerabilities (buffer overflows, format string errors, SQL injection, etc.). I designed most of how the virtualized emulation is done.
• Early 2006: A one-month consulting job for the Croquet group at University of Wisconsin (for Doit IT division, paid via an intermediary contracting company Clotho). Croquet is a 3D Virtual Environment implemented in Squeak Smalltalk. My programming partner Ryan Seto and I wrote the "Xrbf" Remote Desktop package for Croquet, including a controlling HTTP service in Python, and a chrooted Linux subdistro based on Fedora Core.
• 2006: Worked at imeem for six months, doing a variety of little things on a social networking client written in C# for windows .net platform.

• I had a very positive experience with Test-Driven Development, Pair Programming, & eXtreme (Agile) Programming techniques while building Bugscan. Refactor early and often!

Currently at Google

Beginning in January of 2007, I'm a programmer at Google, maintaining diagnostic information about Google's main spidering and indexing of the internet.

Education, Associations, Achievements, Honors

• 1994-current: Invitee at Glenn Tenney's "The Hackers Conference".
• 1991-1999: Bay Area Cypherpunks regular.
• 1989-1995: DJ at Stanford's KZSU-FM. 1987-1989 at Georgia Tech's WREK-FM.
• 1989: Master of Science in Information and Computer Science, Georgia Tech. I was a researcher on the Clouds Operating System project.
• 1987-1988: Worked as a research assistant in Michael Barnsley's Iterated Function Systems lab in the Mathematics Department at Georgia Tech.
• 1985: Scored 99th percentile on Computer Science GRE.
• 1983: Bachelor of Electrical Engineering, Georgia Tech. 1982-1983 Lab Assistant for two years in John Peatman's Microprocessor-based Design Lab.
• Eagle Scout and Order of the Arrow Vigil Honor.
• Erdős Number 3 (via Michael Barnsley via Marc Aron Berger)

Languages and Platforms

• In High School I designed & wire-wrapped an RCA 1802-based microcomputer with 1KB of SRAM.
• Of course, I taught myself BASIC (on my dad's TRS-80)
• In college I designed & wire-wrapped a Motorola 6809-based computer (with a full 64K DRAM) and ported Microware's OS/9 operating system to it (wrote my own bootrom and keyboard & video drivers in 6809 assembly). Then I built a 68000-based machine and its ROM monitor.
• As undergraduate, I used extensive FORTRAN & Pascal and also some APL & CCL on CDC Cyber; and Assembly (6803, 6809, 68000), Pascal, and C for microcomputer operating systems development.
• In grad school, wrote Ethernet device driver for DEUNA on Vax750 for the Clouds (distributed research) Operating System.
• Extensive use of UNIX and programming in C since 1984: BSD 4.1, 4.2 on VAX 750, 780; Masscomp UNIX; SunOS & Solaris; and currently Linux.
• I'm Expert at C, C++, Java 1.0, TCL, & Bourne Shell. I'm quite good in C#, awk, & Smalltalk. I'm functional in many other languages, including APL, FORTH, Lisp, Perl, Python, & Lua. Also in grad school I used Ada, Modula2, Icon, Prolog, & ML.
• I have some conversational ability in German, French, and ASL, and survival skills in Hungarian and Thai. (Once I knew a little Korean, Finnish, Russian, and Chinese.)

Appendix: Inventions by Henry Strickland

Years are approximate. I made this list for another purpose once, and a roommate commented "That's your real résumé!". Some of these are incomplete and unpublished, but feel free to ask me about them!

1. Homegrown Microcomputer and Machine Language monitor program (RCA 1802-based wire-wrapped computer, with 1KB ram, compare to Cosmac Elf)

2. Homegrown Microcomputer ("OMAR", wirewrapped Motorola 6809 CPU with SAM and VDG chipset, Microprocesser Based Design Lab, Georgia Tech EE, 1983. Also there were at least three OMAR clones, by members of GT Micro Users Group)

3. Console & Keyboard drivers, and bootrom & bootsector, and port of Microware OS/9 operating system for Homegrown Microcomputer (for OMAR, with Western Digital Floppy Disk Controller chip)

4. Remote debugger for Operating System Kernel (client-server UDP service for Clouds Operating System, with "kadb" (on Unix) frontend, Georgia Tech ICS, 1985)

5. Ethernet Device Driver for Minicomputer (DEC VAX/750 DEUNA device driver for Clouds Operating System, Georgia Tech ICS, 1985)

6. Capture of type information from a compiler's abstract syntax tree & symbol tables (Schema Capture Tool "cxx2sch", using AT&T "cfront" source code, Versant ODBMS for C++, 1989)

7. Schema definition and evolution tool (Database Schema Tool "sch2db", Versant ODBMS for C++, 1989)

8. Persistent Object mechanism for C++ ("PObject" interface, Versant ODBMS for C++, 1990)

9. Runtime Type Information for C++ ("PClass" mechanism, Versant ODBMS for C++, 1990)

10. Template-expanding preprocessor for early C++ ("cxxfilt", using lex & yacc, Versant C++, 1991)

11. Simulated try/throw/catch exception mechanism for early C++ (using cpp, Versant, 1991)

12. Integration of persistent language tools with a GUI-based integrated development & debugging environment (Versant C++ and ParcPlace ObjectWorks for C++, 1991)

13. Garbage Collector for Object Database (Versant, 1993)

14. Path Query Evaluator for ODB (Versant kernel frontend & backend, 1993)

15. Personal Firewall("infilt" for packet filter for SunOS 4.1.1, 1994, http://www.netsys.com/firewalls/firewalls-9410/0042.html ) [ cached ]

16. Minimalist virtual machine for a subset of Java ("g.c", 1995)

17. Capability model for database access in Java (Versant Java Capability class, 1995)

18. Bytecode dissassembly, virtualized execution, type validation, and bytecode mutation engine (Bytecode Enhancer, Versant ODBMS for Java, 1996)

19. Transparent persistence engine for java objects (Versnat ODB for Java, 1996)

20. Application Framework for Java, providing object naming, navigation, diagnostics, and embedded web server for debugging (Versant "AFrame", 1997)

21. Tiny Tcl-like configuration language interpreter (Versant 1999)

22. Encrypted and Authenticated Virtual Private Network ("orthanz", using Linux Universal Tun/Tap Device, 2001)

23. Internet Server with Web Server, Wiki, SMTP, POP, DNS, and file replication (Smilax in Java and Jacl, 2000)

24. Internet Server with Web Server and Wiki (Smilax in Tcl, 2002; see http://smilax.org )

25. Internet Server Architecture with Nested Sandboxed Safe Execution environments ( Smilax in Tcl 2003, using nested safe sub-interpreters at several levels: an outer "kernel" interpreter with full POSIX access, a safe subinterpreter for the web & wiki application and only a Smilax Kernel API available, a nested safe subinterpreter for webmasters to customize the wiki, and an innermost nested safe subinterpreter for end users to script a document such as a spreadsheet. )

26. Mixin Mechanism in Tcl for customizing a Wiki in a safe subinterpreter (Smilax Mixins, 2003)

27. Minimalist intermediate-code-interpreting Virtual Machines for lowlevel dynamic languages ( UniThorpe, 2004. TriThrope, 2004. )

28. Minimalist JIT-ing Virtual Machine for a lowlevel dynamic language ( Oglethorpe, 2005. )

29. Safe compiled language for high-performance extensions to a Scripting Language, with recursive descent compiler and runtime library ( ParentheTcl, 2004; see http://smilax.org/99 ).

30. Tiny Tcl-like language interpreter (Terp, in Java and C#, 2004)

31. Simple collaborative "game" in Croquet ( http://smilax.org/144 ), originally inspired by Quidditch.

32. A Virtual Machine for Islands (vats) in Smalltalk (Cinnabar, which will compile classes in Squeak, and is designed to (but doesn't yet) run alongside of Squeak)

33. The Lithium Toolkit for experimenting with Genetic Programming, particularly with the question of what type of programming language works best for the genome. Contains over five interpreters for GP, including a bytecode language (Grissom), a lisp dialet (Lithium4), a subset of joy, a superset of Brainf*** (BFA), and a bland statement-expression grammer-based language (EvoPerl). Interpreters built in C++, and Tcl used for for scripting. ( http://albus.yak.net/repos/lithium/ )

---

Cached:

infilt-firewalls-9410-0042.html