dublin.gtugs.org

We’ve put together a simple landing page at http://dublin.gtugs.org. The purpose of the page is to have a single go to with an easy to remember URI which points to all Dublin GTUG related resources. (Before setting this up, we were a little distributed over twitter, wordpress, the Google Group and some content describing who we are on gtugs.org).

(The main purpose of this post is to link to the above to help it appear in search listings!)

Advertisements

September 2011 GTUG Meet

The September 2011 meet was comprised of three talks.

First up, Kenneth Macleod gave a presentation on appengine with a specific focus on the new pricing and how it impacts app design and development. Kenneth gave examples of how poor design can lead to significant increases in cost and some tips on best practice to minimize costs. As this is quite virgin territory in the sense that there is minimal expertise in optimizing applications for the new pricing scheme (in appengine), these pointers should prove valuable. [Link to slides].

After Kenneth, Pawel Kowalski described a whiteboard app that he was involved in building at the HTML5 hackathon. The initial idea was to use websockets to realize a kind of peer-to-peer whiteboard, but this proved impossible. Instead, the team built a server based system in which the clients communicated over websockets to the server. Pawel did describe a couple of different ways to use websockets and noted that the socket.io library was very powerful and very easy to use. [Link to slides].

Finally, I gave a talk on the project we tried to execute during the hackathon. The project idea was initially to try to get some dropbox like client working off Google Storage in a browser and leveraging the HTML5 Filesystem API. However, this proved impossible for a number of reasons and the scope was relaxed considerably. At the end, we didn’t get much working, but we did learn that the Filesystem API is still very raw (eg, we had to start Chrome with the <tt>unlimited-quota-for-files</tt> flag to get it working) and that Google Storage has considerable complexity which was not apparent, mainly due to sophisticated access control. [Link to slides].

October’s meet will have a Go focus.

[Video Content on Jean’s Youtube Channel right now.]

August 2011 GTUG Meet

The August GTUG meet was divided into two distinct components – a comprehensive talk on Clojure and a few short talks describing the outputs of the HTML5 hackathon we had earlier in the month.

Kevin Noonan took to the stage first to give an overview of Clojure. Clojure is a relatively new language, being about 3 years old, but is receiving a lot of interest within the community right now. Kevin explained why people are interested in it – primarily because it’s designed to put concurrency under the hood, meaning developers don’t have to concern themselves with it – how it works and gave some examples of how to use it. Kevin provided a great intro to the language for those who were curious but have never managed to explore it. [Kevin’s slides]

After the break, there were three short talks demoing what was achieved during the HTML5 hackathon. Brendan Wyse talked about the crowd sourced traffic information application that he had been working on. This application uses some of the geolocation capabilities which are quite commonly available on smartphones to update a server with traffic information, thus enabling the backend to build a picture of traffic activity within the city. Brendan talked through the workings of the Geolocation API and gave a demo of it working on his laptop. [Brendan’s slides]

After Brendan, Marcin Olak talked about a project he did which focused on the audio capabilities of HTML5 for use in a simple beatbox application. Marcin showed how the audio capabilities work, by demoing how easy it is to interact directly with the audio capabilities from the Javascript console and then he did a demo of the application they developed over the weekend. Marcin did note that the audio API is currently not very powerful and probably wanting when it comes to development of sophisticated audio processing applications. (Sergio did point out that there is a Webaudio group working on much more advanced audio capabilities – they actually have a beatbox demo too!) [Marcin’s slides here.]

Finally, Noel King and Shane Curran talked about an app they built which is intended for localized photo sharing. The app will permit people to easily share photos which are geotagged close to each other. Like the first app, it makes use of the Geolocation API. The team did initially focus on using HTML5 to build it, but later decided to move it to Android as this afforded more control and would run more reliably on a larger set of devices. [Noel/Shane’s slides here.]

This was the second session we recorded, although we had some issues with the first recording truncating prematurely. The video content is still within the Googlesphere, but it should be freed soon – will put a link here when it’s available.

HTML5 Hackathon – August 2011

We held a HTML5 hackathon on Aug 6-7 2011. AOL Ireland were kind enough to offer their premises to host the event. 19 people showed up for the event, with a varying mix of skills and experience – some students, some experienced developers with  no HTML5 experience and some folks with a bit more exposure to HTML5.

As is usual, prior to the event, we had a little bouncing around of ideas – there were not a huge amount of ideas put forward, but enough to get people thinking. When we met on Saturday morning, we went through the various things that folks might be interested in working on. There were about 10 ideas proposed – given the size of the crowd and the fact that teams of 2/3 people would find it a bit difficult to co-ordinate over such a short period of time, we only needed about 6/7 ideas. After asking which projects people would like to work on, we managed to whittle the initial list down to 7 easily. Thus, the teams and projects were decided on in about an hour and people got to work before lunch on Saturday.

