Full Stack Fest in Barcelona: the capital of web development
When you look at the list of programming conferences, there is usually a clear distinction between the front and back-end oriented – but it’s not the case with Full Stack Fest. Organised by Codegram, it merges 2 conferences: Barcelona Ruby Conference and FutureJS with a day of workshops and hackathon in between. This special event was the reason why Maciek and I visited beautiful Barcelona at the beginning of this month. For me, Full Stack Fest was the longest programming conference in my career, and I was really curious how it will be – conference time is usually really intense, and 5 days seems pretty much time.
Talks were very diverse and the schedule was well thought – there was a mixture of strongly technical talks, with lots of code examples and less technical talks, focusing either on soft skills, managing development process or other areas that could be inspiring for software developers. The conference’s schedule was divided into blocks of 2 talks. Between every block, there was a coffee break, breakfast or lunch – great opportunities to meet other participants. Apart from delicious food, there were plenty of coffee and drinks. Between the talks, Liz Abinante did a great job as a master of ceremony, providing necessary information and preparing the audience for talks. I really liked the sequence of talks – I think it helped to maintain a better level of overall focus by providing a variety of stimuli. The beauty and relaxed atmosphere of Barcelona helped us rest in the evenings so that the next day we could wake up ready to dive in the next portion of code.
The very first day of the conference was the most intense, but also the most interesting for me, so I decided to write about it in details. It started as usual with a Ruby celebrity – Yukihiro Matsumoto, this time revealing ideas on Ruby 3.0. He shared a lot of inspiring thoughts – he is a language designer, and he encouraged all the programmers out there to be language designers as well (after all, in the process of writing code we encounter design issues). He also told about improving thread safety, a need for more abstract concurrency model, and presented stream model – you can take a look at the prototype here.
After a short break, we had Bryan Liles from Digital Ocean advising on the choice of development strategy. While comparing deployment environment, he used a metaphor of pets vs. cattle. Pet requires help when it gets ill, and there’s only one instance of it while cattle have many identical instances. If something goes wrong, they can be easily replaced. How to recognise the type of your current strategy? Well, if you need to ssh to your server to see logs, then you probably have a pet, not cattle. He also presented a couple of ways to make logs more accessible – mentioned https://getsentry.com/welcome/and http://prometheus.io/.
Then we had a pleasure to listen to Eileen Uchitelle, who is a Rails contributor and shared with us her experience while trying to speed up Rails integration tests. She bravely took on the topic of measuring tests’ performance, which can be a difficult task – there is a number of benchmarks and profiling tools to choose from, but their output is usually difficult to read and compare. However, it’s worth trying – thanks to benchmarking we can investigate the most time-consuming parts of the code, and significantly improve overall performance. She showed us how to use these tools and recommended to do it in every project.
After lunch, there were two interesting talks focusing on the protocol and related issues. The first one was by Aaron Patterson, and apart from providing us with a serious dose of humor and photos of his gorgeous cats, he told us about Rails request and response lifecycle, what is wrong with it, and how HTTP/2 could make it better. It introduces a lot of interesting concepts – for example, instead of 4 – 8 in HTTP/1, there’s only one connection – this way, we can track what has been pushed. And since we usually have plenty of assets in our apps and want a fast development environment, this sound promising. One concerning issue is the compatibility, as HTTP/2 is pretty revolutionary. The good news is that they’re planning to focus on backwards compatibility.
The other talk, presented by Aaron Quint focused on improving how the app communicates internally, and externally. The default choice for many developers is JSON, and in the beginning, it work very well indeed. It always starts small, but with time it’s becoming more and more complex and difficult to handle. He showed us a neat solution developed by Google – protocol Buffers described as language and platform-neutral extensible mechanism for serializing structured data. How does it work? You need to define the schema, a proto-format – it has explicit types and it deals with repeated fields, nested types and optional/required fields. It handles removal /addition of fields easily, but the output is not human readable. He also mentioned GRPC – a mobile and HTTP/2 first framework developed by Google using buffers – and TCPEZ – protocol and client-server implementation for a request/response TCP Server, where the client is the load balancer. The last solution has been in prod for 2 years already! The moral of the talk can be sum up in one sentence: don’t accept the community defaults without checking out the alternatives.
Another break, a bit of networking, and finally long awaited talk by Sandi Metz. She started with a little story about the past when she published the book which made her finally quit the job in order to teach people. He topic was null object pattern, the active nothing. She described her approach to software development in four statements: infected by smalltalk (it was her day job for 12 years!), condition aversed, message-centric and abstraction seeking, then explained all of them in details. With more and more slides, she was revealing why using inheritance is not always a good idea and that it’s made for specialisation, not sharing code. She suggested making classes more alike, isolating the thing that varies and thus showed how composition and dependency injection are correct abstractions in this particular case.
The first day was closed with Rin Raeuber’s talk on the artificial intelligence and neural networks. She presented some basic ideas behind these terms, starting with biology, and then jumping to computer science perspective. She showed simple calculations and how learning with back propagation works – how we choose training data, adjusting weights etc. We also got to know what is the good use of neural networks – pattern recognition, filtering out the noise, signals processing.
The second day of Baruco was very interesting as well. It started with a talk by Yehuda Katz showing how a naive Rust implementation of a Ruby gem beats the performance of a hand-tuned C version. Then we had Nell Shamrell talking about responsible refactoring – how to distinguish necessary changes from cosmetic ones, and how to evaluate the risk of starting a refactoring session. After the breakfast, we had an inspiring talk delivered by Ernie Miller about the history of building skyscrapers being a metaphor of software development.
Another talk presented by Piotr Solnica was about blending object-oriented and functional approaches. He started with describing his past – as many people from Ruby community, he started with PHP, found Ruby on Rails, and after initial enthusiasm realised it doesn’t work that well when the codebase grows. He told us about functional objects – immutable, having ‘call’ method and no side-effects. In his approach, immutability is a virtue – that’s why he advised to get rid of mutable objects – it is a mind shifting change, the objects must be ready as they can’t be changed later. Functional interfaces built as consistent and side-effectless are a great foundation for higher level OO abstractions.
After the lunch, there was a talk with a live programming session introducing lambdas in Ruby by Corey Haines. Then we heard a talk by John Cinnamond inspired by Sandi Metz – extreme object-oriented Ruby and learned why we shouldn’t try to create pure OO languages. The last talk of Baruco was presented by Laureen Scott and it mixed programming with poetry. I had no idea they have so much in common! For example, there are some specific constraints in both, white space or a semicolon matters in these two things, it can change everything. Also, “say a lot with a little” applies to both fields.
Both me and Maciek decided to attend React.js workshop, held by Erik Wendel and Kim Joar Bekkelund. It was a well prepared, interesting workshop, focusing on understanding the basic concepts of React, and how it really works. At first we got familiar with the theory behind React (they made a cool presentation, explaining it all!) and then jumped to practical challenges. Starting with these small exercises made us better prepared for the actual task – creating a real-time monitoring app for Twitter. We didn’t have to bother with setting up the API access for Twitter or Google maps, and we could focus on getting to know React. Erik and Kim were really helpful and gave thorough, satisfactory explanations. If you want to start your own adventure with React.js, the instructions are public. Go and try it!
FutureJS was even more diverse than Baruco. It was started by a great, informative talk by Rachel Adrew talking about the business of front end development. She started with going back to the beginning of her work, and describing how the web development was changing throughout the time. She expressed fear that due to our reliance of frameworks, we will stop pushing for better solutions. She stated that people should still value old-school fundamentals of web development – to be able to sit with a server and build a simple website. Let’s not become single tool experts! Rachel also presented her ideas on how should a web product be built – it should start with core experience to build progressively enhanced websites.
Functional programming was present in this part of the conference as well. At first, Massimiliano Mantione made an introduction to transducers – functions that take transformation and give another transformation. On the second day, Stefanie Schirmer gave a talk on the basic functional programming concepts, using cooking metaphors.
There was one presentation which clearly stood out. Ben Foxall elaborated on the Internet of Things – he said that web browsers can do much more than just presenting the content. He presented a really impressive demo – an app which investigated various parameters of devices connected to the given URL (battery level, location, device orientation, touch, light and other). Then, after determining the position of every device, he played a sound of singing birds on every device – suddenly, the conference room filled with sounds of the jungle!
Another very impressive talk was delivered by Steven Wittens. I think he presented the best maths visualisations I’ve ever seen – he focused on showing various image transformations (sampling, bilinear filter etc.) and different pixels representations. All presented on interactive, moving models, which brought a lot of applause.
Mikeal Rogers from Node.js Foundation spoke about developing Node.js, and what problems did they encounter while working on it. There is a huge ecosystem, but in 2014 they found themselves in a crisis, as there was no community focus on developing Node’s core, and no collaboration on standards. He described their need to work out a better process, and that it should be participatory, efficient and transparent.
I must say that I’m a big fan of Baruco. Last year’s conference was awesome (see Tomek’s recap), and it was the same this year with Full Stack Fest. Again, chapeau bas to the organizers – I had an impression that they had a backup plan for every possible thing that could go wrong. They reacted quickly when one of the talks violated the code of conduct and did the same when live captioning problems arose – found an awesome replacement in no time (see this post). Thank you for a great conference, and see you next year!