There were two talks at the February session (we were supposed to have three, but Mark Ahern was a bit under the weather and couldn’t make it).

First up, Trevor Parsons of LogEntries gave a talk on issues they had to take into account when building their logging system. Trev opened by talking a little about the large amounts of data generated by logging systems and the issues diagnosing problems within a large body of log data: LogEntries is providing a solution in this space. After motivating the system, Trev proceeded to descrie some key points in their system design bearing in mind the fallacies of distributed computing which are often erroneously assumed by application developers. Trev noted that in the world of cloud computing, some of these issues are even more acute as there is a greater dependency on multiple services providers who have limits on the reliability of their systems. Trev described the system they had built and how they had to overcome reliability issues, relating to the distributed file system that they used to store their log information. Standard solutions such as Hadoop and Cassandra could not meet their needs and they ended up developing their own. Their system currently scales to handle billions of log messages per day, but they expect to push that up a few more orders of magnitude in the coming months. [Slides]

After Trev, Paul Phillips from scrazzl gave a talk on scrazzl, the problem that they solve and the technology they have built. The problem that scrazzl focus on is to identify when particular products, items or processes are mentioned within research literature: this information is useful to the vendors of those products who typically have little understanding of the use of their products within this community. To solve the problem, the scrazzl team has built a system which can analyze a corpus of research literature, index it and generate different types of analytics relating to the data. Paul described all of the different components of their system and talked through some of the motivations for their design decisions; they have quite extensive experience with Apache Solr to analyse and index the corpus, mongoDB for storing the outputs of the analysis in general, but analytics information in particular. Paul also talked about deployment, configuration and scaling issues and the tack the scrazzl team take on these. All in all, a great overview of a complex application with a lot of moving parts. [Slides]

Next month, the talks session will have a security flavour, with a talk from Fabio Cerullo will be talking about the 10 biggest threats to web application security which arises from a considerable body of work within OWASP. There will also be a talk on Ethical Hacking. Apart from the talks session, there will be an Apps Script Hackathon on March 13th – follow the mailing list for more info.

We finished up the Android Dev Camp on Sunday evening. At the end of the event, all the folks who participated talked about what they had done throughout the weekend, what problems they had and what they managed to get working.

Unfortunately, we had an issue that for a couple of the teams, the person who proposed the project was unable to attend on Sunday – this meant that two teams had lost leadership (and a body to get things working!) and hence found it difficult to produce something interesting. Next time, we’ll have to ensure that only people who are around for the entire weekend can lead a team.

The most significant outcome of the event was probably Eoin’s work on the Hit The Road app. While the service works reasonably well on mobile web clients, the guys thought that a native variant could be a bit tidier and hence Eoin spent some energy getting this going. A beta version of the app which you can play with is here (feedback to contact@hittheroad.ie) – the production version should be in the market in a few weeks.

I was working on another project which was fun and interesting (to me at least), so I’ll make a short comment on it. The objective was to develop an application which can use the accelerometer combined with audio input to determine if someone is dancing in time to music. Initially, I was working on this alone, focused on accelerometer input, but then Noel King bailed in and looked at some of the audio and UI issues. It’s very easy to work with the accelerometer; the challenge was in parsing the accelerometer data to obtain a rhythm, which we did not solve. We did use autocorrelation of the amplitude of the accelerometer vector, but this did not prove so accurate. We also did some analysis of music to determine how rhythm varies in music – it turns out it varies quite a lot. However, some songs have minimal variation in rhythm and were considered good candidates to work with in this context: we focused on this classic as research shows that has a very stable number of beats per minute (BPMs).

Overall, we did not engage very much with the Global Android Dev Camp – the benefit of this was not clear to us, save to ‘force’ us to have an Android focused event at this time. Next year, however, we may make more of an effort to be more integrated into that picture.

an Android interface to allow you to give yourself a ‘socialbug’ for your social network – a socialbug is a badge or ribbon which can be used to indicate a particular status/belief/affiliation and can be displayed on your social network.