The teams spent the next two days working quite intensively on their projects – all of the teams worked in a single space and there was a really good vibe about the room; everyone was working diligently, but there was no specific pressure which made for a good working environment. (On Sunday, Rob was doing DJ and his groovy tunes added to the ambiance). All of the teams then showed their wares on Sunday evening.


Most of the teams managed to do something interesting – at worst, all of the teams learnt something interesting about HTML5, with most of the emphasis on some of the new Javascript APIs. The projects that each of the teams worked on are listed below:

  • Music mixing system using the new HTML5 audio interface: the new audio interface is quite flexible (although its functionality is somewhat dependent on the browser in use). The interface provides for mixing of different audio samples within the browser and hence it is reasonably straightforward to develop a basic audio mixing. Marcin and Monika put together a tool which has a nice UI on top of this functionality and can be used to mix different sounds (eg different drum sounds) at different tempos and generate a backing beat for some music directly from the browser. Their tool works slightly differently in Chrome and Firefox (better timing in the former; some illustration of played out audio in the latter), so it’s worth trying it out in both. [Link to mixer];
  • A geotagged photo sharing application based on HTML5: In this application, Noel and Shane put together a PhoneGap based application in which a photo could be taken on a mobile app, geotagged and uploaded to a server. The server could then show photos taken on a map and photos taken nearby could be viewed. The app used PhoneGap to access camera functionality on the phone, as this is not covered by HTML5 as well as the Geolocation API to determine the phone’s location. The guys wrote a Java based backend which supported file upload and mapping of the locations. The guys plan to move it forward and should probably demo it at our next GTUG;
  • Client side Websockets based whiteboard application: The objective of this project was to build a websockets based whiteboard application, ideally one with no server. The team found, however, that it was necessary to have a simple server component which could be used to broadcast the websockets information to all the clients that were accessing the shared whiteboard. The team managed to develop a canvas based whiteboard on which it was possible to draw (with different colours) and add post its [Non network demo showing canvas functionality here – team working on making networked variant live];
  • Dublin Traffic Camera application: At one of our previous hackathons, Raphael and some of the guys worked on a Dublin Traffic Camera application – an application in which it was possible to see the state of the Dublin road network using the cameras mounted around the city and understand where there are congestion points. This work was developed further by enabling an individual to choose a set of cameras they are interested in (with a nice use of the Drag & Drop API), local storage of their preferences (using the Local Storage API) and some animation of the images to show the change in congestion with time [Demo/link?];
  • Traffic alerting and congestion detection application: This project involved the development of a HTML5 interface to a backend which had been previously developed. The backend supported live monitoring of traffic information to determine traffic congestion (by detecting slow moving traffic) and alerts of incidents on the road – a user can notify the system that there is an incident at a particular spot and users nearby can receive this via a notification. This project made use of the HTML5 Geolocation API on the front end to determine the device’s location and mongoGB on the backend to identify events proximate to the user [Demo/link];
  • Sync local filesystem with Google Storage: The last project was something of a hair-brained scheme that I had – I thought it was possible to use the Filesystem API to access the local filesystem and this could be synced with Google Storage using functionality in a browser. However, it turned out that the Filesystem API only affords access to a local sandbox. We did shift emphasis to a collaborative file sharing project for music applications, but the permissions on Google Storage looked a little more difficult to deal with than we had first considered. We did not get a lot done, but we managed to store content in the sandbox filesystem, read from it, control a HTML5 audio player and talk to Google Storage. However, we didn’t really get anything working which makes a nice demo.

Overall, everyone had great fun; some of the outputs were impressive and everybody learnt. One of the key takeaways was that it is still early days for HTML5 and there is still significant disparity between what the different browsers support. Another interesting point was that it is more likely that HTML5 will get traction first in the mobile space as devices are changed much more frequently meaning that there are a lot less legacy issues to deal with.

We’ll give a report on this event at our next meet – Aug 30th – and some of the guys will probably demonstrate what they managed to do.

Thanks again to AOL for providing a great venue and generally being great hosts.

July 2011 GTUG Meet

The July 2011 GTUG meet took place in Gordon House last night. There were two distinct and quite different components to this meeting: first up, Martin Omander, Developer Programme Manager, talked about the Google Prediction and Storage APIs; this was followed by a panel discussion on Hackerspaces and Formal Education.

