The organiser is a tech start-up based in Shoreditch, called Geckoboard. Geckoboard chose to host the event after publishing a study earlier this year in which more than 300 start-ups around the world were surveyed.

Their research revealed that most start-ups struggle when it comes to making sense of data, and acting upon it. 49% of the respondents do not feel confident about the metrics they are currently monitoring. Based on analysis of data gathered in the report, this group is also less likely to have processes in place to ensure that data is understood and acted upon. There is a clear need for entrepreneurs to understand how to make better-informed decisions.

Paul Joyce, Geckoboard CEO, was already familiar with the authors of Lean Analytics, and seeing the relevance of the book to the current challenges that start-ups are facing, organizing an event with authors in London was an straightforward decision.

The Lean Analytics workshop is targeted to entrepreneurs, founders, growth hackers and analytics professionals in the UK, especially in the tech industry. The workshop will cover the foundations of Lean Analytics, in combination with live case studies where early stage start-ups will be invited on stage to share their data challenges with the rest of the audience.

This event is expected to be intense, and to leave participants with a wide variety of techniques and best practices that can be applied straight away.

In a world where data is becoming one of the most valuable resources, understanding how to make informed decision can make a huge difference.

If you would like to take part, you can book your ticket here.

Take advantage of a 25% discount off the price of the conference when you register with the code OREILLY here.

Starting Simple with a GET Request

Let’s begin by grabbing a list of the gists associated with my GitHub account (a gist is like a pastebin, if you haven’t seen one before):

The response is an array of the publicly-visible gists on my account, each represented by an array and including information about the user that created them (me). The documentation for working with gists using GitHub’s API is here:http://developer.github.com/v3/gists/ The file_get_contents() stream wrapper is by far the easiest and quickest way to grab content from a URL in PHP. There is so much more we can do with it though!

Write Operations with Stream Contexts

All the stream functions in PHP have support for a $context argument, which allows us to send more information about the stream we’re sending. For an HTTP or HTTPS stream like the ones in these examples, that means we can set the headers, verbs and body to send with our request. To try this out, we’ll create a gist on GitHub, and do so we need to be logged in. In API terms, that means we need to identify ourself when we make the request, and since GitHub uses Oauth2, we can just send a header containing a valid access token that I acquired by following their excellentation documentation which you can find at http://developer.github.com/v3/#authentication Our next request also needs to send some body data as well as auth information; this is the content for the new gist which we’ll POST to Github. We can set the verb, the body data, and the headers we need all in the context of the stream. Take a look at this example:

First of all I’m pulling in my access token from a separate include file (to avoid oversharing or having to revoke tokens). Then we set the URL and assemble the data we want to send. This will be different on different systems but I’m working off GitHub’s documentation for creating a gist: http://developer.github.com/v3/gists/#create-a-gist. Setting the context is probably the trickiest bit, and even then you can see the pieces clearly. Set that this should be a POST request, then give some extra headers; we set the Content-Type because we’re sending JSON in the body of this request (the GitHub API works only in JSON), and the Authorization header contains our access token so GitHub knows who we are. Finally we set the data we prepared earlier as the content for the stream. When the gist is created successfully, the response will give full information about this gist and its new URL, along with a 201 status code to tell you it was created (inspect this by checking the $http_response_header> variable). If the first code sample was run again now, we’d see a new entry appear in our list, and it’s also visible on the website: [gists.png] We can work with gists and other types of API data programmatically, and PHP is a great tool for this.

Going Beyond GET and POST

The streams solution is a more friendly interface than the more traditional PHP curl, and it’s equally powerful as we’ve seen in the examples so far. It can be used to make requests using any HTTP verb, the only requirement is that both client and server should understand it. For example, if we wanted to update the gist that we just created, then we’d make a request to GitHub using the PATCH verb. PATCH isn’t supported everywhere, but GitHub have adopted it as a great way of updating records, including partial records, and this is becoming more popular in RESTful services. Here’s an example of how we might do that using the stream context:

The changes are accepted by GitHub and the response contains the updated gist, in this case the script just changes the description field.