We’re getting stuck in to building stuff and we hope to have some stuff to demo by tomorrow eve.

We took our first month off in a year and a half last month (December) and we’re back with a vengeance now.

We had two excellent talks during our January meet. First up, Steve Collins from Swrve gave a great talk on how they see the games industry evolving and how there are new opportunities for tools which provide much greater insight into how gamers behave within the game. Steve described the system Swrve is developing which enables a game developer to perform A/B testing within the game to determine how gamers react to different situations which may arise. The main use of the system is to enable gameplay to be improved by enabling the game developer to test different situations/context/scenarios and determine which are most engaging to the gamers. Importantly, this can also help stimulate increased monetization from the game. [Steve’s slides to be linked to.]

After Steve, Alex O’Connor from TCD gave a talk on linked data and the semantic web. Alex discussed the web today, noting that the original design did not provide good support for search, indexing, bidirectional linkage of data, etc. Further, the emphasis in the design was much more on presentation of information for human consumption, rather than structuring the information to facilitate advanced reasoning and inferences by machines. Alex discussed the so-called web of facts in which subjects and predicates are linked by relations and how wikipedia in particular is an excellent source for building this web. This can be used to perform much more complex information searches than current tools and system provide. Finally, Alex noted that there is still much to do in the semantic web, including dealing with conflicting information, opinion, evolving contexts, etc. [Slides here].

The video of this session should be on the

The next talk session will be on February 28th: we’ll have Trevor Parsons of LogEntries talking about how they built LogEntries and Paul Philips of scrazzl talking about scrazzl’s text extraction technology. More information soon.

For the November meet, we decided to run a panel discussion again as the previous one was pretty well received. This time the focus was on the use of Python, Ruby or Node.js for web development and it was pitched as a battle between the different technologies. We got an experienced representative from each camp to share their thoughts – Declan McGrath (talking from the Ruby corner), Alan Kennedy (taking from the Python corner) and Richard Rodger (talking from the node.js corner) – and we coaxed the shy and retiring Joe Drumgoole out to chair the event. We had a fantastic response to the event with over 100 folks turning up for the showdown.

To kickstart the panel, Declan, Alan and Richard each had to speak for about 10 mins about their technology giving a bit of history and highlighting how it is used in a web development context.

Declan went first, giving some background on both Ruby and Rails. He highlighted the fact that Ruby combines both OO and functional programming thus making it a powerful, flexible language. He noted some of the key points of Rails – MVC, good JS support, intelligent routing, easy REST support, etc – and commented on some of the newer features which are appearing – asset pipelining, http streaming etc. [Slides here].

Alan spoke next, focusing on the requirements of web frameworks in general and how Python fits those needs. Alan highlighted issues including routing, form handling, security, internationalization, templating as important issues for web frameworks. Alan noted that Python has a large number of options for web frameworks, ranging from very simple frameworks such as bottle to very comprehensive ones such as django – developers need to clearly understand their requirements prior to choosing, but Python certainly offers something which will meet their requirements. [Slides here].

Richard then got up to talk about the new kid on the block which is receiving a lot of attention right now. Node.js is a server side Javascript framework which is designed to run in a Chrome V8 engine. A key characteristic of node.js is that it is not thread-based; rather, it’s based on events, making it much lighter than thread-based servers and thus delivering excellent performance. Richard provided some performance data from some sites he had worked on which really showed how well it can work in production systems. He then highlighted some of the pros – performance, can be written in same language as front end leading to developer productivity – and cons – you’ll probably get fired for suggesting it be used in production! [Slides here].

After each person had set out their stall, Joe asked a few questions and then it was opened to the floor. The questions were quite varied and it is difficult to capture them meaningfully here, so I’ll just note a few interesting points that were made.

Node.js is wanting when it comes to MVC, but a common design solution is to just use the backend for serving JSON encoded data and make the front end responsible for structuring the information;

RoR is probably the most in demand in Dublin at the moment;