Martin’s talk opened with some thoughts on focusing on your strengths leading into some ideas around letting Google focus on core IT capabilities and building interesting and useful application on top of these. The first of these base capabilities is storage – Google has built a large, reliable storage and distribution infrastructure and provides an easy to use interface to it. Martin demonstrated gsutil which is a command line tool which can be used to manage files in Google Storage. More specifically, gsutil provides an interface which is very natural to *nix user to perform operations such as list, copy, delete and rename files, etc. Also, it was remarkable how responsive it was – from the demonstration, it seemed to differ little from local file manipulation. Martin also made reference to the Data Liberation Front, which is a Google initiative to make it easy to move data in and out of Google products and services. To highlight how serious Google are taking this, he demonstrated how easy it is to use  gsutil to copy files out of Google Storage and into Amazon S3. Google Storage is free to use (with a quota of 5GB) until the end of this year.

The second section of Martin’s talk focused on the Prediction API. This is a set of machine learning techniques which sits behind a very easy to use API. There are basically two ways to use the API – the first is in a classification mode in which training data is classified in some sense and the predictor can determine how to classify new data; the second mode is one in which there is a single scalar output value which is driven by a number of input variables. To demonstrate the first mode, Martin trained the system with a set of sentences which were either English, French or Spanish – the training set was not so large and the system was trained in a matter of seconds. Then, he used an English sentence as input and the system was able to automatically determine that the input was in English. To demonstrate the second set, Martin chose property price data from California: the input data set comprised of the property price and a number of parameters which influence price including date of build, number of bedrooms, number of bathrooms, total area, etc. Martin trained the system with this data and then was able to choose quite arbitrary values for the variables and the system produced an estimate of the value of the property. Google Prediction API is free to use up to some modest quota; more intensive applications incur some costs.

Martin finished off the talk by noting that these are two powerful and quite fundamental tools which Google are offering, on which many interesting and useful applications can be built. [Slides here.]

Martin’s talk was followed by a quite different event. Based on some feedback from a recent survey we did and some feeling that talks are sometimes not the most engaging format, we decided to run a panel discussion. This first panel was largely borne out of a discussion in the Schoolhouse after a previous GTUG and it focused on Hackerspace and the Formal Education system; it arose from the observation that hackerspaces are interesting, creative places which seem to be quite divorced from education and we wondered if this is as it should be, or can there be benefits from bringing them closer together.

We were delighted to have Bill Liao chair the event. The panellists were John Looney, Engineering Manager, Google, James Whelton, school leaver and entrepreneur, Mark Cunningham, student, member of TOG, Martin Mitchell, Software Engineer, IBM, founder member of TOG and Mark Deegan, Lecturer, DIT. Bill set the scene by making a few initial comments on hackerspaces, their history, how many there are in Ireland, etc. and then he talked about what the education system is doing. Each of the panel members then gave a brief intro and their view on the topic. As it turned out, all of the panel saw significant deficiencies in the education system and understood that the hackerspaces can much more easily be places of learning and innovation. A panel in concord is never going to be as much fun as one which is strongly divided, however, Bill still managed to extract an interesting discussion from the panellists on issues ranging from Google’s hiring policies to how a hackerspace approach could be constructed in a way which is compatible with the formal education system to whether hackerspaces should be self-financing. The floor was invited to give comments/questions and many people wanted to have access to the microphone. Some were commenting on their experiences in hackerspaces, some were commenting on the student societies in universities and some were interested in whether there is any point trying to bring these two worlds together. Clearly, it was a topic that people were interested in and had opinions on.

The discussion itself was somewhat inconclusive – it was clear that all involved believed that hackerspaces are good and interesting places and most believed that they learn more there than in the formal education system. However, there was no consensus on whether it makes sense to have hackerspaces more closely aligned with the education system, what (if any?) benefits this might bring and what problems would arise. Fodder for another discussion, perhaps…

The next GTUG event will be the HTML5 hackathon in AOL on Aug 6/7. The next talk session will be on Aug 30th, subject tbc.

June 2011 GTUG meet

Another great Dublin GTUG event took place last night. Over 100 people turned up for our HTML5 session. The session comprised of 3 great talks, two of which had a strong HTML5 focus and one more generally talking about how to design for the mobile web.

Ilmari Heikkinen took the floor first: he gave a talk which was divided into two sections – first, he gave an overview of the (amazingly large!) set of new features that HTML5 provides and then he talked about some image processing he had done in HTML5 using both the basic canvas and more advanced WebGL. The effects he was able to produce within the browser were very impressive indeed, really demonstrating that the browser can be the platform for even the most advanced video-hungry performance applications. [Link to content].

Next up, Neil Turner gave a talk on his experience putting together HTML5 sites. Neil’s talk complemented Ilmari’s very well, as he cfocused on the problems that developers have to deal with when working with a platform defined over heterogeneous browsers which are constantly evolving. Neil covered the tools and tricks he uses to deal with issues such as multi-browser support, different form factor devices, etc. Neil described how things like Modernizr, HTML5 Boilerplate and mediaqueri.es can make it easier to produce attractive and robust web experiences. [Link to content].

 

