Cookie Consent by TIBET



All The Parts

See if this sounds familiar…

"Well, the project was initially built in Angular 1.0. We converted to React last year. We started out with class-based React components but we're switching to hook functions. We'd like to use TypeScript but we're not there yet. For tooling we updated from npm to yarn and we're using parcel instead of webpack...." -- Anonymous Team Lead

The dirty little secret of a-la-carte ecosystem development is that as a-la-carte projects evolve they collect more and more a-la-carte parts. Client parts. Server parts. Tool parts.

In a-la-carte projects today's new shiny inevitably replaces yesterday's. Your framework changes direction, changes language, or is abandoned. Modules and tools fall out of favor. As new tech is added you never quite get the old code updated so the project mudballs.

Support? Not available. Stability? Not an option. Staffing? Always a problem.

With TIBET we wanted a stable, long-lasting foundation:

TIBET is The Sum Of The Parts, Not Some Of The Parts™

Client Stack

Full Client Stack

TIBET's client stack is fully-integrated, each layer building on the foundation provided by the layers below it. The result is a strong, stable foundation you can count on.

The layers themselves incorporate lessons learned building large-scale web applications for over twenty years. Applications with dozens if not hundreds of screens. Applications that need to run offline. Applications that can run on a desktop without a server of any kind.

TIBET was built to let you do 80% of your work in markup while giving you the layers of abstraction you need to smooth the other 20%.

TIBET's not a-la-carte, it's all-the-parts.

From the bottom up, TIBET's client stack includes:

-- Unified configuration system for client, server, CLI, and tools
-- Dynamic multi-phase loader with shared metadata for tools
-- Extensible object-oriented logger with Log4Java 2.0 APIs
-- Portable platform isolation layer for JS, DOM, CSS, and XML
OO & Traits
-- Smalltalk-inspired inheritance coupled with traits
Signals & Exceptions
-- State / route / responder-aware signaling and exceptions
State Management
-- Nestable state machines w/ app controller integration
-- Extensible Locale types plus native type parsing / formatting
-- Keyboard mapping, key sequences, mouse gestures, D&D
-- Request / Response processing for sync/async Service types
Users & Roles
-- vCard-based user, role, unit, org support with client keyrings
-- URI-based state management with change notification
-- Powerful OO classes for the DOM, XML, and JSON
Queries & Paths
-- CSS queries, JSONPath, XPath, and xpointer() support
-- Full in-client templating with integrated data formatters
Data Binding
-- Single and bi-directional binding with nested scopes
Routing & History
-- Signaling-based router with full history integration
Custom Tags
-- Type-driven multi-phase tag processing with XML support
-- Accessible fields, groups, formatters, and validators
Widgets & Controls
-- Tag-based components supporting d3, SVG, et. al.

Additional TIBET modules cover a variety of enterprise standards:

  • JSON Schema / JSON Path
  • XML Schema / XPath 1.0
  • SOAP
  • vCard
  • XMPP (chat)
  • and many more.

Server Stack

Full Server Stack

If you're building for the Desktop via Electron, TIBET's optional server components can be used out-of-the-box to mock remote Cloud APIs or local endpoints as needed.

If you're building a new web application or web site, TIBET's server configurations are secure, production-ready, and used in a number of installations.

Regardless of your specific requirements, TIBET makes it easy to mock, develop, and deploy new APIs, web sites, or web applications out-of-the-box.

TIBET Data Server (TDS)
-- Pluggable, extensible Node.js + Express-based server
TIBET Workflow (TWS)
-- Powerful, flexible, state-persistent microservice engine
-- Integrated CouchDB support from web app to couchapp


Full Tool Chain

Tying it all together is TIBET's suite of power tools.

TIBET's tools support the entire development and deployment (devops) lifecycle with a focus on ease-of-use and eliminating anything that interrupts flow.

Command Line (CLI)
-- More than a task runner, a reflective development assistant
-- Single test harness for units, modules, and applications
-- Smalltalk-inspired browse / inspect / edit-while-it-runs IDE