The new Webhook Endpoint allows easy creation of Webhooks with Kynetx Apps. Twilio is a cloud-based telephony provider that uses webhooks to script telephone call and sms functionality. Kynetx + Twilio = an easy and scalable way to create contextual telephony apps.

I created a sample app to demonstrate how this works. To try it out, call the Kynetx Demo number: (801) 895-4878

The code for this application is below. It receives the phone call, asks for input, and upon input reads the user's calling area and the weather via a lookup from the NOAA weather service.

Kynetx is free to get started, and the good folks at Twilio have some free credit when you sign up. Free + Free = (wait for it...) FREE! You have NO EXCUSE not to try this out.

Today, we are releasing a new endpoint that provides Webhook support. Webhooks are an easy and powerful way to tie online systems together. Also called HTTP Callbacks, this method of using a simple GET or POST to send a message to another system is an excellent way of tying separate systems together.

This endpoint is new among the endpoints supported by Kynetx, as it lives entirely in the cloud. No configuration is necessary, and you can begin using it immediately. Our documentation for the Webhook Endpoint shows the format of the webhook url and the KRL necessary to respond to webhook requests. We'll be posting an example of these new abilities shortly.

Ready..... Go!

Kynetx developer Mark Horstmeier unveils how to integrate Facebook social graph data with KRL in his blog post.

He also describes a cool Kynetx app called WALLet that takes your Facebook Wall off Facebook and onto other sites where you might want to see what your friends are up to.  Just want to take a quick peak at your wall without going to the Facebook site? Just tap the tab on the side of your browser and a tray slides out with the most recent posts. It even removes the posts about games so you don’t have to waste your time seeing who’s gathering eggs or needs fuel. Check it out.  Powerful stuff here.

You can also access documentation for this Facebook integration in the Kynetx docs at: http://docs.kynetx.com/index.php/Facebook

Come to one day of FREE intensive Kynetx Developer training at the

Kynetx Impact Dev Day - Sept. 18, 2010

9:00 am - 5:00 pm

This all-day intensive training is designed for all levels programmers from those who have never touched KRL, to those who've been using it for months. Learn, brainstorm and create with some of the greatest app developers in the world (and in Utah).What You’ll Learn:

Track 1 – Beginner

• Using AppBuilder to create Kynetx Apps
• Understanding the KRL gem and how to use it.
• Basic KRL syntax
• Writing rules
• Using web events
• Understanding Intrinsic Date

Track 2 – Intermediate/Advanced

• Using Explicit Events
• Event Domains and KRL
• Building Interactive Apps using KRL

Agenda:

9:00 - Welcome by Stephen Fulling, CEO

9:15 - Opening session by Phil Windley, CTO

“Programming the Internet: Why
Coding with KRL, Events and Rules will change your future.”

10:30 - Workshops

Track 1 – Beginner - Basic Programming in KRL

Track 2 – Intermediate/Advanced- Events and Cross Domain Apps

12:00 – Lunch (provided)

1:00 - Workshops

Track 1 – Beginner – Building Apps that use Data

Track 2 – Intermediate/Advanced – Beyond the Web

2:30 - Working Session

4:00 - App Showcase

5:00 - Wrap-up & Goodbye – Stephen Fulling & Phil Windley

Location:

Kynetx HQ

3098 Executive Parkway, Lehi, UT
84043

Get ready to participate in the KRL Challenge during the Dev Day. Everyone that builds an app that day wins!

Never been to a Kynetx Developer Event? Check out the photos from our last conference (Kynetx Impact Spring 2010).

Seats are limited so register today!

Kynetx is known for augmenting web experiences, but the language and platform handles events outside the domain of web pages. Phil blogged about new Kynetx features that allow integration with endpoints of any type.

To show you where we are going, I've put together a demo app called InsultMe. To give it a try, send an email to insultme@kynetx.com and look at the response. Go ahead--do it right now before you read the rest of this--it will make more sense if you do.

There are three components to this demo:

1. Kynetx Network Services

