Phil Leggetter - Real-Time Web Software and Technology Evangelist » JavaScript

JavaScript namespace utility

Phil Leggetter — Tue, 23 Aug 2011 16:09:24 +0000

Over the past 10 or so years I’ve written a lot of JavaScript. From very early on, at Caplin Systems, I had to write things in a way which ensured that code was clear, usable, discoverable, reusable, extensible and can easily built upon. One of the concepts that was used was to put code within a namespace. This ensured that you couldn’t accidentally override a function in the global window namespace and also meant that the namespace would describe the sort of functionality contained within. I’ve continued to use this concept in various forms but just realised that I’ve never actually shared how I do this. So here goes.

It’s actually really simple. I’ve got two functions that I use, and I’ve recently ported over to the com.pusher namespace since I’m creating demos for my work (and play). The first creates some default namespace objects and then defines a namespace function that can be used from then on to create any other namespace objects.

/**
 * @namespace
 * Top-level namespace to stop namespace clutter.
 */
if(!window["com"]) {
  window["com"] = {};
}

// create pusher ns
if(!com.pusher) {
  com.pusher = {};
}

/**
 * Ensures that a namespace exists.
 * @param {String} namespace The namespace to check for and create if required.
 *
 * @return {Object} The existing or new namespace.
 */
com.pusher.namespace = function(namespace) {
  var parts = namespace.split(".");
  var context = window;
  var nsPath = "";
  for(var i = 0, l = parts.length; i < l; ++i) {
    var name = parts[i];
    if(!context[name]) {
      context[name] = {};
      context[name].__namespace = name;
    }
    nsPath += name + ".";
    context = context[name];
    if(!context.__namespace) {
      context.__namespace = nsPath.substring(0, nsPath.length-1); // trim off '.'
    }
  }
  return context;
};

A quick example of this might be:

com.pusher.namespace("my.new.namespace");

my.new.namespace.SomeClass = function() {
};
/* define methods etc. */

Then you can access the class anywhere using:

var instance = new my.new.namespace.SomeClass();

The second function that I’ve only just started to use takes a leaf from node.js. It in that it passes in an exports variable which represents the newly created namespace and then you can add items to that namespace.

Note: I’d previously called the exports variable called export but it would appear this is a reserved word in Safari & Firefox

com.pusher.define = function(namespace, definition) {
  var exports = {};
  definition(exports);

  var nsObject = com.pusher.namespace(namespace);
  for(var thingToexports in exports) {
    nsObject[thingToexports] = exports[thingToexports];
  }
};

You’ll noticed that it uses the com.pusher.namespace function to create the namespace object. The usage of this is then as follows:

com.pusher.namespace("my.new.namespace", function(exports) {

  var SomeClass = function() {
  };
  /* define methods etc. */

  exports.SomeClass = SomeClass;
});

The class can then be accessed in the same way as shown previously:

var instance = new my.new.namespace.SomeClass();

I like this last way of doing things as you declare the namespace at the top and wrap everything in a function. You then can pick what you want to expose to the outside world by just adding it to the exports variable.

I’d be interested to hear what you think about this approach. Do you have a better one?

Notes on Falsy Values

Phil Leggetter — Tue, 24 May 2011 21:32:59 +0000

I spent the majority of last week in Warsaw at Falsy Values where I attended a Games Workshop and a conference day. It was also my first week working as a Developer Evangelist working for Pusher. A big and exciting week all round.

HTML5 Games Workshop

The HTML5 games workshop was ran by @kuvos and @pornelski and we went through building a game of Tetris and then Mario. I was very impressed to see what can be achieved with Canvas and the workshop provided a lot of food for thought about the sorts of things that would be really useful to HTML5 games developers. Watch this space, and the Pusher blog.

The Keynote

Douglas Crockford at Falsy Values - and a Pusher banner!