PHP and Streams

The streams extension is core to PHP and so it will always be available, making it a great choice for code that needs to be deployed to a number of platforms. The interface is simple and elegant, so as a developer it’s easy to work with while at the same time being completely configurable, allowing even the more complex kinds of requests as we saw here. Best of all, if you’re dealing with very large responses, you can handle them in segments rather than loading the entire response into memory, as well as getting all the other features of streams such as being able to filter them as needed. There are many ways to make HTTP requests from PHP but streams are definitely one of the best, combining power with flexibility.

Lorna Jane Mitchell is a web development consultant and trainer from Leeds in the UK, specialising in open source technologies, data-related problems, and APIs. She is also an open source project lead, regular conference speaker, prolific blogger, and author of PHP Web Services, published May 2013 by O’Reilly.

Flávio Glock Soibelmann has developed several CPAN modules for the DateTime Dashboard. He is currently one of the developers of Perl and Perlito is his main current project.

Perlito is an intriguing piece of technology capable of compiling Perl 5 or Perl 6 programs into various backends, currently including JavaScript, Python, Ruby and Go. It may be extended to other backends as the project is very active.

Perlito’s potential is very exciting as it is open to hacking extensions and backends, while also acts as a platform for experimenting with language semantics, optimizations and code generation. Aside from that research and develop aspect, it also bears a practical face for end-users, as Perl in the browser demonstrates.

Looking into the future and in the case that Perlito manages to implement the full language set, then it maybe would spearhead the reshaping of Perl’s landscape.

NV: So Flávio, you work for Booking.com in the code optimization sector?

FG: Yes, for about 5 years now.

 NV: What is this area of activity occupied with – code refactoring, experimenting with algorithms, tweaking Perl’s internals?

FG: It is mostly about identifying bottlenecks – and then fixing; we have some people tweaking Perl’s internals too, but this is not my area.

NV: So what is the motivation behind Perlito?

FG: Perlito started as a bootstrapping compiler for Pugs – we wanted to rewrite Pugs in Perl6. It was called “mini-perl6″ at that time. The plan was to support both Haskell and Perl5 as backends

I think the regex compiler for Pugs still uses mini-perl6:
http://search.cpan.org/dist/Pugs-Compiler-Rule/

This is the mini-perl6 source code for the module:

http://cpansearch.perl.org/src/FGLOCK/Pugs-Compiler-Rule-0.37/examples/Grammar.grammar

NV: Can you provide a short high level overview of Perlito’s underlying architecture or how does it work behind the scenes?

FG: Perlito has 2 compilers – a Perl6 compiler written in Perl6, and a Perl5 compiler written in Perl5

This is an old picture, but this is still pretty much how the Perlito compilers work:

Perlito

There is a grammar, which transforms the input text into a data tree (AST), and there is an emitter, which transforms the tree into machine-readable code. Other modules are provided to handle other more complex cases.

In Perlito5, the grammar is implemented as Perl5 modules which you an see here:

http://github.com/fglock/Perlito/tree/master/src5/lib/Perlito5/Grammar

The internal structure of Perlito6 is more “monolithic”, it needs some refactoring.  There is a third component, which is the Runtime.This is where the backend-specific features (and workarounds) are implemented – for example, the CORE module for javascript:

https://github.com/fglock/Perlito/blob/master/src5/lib/Perlito5/Javascript2/CORE.pm

NV: Perlito’s definition is : “a compiler collection that implements a subset of Perl5 and Perl6 “. Why a subset, what is left out and what cannot be done in comparison to the full-set?

FG: The plan is to support the full language, but this is not possible yet. Each backend supports a set of features; for example this file is a description for Perl5-in-Javascript.

Javascript does not support sleep(), for example. On virtual machines that do automated garbage collection, reference counting is hard and it is important to support DESTROY and automatic closing of file handles.  You can work around in most cases, but there is usually an impact on performance

There are several steps in the compilation. Perlito parses the code, and then emits code that will be executed by a specific virtual machine. In some cases, there is no easy way to generate specific instructions, it is a limitation of the backend

