Change Everything… Evolve the Web!

The evolution is here. The Greasemonkey script of the past has now become a Kynetx App. Client side execution has given way to cloud-based platforms. The loading of libraries replaced with the abstraction of library management. No more uninstalling and reinstalling broken scripts. Bottom line….no more Greasemonkey business. Join the evolution!

Have you ever wanted a website to be more responsive to your purposes? Ever wished that it was more relevant to you? Well, do something about it!

Now you can use Kynetx to change the look, feel and function of any website. It’s like Greasemonkey in the Cloud...but better!

In 2004, a Firefox plug-in called Greasemonkey emerged, changing the way we experience the Web by enabling users to install scripts that make on-the-fly changes to most HTML-based web pages. While cool, scripts came with some serious limitations and security concerns.

True, we love the ability to control the way we experience the web, but we don’t like having to repeatedly download updates to fix broken scripts or worry about who is seeing our data. Moreover, a script is like a robot; it just runs, knowing nothing of the users’ context. There was a need for change, an evolution. Enter Kynetx.

Kynetx is a development platform for building context-aware, rules-based apps that live in the cloud. Leveraging the Kynetx Rules Engine, developers like you can now create apps that respond to users’ context, without the update hassles or security nightmares of scripts.

But that’s not even the coolest part. The real power is in Kynetx’ ability to do the heavy lifting with data access. Kynetx intrinsically serves up primitives designed to optimize data access. Integrating data is the most powerful part of using the Kynetx Rules Language to build cross-site apps that mash-up fractured data and user context. The script has now become an app, an app that responds to the user.

Here’s an example of the Twitter Module in KRL for using OAUTH to authenticate a user. Below is what a code snippet to execute OAUTH looks like in KRL.

   1: select using ".*" setting ()
   2:
   3: if(not twitter:authorized()) then
   4:     twitter:authorize()
   5:       with opacity=1.0 and
   6:            sticky = true
   7:
   8: fired {
   9:    last
  10: }

It’s all of ten lines of code. The real OATH work in the code is done by one line of code.

twitter:authorize()

