Teaching the hard way

When we teach kids to ride a bike, at some point we have to take the training wheels off. Here’s an idea. When they hit eleven, give them a plaintext file with ten-thousand WPA2 keys and tell them that the real one is in there somewhere. See how quickly they discover Python or Bash then.

EPIC

A leap frog

In the last weeks I didn't get too much progress with ShareIt!, between exams and my new job, but specially due to the fact that with the problems I had with the removal of the anonimous XMPP server I was using and that the browsers starting with Chrome v26 generated a big SDP strings, I got fixed on using Chrome v25 if I wanted to keep experimenting :-(

But, in my new job I'm working with WebRTC all the time :-) And doing some experiments not only found that the big SDP strings was a bug of Chrome but also thanks to it another bug on Firefox has been found, but not only that, I was able to find a solution to create smaller SDP strings... and got ShareIt! working directly with Chrome v30 and their native reliable DataChannels :-D Only thing is that seems reliable support is not finished so I'm only able to get fileslist but not files content, so while it got fixed I decided to test it on Firefox and after some work... now it working there.

Yes, ShareIt! working on Chrome and Firefox!!! :-D

Well, sort of. As I said, it's mainly experimental only allowing to get files list, but they are working using native DataChannels, that's a big advance. Now I'll try to be able to use DeviceStorage API on Firefox until interoperability appear since the Filesystem API is not available nor support to upload folders, and also the input tag seems it's a dead end also in Chrome, and maybe I'll start with the Node.js based implementation ;-)

One year ago...

One year ago I didn't know what WebRTC was. In fact, if someone would talked to me about a new in-development technology to directly connect web browsers between them and that I would became some months later a international reference doing keynotes and receiving several job offers thanks to it, I would give him a pokerface :-P

But just one year ago I had a dream. I dreamed about me asking myself why browsers couldn't be able to transfer files between them in real time and how WebSockets could help on this (real time communications between a browser and a server are the main purpose of WebSockets). After this and concluding it was a good idea, I asked myself "how the browsers would meet themselves? They would need an ID"... and at this moment I got something that would be comparable to a revelation or an epiphany: just came to my head an splash of the TeamViewer call ID window...

Just have an ID for each WebSocket connected to the server and use it as an address book! EUREKA!

After that, I was not able to get back to sleep :-P

So, I had the sensation of found something great, just great enough that if I got fired from my work (something that in fact it happened just less than a week after) it only would means that it was my destiny and I should as hard as possible to develop it. So, I asked for advice to a friend of mine about create something like PasteBin but for files (something that recently has developed Pipe). He was not confident about the commercial viability of the project (it would require both ends to be connected at the same time and also there's already a lot of ways to transfer files that doesn't have this requeriment, for instance DropBox), so I decided to take another way:

- Ok, so what if I convert it on a P2P network and register on the Universitary Free Software Championship?
- If you do it, you will crush the others and win them by several heads of advantage ;-)

So I did it... and several months later I won it :-)

I'm the one in the middle with the beard and the trophy in the hand :-)

To be honest, by that time I was not really sure about how I would do it (I've never been a networks guy) nor if someone had my idea before, so I started to look for some example code to start about. That's the way I ended finding DirtyShare, a proof-of-concept whoose concept was almost similar to the mine, but that was talking about something a new technology called WebRTC and also about the WebP2P maillist. That was interesting, so looking for it, I found that it was really a better approach that the original one using WebSockets, that it was starting to being available... and that the part where I was interested, the DataChannels, was not ready yet, so that was the reason I developed DataChannel-polyfill, people started to take interest on my work and I started to forge myself a name :-D

So, this has been a really long and intense year for ShareIt! and for myself, learning a lot and coding a lot and getting more success that what I would imagine on first place :-) But this doesn't means the end of this journey, since in fact I'm still working on it and I will show ShareIt! the next course as my degree thesis thanks to the collaboration of professor Luis López. That's the way seems that the version 2.0 is not only around the corner but also will be really awesome, with a high focus on portability and modularity, code reliability (WebP2P.io, the underlying handshake framework, it's a really nice piece of cake :-D ) and easyling to integrate it on other products, expanding it to new horizonts like using it for P2P audio streaming (yeah! :-D ). Thank you to everybody that has offered to me their support and please don't move from your seats or you would loose the fast moving news that are comming around ;-)