The morning of the conference day saw a few fuzzy heads from the Pusher party the night before, but they soon cleared as Douglas Crockford delivered the keynote. He covered the good and bad parts of JavaScript and how, as developers, we need to us a combination of head and gut (instinct) when writing code. JSLint got a number of mentions and Douglas stressed the importance of following coding practices. He explained that just because JavaScript lets us do something, it doesn’t mean we should necessarily do it. Here are a couple of examples:

Always use treble equals for comparisons

if(myVar === 0) {
}

Many of us already know that double equals can lead to problems. 0 compared with an empty string will evaluate to try, undefined compared with null will evaluate to true and a number of no so obvious examples:

"0" == 0 // true
"00" == false // true
true == 1 // true
undefined == null // true

Therefore Douglas believes it’s best practice to always use treble equals so that the code intent is absolutely clear.

Put curly brackets after parenthesis

function myFunc() {
}

This was a hard one to swallow as I like to put my parenthesis on the left – on the next line. However, Douglas provided an example which made me realise that it could be a bad thing.

function buildObjectLiteral()
{
   return // this returns!
   {
      "someProperty": "hello"
   };
}

The interesting thing here is that undefined will be returned because a line break is also ends a statement in JavaScript. I don’t think I would actually ever do this. I would probably assign the object literal to a variable first and then return it. However, if I didn’t follow this rule I might make the above mistake. If it can happen then the easiest way to avoid it is just don’t do it. So, curly brackets now go on the same line – on the right.

Do the right thing

Douglas explained that he has made some changes to his coding practices recently. A developer had contacted him asking if JSLint should report a problem if it found a switch statement that allowed any code to fall through between cases. Although he had a gut feeling that it was probably not a good thing to do he believed that it would “hardly ever” cause a problem. Some time later the developer got back to Douglas saying he’d found a bug in JSLint. The bug was causes by a switch statement which allowed code to fall through cases. Doug has now formed the opinion that if something can cause a problem, even if it’s unlikely, that the best practice is don’t do it.

switch(test)  {
   case 0:
      // don’t do it!
   case 1:
      break;
   case 2:
      break;
}

When will ECMAScript 6 reach the web browser?

Dmitry Soshnikov gave a talk on ECMAScript 6, codename Harmony. Whilst there seem like some good ideas going to to ES6 the question remains when will anybody actually be able to use it in a web browser? It will probably a be available in node.js before it’s most browser runtimes. It also sounded like a lot of syntactical things were being drawn from Erlang – not sure about this.

Slides: http://www.slideshare.net/dmitrysoshnikov/falsyvalues-dmitry-soshnikov-ecmascript-6

Fabric.js – the new defacto JS Library for Canvas?

I didn’t sit through this talk as I had to pop out and get some work done and thought my tapping on a keyboard would annoy those around me. However, whilst in the games workshop it was very clear that it’s unlikely that people would be accessing the Canvas API directly and that, in the same way that very few people use document.getElementById, very few people will directly call canvas.getContext(“2d”) – they use a library that offers richer functionality to the developer. Fabric.js provides exactly that.

The talk was given by Juriy “kangax” Zaytsev on Fabric.js and you can check out the demos from here:
http://kangax.github.com/fabric.js/test/demo/

JavaScript JIT

Zbigniew Braniecki of Mozilla gave a really interesting talk about JavaScript engine Just-in-time compilation methods. There are two types of compilation, method and tracing. Here’s how I understand they work. Method counts the number of times a method is called and if it reaches a certain number of calls then the method is compiled (no longer interpreted). Tracing analysis code paths and compiles code paths that are commonly executed. Apparently there is very little documentation on this and Zbigniew had to do a lot of work to find out which methods each browser uses and to come up with the slides.

The point of his talk was that we can actually help compilers make our apps faster by writing code with the compilers in mind. In most cases this won’t be necessary but if you are trying to squeeze that extra bit of performance out of your app it’s something you might consider.

Slides: http://www.slideshare.net/zbraniecki/js-compilation-falsy-values-slides

PhoneGap