Finally, Josh Holmes shifted the emphasis to designing for web mobile. Josh surveyed a number of different websites pointing out assumptions that were implicitly made in their design, but can break when accessed via mobile (eg no mouse interaction). Josh also pointed out the importance of context on the mobile device and how the application designers need to put themselves in the mind of the user to deliver them the information they need as easily as possible to provide good user experiences on mobile. [Link to content].

All in all, the session was thoroughly enjoyable and we hope to use the knowledge learnt during this session in a HTML5 focused hackathon most probably in August.

Next month, we’re gonna shake it up a bit by changing the format a bit: as usual, we’ll have a talk – this time on the Google Prediction API and Google Storage API given by Martin Omander who’s going to make the trip all the way from sunny Mountain View. This will be followed by a panel discussion on hackerspaces and the formal education system, which should be some fun. It’s on Tuesday July 26th in Barrow St.

Follow us on twitter or sign up to the group for more info.

Some interesting links from the event:

Thanks as usual to Jean and Sérgio for hosting.

May 2011 GTUG meet

The May GTUG meet took place last night. Unlike most of our other meets, this one involved a larger amount of short talks, all of which were given by final year undergraduate students (bar one). The idea of this session was to see what cool technologies some of the cool kids are playing with – we thought this would be of interest to some of the group.

There were seven talks in all, covering a wide range of topics, from RFID to an iPad MIDI controller. The session went over time (as is not uncommon!), but as most people remained engaged, this was not a huge issue.

First up was Zac Davison from DIT who talked about a MIDI controller he had developed for the iPad. Zac is involved in music production and DJing and recognized the need for flexible controllers to replace legacy equipment, primarily mixing desks, found in music studios. To this end, he developed an iPad app which serves as a flexible device controller – it interfaces to MIDI equipment to control the sound output of the equipment and it is very configurable – sliders, knobs and on/off switches can easily be added to the interface and associated with different devices. [Slides, Video]

Philip Nolan, also from DIT, was up next. Philip did a project which focused on dealing with issues receiving text messages while driving. He developed an Android app which detects when a message is received and notifies the user (who is driving). The app will convert the text message to speech and convey it to the user. The app can also automatically respond indicating that the user is driving and will revert shortly. The app is currently available in the market – search for ‘Driver Safety’ to give it a test drive! [Slides]

Christina Lynch from UCD followed Philip. Christina did a project which tries to give information on the types of people who frequent different venues such as bars and restaurants – the idea being to get some feel for a place based on the characteristics of folks who go there. Christina developed an application with both a web and mobile front end. The application was built on top of foursquare (for venue information) and hunch (for preference information). Christina provided limited distribution of the app and got some useful feedback from people, mostly in the hunch community. The project may be taken forward in different guises. [Slides]

Another DIT student took the stage after Christina: John Breen did an investigation of the use of Knowledge Management (KM) in a small organization. John investigated how such an organization understands what information it has and how it is distributed. Interestingly, John found that a lot of people prefer to have a human component to information dissemination – purely technological solutions lack the human factor and can be wanting in some respects. [Slides]

After the short break, Karl O’Dwyer from NUI-M gave an overview of an eye-tracking project he did. Karl used a high speed camera to detect eye movements targeted at driver training applications. Karl talked about the challenges that eye-tracking presents and then went on to talk about the system that he developed. He talked about a number of different algorithms which are often used for eye-tracking and how they compared in the system that he worked on. He managed to devise a system which has reasonable levels of accuracy with good response times, but there is still scope for further improvement, which may occur if the project is taken forward. [Slides]

Next up was Jeffrey Roe from DCU who presented his work on accurate GPS tracking with a cycle tracking application in mind. Jeffrey developed a system which samples, stores and visualizes location data. Jeffrey developed a system comprised of an Arduino based data sampler, an Arduino based data logger and a backend which talks HTTP. Jeffrey described the particular components he used to build the system and demonstrated the front end functionality which showed where the device had logged location data. [Slides]

Last, but certainly not least, was Kevin Chen from DKIT. Kevin did some work on security exploits in RFID systems in general and NFC systems in particular. Kevin reviewed the different NFC systems that are available and described how standard configurations can be the source of security vulnerabilities. Kevin discussed some of the tools that are used to crack NFC systems and gave some examples in which he cracked school ID cards and Mifare 1k tags. [Slides]

Overall, the session was a very engaging session with the audience asking lots of questions – informal feedback was that this was a good thing to do, so we will probably do it again next year.

At the next session, we’re delighted that Ilmari Heikkinen from Google will come to talk about Chrome and HTML5. More details to follow.

The usual suspects retired to the Schoolhouse for some robust post-GTUG debate.