The education system is not doing enough to serve industry needs relating to these technologies, although there are some folks who are trying to move things forward;

Python has excellent integration support for many different types of systems – it is quite straightforward to integrate given libraries in quite a few languages into Python code (Dec noted that Ruby must have some support for this, given that most Gems are written in C, but was not so clear on the details).

There were some other questions about comparing each in terms of longer term maintainability, in terms of whether they were really well thought out systems for their problem space or whether they brought a lot of legacy baggage thinking, whether runtime performance was such a critical issue and more, but I didn’t get to capture all of these points.

Joe summed up by noting that the best web framework for you is almost certainly the one your are most familiar with – this will enable you to get stuff out the door most quickly. That said, it is useful to have awareness of the pros and cons of other technologies. Of the technologies discussed, Python is probably the most general in terms of how it is used – for web development, it has a rich set of web frameworks which is both good and bad; Ruby on Rails is a very well designed system for web development and can do most things very well, but might lack some of the more esoteric functionalities that exist in Python land; node.js offers the possibility of writing front end and back end code in the same language and achieving high performance, although it is still in its infancy and has many limitations when compared with the others.

While the session was pitched as a battle, there was never going to be any single winner – the purpose of the discussion was to explore the strengths and weaknesses of each of the different solutions and I hope that the folks walked away from the session having obtained some greater handle on this.

I had promised to talk about Google Developer Days in Berlin, but as the panel discussion had a bit of momentum, we decided on the fly to keep it going and drop the GDD talk – for anyone who is interested, the slides I had prepared are here and I wrote a blog post on it here.

There’s nothing lined up for the last Tuesday in December as it’s a bank holiday – we might do something small between Xmas and New Year but it’s less likely than more likely.

Sam Dutton will be with us at the end of Jan to talk about Chrome Development Tools.

We’re working on getting the video from this session online – will tweet when this is ready for consumption.

Dublin GTUGgers attended the Google Developer Day in Berlin – here’s a short note on what went down…

A couple of us got to Berlin early and attended the Berlin Hack & Tell event a couple of days before the main gig. We got there a little late, so we missed some of the coolness. We did see a couple of great demos – two that spring to mind were the OpenGL abstraction layer which supports transmission and remote rendering of OpenGL over Wifi and enhancements to GWT to support mobile in a way that makes the GWT app look like a native app. The former enabled OpenGL content on a mobile to be streamed to a remote embedded device which had a HDMI interface and be displayed on a screen – it supported multiple screens and multiple device types (Android and an N900). The latter project supported development of client side app in Java, conversion to Javascript with GWT and display with some CSS appropriate for the platform to make it look like a native app – we saw a cool demo of the functionality on an iPhone which looked very like a native app.

The Bootcamp was on a day before the big event, but we had not booked tickets for this, so we missed out…have to make sure we’re signed up to this next time!

The main day itself had a keynote followed by 5 parallel sessions. The keynote started off with a review of the evolution of the internet, noting how it has taken such a short time to have such a profound impact on our lives. It highlighted the recent focus on cloud computing and how it is causing significant change in the industry. They touched on growth in the Android platform – it’s now installed on 200m devices – and some of the new Ice Cream Sandwich capabilities were demoed. They talked about the rapid developments that are taking place with Google+ and demonstrated some of the functionality of the new Hangouts API.

After they keynote, the day was divided into 5 tracks: Android, Chrome/HTML5, Cloud, Google+ and interestingly there was a university track in which TU-Berlin and the Humboldt University were invited to demonstrate projects they were working on.

It was not possible to attend all the talks, obviously, so here are some interesting points/observations made from some of the talks I attended:

From the HTML5 offline talk

in germany ‘modern’ browsers account for over 80% of browsers used – this means that most HTML5 apps should work on a large majority of browsers;

offline support for HTML5 is evolving – basic offline access is supported on most browers, but more advanced features such as the FileSystem API are not so well supported yet

chrome differentiates between offline apps installed via the webstore and apps not installed via the webstore – more resources can be given to the former