I’m currently working on the x64 backend, this is very low level and should have fewer or no limitations.

NV: From all the backends the show stealer is the Javascript backend which allows controlling the browser through Perl! What is the generated Javascript capable of, how far can it go?

FG: You can try it out at :

http://perlcabal.org/~fglock/perlito5.html

There is also a Perl6 version, but that is quite behind, because I’ve spent most of the past year working on the Perl5 compiler.

There are a few features specific to the js backend, such as

JS::inline(‘document.getElementById(“print-result”).value’)

This comes from the Pugs-js implementation.

The compiler supports perl objects, simple regexes, as well as more “advanced” features like tied arrays. There is also a more complete js backend, the ‘js3′ version – which emulates more closely Perl5 but that comes at a performance price.

The version that you see online has a reasonable balance between functionality and performance and is good enough to compile the Perlito source code to Javascript;that is how perlito5.js is built:

http://perlcabal.org/~fglock/perlito5.js

NV:  As an industry insider working for one of the biggest Perl5 advocates (if not the biggest) do you think that an organization of such a size would someday consider switching from Perl5 to Perl6?

When would the setting be mature enough for such a switch?

FG: It will eventually happen. At some point people will use it for one-off scripts, and then somebody will use it on a cronjob, but it will not replace Perl5 in this environment – it will instead compete with alternate languages, like Go.

NV: So what are Perlito’s potential uses for developers and end-users alike?

FG: The main product for end-users are the Perl-js compilers. They can be integrated in other projects, like azawawi++ did with the Farabi web-based IDE.

For developers there are a lot of possibilities. Perlito is pretty open to hacking, there are no hard coded limits

NV: Finally, what are your expectations for the future?

FG: The Perlito5::X64::Assembler package should allow for building an efficient, Perl-specific environment. At some point, if this becomes the main development platform for Perlito, we don’t need to work around virtual machine limitations anymore.

The other side of the Perlito development is to allow better Perl5/Perl6 inter-operation;there is already a Perl6-to-Perl5 compiler in CPAN :

http://search.cpan.org/dist/v6/

This is based on Perlito6. The plan is to finish the Perl5-to-Perl6 compiler, that would work about the same way as v6.pm.

For the full interview please follow Perlito – An Interview With Flávio Glock

Nikos Vaggalis has a BSc in Computer Science and a MSc in Interactive Multimedia. He works as a Software Engineer/Database Application Developer and codes in Perl and C#.

Opa just reached 1.1.1 today, and the little version increase brings in support for the Postgres database. This article explains how to move back from NoSQL to SQL.

Hello Migration

Suppose you have a minimal Opa app that uses the database:

    import stdlib.themes.bootstrap

    database mydb {
        int /counter
    }

    function page(){
        <h1 id="msg">Hello</h1>
        <a onclick={ function(_) {
            /mydb/counter++;
            #msg = <div>Thank you, user number {/mydb/counter}</div>
        }}>Click me</a>
    }

    Server.start(
        Server.http,
        {~page, title: "Database counter"}
    )

By default, when you generate the Node.js app with

opa counter.opa

and launch it with

./counter.js

it will run on MongoDB and displays a counter which increments itself when clicked.

To use Postgres as database backend instead of MongoDB, you just need to edit the database declaration to specify to the Opa compiler to use Postgres:

database mydb @postgres {
  int /counter
}

The app does not yet generate the ‘mydb’ database automatically, so before running the application, you need to create the database

psql -c "CREATE DATABASE mydb"

Then just run your app normally:

./counter.js

To specify database credentials you can run instead

./counter.js --postgres-auth:mydb user:password[a] --postgres-default-host:mydb locahost:5432

Digging into Complex Stuff

In our former example case, the database is limited to a single integer… But things get nicer when we store more complex datastructures such as lists, maps (the dictionaries in Python), records or any combination of them. Let’s generalize the previous example to have one counter per page, and create a homepage that aggregates a few statistics.

Let’s first redefine the database declaration to have one counter by page:

database mydb[b][c] @postgres {
  {string page, int counter, Date.date last} /counters[{page}]
}

