A significant part of the work involved in the design of Medici revolved around coming up with a new metaphor for composable objects in a UI. Our solution was cards.
The visual metaphor is described at http://cardstack.io./
A number of attempts were made to build this on top of Tilde's Ember framework, but I was never personally happy with the results.
After the termination of the Medici project, I started from scratch, building a new, functional language that encapsulated the concept of a card as a fundamental first-class data type.
This code could then be transpiled into JavaScript for Web (or Java for Android or Desktop) use with a small run-time library.
This combines closely with the Ziniki project to offer a full-stack delivery system.
The FLAS compiler is implemented in Java and has an Eclipse plug-in. It is fully open source.
After the initial prototyping phase of the Medici project, I decided to step back and attempt a separate effort to build the appropriate underlying back-end infrastructure to make delivery of Medici much easier.
This project was called “Ziniki” and I formed a separate company to build and deliver this system, intended to be the backbone of the Medici system.
Ziniki supports sophisticated object-level security, data types, “envelopes” and “projections”, analytics, reactive event handling, websockets and more.
Since the end of the Medici project, I have worked more on the front end and have moved toward tight integration between FLAS and Ziniki.
As part of the Medici project, we were looking for a new way of thinking about big data analysis as an alternative to either Star-schema SQL or Hadoop-style batch processing.
In 2012, we identified Couchbase as a viable alternative with its incremental map-reduce views.
But it did not do the key thing we wanted ‐ allowing us to build a nested structure of derived analytics.
Ziggrid filled this gap by utilzing reactive processing and a rich set of analysis operators (including machine learning).
We built a demo for the Couchbase Conference in 2013 based on analyzing baseball statistics, which we presented at the 2013 Couchbase Conference.
As yet, this is only really at the "demo" stage, mainly due to Couchbase still not supporting the necessary “event” hook to call back into Ziggrid when views are updated.
It should be noted that I only made small contributions to the front-end of the demo.
- Engine Code at https://github.com/Ziniki-Network/Ziggrid
- “Beane Counter” demo at https://github.com/zinikiGareth/beane-counter-ui
Medici was the working name for the Digital Learning Platform at McGraw-Hill.
The idea was to create a platform which was responsible for all of the core activities: user registration, roles and security, admin, analytics, event handling and distribution, data modelling, commerce and application API. Individual applications or "content items" could then plug in to this architecture in standard ways.
The metaphor we used was that of an underlying operating system, providing services and a container for applications which could then talk to each other through standard “contracts”.
A key feature of the system was to allow embedded-application writers to plug into both the back end and front end seamlessly; for example, to write code once that supported a “search” that could be run either in the user experience or as part of a batch job on the server.
I was involved in the initial architecture and design of this project, and in a prototyping phase.
I was then subsequently re-contracted as a consultant during subsequent phases.
As part of my role at Ternary, I was called upon to deliver a number of small projects and prototypes.
As these were small-scale, low-cost projects, we did not have the budget to do a full evaluation of the most appropriate infrastructure for each job, but reused a standardized architecture consisting of Java, Spring, Hibernate and Velocity (later Freemarker).
Even so, the ramp-up phase to a walking skeleton was around a day or two as all the relevant pieces were patched together and configured using boiler-plate code and XML.
To resolve this (and to further improve productivity), I created Freebird, a project which used the concept of “conventions” to automatically generate all of the boiler-plate code needed for Spring parameter objects and views and for Hibernate DAOs, along with all the XML needed to configure these (before the advent of Java 1.5).
This was the basis of my Agile 2006 hands-on workshop.
TX2 Systems was a client of Ternary Software.
They had a product to assist companies and law firms doing Enterprise Mergers and Acquisitions (EMA). This was built from scratch by Ternary, but by the time I joined the project it was very much tied to the worldview of their first client, a law firm.
Their second client, a major healthcare company, wanted a very different approach to the topic, with much more focus on the post-deal integration of acquired targets.
I led a four-man team that rearchitected the entire product using the strangler “pattern” to keep the existing code operational at the same time as completely replacing it with a much more flexible architecture, including implementing basic versions of libraries similar to Spring, Hibernate and Velocity in C# 2.0.
This enabled the technical staff at TX2 to customize the product using an XML configuration file to support the process appropriate to each of their client's needs.
After this effort, I continued to support the product for another three years, making minor ‐ but key ‐ improvements to support the flexibility of the configuration mechanism.
In 2004, Byford Systems was looking for “the next big thing”. They considered that there was a good possibility it would be mobile.
I worked with them to produce a number of demos of things that could (just about) be done with the hardware technology at the time.
Among the demos created during this time were:
- A GPS receiver that connected to a mobile phone to connect to a server that interacted with mapping software to track the location of vehicles
- A cricket-scoring program on a hand-held device that communicated updates to a server that was able to distribute them to interested parties over the Web
Goldman Sachs contracted with TIBCO to build a transactional messaging platform.
The basic idea was to enable them to reliably distribute transactions and deals around the world.
Thus in New York, they could process a deal as part of a transaction in “real-time” against a local database, and then have the knowledge about that deal transmitted asynchronously but reliably to Tokyo where it could then be included into their database as part of a separate transaction.
The key requirement was that in each location, the transaction was quick and not dependent on network connectivity.
ETX (Enterprise Transaction Express) was messaging middleware that did this.
My role was to deal mainly with the XA-compliant “node” responsible for interacting with the transaction manager; recording the messages created as part of the transaction; and then ensuring the messages were delivered and successfully consumed as part of a transaction on the far end.
(Other parts of the system included: the transaction manager; a logger to ensure that the information captured was persistently stored on disk; the routing infrastructure to move messages around the world; and the client library. From time to time, I was involved with each of these pieces, but mainly in a “pairing” role.)
I was initially hired by TIBCO as a compiler and language expert.
They had a lisp-like language for scripting interactions between the components in ETK called TDL.
I had a number of tasks in this area, including improving the performance of the parser and making code interpretation more efficient.
As part of the deal with Reuters, we were tasked with revamping this to provide an easier-to-use, more optimal scripting language.
Ultimately, our solution was to embed Java (using JNI and Reflection when it became available) to enable the ETK to use it as a scripting language.
The team I worked on for my first two years at TIBCO was building a suite of products known as ETK (Enterprise ToolKit).
It was a suite of messaging and other products designed to work together to enable clients to build distributed systems easily.
My first project with the company was to improve their Remote-Object Framework (ROF) to make it CORBA-compliant.
The result of this was a product called ObjectBus.
As a compiler and language expert, my main role on this project was to build the parser for IDL and then the code generator for the various object types in C++.
(The other portion of the project was to integrate this with the ROF framework.)
All of the content of this resume is my own work, except for most of the icons and clipart.
Most of the icons are derived from public domain sources, but some have asked for attributions:
- "About" Icon made by Freepik from www.flaticon.com
The concept for the visuals and all of the HTML, CSS, JavaScript and PHP contained in it is all my own work.
The boringness of some of the icons mainly reflects the limitations of my creativity in thinking of something to search for, find or design that represented the topic.
The backdrop photograph was taken by my wife on the Pine Walk in Puerto Pollensa, Mallorca.