there are some nice tools available to help package apps for offline use

there still needs to be work done to support easy syncing of data between offline and online modes of operation

From the talk on Dart

Dart was designed by a lot of folks who were involved in designing V8

it brings in ideas from other languages, but has nothing which is really new (smalltalk, erlang, strongtalk…)

the main objective is to ensure that the code running in JS performs about as well as native JS code and the code running in the native Dart VM should run better – right now the native VM grossly underperforms JS, but they expect that to improve quite quickly

a question was asked about the relative merits of Dart and GWT – despite the fact that the presentation was quite slick and interesting, there was no strong answer with respect to this issue

From the Google TV talk

much of this talk focused on highlighting the differences between designing for the TV platform and other platforms (mobile, tablet)

it was interesting to note that the information density on the tablet can be higher than on the TV despite the latter’s much larger screen size

a key issue with designing applications for TV is ensuring that navigation around the app is natural – if the user is controlling the app via left, right, up, down controls, the application components need to know their position relative to other components on view

Google TV is rolling out now – while the amount of TVs was not made clear, the percentage of TVs sold with internet connections was noted

From the ignite talks

it was difficult to catch the idea of all of the ignite talks – here’s a few that stuck in my head

one of the guys developed a simple rain predictor application which took information from various weather information providers and the user’s location to estimate when rain was likely to occur in future

one guy developed an application for cycling in the alps – routes, information on what to bring, distances, places to stop, etc – he’s evolving this into similar apps for walking in the alps, climbing in the alps, skiing in the alps, etc

there was a nice talk on a system called liquiddemocracy which supported flexible means to manage voting: votes on many issues are cast and it is possible to delegate your votes to different parties; this could be done on a per topic basis, for example.

After the talks, there was the usual networking session – unfortunately, I couldn’t stay around to do much networking.

All in all, it was a pretty good event. The event is focused on enabling Google to talk to developers that use its platform: as such, it’s not a place where there is a lot of new information shared. However, it’s a good place to learn about how the technologies are evolving, to meet the Googlers and to meet some of the folks who are working within the Google ecosystem.

Would I go next year? Yes, I think so – of course, it’s nice that it was organized in a city as cool as Berlin where it was possible to enjoy a hard earned Köstritzer black lager (sounds crazy but it is damned nice) after full day of tech talks.

The October meeting was a little less intense than some of our previous meets. There were two items on the agenda, both talks: one was a longer talk focused on Go and the other was a shorter talk describing an application.

Balazs Lecz, a Google SRE, gave a talk on Go. Balazs gave a very nice talk covering the motivation for the language, the key features of the language and covered some of the tools. Balazs talked about the interface features (and divergence from classical object oriented thinking), functions as first class objects and the concurrency features. Following the talk there was quite a lengthy Q&A session which reflected the level of interest in the audience. Questions were asked about the efficiency of the language – it generates code which executes in 1-2x times C/C++ code – and the main benefits of the language – there is no single big advantage to Go; rather quite a few smaller ones, which in aggregate make it a reasonably compelling proposition. [Slides here].

Following Balazs’ talk, Conor Gallagher gave a talk on a web based python IDE he’s working on for a Master’s project. The project focused on how to build an easy to use web-based IDE for python appengine projects – the objective was to support github integration as well as easy appengine deployment. One interesting aspect of the project was the range of technologies he used to construct it: GWT and the Javascript EditArea editor for the frontend, Tomcat for the backend (hosted on EC2), JGit for github integration and used the python appengine deploy scripts for pushing to GAE. The project is not complete yet and needs to be augmented with lots of extra functions to be a real working system, but it is not so far from being a simple teaching tool right now. (Disclaimer: I’m involved in supervising this project!). [Slides here].

The video for this session should be on the channel real soon now. Will update this with link when ready.

Next meeting on Nov 29th will have a panel session entitled ‘Battle of the Backends’ in which we will have a religious war over Ruby on Rails, Python (and its various web frameworks) and node.js – it should be good fun.