In the above snippet, we declare a database set, for which page is the primary key. Switching from MongoDB to Postgres is again just about adding the @postgres keyword.

The next is to update the view, according to the new database declaration. The database update code becomes:

{ page: name, counter++, last: Date.now() };

that naturally sets the page name, with last seen updated to the current time and increments the page views. The database update is performed with a single request. The view itself is:

function page(name) {
  <h1 id="msg">Page {name}</h1>
  <a onclick={function(_) {
    /mydb/counters[page == name] <- { page: name, counter++, last: Date.now() };
    #msg = <div>{ /mydb/counters[page == name]/counter } page views</div>
  }}>Click me</a>
}

Let’s add another view to display a few stats. Basically, we want to show all pages sorted by last update where the counter is greater than 5. To specify the query, we use Opa’s comprehensive data syntax:

function stats() {
  iter = DbSet.iterator(/mydb/counters[counter > 5; order +last])
  Iter.fold(function(item, acc) {
    acc <+> 
    <div><span>{item.page}</span> <span>{item.counter}</span></div>
    <div>Last update:  {Date.to_string(item.last)}</div>
  }, iter, <></>)
}

Finally, we write the controller using an URL dispatch:

function dispatch(url) {
  match (url) {
  case {path: {nil} ... } :
    { Resource.page("Stats", stats()) };
  case {path: path ...} :
    title = String.concat("::", path)
    { Resource.page(title, page(title)) };
  }
}
Server.start(
  Server.http,
  {~dispatch}
)

In this example app, migrating from MongoDB to Postgres (or the contrary) requires almost no code change. If you want to come back to MongoDb just edit the database declaration by removing @postgres annotations or replace by @mongo. Even better, you can mix both database engines in the same application if you want.

In further releases of Opa, we will probably take runtime definitions into separate definitions and support a few platforms-as-a-service straight out of the box.

How it works: DbGen

The magic behind the previous example has a name: The “DbGen” automation layer. Unlike most ORM layers, DbGen as its name suggest is basically a code generation layer. DbGen generates queries statically, in a safe way that prevents code injections, among other runtime errors.

As Opa is a strongly statically typed technology, DbGen uses a database schema which includes type information from the program to validate queries statically. The information-rich schema is used to create the NoSQL data structure or the corresponding SQL schema. In our previous example, the schema declaration:

database mydb @postgres {
  {string page, int counter, Date.date last} /counters[{page}]
}

generates for Postgres a SQL table named counters that contains 3 columns, where the primary key is page:

CREATE TABLE counters(page TEXT, counter INT8, last INT8,  PRIMARY KEY(page))

Note that the generated SQL code is clean and the database structure can be easily used by humans, for instance in conjunction with admin tools. Opa also generates stubs to access the database. For example, the following data access

/mydb/counters[page == name]

is compiled as a pre-compiled Postgres query:

SELECT * FROM counters
WHERE page == $1

It’s efficient, and clean.

Wrap Up

Try it for yourself! Opa 1.1.1 which now supports both MongoDB and Postgres is available from the Opa portal. The source is available on GitHub.

All resources to get you started are available from the portal, and ask your questions on StackOverflow or our own forum. The best reference on Opa is the O’Reilly book, available from Amazon or directly from O’Reilly.

You might think that “things” have always been connected to the internet. Computers, mobile phones, even printers have been connected for years. A lot of the current talk and investment in Internet of Things is large sensor networks and taking information from our environment. What we at DoES Liverpool like to think of when we talk about the Internet of Things is a whole lot more personal and unexpected. How about a bubble machine that blows bubbles when people mention you or your business on Twitter? Or perhaps a clock or dial that instead of showing time or statistics shows where someone is? These are just two of the ideas that members of the DoES Liverpool community will be bringing to Internet World this month.