The KNS cloud hosts and runs the app code for this demo. I'm using the regular production system available to all Kynetx Developers today. No man behind the curtain or unreleased features.

2. Email Endpoint

The endpoint connects contextual systems to KNS. In web land, the role of endpoint is usually played by a browser extension, a bookmarklet, or a proxy. The endpoint I've built connects to email accounts, detects email, publishes events to KNS, and processes the directives returned by KNS. The email endpoint is not yet ready for public release, but will soon be released as open source.

For this demo, the email endpoint has been configured with the credentials to the insultme@kynetx.com email account and the RID of the Kynetx app that has subscribed to the events for this account.

3. The InsultMe Kynetx App

This app runs on the KNS platform, and directs how the system processes any email it receives.  Here's the KRL code.

ruleset a8x50 {
  meta {
    name "InsultMe-Email"
    description <<       Delivers insults via email.     >>
    author "Sam Curren"
    logging off
  }

  dispatch {
  }

  global {
    dataset insult_page:HTML <- "http://www.pangloss.com/seidel/Shaker/" cachable for 1 second;
  }

  rule handle_bounce is active {
    select when mail received from ".*DAEMON.*"
    email:delete();
    fired {
      last;
    }
  }

  rule send_reply is active {
    select when mail received
    pre {
      insultlist = insult_page.query("body center p font[size=+2]", 1);
      insult = insultlist[0];
      mailmessage = <<
#{insult}
-------------------
You have been insulted by the InsultMe Demo App, powered by Kynetx.
Insults provided by http://www.pangloss.com/seidel/Shaker/
>>
    }
    email:reply() with
      message = "#{mailmessage}";
  }

  rule email_delete is active {
    select when mail received
    email:delete();
  }

}

There is nothing special about the meta block and the dispatch block currently doesn't apply and can remain empty.

The global block contains an HTML datasource, which is simply an HTML page that contains random Shakespearian Insult. It's cacheable for one second in this example which allows a variety of insults. Setting the cache time to an hour would cause every email processed within the same hour to have the same insult.

The handle_bounce rule is important for an email bot of this nature. Because this account sends email, it may receive error responses from other mail servers. When the from address matches the regex provided, it will simply delete the email. The fired { last; } postlude ensures that no further processing occurs for any emails that match this condition.

The send_reply rule performs the primary function of the app. Using the query operator, the text of the insult is extracted from the DOM element on the source page. The query operator returns a list of matches, so we extract the first item of the list, and compose that into a message. We then call the reply action, with the message we created.

The email_delete rule is our final rule, and unconditionally deletes the email from the account.

This example is simple, but shows the power of rule-based email processing. Of course, Kynetx isn't the first rule-based email processor. Systems like procmail have been around for a long time. But it is the first rule-based email processing system that is in the cloud and incorporates rule-based Web processing as well. Imagine the possibilities.

Salt Lake Tribune
By Tom Harvey

photo by: Jim Urquhart | The Salt Lake Tribune

Apple rolled out the slogan “This Changes Everything” when Steve Jobs introduced the latest edition of new iPhone in June. Fine, but that’s the trademarked slogan for a Utah company.

Apple used the phrase to promote the iPhone 4 as a game-changer in the realm of smart phones and their capabilities. Kynetx (pronounced KIN-NET-IX) of Lehi believes it has a game-changer that may revolutionize your use of the Internet.

How? Imagine being able to rearrange Google search results so that companies or products with which you get discounts rise to the top. Picture searching for a book on Amazon, and a note pops up saying your branch of the local library or a bookstore has it available right now. Imagine that when reading about the latest news on your local sports team you can see all the Tweets and Facebook messages commenting on it.

To read the entire article

MaximumPC Magazine

Posted 06/02/10 at 09:16:31 AM by Alan Fackler, Alex Castle, and Ambika Subramony

Sweetter by Kynetx
Find like-minded folk

