The Future Is Written In Markup™

JavaScript is here to stay. From server to desktop, from mobile to IoT, today's apps depend on JavaScript and JavaScript coders.

The problem? Demand for JavaScript skills consistently outpaces supply... a condition that's been true since the dawn of the web.

Ironically, most modern frameworks increase demand for JavaScript skills; some require TypeScript, forcing you to hire from an even smaller pool of qualified coders.

Business-wise that's just plain backwards; more complex code from a smaller developer pool?

The good news is there's a solution... the one that grew the web to over 6 Billion pages. The answer? Authoring in markup augmented by JS, not embedded in it.

The popularity of Angular's tag-based design; experiments like Google Polymer; W3C WebComponents; all trends point to a future of apps written in markup:

<hello:app>
    <hello:world/>
</hello:app>

Markup; it's not just for the UI...

TIBET's revolutionary tag system lets you use markup to display UI widgets, access data sources, trigger actions, and much more.

REST service access? Use tibet:service and save the data in a TIBET URN:

<tibet:service id="getConfig" href="~app/tibet.json" name="urn:tibet:config"/>

Binds? Bind in, out, or io (bidirectionally) with bind: and JSONPath or XPath:

<input type="text" id="projName" bind:in="urn:tibet:config#jpath($.project.name)"/>

Actions? You can trigger signals using on: attributes or TIBET action tags:

<button id="b1" on:click="SpecialEvent">Go!</button>

With TIBET a small team coding tags can support teams using nothing but markup.

The result? Hiring that scales. Encapsulated logic. Apps that are maintainable over time.

But wait...there's more... ;)

TIBET Shell (TSH) lets you quickly write embeddable "scripts" using UNIX-like syntax.

Need to access some JSON, put it in a textarea, and make that textarea the content of the id="target" element? Easy peasy:

~app/tibet.json .| 'html:textarea' .> #target

Drag-and-drop your script from the TIBET Developer Console (TDC) into your UI and TIBET will embed it is as simple markup:

<tsh:script>
    <tsh:uri tsh:pipe=".|" tsh:href="~app/tibet.json" />
    <tsh:eval tsh:pipe=".>"><![CDATA['html:textarea']]></tsh:eval>
    <tsh:uri tsh:href="#target"/>
</tsh:script>

Use the Sherpa's "make custom tag" feature to encapsulate that script logic in it's own tag:

<hello:tibetjson id="fetchit">

Run your newly-created action tag by adding an on: signal to a button or other trigger:

<button on:click="{origin: 'fetchit', signal: 'Act'}">Run that baby!<button>

TSH lets you write data access logic using simple pipes that handle async data with ease.

Got XML? TIBET has your back...

SVG, RSS, ATOM, KML, XMPP, SOAP. While JSON gets the spotlight, XML remains essential to many business and Government systems.

TIBET is the only modern web platform with full support for XML including XPath, XMLSchema, and XSLT for binding, validation, and more.

Query XML data sources via tibet:service tags or TIBET URIs... or embed XML content directly in your page via tibet:data tags:

<tibet:data name="urn:tibet:person">
    <person xmlns="">
        <lastname>Smith</lastname>
        <firstname>Joe</firstname>
    </person>
</tibet:data>

With TIBET there's no need to convert existing XML to JSON, just use it:

<input type="text" id="fname" bind:io="{value: urn:tibet:person#xpath1(/person/firstname)}"/>

In TIBET you can load XML, transform it with XSLT, place it in the UI, style it with CSS; no need to do the markup-to-JSON-to-markup shuffle.

TIBET is the future...delivered.

TIBET isn't technology in search of a problem or, worse yet, technology that keeps you digging a deeper hole using more complex JavaScript.

TIBET is technology that solves the three problems plaguing web development for decades, problems other platforms ignore.

By design TIBET:

• lets you eliminate coding over time;
• has unmatched development tools;
• is a complete buy-vs-build solution.

TIBET supercharges development with Sherpa™, our "saw-it-and-still-don't-believe-it" IDE:

We write JavaScript...

...so you don't have to.™

There are a lot of "good parts" in TIBET, each focused on helping you author apps with type-backed markup, each putting you on the path to a more scalable, stable, supported future.

Install TIBET; sign up for support; take the first steps toward that future today.