Why TIBET? Less Risk, More Reward
TIBET was created to reduce your 3 biggest risks.
Developers tend to say those are:
- getting async code right,
- getting code to load efficiently, and
- managing client-side data.
Those are definitely challenges…
…but they're not the problems that cause projects to fail.
Projects fail because:
- they can't hire at scale,
- they can't maintain a stable stack, and
- there's no SLA-based support backing their efforts.
Projects fail because of staffing, stability, and support.
TIBET is specifically designed to solve those problems.
Staffing: The Problem Most Frameworks Make… Worse?
During our 25+ years in the web we've spoken with dozens of decision makers about the issues they face with their projects.
Not once have they mentioned things like "callbacks are complicated", "we need static typing", or "we need better module support".
Without exception managers never mention technical issues at all.
Every business leader we've encountered complains almost solely about one issue:
Hiring good JavaScript coders is impossible.
TIBET addresses your staffing problem by:
- reducing coding through a unique markup-first approach;
- enabling top-down graphical development via our In-App IDE;
- aligning skill requirements with market availability via our authoring pyramid.
Each of these elements reduces your dependence on coding, replacing it with a scalable markup-first approach that's easier to staff for and maintain over time.
The 80/20 Rule Revisited
Most frameworks force you into a minimum 80/20 ratio of code to markup, forcing you to focus on hiring for JavaScript or TypeScript rather than HTML/CSS skills.
TIBET inverts that relationship, letting you do 80% or more of your work in markup and 20% or less in code. For many common operations TIBET lets you work purely in markup.
How does that work?
It's simple really.
TIBET's "component consumption model", the way in which you consume pre-built components, uses 100% markup.
Most modern frameworks, Angular, React, Vue, require you to write code to use a component. It's a simple design decision but one with dramatic impact over time.
TIBET lets you create new components or consume existing ones without having to immediately write code. A majority of common operations require almost no code.
TIBET is designed specifically to solve the web's staffing problem by allowing you to reuse components entirely in markup, reducing reliance on code over time.
Stability: Avoiding The Pain Of À La Carte Stacks
Selecting, integrating, and maintaining a full stack and toolchain requires time, effort, and a skilled team, increasing staffing pressure.
In addition to its negative impact on staffing, choosing à la carte development is the root cause of another business problem: platform instability.
The JavaScript market is a hot mess of churn; the very antithesis of stable.
You might think when you choose React, Angular, or Vue you've chosen your solution.
Nothing could be further from the truth.
These platforms (React, Angular, Vue) are not complete solutions on purpose.
For example, the React core is intentionally small, the idea being you'll add the modules you need. Not even data management is built in, Redux is only one choice.
The irony of choosing React is you'll be choosing from then on; choosing a data manager, choosing a router, choosing a state machine, choosing this widget, choosing that widget.
The choosing never ends, by design.
Worse, the missing parts of your application aren't supplied by the "vendor", they're found in the form of hundreds if not thousands of open-source modules created by independent developers who all-too-often wander off when their interest wanes.
How many data managers, state machines, routers, layouts, widget kits, css processors, task runners, minifiers, bundlers, loaders, test harnesses, coverage tools, etc. have been "the best", only to be replaced on the next project by whatever was new and shiny?
TIBET saves you from the pain of à la carte JavaScript development at every level:
- TIBET provides the web's most comprehensive client stack, a stack that's fully integrated and fully featured.
- TIBET's full suite of optional server components supports projects open to a Node.js-based solution and further simplifies your stack requirements.
- TIBET's command tools handle linting, testing, building, deploying, and more, giving you a powerful tool chain that has remained stable over time.
TIBET is truly "The sum of the parts, not some of the parts.™", providing you with the most comprehensive and integrated platform available for cross-platform development.
Support: aka Authored By !== Supported By
TIBET is fully supported by the vendor who built it.
In contrast, most of today's prominent platforms are unsupported. They're popular, powerful, and often authored by prominent companies but there's a catch.
The core business for today's prominent platform authors is not frameworks. They don't "back them"; they merely authored them.
There's no SLA. You can't call the vendor. As a result they're free to abandon them, and you.
A perfect example is Google's Angular1 to Angular2 transition, a change that stranded Angular1 projects on a now-moribund platform.
The thing is, abandoned frameworks are nothing new.
Yahoo! walked away from both YUI and Mojito. Google has gone through Closure, GWT, and Angular1. Today's offering is Angular2+. The jury's still out on Dart and Polymer. Facebook has changed React repeatedly over the years both technically and in terms of licensing.
With WebAssembly and WebComponents on the horizon there'll be even more churn as these companies compete in their core business: advertising.
Yes. Advertising.
The scale at which the Googles and Facebooks of the world operate is such that miniscule improvements in performance can affect millions if not billions in revenue.
Those changes would never cause you to abandon your current platform, the incremental value would be impossible to measure or recoup.
That's not true for them. They can, have, and will continue to abandon platform after platform. There's too much at stake for them not to.
We're different.
Since 1999 our only business has been the design and development of business web applications and tools.
This is what we do.
It's all we do.
When we say TIBET is supported we mean it; our business and your project depend on it.
Speed and Simplicity: The Bonus Round
TIBET development is an immersive, top-down experience that's fast and easy.
At the center of that experience is the Lama™, an immersive, interactive IDE designed specifically to speed development by letting you focus on tags rather than files.
Most web development tools retain a long-standing development tool focus on editing files. Files of markup, files of JavaScript, files of CSS, files files files.
The thing is, the essence of web applications isn't found in files, it's found in tags, tags with containment hierarchies, tags with event handlers, tags with style.
Tags are the "quantum" of web development.
Lama™ lets you focus on tags; creating them, moving them, styling them, giving them behavior, sharing them across projects, using them as commands. Need to make a service call? Use a tag. Need to read local storage? Use a tag. Need to bind to a remote URL? Use a tag.
TIBET's "component consumption model" is tags, not code.
By focusing on tags instead of files Lama changes the fundamental nature of web development.
Take the plunge, install TIBET,
and dive into the Quickstart Guide.
We think you're going to love working with TIBET!