Contrast that with the JavaScript code sample that follows. 114 lines of code. Complicated. Lots of opportunities for bugs. KRL is doing all this messy stuff for you. All of the setup, the calls to the twitter API, the OAUTH process—everything—is done for you.

   1: var consumer = {};
   2:
   3: consumer.example =
   4: { consumerKey   : "myKey"
   5: , consumerSecret: "mySecret"
   6: , serviceProvider:
   7:   { signatureMethod     : "HMAC-SHA1"
   8:   , requestTokenURL     : "http://cut.ms/Jj3
   9:   , userAuthorizationURL: "http://cut.ms/Jj4
  10:   , accessTokenURL      : "http://cut.ms/Jj5
  11:   , echoURL             : "http://cut.ms/Jj6
  12:   }
  13: };
  14:
  15: consumer.madgex =
  16: { consumerKey   : "key"
  17: , consumerSecret: "secret"
  18: , accessToken: "requestkey"
  19: , accessTokenSecret: "requestsecret"
  20: , echo: "accesskey"
  21: , echoSecret: "accesssecret"
  22: , serviceProvider:
  23:   { signatureMethod     : "HMAC-SHA1"
  24:   , requestTokenURL     : "http://cut.ms/Jj7
  25:   , accessTokenURL      : "http://cut.ms/Jj8
  26:   , echoURL             : "http://cut.ms/Jj9
  27:   }
  28: };
  29:
  30: consumer.mediamatic =
  31: { consumerKey   : "e388e4f4d6f4cc10ff6dc0fd1637da370478e49e2"
  32: , consumerSecret: "0b062293b6e29ec91a23b2002abf88e9"
  33: , serviceProvider:
  34:   { signatureMethod     : "HMAC-SHA1"
  35:   , requestTokenURL     : "http://cut.ms/Jka
  36:   , userAuthorizationURL: "http://cut.ms/Jkb
  37:   , accessTokenURL      : "http://cut.ms/Jkc
  38:   , echoURL             : "http://cut.ms/Jkd
  39:   }
  40: };
  41:
  42: consumer.termie =
  43: { consumerKey   : "key"
  44: , consumerSecret: "secret"
  45: , accessToken: "requestkey"
  46: , accessTokenSecret: "requestsecret"
  47: , echo: "accesskey"
  48: , echoSecret: "accesssecret"
  49: , serviceProvider:
  50:   { signatureMethod     : "HMAC-SHA1"
  51:   , requestTokenURL     : "http://cut.ms/Jke
  52:   , userAuthorizationURL: "accessToken.html" // a stub
  53:   , accessTokenURL      : "http://cut.ms/Jkf
  54:   , echoURL             : "http://cut.ms/Jkg
  55:   }
  56: };
  57:
  58: consumer.initializeForm =
  59: function initializeForm(form, etc, usage) {
  60:     var selector = etc.elements[0];
  61:     var selection = selector.options[selector.selectedIndex].value;
  62:     var selected = consumer[selection];
  63:     if (selected != null) {
  64:         consumer.setInputs(etc, { URL           : selected.serviceProvider[usage + "URL"]
  65:                                 , consumerSecret: selected.consumerSecret
  66:                                 , tokenSecret   : selected[usage + "Secret"]
  67:                                 });
  68:         consumer.setInputs(form, { oauth_signature_method: selected.serviceProvider.signatureMethod
  69:                                  , oauth_consumer_key    : selected.consumerKey
  70:                                  , oauth_token           : selected[usage]
  71:                                  });
  72:     }
  73:     return true;
  74: };
  75:
  76: consumer.setInputs =
  77: function setInputs(form, props) {
  78:     for (p in props) {
  79:         if (form[p] != null && props[p] != null) {
  80:             form[p].value = props[p];
  81:         }
  82:     }
  83: }
  84:
  85: consumer.signForm =
  86: function signForm(form, etc) {
  87:     form.action = etc.URL.value;
  88:     var accessor = { consumerSecret: etc.consumerSecret.value
  89:                    , tokenSecret   : etc.tokenSecret.value};
  90:     var message = { action: form.action
  91:                   , method: form.method
  92:                   , parameters: []
  93:                   };
  94:     for (var e = 0; e < form.elements.length; ++e) {
  95:         var input = form.elements[e];
  96:         if (input.name != null && input.name != "" && input.value != null
  97:             && (!(input.type == "checkbox" || input.type == "radio") || input.checked))
  98:         {
  99:             message.parameters.push([input.name, input.value]);
 100:         }
 101:     }
 102:     OAuth.setTimestampAndNonce(message);
 103:     OAuth.SignatureMethod.sign(message, accessor);
 104:     //alert(outline("message", message));
 105:     var parameterMap = OAuth.getParameterMap(message.parameters);
 106:     for (var p in parameterMap) {
 107:         if (p.substring(0, 6) == "oauth_"
 108:          && form[p] != null && form[p].name != null && form[p].name != "")
 109:         {
 110:             form[p].value = parameterMap[p];
 111:         }
 112:     }
 113:     return true;
 114: };

Now imagine saving hours of your valuable time working with Kynetx’ API integrations from Amazon Web Services, Google, PayPal and others. Discover how to apply these data access tools to your app ideas. You have nothing to lose but headaches and limitations.

Why should you use Kynetx to build apps?

  1. The power of context
  2. The flexibility of a development framework that’s platform, browser and end-point agnostic
  3. The freedom to create open-source apps that evolve the Web
  4. The ability to monetize your apps with any number of business models

Kynetx apps change everything across the web and beyond by empowering you to distribute context aware apps through a variety of end points including: mobile apps, browser extensions, bookmarklets, identity cards, proxy servers, toolbars, desktop agents and sprinkler systems. Check out the examples over on the sidebar to grok the evolution!

Kynetx is evolutionary… It’s powerful… It’s FREE… So start building!