Wakanda
A project dedicated to creating a
new end-to-end JavaScript platform

4D
4D has been publishing business application
development tools for many years, with a focus on
simplicity, compatibility and integration, across
desktop, client-server and Web.

We are a "small-large" company based in Paris, with a
presence all over the world.

Inner magic
It's what Wakanda means in the Sioux language.
We intend to bring our style of ease and
simplicity in development to your complex
business Internet applications.

The Wakanda Team

Why is JavaScript the best choice
for Wakanda today?
http://tr.im/javascript_rocks

The Wakanda Project

Studio
- users & groups management
- database / entity models design & administration
- WYSIWYG editing
- JSDoc / ScriptDoc (type-ahead, outline, publication)
- source control
- validators (JSLint, W3C, ...), ATAG conformance !?!
- unit testing (TDD, TDR), client & server debugger
- minifier, caching properties

Web Admin
Solution, Applications, Servers, Services

HTTP & JavaScript
Unit Testing Tool
HTTP test case editor in the Firebug console

HTTP & JavaScript
Unit Testing Tool
Use the Bespin JavaScript editor to
customize test cases

HTTP & JavaScript
Unit Testing Tool
Test suite management - YUI test compatibility - JUnit support

Remote JavaScript Debugging
CrossFire, v8 protocol compatibility !?!
- debug the client from the studio
- debug the server from web clients
breakpoint, step by step, callstack,
JavaScript expression evaluation

JSON-RPC Client & Server
A simple protocol
Request by position
--> {"jsonrpc": "2.0", "method": "subtract", "params": [42, 23], "id": 1}
<-- {"jsonrpc": "2.0", "result": 19, "id": 1}
Request by params
--> {"jsonrpc": "2.0", "method": "subtract", "params": {"subtrahend": 23, "minuend": 42}, "id": 3}
<-- {"jsonrpc": "2.0", "result": 19, "id": 3}

JSON-RPC Client & Server
Simple function declaration,
request validity control from JSDoc or JSON-Schema
Server-Side
/**
* get the number of connexions on an application server
*
* @param {String} appName application name
* @return {Number}
**/
function countConnections(appName) {
return applications[appName].servers.http.connections();
}

JSON-RPC Client & Server
Simple client binding declaration,
Client-Side
<meta name="WAF.config.rpc.namespace" content="customAdmin" />
<meta name="WAF.config.rpc.methods" content="countConnections" />
or
<link rel="WAF.config" href="/wafConfig.json" type="application/json" />

JSON-RPC Client & Server
Simple and advanced method calls,
request sent only if parameters are valid
Client-Side
customAdmin. countConnections("killingApp");
customAdmin. countConnectionsAsync(showResult, "killingApp");
var infosHandlers = {
onsuccess: function (result) { /* ... */},
onerror: function (error) { /* ... */}
};
customAdmin. countConnectionsAsync(infosHandlers, "killingApp");

JSON-RPC Client & Server
Easy way to call external Web Services
and to had client validity checking
Client-Side
WAF.rpc.call("otherMethod", paramA, paramB);
WAF.rpc.callAsync(methodHandlers, "otherMethod", paramA, paramB);
or
WAF.rpc.call(otherServerConfig, "otherMethod", paramA, paramB);
or
var rpcOut = new WAF.classes.Rpc(otherServerConfig);
rpcOut.callAsync(methodHandlers, "otherMethod", paramA, paramB);
rpcOut.getInterface("otherMethod", "rpcOut");
rpcOut.otherMethodAsync(methodHandlers, paramA, paramB);

End-to-End JavaScript
SquirrelFish Extreme (Nitro)
64 bits - multi-thread - lightweight - extensible - the fastest ?

CommonJS
Modules/1.0
«4D is implementing this in Wakanda»
http://wiki.commonjs.org/wiki/Modules/1.0

HTTP Incoming Request JS APIs
JSGI (0.2)
Jack
Persevere
Jaxer
v8cgi
EJscript
node.js
Wakanda * http://wiki.commonjs.org/wiki/JSGI
http://tr.im/http_ssjs_api

Native REST & JavaScript
Database Engine

Core DBMS
64 bits - Unicode - multi-thread - multi-process
Improved database engine

Core DBMS
catalog data indexes
Entity Models
SQL
JavaScript REST HTTP
Lowest level JavaScript and HTTP binding

Core DBMS
Entity Models
JavaScript SQL
REST HTTP
db.tables.employee.all();
Access to relational database layer from JavaScript

Easy way to design the Business interface

Core DBMS
Entity Models
SQL
SquirrelFish JavaScript REST HTTP
var emps = db.employee.all();
function hello(emp) {
return ‘hello ’ + emp.name;
}
hello(emps.first());
Access to the Business interface layer from JavaScript

Core DBMS
Entity Models
SQL
SquirrelFish JavaScript REST HTTP
db.employees.find("name = alex").drop();
function getWorkLocation(employee) {
return employee.company.address;
}

Core DBMS
Entity Models
SQL
SquirrelFish JavaScript REST HTTP*
GET /rest/employee(5)
GET /rest/employee/name?$query=salary < 50000
DELETE /rest/employee("Tom Cat")
* JSON or XML layout
Access to the business interface layer from
HTTP trough a REST API

JSON View of an entity set

XML View of an entity set

Direct HTML interface
• Unlimited number of entities in the datatable
• Automatic Forms with unlimited property hierarchy
• Very responsive filters, server side ordering
• Possibility to add, remove, and update the entities

Core DBMS
Entity Models
SQL
SquirrelFish JavaScript REST HTTP
SELECT * FROM employee
Still an SQL access to the relational layer with ODBC & PDO
for specific clients or imports/export

WAF adapters

Upcoming?
Yours...?

Summary
- Powerful Server Side JavaScript engine
- Native Business Logic abstraction
- No SQL generation
- direct JavaScript interface
- direct REST interface
- Open Platform
- Streamlined development process

Get Involved
Developer preview: 1st quarter 2010
http://www.wakandasoftware.com
@wakandasoftware
@amorgaut
@amorgaut/wakanda
@amorgaut/javascript-gurus
@amorgaut/accessibility
http://wiki.commonjs.com
http://tr.im/wtframework