Achievement unlocked

Banned from W3C Restricted Media mail list for being critic with EME & DRM on HTML5. I love to be on the first line of fire... >:-D

And the winner is...

Two days late, but my mobile internet got down this weekend.

Just to say that ShareIt! has achieved the second position on the general category (first one was for Lynckia, that was using WebRTC too, by the way) and has won the Most Innovative Project category of the VII spanish national Free Software Universitary Championship 2013.

Yeah!!! :-D

Going mobile

One of the reasons why I though it would be cool to develop a P2P application inside the browser was that it could run everywhere there was a browser, without needing to install nor configure anything, just open a web page et voila! It was working. That's one of the reasons why some time ago I started to add some integration and responsive design to allow ShareIt! to work on mobile phones browsers and limited resources ones, not only natively but also as a "remote control" for a Node.js-based client, and it was fairly simple to modify the architecture and split the different components to make it possible, and also based on this architecture ShareIt! core could fully work inside a SharedWorker and being independent from the user interface (unluckily PeerConnections are not able to work inside Workers at this moment, but that's another story...). Problem was, I didn't have a mobile browsers modern enough to test it (also using WebSockets and my DataChannels-polyfill... mobile browser s*cks).

But now I have a Galaxy Note II, and can be able to run Chrome4Android for it :-) Since lately I was able to make ShareIt! work using native DataChannels, it was the perfect moment to give the mobile interface a new opportunity, and after some tune-ups on it, now I can say that ShareIt! is the first P2P application that can run on a mobile phone (and not just a proof-of-concept like the bittorrent port running on the Nokia S60 Python port... ;-) ). It need some improvements on usability and functionality (at this moment Chrome4Android doesn't support to share folders), but definitely it's almost as intuitively to use as the desktop version, and open new horizonts about what usages are possible with the WebRTC technology :-)

And if you are thinking about it... yes, DataChannels + reliable library are stable enough to be used on production, although is really slow (at least for me). I'm thinking about a solution for this like reducing packages size and wipe completely the need for reliable comunications, but I didn't take a final decision about this point...

Not so dead...

Remember my last post where I told would kill DataChannel-polyfill and work since now on native DataChannels because I got too much behind with them? Well...

...not so real :-)

Since the last post I have been thinking almost obsesively with the problem of needing a deprecated browser version just because of using my DataChannel-polyfill using WebSockets, and not working in latest versions with native support for DataChannels (that, by the way, sucks). So taking in account that the DataChannel-polyfill test code works with native ones I conclude that it would be just a problem on ShareIt! side not being fully compliant, so I went straight to it, removed all references to my polyfill and started again over with the handshake and PeerConnections layer from scratch, fixing one bug at a time.

And finally, after just some hours of work (instead of several days as I thought), it worked :-)

I must to admit that it's not the best implementation ever (I still ask my self why the h*ll is required to exchange some 'candidate' messages between the peers) and also it only support to transfer files and data up to 1Kb until they implement native reliable support (or I use reliable library, whatever comes first... :-) ), but the fact is that this almost mystical sensation after seen this thing working and with so few work (just some little tune-ups on the code thanks to the fact I develop DataChannel-polyfill trying to mimic the original specification API) it's really awesome :-D

So, not only I have experimental native DataChannels support on ShareIt! (F*ck yeah!!!!! :-D) but also being so little the diferences I've decided not only don't kill DataChannel-polyfill, but also try to improve it now that I know how native DataChannels work (and being so easy to use :-) ) and think about how to make a backward compatible API so older browsers could talk with newer ones :-)

But don't get me wrong little friends, the most important part of this post, if it was not clearly noticed yet, is the fact that now we don't need servers at all, being fully decentralized and serverless :-D Combine this with the Holy Grail of Internet that almost can bring us the HandshakeManager and the handshake servers, and wonder what an awesome future is waiting us... :-D