Web of Things

Web of Things @ SXSW 2011?

2010-08-24T18:24:42Z

Some of you might remember/have attended our SXSW 2010 workshop. Well we enjoyed giving it so much that we decided to come up with two brand new proposals for this year’s SXSW!

The Real-World as a Web API is our first proposal:

The world of “physical devices” such as home appliances/electronics, real-time city data, RFID-tagged objects, mobile phones, etc. has long been longing for a seamless and universal integration platform. Out of a great number of heavy-and-not-so-great middleware a surprising one is emerging: the Web! In this presentation we would like to show how Web developers might well be the next generation of real-world hackers. We’ll demonstrate how the current developments in Web standards make it one step closer to the real-world. We’ll show how REST and the light IPv6 (lowpan) protocols fit really well to control most physical devices. We’ll illustrate how the real-time Web (Web sockets, Pubsubhubbub, Twitter, etc.) makes it easy to sense the world and get physical devices to trigger events. We’ll show how HTML 5, Microformats/data, rich snippets and social networks can help us to search and share the real-world. We will finally show how this Web integration and Javascript toolkits (e.g. JQuery, Sencha touch, etc.) enable us to mashup the world on the Web layer as we wish: from configuring our connected homes to building on top of our real-time cities with our mobile phones. The success of books such as “The Next Internet” or blogs such as Web of Things and theinternetofthings.eu emphasize it: the Internet of Things is coming and Web developers are its most powerful actors!

Next, we have a closer look at the city use-case in:

The public infrastructure of our cities are obscure structures whose workings are not accessible to most citizens. What if every sensor in our cities would have a Web API anyone could access in real-time and mashup? Open and easy to use Web platforms that enable efficient integration, processing, storage, and access to the enormous amount of data digital cities generate are increasingly needed, and we’ll explore the various technologies that are making such solutions possible. Furthermore, we’ll go much more beyond the technical aspects of such a platform to address the more controversial implications of such an Orwellian scenario. Hopefully, this session will provide a forum for the different disciplines involved in the design of future cities to establish a common ground for better interdisciplinary cooperation and understanding in this area.

The idea is to concentrate the first workshop on the technology side and the second a little more on the conceptual side, if you want to be able to attend any of those at SXSW 2011 then please vote here: The Real-World as a Web API or here Web Mashup Platforms for Future Programmable Cities. Or better vote for both
Votes are closing Friday 27th of August!

Share this story

Prepare your submissions: Workshop on the Urban Internet of Things, Tokyo

2010-08-19T10:42:03Z

We are organizing the First International Workshop on the Urban Internet of Things at the IOT 2010 conference, at the end of this month, and we would love to invite you all to submitting a demo or a paper.

Unlike the WoT2010 which brought together WoT researchers, we emphasize here concrete applications practical solutions that can be built on top of WoT. We particularly welcome real-world deployments that can highlight the plus/minuses of using WoT as infrastructure for a scalable urban-scale data collection and processing.

We would like to bring closer practitioners in the area of smart cities (industries that build the various components of smart cities such as infrastructure, sensor, software, middleware, hardware, etc), along with researchers in various fields related to networked objects (that’s why we do this workshop in the context of IOT conference), and with architects/designers/urban planners that are in charge of designing the points of contact between citizens and this invisible (& growing) digital infrastructure.

The outcome would be for participants to get to know the latest trends in research/technology (& each other) and at the same time get practical insights about the challenges in building such scalable (city-wide+) infrastructures to collect, process, share and store huge quantities of real-time data from various urban sources. Pretty much like a combination between twitter and data.gov, but for sensor data which emphasizes open access to real-time data streams from cities (public APIs that anyone can access and code with).

As we wanted to avoid a “classic” mini-conf like workshop to enable active participation, we have been preparing a few surprises that will allow you to get your hands dirty and join the conversations and hands-on sessions with world-class experts in this area. More to follow soon.

Also, we are still looking for sponsors that could cover the travel costs of our keynote speaker, so if you know someone or are interested to sponsor us in exchange of some promotion/visibility, please get in touch with us (info@{guesswhat}.com would do).

Share this story

OpenPicus Community & FlyPort

2010-07-27T03:22:15Z

The OpenPicus community released a wi-fi module called FlyPort. It is a small device that uses the Microchip PIC24F (256K Flash+16K Ram, 16Mips@32Mhz) and MRF24WB0MA/RM WI-FI certified module. FlyPort runs a wireless Stack (TCP/IP version 5.25 from Microchip) and has a 26 Pin connector for easy prototyping. Applications and libraries are open source and can be freely downloaded from the openpicus website. Programmers have full control of the wi-fi module, thus the Flyport can act as tiny Web server and client that can directly interact with other Web resources directly, without requiring a gateway. Besides, this project has a social aim too, they give away free development kits for students and universities that want to develop their applications on this platform, as long as they want to share the code and results with the community (mail us if you are interested by such a kit, or just write in the comments and we’ll get back to you). According to the project’s founder, Claudio Carnevali, the Flyport will be available soon to a wider public for less than 30 Euros each.

We have seen more and more projects around embedded wi-fi modules, and we believe this direction will have a strong impact in making the Web of Things happen. For a few bucks more, every electric appliance out there could host one such wifi module on-board, and coupled with a Web server on it this. For example, companies such as RedPine, GainSpan, ZeroG Wireless (that has been recently acquired by microchip), or G2 Microsystems are among the key players to watch in this area, and I’m sure that we’ll see a proliferation of Web-enabled appliances in the next years [ thou, smart fridge, will u finally become real?? ]

Now that wi-fi chips are virtually easy to integrate in appliances, the next important step to make WoT happen is to also offer a free, easy to use high-level programming environment that would allow people to fast prototype Web of Things applications on top of the wi-fi substrate – just like the Arduino did, but on a even higher level. Instead of learning how to read and write signal to digital & analog pins, developers could interact with these devices simply through a RESTful Web API. After a great discussion I had last october with Massimo Banzi (co-inventor of the arduino), the next stage is clearly a wifi version of the Arduino (nothing disclosed about that yet), which would make it straightforward to also run a Web server on it. I can’t wait for the day this will happen.