People who don't understand Twitter think it's all about sharing what you had for lunch, or other miscellaneous trivia. The truth is, it's about having conversations about the things that interest you, and Sweetter helps you find people on the web who are talking about the things you care about. If you like a certain website, or a certain blogger, just go to that content, click the Sweetter bookmarklet, and you'll see the 10 most recent tweets about the site.

Read entire article.

As we mentioned earlier, along with the new AppBuilder came an open source command-line Ruby gem that lets you access most of the features of AppBuilder through an API. This allows you to write KRL with your favorite editor or IDE and then push your code to KNS from the command line or a plugin.

Installing the Gem

You can find the complete installation instructions here, but this is the basic process:

1. Install Ruby (version 1.8.7 or later).
2. Install the KRL gem (leave off sudo if you're on Windows):
   sudo gem install krl
3. Use OAuth to connect to the KNS servers:
   krl-connect
   This will start a server on localhost:3009 that will walk you through the OAuth ceremony. Once that's all finished, you can kill the webserver (with Ctrl+C).

Once the gem is installed, you're ready to get started.

Basic commands

First off: krl help is the definitive guide to the gem. The command will list all the possible things you can do, along with their syntax. (Tip: the text is easiest to read if your terminal is at least 90 characters wide.)

Check out your app

Run krl apps to get a list of all your apps. That displays the ruleset ID and name of each app, along with your role on the app (owner or developer).

Note: Until you save your app in the new AppBuilder or with the command-line gem, its name won't show up in the list. You can see that in the screenshot--the third app in the list has only been edited in the old AppBuilder, so the name doesn't show up yet.

Once you know which app you want to work on, a krl checkout command with the ruleset ID, like this:
krl checkout a163x2

This will create a new folder in your working directory with the ruleset ID as the name. (You can rename the directory to something more descriptive if you like.)

Editing your app

You can edit the <rulesetId>.krl file with any editor you like. Near the end of this post are some plugins for common editors to do syntax highlighting and integrate with the command-line gem.

Committing your changes

Once you've made changes and want to commit them, simply run krl commit in the same directory as your .krl file. If your code had any parse errors, these will be displayed to you. If everything passed, the gem will tell you what version was committed:

If you (or another developer) makes some changes later on AppBuilder and you want to pull them down to your local copy, simply run krl update. Note that this will overwrite your local copy of the code; it doesn't do version-control-style conflict resolution for you.

Generating endpoints

The gem will let you create both test and production endpoints. Here are the various commands:

• Test bookmarklet: krl test
• Test Infomation Card: krl test infocard
• Production bookmarklet: krl generate bookmarklet
• Production browser extension: krl generate [firefox|chrome|ie] <name> <author> <descr>
• Production Information Card: krl generate infocard <name>

Viewing older versions

If you ever want to go back and look at an older version of your app, simply run a krl show <version number> command. This will print out the KRL from that version to your console. You can even pipe it to a file to open in your editor (although you'll have to remove the first line, "KRL for version XX," if you want to use the file as a valid ruleset).

Running the krl versions command will list all the versions your app has been through, along with the timestamp, the developer who made the commit, and any notes associated with each version. That list will also tell you which version of the app is currently in production.

A note on the commands

Most of the functions must be performed inside a directory where you've checked out your app. commit and update are good examples of commands in that category. A few functions can be performed anywhere, since they're not specific to any particular app. Those are apps, checkout, create, and info. Refer to krl help for more information about where you can run the various commands.

Integrating with your favorite editor

The command-line gem is platform- and editor-agnostic, so you can create plugins for any editor or IDE the offers a programmable interface. Here are a few of the ones that have been developed so far:

Emacs

This Emacs mode provides syntax highlighting for KRL. Find the .el file here.

TextMate

This TextMate bundle maps Cmd+K to save the app and then commit it. Find it here.

Vim

This Vim plugin enables syntax highlighting and intelligent indentation of KRL files. Get the .vim files here.

Growl and libnotify integration

You can have bash notify you when the krl commit command finishes running. See the solution here for Growl (Mac OS X) or here for libnotify (Linux).

Other editors and IDEs

Have you created a package for any other editors or IDEs? Leave a link in the comments!

The gem is open source

The Ruby code for the KRL command-line gem is open source. You can find it on the Kynetx github account.

If you have any issues with the gem or if you'd like to offer improvements, please do! You can submit bug fixes on the Issues tab on github. Or (even better) you can fork the code, fix the bug you found, and then send us a pull request.

Announced at Kynetx Impact in April, the powerful new Kynetx AppBuilder is now live at http://appbuilder.kynetx.com/. Here's a quick tour to get you up to speed with the awesome new features.

Logging in

AppBuilder now uses OAuth authentication for long-life logins, meaning that you won't have to log in again every time you visit the site.

Application list

When you first log in to AppBuilder, you'll see a list of all your apps with their ruleset IDs. Clicking on the name or ruleset ID of an app will open the app so you can edit it.

You can now easily duplicate an app with the link in the right-hand column.

Another cool new feature is searching--you can filter the list by app name, ruleset ID, or by your role in the app (owner or developer).

Editor

The most salient feature of the editor in the new AppBuilder is the beta Bespin embedded editor. It provides a lot of the functionality you'd expect from a full-fledged text editor. Syntax highlighting makes it easy to see that your code is correct, allowing you to catch errors even before going through the parser.

Even if you've never used Bespin before, it will be pretty familiar to you. It behaves quite like a desktop code editor: you can type as usual; it will handle indentation (including the use of the tab key); you can select and scroll with the mouse. And of course syntax highlighting, a must-have for any serious coder, is built in.

Saving an application is as easy as Ctrl+S (also Cmd+S in Firefox on the Mac). It's all done through AJAX, so you can keep working on your code while it saves.

If your code has errors in it, you'll see en error icon below the Save button, and the error log will pop up at the bottom of the window. It describes where the error occurred in your code. If you want to close that log so you can get back to coding, click on the X in the corner of it or press Ctrl+E. Clicking on the error icon also toggles the error log, so you can show or hide it as you like.

If the save was successful, you'll see a green check mark below the Save icon, as well as the timestamp of the last successful save.

Bespin uses the HTML5 canvas tag, so any browser that supports it will be able to run Bespin without any trouble. If you're using Internet Explorer, you'll be redirected to an old-style (less feature-rich) editor.

Production and development versioning

AppBuilder gives you an intuitive, simple way to manage production and development versions of your app. The Deploy tab shows you a list of all the versions your app has been through. You can "deploy" a specific revision, meaning that it will be the production version that is run on the endpoints your clients use (browser extensions, InfoCards, etc.). Your development branch is the most recent revision of the code that you're using to test.

You can give each revision a label to make it easier to identify. That way if something breaks, you can easily go back to an older stable version that you are sure works.

The Deploy tab also lets you see the KRL for any particular revision. Simply click on the version number in the left-hand column.

Testing and distributing your app

The Test and Distribute tabs let you work with various test and deployment endpoints for your apps, such as browser extensions, bookmarklets, site tags, and InfoCards.

The other cool new feature here is integration with the Kynetx Marketplace. You can list your app in the Marketplace with just a few clicks. Choosing the "Marketplace" option from the Distribute tab will take you directly to the Marketplace and pre-fill all the fields that AppBuilder already knows about.

AppBuilder Ruby Gem

The new AppBuilder is an open source Ruby on Rails application, and it's built on top of an open source Ruby gem we created. What this means for you is that if you'd prefer to write KRL in your favorite desktop editor, you can! The Ruby gem allows you to access the majority of the AppBuilder features right from the command line or your IDE. Keep your eyes open for a blog post all about that, coming soon.

Where do we go from here?

Below you can watch the Kynetx Webinar that walks through AppBuilder for a more in-depth introduction:

You can also watch Mike Farmer's presentation of AppBuilder from Kynetx Impact 2010 (a series of 7 videos beginning here).

Try it out today! Log in now with your Kynetx account and get started right away.

If you have questions about using AppBuilder, feel free to ask them on DevEx. You can also send support requests to support@kynetx.com.