Unfortunately I missed this one but it was delivered by Brian LeRoux and he demonstrated how to build an app in PhoneGap. Go check out PhoneGap, it sounds super useful.

Has JavaScript won?

There were two other presentations, first Tom Hughes-Croucher on node.js, who also ran the node.js workshop on the first two days, and finally Tantek Çelik talking about his new project CASSIS which defines a sub-set of JavaScript which can run both in JavaScript and PHP. As I mention in my post about Falsy Values on the Pusher blog, right now is a great time to be a JavaScript developer. You can now developer server applications, in the browser, for mobile devices and also for the desktop.

It’s really strange to think that in 2004 I left a job because I was doing purely JavaScript and I wasn’t sure the language was going anywhere. How wrong was I?

Finally, a big thanks to Pawe? Czerski and Damian Wielgosik who organised Falsy Values. Well done guys!

Kwwika Silverlight API – Chat Example

Looking for a C# (ASP.NET MVC), jQuery & Real-Time Web Contractor

Phil Leggetter — Wed, 23 Mar 2011 09:45:04 +0000

I’m looking for a contractor for a provisional 3 month contract with the following skills, experience and interests:

Essential

C#
jQuery
TDD/BDD
ASP.NET MVC
ADO.NET Entity Framework or other ORM

Great to have

Passionate about the real-time web and real-time data (essential for the longer term)
Knowledge of building scalable systems on Amazon Infrastructure
Experience of integrating with 3rd party payment systems and building basic ecommerce functionality
Experience of building a SaaS or IaaS offering
Interest/experience in API and Web Service development
Advanced JavaScript
CSS
Excited about HTML5
Part of a tech community

Location

The role will be primarily home-based but at times we may need to meet around 2 to 3 times a week at a location that we agree on anywhere between or around Dundee and Edinburgh.

Moving forward I’m hopeful that this could develop into a fulltime role so it would be ideal if we could get somebody who was interested in this also.

If you are interested please get in touch with your availability and your rate.

Kwwika Powered Real-Time Opta Sports Cricket Widget

Phil Leggetter — Fri, 17 Dec 2010 01:54:00 +0000

Over the past couple of weeks we’ve been involved in developing a Real-Time Cricket widget. It’s been a collaboration, with Opta Sports providing the data, Kwwika powering the real-time client push as well as doing a bit of dev on data architecture and feed parsing and Matador Digital helping us build the widget itself.

There’s quite a bit of work gone into this widget in a short space of time and I’m really pleased with the result. I’ll go into exactly how it was built in more detail in a later post but for now i’ll focus on what the widget can do and be used in this post.

Features

Opta Sports have created a an overview page for the widget which details the features at a higher level but I’m going to drill down a little bit deeper into the tech and explain how easily the widget can be embedded on any website.

Real-time ball-by-ball updates

For each event that occurs within a cricket match Opta Sports generate a feed. We get this feed, parse it and push it through Kwwika and into the web page. This means that every event is displayed on the widget.

Show either full scoreboard or simple match status

Ok, we finally get to see how you embed the widget in your page. It’s simple!

opta.cricket.widget("#scorecard-wrapper",
    {
        style:"scorecard",
        gameDirectory:"/OPTA/CRICKET/FIXTURES/AUSTRALIA_V_ENGLAND_ASHES_2010-11/20101226/4TH_TEST"
    }
);

The first parameter you pass to the opta.cricket.widget function is a jQuery selector. This tells the widget where it should be created. If the selector matches multiple elements then you’ll get multiple widgets. You probably wouldn’t want this but it’s a cool trick. The widget will replace the contents of the selected element(s) so until the widget loads you can have some HTML that says the widget is loading or just some static cricket data. If the widget can’t load for any reason then the contents of the element(s) won’t be replaced. This won’t happen though

The second parameter is options for the widget. We have a number of options that we support but the example above shows:

style: The widget can be created in a number of forms and this option parameter indicates how the widget should be displayed:
- scorecard: This style is the full scorecard for an innings. This displays an overview section and all batsman and bowler information.
- mini: This style is very similar to the scorecard. It displays the overview section and just the batsman and bowlers that are active.
- overview: This style shows just the overview section of the widget.
- livescores: This style just shows the current score in a smaller widget area.
gameDirectory: This identifies the Kwwika topic to request for the game and the data for this game will be displayed in the widget. The following topic is used for the 3rd test of the Australia v England Ashes 2010 to 2011 series: /OPTA/CRICKET/FIXTURES/AUSTRALIA_V_ENGLAND_ASHES_2010-11/20101216/3RD_TEST

See and download the full gallery on posterous

We also have a few other option parameters:

innings: The widget defaults to displaying the latest available information. However, we cache some of the cricket data so it’s possible to display the data for an earlier innings from a match by passing in an innings number.
flashTime: When an update occurs such as a run being scored or a bowler bowling a batsman out we flash the widget. This allows you to set how long the flash will last for.
title: This is displayed at the top of the widget if it is in the livescores style.
topicErrorMsg: A bit techie. If you have entered a gameDirectory that doesn’t exist then the widget displays an error message. This allows you to configure what that error message says. It can contain HTML.

Developed using Kwwika technology for instant data streaming

Yep, it’s the real-time web. Delivered Do you have any data that you want to instantly distribute to any web-enabled device? If so, get in touch.

Easy to customise – apply your own styling and branding

Since the widget is purely HTML and we’ve styled it with CSS you can easily customise the widget. Aaron Basset of Matador Digital did a great job when I asked him to supply a few different stylesheets. He told me that he’d used LESS to generate the CSS for the widget so it was easy to create different styles. Within 15 minutes Aaron had sent 10 different styles my way. You can apply the different styles in our example pages by just changing the drop-down at the top-left of the page. My favourites are the Kill Bill or Comic styles.

See and download the full gallery on posterous

Can be embedded anywhere within the website with just three lines of code

We’ve classed the HTML container element for the widget and the single widget script include as lines of code which bumps this up to 3 lines. I’ve used a number of widgets in the past and I think we’ve done a great job here.

Okay, that last line is a bit long and maybe counts as 4!

Multiple matches on a single web page

You can call opta.cricket.widget as many times as you like and for each call you could pass a different game directory. That way you could easily have multiple games displayed on the same web page if you liked. You could also mix the styles of widgets that are on a web page.

I want that widget!

Opta Sports specialise in high quality sports data. They have a number of sports products and this real-time cricket widget is the latest such product. Opta Sports are looking for companies who are interested in taking this widget and embedding it on their website or within their web application. If you are interested please get in touch with us or or directly with Opta Sports via their cricket score centre page.

Since the ashes are nearly at an end we will also consider allowing you to embed this widget free of charge on your website for the remaining Ashes matches. Just get in touch.

I want the cricket data!

One of the things that excites us about this widget is that we are now seeing high quality sports data streaming through our servers. We’ve also proven that Kwwika is a fantastic distribution channel for real-time data. And we’ve seen that the delivery speeds between the data being captured and appearing on a web page are fantastic! We hope that this is the start of a big DAAS (Data as a Service) trend and that Kwwika can be at the forefront of it.

If you like the widgets but you’d love to just get hold of the raw data and build your own widget, web app, mobile app or desktop app then please get in touch too.

Examples

You can find a link to all the the live examples on Opta Sports – Cricket Match & Events Centre demo page.

The above examples are hard-coded to show the Ashes 2nd Test but here are the Scorecard widget links to allow you to view the data from the 3rd and 4th tests:

From the format of the above links I’m sure you’ll be able to work out how to view the other examples with different games

Additional: You can also see the South Africa v India test using this topic:

/OPTA/CRICKET/FIXTURES/SOUTH_AFRICA_V_INDIA_TEST_SERIES_2010-11/20101216/1ST_TEST

Thanks