But first, what is DoES Liverpool? We are many things. We are an online community of creative and often tech savvy people, of tech startups and “makers”. DoES Liverpool is also a physical space. It provides a co-working office space for members of the community to hot desk from or to take a permanent desk. There’s also a shared workshop with lots of equipment available for use; traditional tools such as soldering irons and band-saws to the more modern digital fabrication equipment like the laser cutter and 3D printers. We also hold regular events on many topics from specific programming languages like Python and Clojure through to more business focussed events like Lean Liverpool and Saturday Startup Club. We have a great community coming up with some wonderful ideas, and we’re looking forward to showing some of these to you at Internet World 2013.

Adrian McEwen has been putting things on the Internet for many years. He led the team who developed the first full web browser for a mobile phone, and his code (he’s slightly ashamed to admit) made it onto the Amstrad Emailer. He was recently described as an IoT pioneer by Kevin Ashton, the person who coined the term “Internet of Things” in the first place! Adrian will be bringing two of his IoT inventions to Internet World. Bubblino, the aforementioned twitter activated bubble blowing machine, was actually one of his first IoT projects but is well loved at conferences around the UK and has now been sold to various people in the UK and Europe. The Acker’s Bell was a more recent commision to provide Liverpool Startup ScraperWikiwith a bell that would chime each time they made a sale. The mounting for the bell was designed and laser cut in DoES Liverpool with Adrian developing the software and electronics. Usually living in ScraperWiki’s office in Liverpool the Acker’s Bell will be visiting London for you to see at Internet World 2013

With another DoES Liverpool co-founder, Hakim Cassimally, Adrian has spent the last year writing the definitive IoT book – Designing for the Internet of Things. Both Adrian and Hakim will be available to discuss their book and IoT in general, and of course you can pre-order the book on Amazon!

Inspired by the clock owned by the Weasley family in the Harry Potter books, the WhereDial provides a delightful way to make a personal connection with a family member or friend. The WhereDial is made from laser cut plywood or colourful plastic and features a list of location categories around the dial. Through the cloud based location aggregator –MapMe.At – the WhereDial can retrieve a person’s location from FourSquare, Google Latitude and a variety of other services. It then rotates the dial to show where the person is. It’s a great device for people who are less comfortable using mobile phones and computers but is also a really handy glanceable object that fits nicely on the desk of a technophile too. The WhereDial was designed and is built in Liverpool by John McKerrell, also a co-founder of DoES Liverpool.

Perhaps saving the best for last, the final headline item that we’ll be bringing to Internet World 2013 is the Good Night Lamp. Darling of CES and Gadget Show Live, these lamps have a superstar team behind them. They are the brainchild of Alexandra Deshamps-Sonsino, previously a co-founder of smart product design studio Tinker London and the organiser of the monthly Internet of Things meetups in London. She launched the Good Night Lamp as a startup a year ago by committing to taking a booth at CES; 10 months of development later and with a live Kickstarter campaign garnering much publicity she took CES by storm. Her team includes our own Adrian McEwen as CTO; John Nussey as Head of Products and interior designer & architect Konstantinos Chalaris as Lead Designer.

We really hope you will enjoy our exhibition and go away inspired, potentially with some ideas for an IoT product of your own! DoES Liverpool is all about inspiring people to start interesting businesses and while our focus is in Liverpool, we know that IoT is going to take off around the world!

• the tarsier book (Learning the vi Editor) 
• the llama book (Learning Perl)
• the camel book (Programming Perl) 
• the polar bear book (Information Architecture for the World Wide Web) 
• the Rhino book (JavaScript: The Definitive Guide)

etc.

At conferences, our animals are very often the opening topic of conversation at the booth. A question I am always asked is “What are you going to do when you run out of animals?” or “Why do you use this animal?” I listen to some very funny conversations -

- Why do you use a bat on the sendmail book?
- because sendmail sends you batty.

or

- Why do you use a camel on Programming Perl?
- because a camel goes a long way.

Right or wrong, it does not really matter. What matters is that people are talking about our books as a great source of knowledge. But… what happens to the animals? So please listen to Edie Freedman, the O’Reilly Creative Director.

“When I designed the first Animal covers for O’Reilly, I had no idea how popular the animals would become; 25 years later, the brand continues to flourish. Unfortunately, the same is not true of the real-life animals whose images appear on many of the book covers.”

