TIBET Documentation

Documentation


For installation see TIBET First Steps or the full install guide.

Contents

Client Stack

Server Stack

Power Tools

API Documentation

Special-Interest Topics

Standards & Conventions


TIBET Client

Client Stack

TIBET's client stack is fully-integrated, each layer building on the foundation provided by the layers below it. TIBET's level of functionality and integration is unmatched.

Many of the terms we use to describe TIBET will sound familar: tag-based, MVC/MVVP, object-oriented, event-driven; however, TIBET's implementation often exceeds expectations.

For example, we believe TIBET's OO+Traits features are easier to use, more powerful, and more flexible than TypeScript or ES6/7 classes. We think the same is true for much of TIBET.

We've worked hard to solve the problems facing developers building standalone applications for the desktop or applications that need to run offline.

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

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

Configuration
-- Unified configuration system for client, server, CLI, and tools
Loading
-- Dynamic multi-phase loader with shared metadata for tools
Logging
-- Extensible object-oriented logger with Log4Java 2.0 APIs
Primitives
-- 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
I18N
-- Extensible Locale types plus native type parsing / formatting
Devices
-- Keyboard mapping, key sequences, mouse gestures, D&D
Services
-- Request / Response processing for sync/async Service types
Users & Roles
-- vCard-based user, role, unit, org support with client keyrings
URLs & URNs
-- URI-based state management with change notification
Content
-- Powerful OO classes for the DOM, XML, and JSON
Queries & Paths
-- CSS queries, JSONPath, XPath, and xpointer() support
Templating
-- 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
Forms
-- 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

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
TIBET + CouchDB
-- Integrated CouchDB support from web app to couchapp


TIBET Power Tools

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
TIBET Test
-- Single test harness for units, modules, and applications
TIBET Lama™
-- Smalltalk-inspired browse / inspect / edit-while-it-runs IDE

You may be thinking you've seen tools like these before…

We invite you to take a closer look.

The TIBET CLI runs commands but it also runs your application; reflecting on it, testing it, interacting with it to provide functionality guided directly by your application's code.

TIBET's test harness lets you test at whatever granularity you require from single functions to full applications. TIBET tests are associated with the objects they test, providing a uniquely focused approach to testing and coverage tracking.

The Lama™ is a real-time, in-situ development environment with full interactivity and zero-reload operation. With a top-down, teach-as-you-go, development model the Lama is truly special.

As with all of TIBET, TIBET's tools are fully-integrated, leveraging TIBET's configuration system, reflection metadata, and each other, to optimize your workflow.

API documentation

API Documentation

API documentation for TIBET is generated on-the-fly by the TIBET runtime system. This up-to-the-minute documentation is accessible via both the TIBET CLI and Lama.

TIBET's tools can lint-check as well as generate API documentation for your application code provided you follow TIBET's coding standards with respect to commenting.

The tibet apropos command lets you query for functionality related to one or more terms. These are a good starting point.

tibet apropos <topic>

The tibet reflect command lets you focus on a particular object or method, or reflect across the currently loaded code.

tibet reflect [<target>]


manpages

TIBET's manual pages (aka "manpages") document the CLI and related topics.

HTML-formatted manpages are linked via the TIBET manpages document.

Command-line versions of the manpages can be viewed via the tibet help command:

tibet help <topic>


Use the source Luke…

TIBET source code is heavily documented. Heavily. To the point where we get criticized for writing too many comments. (Is that even a thing? ;)).

Seriously though. Use the source. It's an incredible resource. After all, it's what apropos, reflect, and a number of TIBET's reflection-driven tools run on.


Special Interest

Special-Interest Topics

TIBET and Electron
-- Building desktop apps with TIBET+Electron
TIBET and React
-- Using React widgets from TIBET markup
TIBET Deployment
-- Deploying TIBET applications
TIBET Integrations
-- Configuring TIBET service integrations
TIBET Troubleshooting
-- Dealing with unexpected errors

Standards

Standards & Conventions

TIBET for JS Programmers
-- TIBET differences from typical JavaScript
TIBET JS Patterns
-- Coding patterns for your TIBET code
TIBET and ECMA classes
-- Using ECMA-6 classes with TIBET OO
TIBET Coding Standards
-- The coding standards used in TIBET itself
TIBET + Web Standards
-- TIBET is highly web standards-compliant


Feedback?

As always, we appreciate any feedback you may have about our documentation, what subjects you would like to see covered in more detail, etc. Contact us with any input you may have!