Last but certainly not least, a bit thanks to everybody we worked with on this.

Opta Sports

A big thanks to Opta Sports for working on this product with us and giving us a chance to show off our technology. Working with Alon in particular has been a pleasure.

Matador Digital

We’d also like to thank Matador Digital for the UI work and doing the majority of the widget functionality (I couldn’t help “lending a hand” though). Dave did a great job helping us come up with the UI and Aaron never ceases to amaze me with little pieces of information that make daunting tasks seem so simple. Really appreciate your hard work guys!

Permalink

| Leave a comment »

978d6a1bd7d647028d1d1f29d49cd10d

Kwwika support for webOS

Phil Leggetter — Tue, 07 Dec 2010 16:50:57 +0000

We’ve got a potential client interested in using Kwwika on HP webOS so we’ve been working with them to test the Kwwika JavaScript library on a platform that we’ve not been directly targeting. After a problem glitch with the 64bit webOS SDK (mainly JVM and PATH problems) we got the 32bit one up and running and the a webOS emulator fired up. From there Palm have created a really nifty web IDE called Ares. Ares communicates with the webOS emulator, which runs on Virtual Box, via the web browser Java plugin and it allows you to launch the application and debug it. This works surprisingly well.

We came across three problems with the Kwwika JavaScript API where we’d made assumptions that the library would be running within a web browser. We fixed this by stepping through the code with Ares debugger and soon we were connected, logged in, subscribing to data and publishing data.

The code is super-simple since it’s just a normal HTML page:

And our application didn’t have any UI but you can see from the log at the bottom of this screenshot that the Kwwika JavaScript library is working with webOS as expected.

Permalink

| Leave a comment »

Client Push Services Open Up Real-Time to Everyone

Phil Leggetter — Tue, 14 Sep 2010 04:00:58 +0000

The number of services offering real-time APIs is slowly but surely expanding and it looks like we’re going to have to add quite a few more. Since the start of the year a new type of service has started to appear–client push services, which help developers include real-time updates in their web apps.

Real-time client push APIs have actually been around for quite a while (around 10 years) as they are shipped with Comet servers but only recently have these been moved into the cloud and offered as a service. The service flavour of these APIs give the developer the ability to instantly push information from their web server, through their chosen push service and into a web browser viewing their website.

Real-time client push is intended to replace the previous pull, or polling, mechanism that has been used for many years to mimic live data on a website. Using push via a dedicated Comet server is generally more resource efficient than polling a web server, and by using a service the resource load and complexity involved in setting up and running a Comet service is completely taken away from the developer’s considerations. This means that the web server is under much less strain, the developer can concentrate on building a killer real-time application and the website user gets the benefit of a truly real-time experience.

These services have only recently started to pop up due to a number of technology advancements. To be able to use a real-time client push service the web browser needs to be able to maintain a persistent connection back to the web server so that the web server can push information to it as soon as it becomes available. This has been achievable for a number of years via what some developer have labelled as “hacks” but is now easier than it has ever been. Most of the new services use the JavaScript WebSocket object to achieve this and fallback to using Flash if WebSockets are not supported by the browser.

The web browser also needs to be able to maintain a cross domain connection from the JavaScript code running in the website to the service e.g. a connection from blog.programmableweb.com to www.example.com. In older browsers cross domain connections were not allowed but the introduction of client access policy files (crossdomain.xml and clientaccesspolicy.xml) and more recently the Access-Control-Allow-Origin HTTP header have made cross domain calls from JavaScript possible (You can find more information and a demo of this in action here).

All of the real-time client push services have adopted a data publisher subscriber model with the web server code generally acting as the data publisher and the JavaScript code running in the web browser acting as the data subscriber. Subscriptions are made to a channel (or topic), that either exists or will be created, within the service and are identified by a name e.g. “my_channel” or “/PW/CHAT”. The publishers then simply publish data to that channel or topic using a service API and the information is instantly received by all subscribers, again via an API.