Our books have been there to help you achieve your dream career but during that time, gloom has descended on our animals, and many are now critically endangered. Conservationists are in desperate need of people with your tech expertise and O’Reilly hope to help by putting you in touch with them. Please read on and find a way to help our animals so that our future society can benefit from them.

There are many ways to get involved:

• making donations to conservation organizations 
• volunteering your time in the field and/or bringing your technical expertise to bear on the problems
• using technological expertise to track populations, detect poachers and help the conservation organizations achieve their goals.

On The O’Reilly Animals, you will find all you need to help.

Please follow us on Twitter, @OReillyAnimals, retweet and spread the word!

Thinking Digital Announces Speaker Line up for 2013 (Monday 18th March)

21st -23rd May 2013 sees the 6th annual staging of the Thinking Digital Conference at the Sage Gateshead Music Centre. Over the years Thinking Digital has built a reputation for attracting the best thinkers and speakers from the around the world to Tyneside.

For the 2013 Conference, our first speaker announcement includes..

• Aza Raskin – the co-founder of the Massive Health startup that was recently acquired by Jawbone. Aza was formerly the design lead for Mozilla. His father, Jef, started the Macintosh project at Apple in 1979.
• Mike Bracken – formerly the Digital Director of Guardian News & Media, Mike was named the Director of Digital for the Cabinet Office in 2011. He leads the Government Digital Service (GDS) which aims to make the government’s digital presence much easier to find and use. His team has led the launch of the GOV.UK portal.
• Jack Andraka – is a 16 year old scientist who won the 2012 Intel Science and Engineering Fair for creating a pancreatic cancer test that is estimated to be 168 times faster, 26,000 times less expensive and potentially almost 100% accurate. He’s spoken most recently at the TED Conference in Long Beach, California.
• Maggie Philbin – the former presenter of the BBC’s Tomorrow’s World and current presenter on BBC One’s Bang Goes the Theory, Maggie is a very well known face for UK science and technology enthusiasts. What’s less well known is that Maggie’s a Director of TeenTech which she co-founded with IOD Chairman, Chris Robson. TeenTech is busy inspiring Tomorrow’s Generation of young scientists, engineers and techies.
• Horace Dediu – was declared “the new king of Apple analysts” in 2010 by Fortune Magazine. While most of his competition come from richly resourced firms such as Morgan Stanley or Credit Suisse, Horace’s analysis is completely independent and self-financed. Horace’s Asymco blogs and charts on the smartphone and personal technology market  have built him a huge readership.
• Karen Dillon – was until recently the Editor of the Harvard Business Review. She left to co-author How to Measure Your Life alongside management guru Clayton Christensen.
• Ed Parsons – was the very first CTO of the Ordnance Survey in its 200 year history. He is now helping define the future for Google Maps as their Geospatial Technologist.
• Dr. Sue Black­ – rose to fame helping spread the word to save successfully Bletchley Park, home of the world’s first programmable computer and the epicentre of the UK’s WWII codebreaking efforts. Currently, she is very active in helping encourage more women into technology.
• Aral Balkan – a well known and liked experience designer who was recognised by Microsoft and .Net Magazine as one of the top speakers of 2012.
• Alexa Meade – an American artist who has innovated visually stunning technique for painting directly onto live models in 3D space to make them look like 2D paintings.
• Graham Hughes – this British filmmaker recently completed a four year journey to every country in the world without ever once resorting to an airplane. His exploits have earned him a show on the National Geographic channel and a place in the Guinness Book of World Records.

The full roster of 25 announced speakers is available here.

Tickets will remain priced at ￡225+vat until Thursday, 28th March.   More information.

The Founder & Director of Thinking Digital 2013, Herb Kim, said, “Thinking Digital has built a reputation for attracting the world’s best thinkers and speakers. We are genuinely blessed  to have such a roster of rock stars make the journey from around the globe to Tyneside in May for Thinking Digital 2013. We look forward to creating a fabulous experience for the entire Thinking Digital community.”