[Thanks to Claudio Carnevali for providing us this information and we're looking forward to the evolution of the OpenPicus project]

Share this story

Touch the Web 2010 @ ICWE 2010

2010-07-30T07:06:25Z

A few days ago I had the chance to participate to the “touch the Web 2010” workshop.
The goals of the workshop were rather similar to the ones of WoT 2010 however, rather than being hosted at a Ubicomp/Pervasive venue, Touch the Web was collocated with ICWE2010, a pure Web engineering conference.

The most surprising fact was probably how close the two communities are getting. Web people are increasingly interested in embedded/physical/sensor computing, and on the other hand, pervasive people are getting more and more convinced that the Web protocols as not so bad after all (take this paper for instance), at least good enough for a good range of applications. Quite a change of mindset compared to a year ago.

One of the good outcomes of the workshop was the fruitful final discussion. Three big challenges seem to emerge: the discovery of things, the real-time things and understanding the needs for Web-enabled things. Three challenges that were also identified as keys at WOT 2010.

Discovery
We need to look at describing things so that they can be both discovered by machines (i.e. network discovery) and their “services” understood by humans (i.e. service discovery). REST is good, REST is great but it’s raw expressiveness is not enough to understand things. By crawling a RESTful API you can find the resources it exposes, by reading the URIs you can get rough “tags” (e.g. /temperature) describing their nature. But this is not enough for users, neither for machines. As an examples, attendees mentioned the need to generate sense-making UIs on the fly or to customize page rendering depending on the thing one discovers. A simple example of this is Google rich snippets where the search engine renders the page results differently if they embed some semantics. What if Google could render search results for things in a way that helps users interacting with them.

Thus, researchers are exploring ways of better describing things directly inspired from the semantic Web. In “A Triple Space-Based Semantic Distributed. Middleware for Internet of Things” the authors suggest using RDF. In the mashup framework we presented an RDFa based solution to be able to integrated newly discovered devices as mashup actors directly. Those solutions however have the drawbacks of being based on well-know syntax but “proprietary semantics”, i.e. they cannot be understood by One alternative we (and others) currently explore is the use of Microformats which enables to use “agreed-upon” lightweight semantics. Their recent fast-pace expansion makes them even more interesting (I should post about our early experiments with things and microformats here soon!).

Real-time Things
Next in line of the important aspects for a WoT was the need for real-time communication patterns. Not ground-breaking, since this topic has been around WoT architectural discussions since the beginning but the workshop made it clear: client server architectures are great for controlling things, but for monitoring we also need things to be able to push data. Of course, we would also like this push pattern to be as Web oriented as possible. On the REST-side People talked about Atom and especially the latest push based mechanism using it, aka PuSH (or pubsubhubbub). On the more WS-* side, speakers talked about using WS-eventing. We also talked about our experiences with WS-eventing in DPWS (a device tailored WS-* stack) and concluded that it was getting better but still quite heavy for many devices and rather hard to get hands on.
Overall it seemed that this space for still open for further exploration. Speaking of which we also presented a paper at the main conference about a light messaging service for things called RMS (Vlad will tell you more about it here soon!)

Understanding the Needs for Web-enabled Things
Last but not least one really tricky question emerged: “why do we do this?” We propose a re-programmable world where everything is created not as a single purpose object but rather as an API ready for opportunistic applications, but do people want that and why?
Most of the people there believed they do and for various reasons ranging from sustainability (objects have a second life thanks to involving them in new use cases), to customization (things are often not quite the way we want them to be) and satisfaction of DIY (Do It Yourself).
However, raising this question is key and depicted the strong need for better understanding the “mashup space” from an end-user point of view. What would people like to mash in their homes, cities and offices?

Share this story

CouchDB 1.0 released

2010-07-15T01:10:27Z

As in our project we needed a (quickly setup, reliable, and flexible) backend system to store sensor data, I played around with CouchDB as I wanted to explore a RESTful data store. As a matter of fact, the version 1.0 was released just a few minutes before I installed it. First impression, wow. Sleek, pretty fast, damn easy to use, flexible as any software should be (not the conventional click and run install, but damn well documented installation). I have to admit I’m impressed by the quality of this release, just as much as by the documentation.

I think this is the best option out there to store relatively low-frequency changing data, such as device metadata, information about locations, etc, but I really wonder how it performs for high-frequency data, such as sensor samples. Considering that it is a document store (for JSON data for example), I wondering how it handles the storage of thousands of incoming “documents” per second. This question is certainly worth exploring and I will hopefully be able to share some insights on this question soon.

In the meanwhile, we are looking forward to hear about your experiences with Web-oriented datastores.

Share this story

COAP-01 draft out!

2010-07-12T11:44:12Z

After the last draft released in december, the COAP folks just released a few days ago a more refined version of the COAP draft, with additional thoughts on coap-http mapping, RESTful verbs for constrained environments, and pub/sub notifications, and more.

Abstract

This document specifies the Constrained Application Protocol (CoAP), a specialized RESTful transfer protocol for use with constrained networks and nodes for machine-to-machine applications such as smart energy and building automation. These constrained nodes often have 8-bit microcontrollers with small amounts of ROM and RAM, while networks such as 6LoWPAN often have high packet error rates and a typical throughput of 10s of kbit/s. CoAP provides the REST Method/ Response interaction model between application end-points, supports built-in resource discovery, and includes key web concepts such as URIs and content-types. CoAP easily translates to HTTP for integration with the web while meeting specialized requirements such as multicast support, very low overhead and simplicity for constrained environments.

Definitely worth looking at it and try to reuse as much as possible from there in your designs. I’ll be analyzing it soon and give my thoughts on it later.

Share this story

Fast Prototyping WoT Apps with NIWEA

2010-06-29T15:56:52Z

I gave a few thoughts recently about what the iPad (& iPhone) represent for the WoT.

NIWEA

As our friend Hannes Gassert awesomely summarized it recently, NIWEA (Native Interoperable Web Applications) is the sweetest method to build interactive applications for all things mobile, plus NIWEA feels like it was made for the Web of Things. In a nutshell, NIWEA are simple Web applications (developed only with HMTL/CSS/Javascript) designed to look & feel like a “real” (native) mobile application. This not only provides a great environment to develop easily apps for the iPhone/Pad, Android, Blackberry & co, but in particular it is the perfect platform to fast prototype various interactive applications for the WoT.

What it means for developers is that one doesn’t need to learn cocoa & co. and similar weird & proprietary languages for each target platform anymore. It takes time & money to develop an iPhone app (thus the designers’ nightmare when the client says “me too want iPhone app”). As our colleague Erik Wilde mentioned, many apps in the Apple Store could be implemented as Web apps directly (games are a different story and might need to be native for performance reasons). Besides, HTML5 seems to be a pretty versatile, lightweight, and powerful alternative to Flash, and full HTML5 support on future mobile browsers would be the perfect trick against the lack of support for flash in the iPhone (not everyone seemed to agree with the end of flash though, maybe now things have changed 2 years later…).

There’s been a significant move towards more and more simple Web apps directly for mobiles (especially as mobile internet has pretty much become a commodity), and what we see is only the beginning. Simply look at the tremendous progress in Javascript recently: more and more server-side javascript engines, tons of libraries for animations, pretty plotting & vector graphics, etc. Additionally, with all the noise around Real-time Web, highly responsive event-driven Web applications can be developed, especially with the Web Sockets in HTML5, which is much cleaner than Comet, therefore paving the way for a new generation of versatile and mashable-by-design Web content distribution platforms.

Beautiful Interfaces

There is a lot going especially around sleek framework for building interactive and visually appealing UI for mobile devices, among which jQtouch, iui, or Sencha (pretty much everything about this was said by Jonathan Stark at our favourite sxsw’s presentation).

Sencha Touch Introduction. “Sencha Touch allows your web apps to look and feel like native apps. Beautiful user interface components and rich data management, all powered by the latest HTML5 and CSS3 web standards and ready for Android and Apple iOS devices. Keep them web-based or wrap them for distribution on mobile app stores.“

Caching & the N of NIWEA (native)

Using Web apps for mobile device might give the impression that the mobile *must* have Web connectivity at all times, which obviously wouldn’t be that practical. The simplest solution to have stand-alone (offline) Web apps is to use PhoneGap (PG) or Titanium which are the first steps towards NIWEA.

PhoneGap is described on the original site as:

An open source development framework for building cross-platform mobile apps. Build apps in HTML and JavaScript and still take advantage of core features in iPhone/iTouch, iPad, Google Android, Palm, Symbian and Blackberry SDKs.

An interesting alternative is to leverage the caching features of HTML/HTTP, so you can explicitly specify what data can be cached locally on a devices and for how long. But there’s a long road ahead towards a common definition (& rigorous/uniform implementation on all browsers). This is definitely an area that deserves through exploration, in particular for how to optimize Web apps rendering and sensor integration for various classes of devices.

iPad is more than just a big iPod

An essential virtue of the iPad was to open our eyes towards what it means beyond just an iPhone with a bigger screen, especially in terms of HCI. As explained by Matt Jones, the novel types of multi-users/-touch interactions enabled by such a larger display offers a fresh perspective for devices, an interactive surface you can share and use with others. Another excellent example is the great iPad radios (sorry, in german), an intriguing Web radio that augments the listening experience with pictures of the singer, and has been developed by our friends at liip (check this awesome “behind-the-curtains” overview of radios).

If you think of the Chumby as a great platform for interactive information display, then NIWEA is Chumby on steroids. Not only because it runs on many more platforms, but especially because the development life-cycle of NIWEA apps is so much shorter. And trust me, there are many Web developers out there waiting eagerly [for NIWEA frameworks] to put their talent and build great Web apps for pervasive screens.

Mag+ from Bonnier on Vimeo.

Looking at the Mag+ concept video above offers a great glimpse into the future of media. In this gorgeous example, a digital surface such as the iPad offers countless new ways to distribute and interact with information, while gaining back the clean and aesthetically pleasing features of print media – the tangible experience. In our world overloaded with information, subtle, appealing, and efficient interfaces are required to interact with all types of media, and a flexible solution accessible to most is needed to maximize its utility.

An iPhone is useful only when you use it, else it’s just there, doing nothing. Because of its form factor, an iPad can be useful even when not used: while you leave it on a desk to charge, it can show stuff to you. The idea of ambient information display is certainly not new, but the iPad just reminds us how we (as designers) barely scratched the surface of all the interaction possibilities hidden behind such a simple (& falsely considered non-disruptive) gadget. What is needed now, is an elaborate, ease-to-use, and efficient framework for building flexible UI with support for smooth tangible interactions of all sorts (multi-touch, sensors, GPS, etc) that can run on a various classes of devices. Such a framework would offer a uniform, high-level, and transparent API that can be used directly from Javascript by people without deep technical expertise, thus enable them to explore the realm of possibilities offered by such displays. This would allow to easily (& cross-platform”ily”) leverage a common set of interactions seamlessly in various NIWEA apps, yet could be still optimized and suited for the hardware platform under consideration.

More to follow soon!

Share this story

Java and the Web of Things

2010-06-18T17:10:10Z

Coming back from Jazoon, a conference that some people see as the European version of Java One. Since this conference is for me a nice concentrate of what’s coming in the Java/OO/Business software world, I wanted to report a little on what I’ve seen there and what this implies/offers in a Web of Things context.

Let’s be modular

As last year, modularity was a BIG keyword. The Java community has acknowledged the success of OSGi and is looking for a somewhat closer integration of these concepts. The Language Support for Modular Programming (JSR 294) will be part of Java 7 and will pave the way towards truly re-usable software components. In the WoT community and in our personal projects here at ETH and SAP research, we started using OSGi a little while ago. The physical world is definitely not homogeneous in terms of protocols, thus the need to create device adapters or drivers, understanding a particular device and providing its functionality as a Web API. OSGi helps there as it enables us to package these drivers and inject them, at run-time, on different platforms such as “smart gateways”.
But using OSGi also complexifies the whole developement cyle and thus a seamless integration to Java of the modularity concepts might help simplifying it! Wait and see…

REST rules
REST ohhhh REST core of the Web of Things! REST was already pretty strongly represented at Jazoon last year but it now seems to have gone beyond the hype and is in the process of being “tool-supported” in lots of ways in the serious world of Java Enterprise. The most prevalent example of this is the number of Java frameworks offering to help you implementing your RESTful API both on the server and client sides.
When we began our exploration of REST we basically had the choice between RESTlet and …. RESTlet (in the Java world). To me RESTlet has always been a great tool with a great community however, as a developer with Java Enterprise background I always felt not totally at ease with the level of abstraction used by RESTlet (which are really close toFielding’s thesis) and with the relative lack of tight integration with the enterprise tool-box such as JAXB.
The JAX-RS standard changed the deal. It offers abstraction levels which are more familiary to the Java developer and its implementations a tight integration with the Java enterprise tools (JAXB) and techniques (annotations, etc.).

Two implementations of JAX-RS were dominating at Jazoon, Jersey and RESTeasy. Jersey is the reference implementation from Sun (ohhhh sorry Oracle). We’ve been using it in two of our latest projects (that I shall present here soon) and I must say and really really like it. It was presented in several talks but I especially liked this one.
I can only advise you to have a look at Jersey and especially it’s integration to Grizzly, a embedded Web server to follow being only because of its very fast integration of bleeding edge technologies (e.g. Comet) and scalability!

The second framework I had the chance to discover was RESTeasy, a full implementation of JAX-RS as well. I did not have the chance to test RESTeasy yet but I was impressed by the presentation. I especially liked its out of the box support for lots of representations (e.g. RSS, XML, ATOM, JSON, YAML, etc.) and its out of the box support for caching, which is extremely valuable in a WoT.

One of the big problems Java WoT developers will now face is choosing the right framework because these are just three amongst the many poping up every month, the graph below is a hype-meter of the four major REST frameworks for Java:

It was created by a colleague at SAP who also made a great benchmarking of these frameworks (and others). I should soon be able to publish it here…

[to be continued]…

Share this story

Healing the WoT Feed!

2010-05-14T16:08:06Z

Dear readers,

A few days ago we missed being listed here because our feed was ill (a weird, non ASCII char appeared in one of the posts)!

I gave it some steroids and while at it moved it to an Atom feed. For a RESTifarian community as such as ours, it was somewhat weird to actually support RSS and not Atom and its great, RESTful, AtomPub protocol.

Now, since I moved the default Atom, subscribed members might have some problems, many (only?) in the case they use a bad feed client.
Thus if you suddenly are not able to see the webofthings.com feed anymore (then you probably won’t read this message, hem) you might want to register to this, old-fashioned, RSS 2 feed, or get a proper reader.

Plus, you shall also comment this post to tell us how unhappy you are with this move to Atom as a default.
Yes, let’s make it political

Share this story

Yaler 1.0 released

2010-05-11T07:39:52Z

We’re happy to announce that our friends at Oberon Microsystems have released the first open version of yaler (reverse of relay). The have made an excellent impression at our WoT2010 workshop by showing a demo of an essential building block for building an infrastructure for the Web of Things. In two words it’s a server to which embedded devices can initiate an HTTP connection, which will be kept open. Using the reversehttp protocol, notifications can be send anytime from the server to any device connected to yaler, even when behind a firewall or NAT.

From to the official website:

A few lines of code make your embedded or mobile device accessible, no matter if it’s behind a firewall, a NAT or a mobile network gateway. Publishing your web service through the Yaler REST API requires just a TCP Socket and some basic HTTP. On the client side a standard Web browser is all it takes to remotely monitor and control your device.

Download yaler with hg clone http://hg.yaler.org/yaler or download it as a ZIP file. Definitely worth a try! We’re looking forward to what they’ll come up with next.

Share this story

WoT 2010 and WoT 2011?

2010-05-11T12:12:56Z

Since we came back from WoT 2010 about a month ago, I’ve been wanting to post a small wrap up about it. So let’s really do it before WoT 2011 takes place

Before WoT
The idea of launching the WoT workshop came from discussion with our Professor Friedemann Mattern and Erik Wilde from UC Berkeley. The main goal of the event was to bring together researchers interested in the Web of Things concepts and bootstrap a scientific community on the topic.

We got a total of 28 papers and 5 demo papers, not bad for a first edition! Our very supportive Program Committee helped us to select 12 papers (about 40% acceptance rate).

We wanted the workshop to be international and thus were glad that the submitted papers came from 15 countries as shown below.

Your browser does not support iframes.

During WoT 2010
The workshop was held at Percom 2010 and attracted about 40 totally motivated people. An number of people also came from the world of industrial research (such as the Sun Lab guys, presenting their great Sensor.Network.

Most of the participants where coming from the Ubicomp/Pervasive world and just two came from the “Web” world.
As one of our goals was to bring the two communities together we definitely see that there is room for improvement on that point (any suggestion? please comment!).

The topics where quite diverse but all discussions really focused on a “Web of Things” being either built using WS-* Webservice (the DPWS folk was well represented) or using REST. The discussions between the two communities were quite constructive and very far from those REST vs WS-* wars.

The workshop definitely did not only focus on those topics but rather started from there and discussed what was missing in those architectures and principles to fully apply them to things. The word cloud below tries to encapsulate the keywords of the presentations and discussions.

created at TagCrowd.com

As you can see, lot’s of discussions were rotating around missing key features of the current architectures for things. In particular people talked about semantics and discovery of things. Several approaches where proposed. On the one hand-side the WS-* folks presented how DPWS had service discovery mechanisms directly at hand. The REST people explained how microformats (btw, we currently run a little study of Microformats for things to see how Google will register them!) and more generally the semantic Web could push discovery beyond the “discovery by browsing” paradigm of REST for more complex use cases. Sharing through social networks, concentrators such as Pachube or Sensor.Network or the use of a location infrastructure reflected in URLs were also mentioned as a means to better discover relevant smart objects.

The real-time Web was also a hot topic. Thinking about how event-driven protocols could be built and reused (e.g. Twitter, Pubsubhubbub) on the Web to better fit the needs of sensor networks applications.

More network related topics where discussed such as how to solve the mobility of smart objects and the fact that they often connect behind firewalls. Solutions like using reverse HTTP and Yaler where presented. Still in these topics, a number of paper dealt with evaluations of the proposed protocols and architectures (e.g. DPWS, REST, ontologies, etc.) for things. IPv6lowpan also gained momentum during the workshop as a (soon) viable solution to get rid of the Web of Things software gateways bridging non-IP networks with IP networks.

Finally, novel architectures and integration patterns (based on REST or on custom middleware such as SWE) were proposed to create an organized and composable Web of Things.

You’ll find all the papers and most of the presentations on the workshop official Webpage have a look at them, it is definitely part of the material that will influence the future Web of Things!

After WoT
Overall, WoT 2010 was a success, thanks to all the people who participated and made it valuable! Obviously I’m not the most objective person to say that but according to the feedback we got, people definitely enjoyed it and look forward to the next edition. Perhaps the only downside of this first edition was the lack of Web people… we can certainly improve that!

Speaking of which I wanted to get your feedback:
Where (@ what conference?) should WoT 2011 take place? (should it take place?)
Who should drive it?
When should we plan it for?
How do we get more Web people on board?

Share this story

Sharing Using Social Networks in a Composable Web of Things

2010-05-11T12:02:09Z

A few weeks ago I posted about a project we currently work on for sharing web-enabled things using social networks. During WoT 2010 (which I’ll wrap up here soon!) I had the chance to present it and got quite a good feedback.

People where mainly wondering about the scalability of such a system. If an access controller such as SAC was to be implemented for every “thing” how would that scale? We discussed its deployment on platforms such as Google Appengine which are highly scalable. We also talked about distributed versions of SAC.

People also had concerns about the “user-friendliness” of the approach. While using social networks instead of classical Access Control Lists seemed one step towards the right direction people mentioned the importance of being able to share with clusters of people rather than single persons. A feature which is probably going to be supported by most social network APIs sooner or later.

Last but not least we talked about the Social Network Standards. Researchers in the audience all agreed in one voice that OpenSocial was the way forward. Let’s just hope Facebook and Twitter will eventually join…

Anyway, thanks for the good feedback WoT 2010 crowd!
You’ll find the slides below and some more WoT 2010 slides by searching for WoT 2010 on Slideshare.

Social Sharing In a Web of Things

View more presentations from Dominique Guinard.

Share this story

Internet developers day – part 2

2010-04-07T16:09:22Z

Here is part 2, part one is here.

One Web, Yoan Blanc, doSimple.

We thought of a single uniform web. Banana phone, with WAP. Now we have tons of devices that try to surf the Web and they all want the same level of experience (mobile browser market share version 1.0 image). Discusses the <meta viewport>, that allows it to fit on many mobile devices (he talks about ppk, peter paul koch who does testing of mobile browsers). Testing: MicroEmulator runs opera mini. You don’t need an iPhone app! Html is enough. You can also use manifest.cache to specify what to cache. Quite nice when it comes to mobile programming. This echoes with the mind blowing talk about js+xhtml+css mobile app development tutorial by Jonathan Stark we saw at SXSW.

Software Estimation: The impossible task? Aaron Arcos, Google.

Things that don’t work. Aaron likes to work on different project. A 6-month project took 2 years to complete. How long does it take to drive from zurich to london? Many factors, and what is the proba that it won’t work? Projects get cancelled. Reviews, privacy issues, changed, review again, management says “hmm must work for all domains, not just .com”, fixed again (you can’t really argue with employee #5 and #7 at google, lol), security issues, fixes, last minute PM asks for facelift (“yes sir, we’ll do it in 2 weeks”… took 2 months). Initially it took 2500 lines of code, but ended up with >25k LOC. If you want to forecast, you must measure. Creating software is a probability, and things can go wrong. Measure your efforts (scope, resources, time, events, etc). Even coarse data is better, a great reality check. Incremental retrospectives are a great tool to collect measurements. More measurements = better estimates. Scope creep is a certain fact during software development. Factor at least 3% of monthly scope increases. If nobody went up there, there are high chances you don’t see the dangers higher up the mountain from down there.

The more people involved, the higher the chances “s**t” will happen [ndlr: texto in the speech], factor that. Expect scope spikes, so overstaff to mitigate risks. You might need a pool to tap on just in case. Over-aggressive deadlines only will delay you project [@misterdom: reminds me of someone ]. Try to finish projects as fast as one can, the longer it lingers the lowest the chances the project will finish. Team was efficient, only the estimates were wrong.

Boosting Requirements Analysis, Marcel Altherr, Managing Director MaibornWolff et al.

Usually development is a moving target, and for that agile methods are just great. It is so because we learn by doing the project. They do most of their projects using scrum. In agile methods they use “user stories”, story, options, UI, etc. Apps must be well described. Then apps will change, therefore must be flexible so that it can change. User stories developers, critiques, and information transmitters. Intro, brainstorming, clustering (marktplatz, you reduce ideas into a market and sell ideas). He basically explains a lot about scrum project management, and how to implement it. Very interesting but not directly wot-related, so I stop here.

Implementierung einer State of the Art iPhone App, Andreas Weder, mp technology consulting GmbH.

Demos the starticket app, but there is no ticketing on the iphone?!? It’s different from the sbb application, because the train readers can work with the reflective surface of the iphones, but this wouldn’t work at a concert. They use balsmiq and paper to design the UI mockup. Must work offline. Interface builder, nice start, but what do you learn when you use it? If you do everything on your own it’s maybe better, but it’s more complex and limited. They decides to use Three20. Good library with powerful concepts, excellent GUIs, but must be learned additionally to SDK. It’s also complex to mix both (three20 & sdk), but feasible and gives you more power and design flexibility.

And my talk at the end of the day:

Web of Things – Towards Open and Sharable Networks of Embedded Devices

Really fun event! Thanks for the invite Reto!!!

Share this story

Internet developers day – part 1

2010-04-07T12:25:49Z

I was invited today at the Internet Developer summit (#devkon) (thanks for the invite Reto), to present our vision and work on the Web of Things. I’ll try to blog as much as I can because it’s a lot of tips & tricks for internet developers, and the program is juicy. Sorry for the random notes, hopefully it’s usable enough (not only it was great so I had to listen, but I also had to translate from german, so please be kind).

Real-Time Web: Technische Standards und Herausforderungen Jörg Stucker (@jstucker), CEO Namics.

Find more about the talk & slides here (in german).

Web is an ecosystem (APIs, networked data, twitter, extreme network effects). Interesting to analyze the growth (and not). Introduced pipes and friendfeed -> republication (retweets), platforms such as “thunder”. Flickr pics are sorted using times. Schools now have high speed internet but extremely bad computers (the colored round early iMacs). Yslow, page speed & other tips from yahoo.

Good APIs are nice and useful, self-describing, stateless, and the client decides the returns format (using REST of course). It makes sense to outsource the delivery CDN tips, oustource media data (aws, etc. several hostnames sockets) & better infrastructure, exception central repositories (eg. data on google code), his favorite is amazon web service (with or w/o) cloudfront. On facebook, when you want to build all the infrstrctuture from scratch, to support time-ordered storage of multimedia data: good luck. Relevance means for him “here and now”, so how does a search engine now the current here and now (the context)? Real-time search on twitter, only keeps the time index recently. Everything runs from memory. Check out docs about the infrastructure for facebook/twitter. Key/value pairs held in ram and simply distributed. Realities of distributed systems, disk, memory, i/o errors, transactions must be sync’ed. This requires new algorithms, partitioning (separation of concerns), simple interfaces, not invasive, no possibility of central data, acid vs base (eric brewer, towards robust distributed system). BASE (basically available, softstate, eventual consistency). CAP theorem: choose 2 of these consistency, availability, or tolerance network partitions.

Feeds: output point. Content available as feeds (RSS/Atom) with stateful URL. Polling sucks. Feed-discovery.Take home: offer APIs (& use them), offer notifications over platforms, scalable & elastic infrastructure, cachability & data storage.

Twitterapplikationen programmieren, Christian Stocker (@chregu), Partner liip.

Christian presented Twitcheln, which is an application to offer virtual presents over twitter. It’s an app with 3 APIs (normal, search & streaming) on top of twitter, rate limiting. Fully restful, different formats, classic API description + twitter features used (oAuth, list, autofollow, etc). They used CouchDB so could scale on the cloud. On twitter you can see a list of all users that have used it. What a cool and simple idea that was programmed very quickly (2 weeks thanks to the easy & cool API @twitter), twitter has reacted quickly (whitelisted them), no special libs other than pecl/oauth & some other php libs. Then he briefly introduced his real-world real-time web example I’ve heard about a while ago (check it out). I love his vision of the future Web fully automated, connected, linked. He talks about how this could be realized, and discusses other variants such as Weblog ping, SUP, pubsubhubbub, xmpp, prowl. He showed and demoed his setup, where he takes a pic, which gets, tweeted, friendfeeded, flickred, etc. I would love to play with his stuff

The slides of his talk are here.

Facebook Applikationen entwicklen, Lukas Fischer (@lukasfischer), CEO netnode.

Start here. Then create an app, give the name & callback (where the app is actually running). Facebook acts as the intermediary, requests data from your server (the app), and relays it back to the client. Choose a client library and include the libs, then you can use the API (>200 API methods for authentication, management, users, queries, photos, etc.). You can have access to more than 80 data about users, and then one can setup permissions. Then you can use over 100 FBML tags (fb:header, fb:bookmark). Then you can use FQL, a pseudo SQL to query for data. The API is completely changing, be consequent. You can link data, operations, pictures, etc. There is a developer FAQ, a wiki, a forum. See the live health status of facebook (because it’s not necessarily your apps that bugs). Then he showed a little demo and code examples of how one can easily build an app.

You can find the slides here.

Single Sing on mit Facebook, Twitter, und Google-ID, Dani Niklaus, CEO netlive.

He introduces the issue of SSO with the facebook connect login function on blick.ch. You have three types of SSO types, pure openID provider. When you create an openid accout to a provider, you get a unique ID that you can use (google, flickr, yahoo, etc). However, facebook & twitter have their own system (which is problematic as they have most of the users in social nets). Windows live… hmmm… yeah, we wait that they upgrade. With fbook connect, you can see a nice window that looks and feels facebook, but the domain name is www.facebook(.got.your.password.ru), so pay attention. Then you risk things such as crosssite forgeries (xss/csrf). Use https! When users have different ID systems, how can you link all these to a single ID, you need to find doublets. How to install that, how to deal with lost passwords? There are many many facebook starter kits for fb developers in many languages. Then you can use openID libs to login. Then who gives what? He told us about the suisseID project (electronic ID & valid electronic signature).

Skalierbare Applikationen mit HTTP, Patrice Neff (@pneff), Co-founder nektoon.

Find more infos here and slides/docs here. We have two issues as developers that shouldn’t be mixed: performance (leopard) & scalability (bird flocks). Starts with SOA, and how the front-end/back-end architectures looks like (with the example of local.ch where Patrice was front-end developer). Key points: dependencies local to services (DB, queues, synchronization), data replication/rsync. Try simple service that works. Services are the new classes, or maybe the new packets, or DB table. Motivation: modularity (team separation, clear boundaries, easier migrations, replacements, versioning), services/code reuse, best tool for each job (language, dependencies, tools), scalability, & competence center (each modules knows how to do its own job). On the other hand, it’s more expensive, complex set-up (training, deployment, training, automation), hard to see the big picture of the app & runtime, performance, data joins over net (should be avoided anyway). HTTP has a lot of problems already solved, so don’t re-implement your own RPC protocol (caching compression, error handling, authentication, content negotiation, documentation). Bonus: load balancing, proxying (squid), encryption (ssl). 500 internal server error is cool, because it says “we don’t want to find out what the real error is”. 402 payment required is also nice. He gave a little intro to caches, with ETags, if-none-match, expires, etc.
Then he shows the mnemonic architecture, how the different computers are bound and yield the final application. They have developed a python framework (on top of wsgi). It seems a clean tool to build distributed apps that fully communicate over HTTP.
NoSQL oder Not only SQL, Dr. Michael Marth (@michaelmarth), Founder marth.software.services.
NoSQL? Bunch of projects with common persistence requirements. Relational overlaps with non-relational. Two focuses: data models and scalability. no signle point of failure, transparent to the app, horizontal scaling (more servers=more capacity). Data first, structure later. Data model, granular, binary, node level access control. He mentioned jackrabbit as an example. The sweet spot of web content. The CouchDB uses a schemaless data model (just JSON). No odbc, no jdbc, just http. Example of couchdb. No SQL, but map-reduce (for queries in CouchDB), and gives an example. Parallelizable (cool word, eh?)! CouchDB designed for replication (incremental & on demand). For example, synchronize address book on mobile phones and computers & apps (hear that apple?). Sweet spot: distributed databases with schema-less data. Apache cassandra (initially for facebook mail search, but now also twitter, digg). Data model: key-value on steroids. High availability (suited for datacenters), eventually consistent, tunable tradeoffs between consistency. Sweet spot: really large data sets & high availability. When it comes to performance, hmm…, well depends on what we want to compare.
The rest of the talks will follow later.

Share this story

Our Workshop Presentation @ SXSW 2010

2010-03-14T16:23:26Z

We just finished our Web of Things workshop @ SXSW 2010. A really impressive conference room (or should I say football-field…) with great, very enthusiastic, awake people and a great host!

Thanks to you all for coming. Thanks for your feedbacks Let’s continue the discussion here and on Twitter #webofthings.

You’ll find the slides below and the doggy bag here.

Web of Things – Connecting People and Objects on the Web

View more presentations from Dominique Guinard.

Share this story

Live Feedback of the Web of Things @ SXSW 2010

2010-03-14T16:42:05Z

Let’s mash things up: a Twitter widget showing you the live comments regarding our SXSW 2010 presentation.

Share this story

Live from SXSW!!

2010-03-12T22:42:42Z

We just arrived in Austin, TX for one of the largest geek/tech/media festival, South by SouthWest. It’s just great HUGE! We are presenting on sunday a workshop on the web of things. It’s the first part of a blocks workshop on javascript (the two others by Kyle Simpson and Dan Nichols), and we’re there to provide the things layer. It’s a unique opportunity to share our experiences with WoT with many other hackers, coders, masher, and we have been preparing a huge amount of nerdy meaty stuff to chew on (read: handouts, code, examples, demos, etc). It’ll be fantastic to connect with other people in the Web community and see how our projects work out there in the real world.

We’ve been busy preparing the demos, but we’ll soon put all of that material online (we just wait after the workshop, as I’m afraid all the folks trying our apps might crash our little wot server).

Anyway, follow us on twitter #webofthings! We’ll try to blog some stuff too, but there’s so much going on, we might… forget.

Thanks a lot Mitchell for the invitation, it’s great to be here!

Share this story

When Things Will “Speak Web”: Invited Lecture at Lancaster University

2010-02-26T13:48:07Z

A few days ago, I was kindly invited by Gerd Kortuem to give a lecture on the Web of Things for students of Lancaster University. The talk was given in frame of a “Software Innovation and Entrepreneurship” lecture. Thus, the students had both business and technical backgrounds. I quite enjoyed giving it especially since the students asked very relevant questions on aspects such as security, discovery, the real-time Web, etc.

You can find a full recording (about 1.5 hours) of the lecture here, but you’ll need to install the plug-in to watch it (sorry about that!).

Alternatively you can find the slides below:

When Things will Speak "Web" (Lecture)

View more presentations from Dominique Guinard.

Share this story

Sharing in a Web of Things

2010-07-15T16:41:26Z

Sharing smart things with your social networks using FAT (Friends and Things)

There are still many challenges to face towards a Web of Things: discovery, search, scalability, event driven interactions and sharing. For the last few month we’ve been focusing on the latter, because let’s face it: if you do not have a mechanism to share your Web-enabled things it is not really worth having them Web-enabled in the first place!

Core to the Web of Things vision there is this idea of the physical world as a “composable ecosystem” where devices can be used and re-used simply to create emerging applications, i.e. physical mashups.

Well, the success of Web mashups is closely dependent upon the trend for Web 2.0 services (e.g. Google, Twitter, WordPress, Doodle, etc.) to provide access to some of their services through relatively simple, often REST-based, open APIs (Application Programming Interface) on the Web. Mashup creators in turn often share their mashups on the Web (sometimes through directories such as Programmable Web) and expose them through open APIs as well, making the ecosystem grow with each application and mashup.

Enabling this model on a Web of Things requires a sharing mechanism for smart things, by enabling access to the services offered by devices through their API. For example, you could share the energy consumption sensors in your house with the community. However, this is a complex process since these devices are part of our everyday life and their public sharing might result in serious privacy violations.

The most straightforward way of solving the issue is to create ACLs (or Access Control Lists) for your devices. For each device you create a number of credentials (login + password pairs) and give them a number of roles (e.g. admin, reader, etc.).

This is, however quite a heavy and time consuming solution. When considering a large number of smart things it becomes simply unmanageable. Furthermore, it also quite abstract and does not reflect the social structure of the real-world. What if we could simply re-use existing social structures as a basis for sharing our things and sensors? Social networks such as Facebook and Twitter increasingly reflect our social relationships. Using them I could simply share access to my things with friends (e.g. Facebook) or colleagues (e.g. LinkedIn). No need to create and maintain abstract lists, simply select friends or group of friends you want to share with!

Thanks to the APIs most social networks now offer, we (together with Mathias Fischer, from ETH) were able to create a platform (SAC, or Social Access Controller) and a Web app (FAT, or Friends and Things) which lets you share REST-enabled things with the rest of YOUR world.

Architecture of the Social Access Controller

I won’t give more details about the platform here as it is the matter of an article we got accepted for the First IEEE International Workshop on the Web of Things (yeah, the one we organize BUT the article was peer-reviewed, and the reviews were tough!)

Get the paper here!

And the Bibtex below:

@inproceedings{Guinard,
Address = {Mannheim, Germany},
Author = {Dominique Guinard, Mathias Fischer, Vlad Trifa},
Booktitle = {Proceedings of the 1st IEEE International Workshop on the Web of Things (WoT 2010) at IEEE PerCom 2010},
Month = {March},
Title = {Sharing Using Social Networks in a Composable Web of Things},
Year = {2010}}

Share this story

IP-based Sensor Networks

2010-01-11T10:27:12Z

J.P. Vasseur from Cisco (IETF ROLL co-chair, IPSO tab chair) and Adam Dunkels have written a book on IP-based sensor networks called Interconnecting Smart Objects with IP – The Next Internet. The book covers IP-based sensor networks from the link layer and up, and covers network architecture (IPv6, transport, web services, …), technology (RPL routing, 6lowpan IPv6 802.15.4 adaptation, hardware, software, uIP,…), and applications (smart grid, industrial automation, home automation, smart cities, …).

The foreword is written by Vint Cerf. The book will be available in June 2010, but is already available for preorder from amazon. This is great news and very likely a solid reference for future research direction for the Web of Things, and more generally to extending the internet to smart devices (& written by – could I say – the inventor of IP-enabled sensor nets). In my wish list (& my birthday is soon, so you know what to offer me).

Share this story

COAP draft available!

2009-12-23T23:34:58Z

Fresh out of the box, COAP draft is available since ahem… a couple of hours (self-pride for my timing as you can notice). This is definitely for me, us, and you all a definite pace for mankind – a solid and viable proof that the WoT is coming, and a very nice Christmas present.

What is COAP I hear you saying? From the draft:

The use of web services on the Internet has become ubiquitous in most applications, and depends on the basic REST architecture of the web. The proposed Constrained RESTful Environments (CoRE) working group aims at extending the REST architecture to a suitable form for the most constrained nodes (e.g. 8-bit microcontrollers with limited RAM and ROM) and networks (e.g. 6LoWPAN). One of the main goals of CoRE is to design a generic RESTful protocol for the special requirements of this constrained environment, especially considering energy and building automation applications. The result of this work should be a Constrained Application Protocol (CoAP) which easily traslates to HTTP for integration with the web while meeting specialized requirements such as multicast support, very low overhead and simplicity.

I can’t wait to read it, as it’s definitely what we’ve been pushing since we started WoT: show that REST is indeed a viable protocol for constrained devices. We’re glad to see this great milestone rolling out, and we’re glad we’re here to make WoT a reality.Next step: turn it into a RFC! Maybe now, our papers will finally be better understood and not rejected on the basis “REST is not good for sensor networks”. Yay!
Oh, our WoT team wishes you all a Merry Christmas and a fantastic 2010! Thanks folks for all your support, encouragements, comments and emails, and we’re confident in saying that 2010 will be the WoT year! Keep up the good work, and looking forward for even more fruitful collaborations with you!!!

Share this story

MySpace going open!

2009-12-16T11:58:25Z

I’ve been following a few different activities related to life-streaming and and social nets all around (such as: diso/activity streams). A few days back MySpace posted on their blog a summary of their activities towards providing a more open platform for social data. This is definitely excellent news and is very relevant here, because first it’s more open, shareable, and distributed social network are in my opinion the direction the future Web will be taking, and second because we’ll soon be seeing more and more devices feeding information to these networks as well (e.g. a high-level, human-understandable stream of activities as inferred from tons of data streams from devices).

Looking forward to see how this will develop in the future, and feel free to share in the comments related projects you know about!

Share this story

Web of Things is a Trend!

2009-12-07T11:06:17Z

Like it or not, the “Web of Things” first appeared last month on Google Trends.

As a recap, Google Trends only shows trends for search terms (or combinations of terms) when the volume of single queries becomes interesting enough (i.e. big enough).

Note that, of course, the trend for the “Web of Things” is not as big yet as the one from his mother “Internet of Thing”, but it is growing (IoT is in blue, WoT in red)

This means that the popularity around WoT is growing and so is the hype. Let’s just makes sure it’s not only a hype and that it also roots on some solid ground that will, one day, make the world of “real things” truly part of the beautiful World Wide Web.

For that we need to do that thing Dilbert calls: “work” (thanks to Vlad for that one):

Share this story

Energie Visible: Live and Free!

2009-12-03T15:17:48Z

After being asked by several members of WoT the community and beyond to release the Energie Visible prototype, we finally managed to find the time to package it and now give it for free on the Web! To recap: the Energie Visible project aims at making the your energy consumption … visible!

We created a page to host the application, you’ll find the latest version and additional info there.

Note that it currently only works with the Bluetooth Ploggs and on Windows (XP or later).

The bundle you download there basically contains two applications. First is contains a Web of Things Gateway for the Ploggs (written in C++) which is discovering the Ploggs and making them available through a RESTful interface. Then, it contains a Web UI and datastore based on the great Google Web Toolkit and on the wonderful RESTlet.

The bundle contains the binaries but not the source code. If you are interested in getting the source code please contact us.

We hope you’ll enjoy the software! Note that it is provided “as is” without support. However, you are very welcome to use this blog entry to post your comments, bugs reports or feature requests.

Share this story

Trillions

2009-12-04T09:07:36Z

Several days ago I stumbled upon a very interesting video called Trillions, produced by Maya Research. It takes you on a short journey through the history of computing and ends up with interesting insights about the fast approaching challenges in the pervasive computing age. The guys at Maya claim that we need to change our way of thinking and start designing for trillions of interconnected objects. For inspiration they turn to the only system that seems to have achieved that and functions properly – Nature. Certainly a very interesting and futuristic view, I am looking forward to their revelations!

In any case the video is definitely worth watching. And the guys at Maya Research certainly have good ideas (e.g Interstacks) so check them out. And forgot to say they work with DARPA, which is always a good thing.

Enjoy!

Trillions from MAYAnMAYA on Vimeo.

Share this story

Fellow Researchers, let’s Unite!

2009-11-09T17:24:52Z

This Sunday (15th of November) is the deadline for submitting to the first International Workshop on the Web of Things (WoT 2010).

We would like to invite you to participate to this event by submitting a contribution about your current project(s) in that field.

WoT 2010 is also a unique occasion to share experiences in the field as well as to bootstrap a Web of Things scientific community.

Note that we also welcome demonstration papers reporting about your latest prototypes of things integrated to the Web or Web applications using sensor networks, embedded devices or real-world data.

Looking forward to see many of you in Mannheim!

Share this story

Java card 3 released

2009-11-05T15:06:36Z

SUN is about to release the newer java card 3! Quoting the wikipedia article:

Java Card refers to a technology that allows small Java-based applications (applets) to be run securely on smart cards and similar small memory footprint devices. Java Card is the tiniest of Java targeted for embedded devices. Java Card gives the user ability to program the device and make them application specific. It is widely used in SIM cards (used in GSM mobile phones) and ATM cards. The first Java Card was introduced in 1996 by Schlumberger‘s card division which later merged with Gemplus to form Gemalto. Java Card products are based on the Java Card Platform specifications developed by Sun Microsystems. Many Java card products also rely on the GlobalPlatform specifications for the secure management of applications on the card (download, installation, personalization, deletion).

Here are some features of it (text stolen from here):

JDK6 Compatible VM: Except for floats, it support class file version 50.
Full Java Language support: Java Card 2 has restrictions on the language itself. But JC3 has no limits. You can use all language features like annotations, enhanced for-loops etc… (except floating point)
Rich API: This is mixture of CLDC, GCF, Servlet, JavaCard2 API, Sockets, Threads, Transactions …
Three application models and two library models, which makes it possible to have virtually any kind of secure application on JC3: o Servlets, extended-Applets, Classic-Applets o Extension-Library and Classic-Library
Servlet Container with Servlet 2.5 support.
HTTP and HTTPS interface: No need for special client programming. Use any web client to reach JC3.
Still tiny(!!):24K RAM, 128K EEPROM, 512K ROM with a 32 bit processor
It is not just “Card” any more: With the newly added USB interface this technology can go beyond Smart Cards into devices like secure USB tokens, Secure Personal Databases, Embedded Servers, WebDAV compliant thumb drives and more.

The hot part is that smart cards support directly HTTP/HTTPS. This means it can be part of WoT and support natively Web-based communication (HTML/SOAP/REST), so it could be very nice to see new applications that could be built with it. Any experience on your side with that?

Share this story

Netgear releases Open 802.11n router

2009-10-07T09:08:08Z

As a few days ago, Netgear has released a gigabit and programmable router, the WNR3500, which is supported by the MyOpenRouter community. This is a fantastic piece of equipment as it enable developers (hint: us) to install custom software on router, typically WoT software that can bridge proprietary embedded devices with Web directly on a router, thus not requiring any additional devices for this purpose.

Just as Sputnik has done with legendary WRT54g, one can easily develop custom firmware running directly on cheap routers and sell the whole thing as an augmented product. Which is what that they did for offering a web-based management system for public Wi-Fi hotspots. Besides, just having the possibility of hacking directly with the router, allows you to integrate network-level data into your application (think of your router tweeting each time a new device connect and gets an IP address with DHCP). Can I be more explicit? Just get this thing, because at 119$ it’s a steal!

Oh did I mention that this beast has 64 MB Ram, USB 2.0, and a 480 Mhz CPU?

Share this story

REST-*, oh my … They Dared!

2009-09-25T16:42:26Z

In an attempt to “standardize” REST a little more, Red Hat is launching an open alliance and community towards creating standards for RESTful Web Services (hem aren’t RESTful Web Services already implemented using some standards like… HTTP ) Of course this is of interest to our Web of Things community since we definitely foster the use of REST towards a architecture to integrate things to the Web (see paper and that whitepaper for instance).

However it seems like the REST-* initiative is also generating a lot of unhappy people amongst the RESTians. One of the reason is that they fear the REST-* initiative being a generated WS-* initiative (which is pretty much the case, JBOSS is an Enterprise Server after all, not a Web Server…) will end up with lessons like: “look guys, we did great stuff in the WS-* world now let’s apply what we know to the REST world”.
Fundamentally this would of course be wrong. If the initiative really takes off (which I quite doubt looking at the virulent feedbacks) then it is a great opportunity to rethink the WS-* integration patterns and not re-do what was done for WS-* in REST.

Essentially the first goal of such an organization should be (and is probably going to be, let’s hope) to educate people on the RESTful philosophy. Because it is definitely not trivial to entirely master (while trivial to use) and takes a while to fully understand. It probably took me over a year to go from “REST is just about URLs and Verbs (PUT, POST, etc.)” to “REST is really an architecture with constraints and great great benefits when you are interested in making you application PART of the Web”
REST is simple to use for the RESTful “API” (as word that RESTians don’t always love…) user but hard to grasp in a correct way for the RESTful “API” architect or developer.

So please REST-* guys and gals, do not do standards for the sake of it. The WS-* galaxy has so many standards that no one on earth can tell me how many (watch you eyes if you click on that). REST-* is a great idea which could turn so wrong, don’t waste it!

Indeed, there is a need to clarify what RESTful Web Services (which go beyond REST only) are about and this organization may help towards this particular goal. As a starting point what really helped ME towards this goal already exists. It is a book (a thing with a lot of pages that you can read without Internet connectivity) by people who understood most points of a RESTful architecture. A book that I read over and over again, understanding each time a little more while putting it in practice.

Btw, we are currently writing a more techie and scientific article for a conference which we will publish as a more detailed white paper once it is ready. It should also give its share of advices on building RESTful architectures for… things!

Share this story

PICNIC!

2009-09-23T06:52:36Z

I’m at the airport, ready to take the skies (that is an expression in french, maybe not english) for Amsterdam where the huge Picnic conference will take place.

I have the pleasure to invite all of you who will be around to join our Web of Things special session. We have the chance of having five awesome speakers with us: Usman Haque, Jean-Louis Fréchin, Matt Cottam, German Leon, and Timo Arnall. Also, we have a hot demo session with Widetag, Roomware, and nodesign. Thanks a lot all of you guys (& girls) for making it possible!

Simply put, this event will rock (and oblige us to start blogging much more decently, so be sure this site will be back to life as it used before vacations). Lots of things ahead so stay tuned, as we’ll be live-blogging (& picturing) most of the conference!

Share this story