The real-time client push services that we know of at the moment are:

Beacon
Hookbox
Kwwika (disclosure: author is a founder)
PubNub
Pusher
WebSync

And some examples of their use include:

A real-time news reader
A Facebook “meh” button
Interactive games
Real-time sports statistics (requires HTML5 support)

You can also check out the demos on each of the services websites.

Real-time is already a big topic and users are starting to demand data and results as fast as possible. There is also the expectation that they should be informed as soon as new data is available or the existing data changes. Google are already pressing ahead with new real-time advancements such as Google Real-Time search (which actually uses polling) and Google Instant but the good news is that with the availability of real-time client push services any developer can now add real-time to their website.

Let us know if you are interested in finding out more about these real-time client push APIs and services and we’ll cover each one in more detail.

Photo via Blake Patterson

Originally posted on Programmable Web

Geo Grandfather ESRI Makes Strides on the Web

Phil Leggetter — Mon, 23 Aug 2010 12:30:09 +0000

Most of the time we write about mapping, it admittedly includes Google Maps (we list over 2000 Google Maps mashups). However, ESRI, the biggest supplier of geographic tools for the enterprise, has made huge strides this year with its tools, including its own web mapping platform, ESRI ArcGIS JavaScript API.

Earlier this year ESRI released ArcGIS Server 10 and in the the past few months a stream of associated updates and new releases have been announced including version 2.0 of their JavaScript, Flex and Silverlight/WPF APIs. ESRI has also announced the release of a compact ArcGIS for JavaScript version designed for building applications where slower Internet speeds and network latency is an issue, such as mobile phones. They also plan to release a native iPhone API (ArcGIS API for iOS), which is slated for the third quarter of 2010, and an ArcGIS for Windows Phone API down for mid-August as part of version 2.1 API releases.

“It’s exciting to hear news of ArcGIS Server instances in the cloud, coupled with the new mappings APIs,” Rob Dunfey, who has previously worked at ESRI and now works at Shell, said of the new tools. “We can start to deliver easy to use apps which answer business problems with a geo component. For example, the iPhone app for the CEO which downloads local sales stats as they move from site to site.”

The version 2.0 API release adds new functionality and exposes a number of new features available in ArcGIS Server 10:

A features service which expose access to vector feature geometries and attributes.
Geometry service updates to facilitate Web editing.
Time aware layers to allow you to query or display time-aware layers using a particular slice of time.
Network analysis.
Bing Maps support updates.
Geocoding updates.
Mapping enhancements.
Built-in support for touch gestures in the JavaScript API.

For a full list of features see the What’s New sections of the guides for ArcGIS Server 10, ArcGIS for JavaScript, ArcGIS API for Flex and ArcGIS API for Microsoft Silverlight / WPF.

The ESRI mapping APIs, which are freely available, differentiate themselves from the plethora of consumer focused mapping APIs out there in their depth of GIS analysis they support, their ability to ask complex questions of spatial proximity and topology. However, to access this extra functionality on your own data you need to buy a license.

The implications of all these APIs means that the accessibility to commercial-grade GIS technology is much greater and as developers become more familiar with GIS they could potentially start bidding for development projects that were previously only accessible to GIS development houses. It also means that platforms and devices that were previously only used by consumers can potentially be used in the field.

With platforms such as the Web (JavaScript, Silverlight and Flex), desktop (WPF and Flex using Air) and mobile (JavaScript, Silverlight for Windows Phone and iOS) covered, and with an extra level of GIS functional, ESRI appears to have everything in place to continue being the go-to company for GIS map-based application development.

This post was originally on Programmable Web.

No related posts.

Plotting tweets in real-time using Smoothie Charts and Kwwika

Phil Leggetter — Fri, 13 Aug 2010 00:35:00 +0000

I noticed a tweet today about real-time JavaScript charts and couldn’t resist having a play. The charts are call Smoothie Charts and have been developed by Joe Walnes. You can read the blog post where he announced the release of them here.