There were two exhibition areas: upstairs and downstairs. Thanks to Grzegorz I had a privilege spot next to Atlassian. Our area was very lively with Luxoff, the composing software people that demonstrated their stuff and invited public participation. You guessed at times it was a little too lively or shall I say plain noisy. Unfortunately I did not manage to go to the second exhibition floor, all I know is that JetBrains was there…. And with JetBrains comes Hadi Hariri. Hadi has the most wonderful personality – he has the knack to make me laugh. Like a lot of funny guys, he give the impression that he does not care but behind the curtains he is pretty scared even though he puts a lot of time preparing his presentations. On the last day, he invited me to listen to his keynote – Developers: Prima Donna’s of the 21^st Century. You can see a resume of his talk here.

Other speakers included some of our authors:

. Venkat Subramaniam who wrote the bestseller of this conference  – Programming Concurrency on the JVM.  Venkat mentioned that he is writing yet another book on functional programming and Java. The book is not going to be available for a long time as he awaiting the latest release of the software.

. Oliver Gierke, co-author of Spring Data.

. Tim Berglund co-author of Building and Testing with Gradle.

I also should mention Dan North who gave several talks and did a great job explaining me what MapReduce means . I think I got it at the time but I slept since and it is gone. Next time I will write it down.

As you can see, the 33^rd Degree conference brought together a great bunch of speakers who delivered timely information on the latest developments.

…but what do I think of Warsaw?

COLD! I suppose I should have expected it since most of Northern Europe suffered heavy snow showers that week.  As previously mentioned the conference was near the airport so no chance of seeing the town. So on Saturday afternoon, I took the 175 articulated bus and ended up in the Old Town. I was told that 85% of the buildings in Warsaw were completely destroyed during the 2^nd World War. The Old Town has been painstakingly completely rebuilt in the old style. It is just beautiful. I would very much like seeing Warsaw in the Summer with its spacious squares and lots of trees. Unfortunately I saw only a little of Warsaw –

• Copernicus statue
•  the University
• The University Library
• the Royal Palace
• the cathedral
• the Vistuala (never walk near a river when it is cold)
• the monument celebrating the 1944 Warsaw uprising.

As you can see one could spend a few more days there exploring the town architecture, history, arts etc. Unfortunately it was too cold to go and see the Chopin statue in Łazienki Park. That will be for another trip.

Yes of course, Poland was part of the Eastern block and some of the features of that time are recognizable such as the Palace of Culture and Science and of course the large blocks of flats.  Here the blocks have been painted! Would I go back? Yes, but in the Spring or Summer.

• Maximiliano Firtman – it was Maximiliano’s second visit to QCon. He is the author of the forthcoming Programming the Mobile Web, 2nd Edition (due in April) and jQuery Mobile: Up and Running.
• Ian Robinson, Jim Webber and Savas Parastatidis – the 3 authors of REST in Practice, 1st Edition, together for the first time in a long time. Ian and Jim have also written Graph Databases due in June but already available here as an e-book.
• Russ Miles, author of some O’Reilly classics and allegedly writing a new book, Programming Spring, due in November.
• Damian Conway – most of you know Damian as a prominent member of the Perl community, author and presenter. I was lucky enough to attend his “Instantly Better Presentations” keynote. Damian captures his audience very quickly and holds their interest 100%: not only does he educate them but entertains them for 50 minutes. In this talk, he explores seven simple and effective techniques to help us achieve great presentations. It all sounds so easy when Damian is presenting, but one should not forget that he spends hours and hours preparing one talk.
• Francesco Cesarini who wrote Erlang Programming. I believe he is now working on another book on Erlang.

Unfortunately, I was unable to meet Arun Gupta (Java EE 6 Pocket Guide) and Mike Amundsen (Building Hypermedia APIs with HTML5 and Node) who were also speakers. I am sure we will meet somewhere in the future.

Delegates came from all over the world, as far as Australia, Mexico etc. One of my little games is to look at the name badges or listen to the accent and try to figure out where the person come from. I usually get it wrong but I suppose that’s the reason I keep trying.

Off to 33rd Degree Conference in Warsaw!