The demos that I’ve seen don’t use real-time data so I thought I would create a small demo using real-time tweets being pushed through Kwwika. I updated the Kwwika TweetStreamer component (which I must get around to putting in GitHub) to push through updates from some popular hashtags including #nowplaying, #news, #tech and a few others and then wrote a bit of code to count the number of tweet updates over an interval and push that value into a Smoothie chart. The result looks like this (Smoothie charts use Canvas so only work in some browsers. I’ve tested this demo in Firefox and Chrome):

You can see the Smoothie Twitter Real-Time Charting demo using Kwwika here: http://kwwika.com/Standalone/Demos/javascript-examples/smoothie-twitter-charting/

I’ve got the Smoothie chart showing the number of updates for each twitter hashtag, a table showing the count and a list of the tweets at the bottom.

The code is in GitHub so feel free to fork/download and have a play yourself. You can run the code on http://localhost but in order to get the code to work on your own website you’ll need to register with Kwwika and get in touch to let us know you want access to the real-time Twitter hashtag topics.

Update: We found a bug in the Smoothie library which Joe Walnes promptly fixed.

One thing we’ve noticed is that the Smoothie chart stops working and throws an exception and as yet we’ve not been able to work out what the problem is due to lack of time. It’s probably something to do with not getting any updated values in a TimeSeries. This is what the exception look like in Firebug:

If anybody can work out what the problem is please let us know. Failing that we’ll look into it when we can.

Permalink

| Leave a comment »

Kwwika Silverlight API – Chat Example

Phil Leggetter — Mon, 10 May 2010 17:30:49 +0000

This video shows a chat application built using the Kwwika JavaScript API and a chat application built using the Kwwika Silverlight API. Both applications can communicate with each other in real-time using the Kwwika service.

We'll release the source code for both applications in the very near future.

Defining the Kwwika API

Phil Leggetter — Fri, 02 Apr 2010 11:34:48 +0000

Update: Hang on a minute. You’ve not explained what Kwwika is!
In a really informative chat using Nurph, which has been really useful in getting feedback, it was pointed out to me by @rythie and @NeilCauldwell that I need to explain what problem Kwwika is trying to solve before asking what the API should look like.

Why do we need Kwwika?

There are loads of real-time technologies available at the moment. Almost all of them have a reasonable learning curve and require a developer to sort out server infrastructure, perform installation, do all sort of configuration and then finally get around to writing an application. In the same way that a lot of developers or organisations have moved into managed hosting for their websites, or more recently moved a lot of their IT infrastructure into the Cloud, Kwwika offers a managed and scalable real-time infrastructure so you can concentrate on building your Real-Time Rich Internet Application.

The way I’m describing Kwwika at the moment is:

Kwwika is a real-time web data sharing platform with APIs in JavaScript, Silveright, .NET, Java and C.

An example of where Kwwika could be used

Martin Tyler recently wrote a blog post that provides a great example of where a service like Kwwika would have been really useful. In the situation described in the blog post CricInfo could simply publish their cricket updates to their defined topic in Kwwika, maybe /CRICINFO/GAMES/INDIA-SOUTHAFRICA/, from a single server. They would then add a small piece of script to their game web page that subscribes to this topic and updates that web page whenever any new data is available. Users would see the real-time in-page updates and would no longer continue to hit “Refresh” to see if the score had updated. Kwwika would instead take the hit of the data transfer and push the live updates to the web page. This would take a massive load off of the CricInfo server and clearly save them a lot of time and infrastructure costs.

How will I use Kwwika?

When we launch Kwwika all you’ll need to do to use the service is:

Register for Kwwika via a sign up page
Define your topics that you would like to publish data to in the Kwwika dashboard e.g. /PhilLeggetter/Kwwika
Find some topics with information on that you are interested in using e.g. /BBC/NEWS/SPORT/FOOTBALL (doesn’t exist – just an example – but how cool would that be!)
Embed the Kwwika