Railsberry 2013

The Railsberry 2013 conference took place in the nice old tram depot in Kraków. After last year's conference earned a good reputation and the company I'm working for sponsored this year's conference, I got the chance to attend this conference. It lasted for two days (with sponsored parties in the evening ;-)), and nearly 500 attendees travelled to Kraków.

The first day:
The conference started with a decent keynote by Chad Fowler about not getting stuck, but staying curious and keep on experimenting. Experiments lead to data-driven decisions and more confidence. BTW, he used tpp for his presentation - which was an experiment for him.
That one was followed by an entertaining talk by Fred George about a measurement system that helps you understanding how agile you/your project/your team/your company is. He uses categories like who can deploy, how many tools you use, how are your processes defined, how many deployments you perform etc. and adds or subtracts points from your score depending how agile you are in each category.
Then Eric Redmond talked about distributed patterns like consistent hashing, PubSub, vector clocks - concepts you also find in Riak.
After that Agnieszka Figiel talked about common table expressions and windows functions in PostgreSQL and showed applications within the field of the animals's taxonomy system.
Followed by Mathias Meyer and his talk about about message queuing systems and their basic concepts and patterns (task lists, PubSub). He also dealt with capacity planning, error handling in message queues (drop vs. retry) and building an API around a queue.
After the lunch break Elliott Kember talked about bridging the gap between native MacOS applications (mostly written in Objective-C) and Ruby applications.
Alex Koppel's talk was about the consequences of sleep deprivation - which is quite wide-spread among IT people. So, being short on sleep over a couple of days impairs the brain function significantly, and you can't catch up even if you sleep all the weekend long.
Chris Kelly talked about some object-oriented design pattern (separation of concerns, DRY etc.) ending up in some ideas about how REST APIs should look like.
The first day's track of regular talk was finished by Joseph Wilk. His topic was creativity - human creativity and machine-based one. He also showed some computer-generated sounds and haikus based on mathematical functions, generational algorithms and fuzzy logic.
The first day closed with lightning talks. Topics presented in a 5-minute timeframe were Extremist Programming, Rails Girls Summer of Code, RVM, Wagons, CSS Outlines, GitLab, SmartProperties and Cloud Foundry - all very entertaining.

A site note: The team of designers who are responsible for the conference's design also designed underwear - here you can get an impression about them.

The second day:
The next day started with a talk by Geoffrey Grosenbach about the art of coding and its continuous improvement - tools and their customization, workflows, processes, habits, re-thinking. And: Learn from others!
So, the following talk by Gregg Pollack was some kind of a perfect match for the talk before. Gregg talked about e-learning, its motivation (e.g. save costs, learn at your own pace), what its makes special (e.g. diversity of communication channels, collaboration, instant feedback) and what it's heading to (e.g. more interaction, gamification). He also showed a bunch of e-learning platforms. BTW, give VIM Adventures a try.
After that Katrina Owen talked about testing code. There is no doubt about that tests are needed, but often not the behavior is tested, but the implementation itself. She introduced a schema about how to decide when to test what with the help of assertions, mocks and stubs.
Then Paolo Perego gave a talk about web penetration tests based on the OWASP top 10 including detection of entry points on different layers and how to use some Ruby code to automate this.
As Ben Orenstein couldn't make it to the conference, his talk was substituted by a session of power posing lead by Chad Fowler - fun.
After the lunch break Marcin Bunsch & Antek Piechnik talked about the current trends concerning mobile devices, handling users changing their online status from time to time, data gathering and natural interfaces of apps.
After that Andrew Gerrand gave a good introduction into Go with some examples and demos.
Then Keavy McMinn talked about internal tools to increase transparency, team happiness and productivity.
The final talk was held by Felix Geisendörfer. He introduced the NodeCopter community, a sort of hardware hacking project, including some really cool live hacking for controlling a drone. He also mentioned the Summer of Drones.
And again, this day also closed with lightning talks, but this time with a timeframe of just 3 minutes: Shoes, Makerland, Teaching Ruby Basics, HackKRK, Using Instance Variables in Views, Reading Files In WebApps, Just Ruby (The Extremist Programmer Way), Mehackit, eurucamp, Rails Security Releases, application performance in general, Media Queries for Sass and Tropo/GeeksWithoutBounds.

Coursera

Some time ago a colleague had the idea to take an online course at Coursera, and he asked me whether I'd like to join. So I did. We've chosen a course called "Programming Languages", which focuses on functional programming and introduces ML (namely Standard ML of New Jersey), Racket and Ruby.
It's over a decade, since I've learnt and used functional programming on a day-to-day basis. Now, that the first week is over and the first homework has to be submitted, I really have a positive impression: The sections are split into small pieces and can be consumed on your own pace, the material is quite extensive and the lecturer is really decent - plus a users' forum and reasonable homework.
So, I can really recommend this online course.

DynamoDB & Ruby

I played around with DynamoDB and Ruby and put down a small sample. Here is what you need to run this sample:

1. Get yourself an AWS account. The access key id and the associated secret access key are to be stored in a YAML file called aws_config.yml with the following format:
   access_key_id: <your access key id>
   secret_access_key: <your secret access key>
2. The AWS SDK for Ruby: Download and extract.
3. A Ruby interpreter: The SDK requires Ruby 1.8.7 or later - I've run this sample with Ruby 1.9.3.
4. Store the sample in a local file within the same directory as the YAML file and make it executable for convenience. Maybe you have to change the location of the AWS SDK for Ruby in line 5.

Here's a shot short outline of what the sample does:

1. Setup the load path and load some required files.
2. Create two tables, if they do not already exist - one with a hash key and one with a hash key and a range key. The sample waits until the tables have left the creating state.
3. Create some items within these two tables. As DynamoDB is schema-less, you are free to store any information within these items - except for the keys you've defined, they are mandatory.
4. After counting the items, a query and a scan is performed. A query uses the defined keys to return items, a scan runs through all items of a table.
5. Wait 20 seconds and delete the two tables. The sample waits until the tables have left the deleting state.

It is notable that in DynamoDB tables take some time to be created and deleted. The sample takes this into account. You can watch the current state of your tables using the AWS console.

eurucamp 2012

This weekend the eurucamp 2012 took place in Berlin in a hotel located directly at the lake Müggelsee. On Friday, there were also the JRubyConf EU and some workshops, while the talks were held on Saturday and Sunday attended by approximately 150 persons. On Saturday:

1. Sinatra in 8 Lines: A really entertaining and not so serious talk about code obfuscation with Almost Sinatra as an example.
2. ZeroMQ: Scriptable Sockets: An introduction into ZeroMQ and communication in distributed systems in general. Here you can find examples of concepts and usage patterns.
3. Slanger & Data Warehousing: About WebSockets and the message and subscription model of Slanger.
4. Ruby on the Command Line: Tips and tricks concerning Ruby command line scripts, e.g. Trollop for command line option parsing.
5. Writing a Rails Engine: A brief history of Rails evolution and an introduction into creating Rails engines and plugins.
6. Do I need DI?: Some general remarks about software design, abstraction and modularization. 
7. RubyMotion: An introduction into Ruby on top of iOS including some demos.
8. A fishbowl discussion that started with SPDY and push and moved to Ruby refinements and operators in Ruby.
9. Idempotence as the holy grail of scaling: Functional idempotency as an important base for scalability.
10. Clean Documentation: A talk about testing your docs by reviews, using references to avoid redundant contents and README Driven Development.
11. Superheroes can do it and so can you!: An entertaining and interesting report about a project in Papua New Guinea to preserve the local languages by recording stories and songs with the help of a mobile app and a distributed synchronization infrastructure.
12. Living in the data mapping world: An introduction into DataMapper, an ORM, and an outlook of future developments.

On Sunday:

1. All you need is love: About art, motivation and passion as important support for creative work like software development, but also about analytic skills and discipline. Performed as a two-person discussion.
2. Complex Calculations Within a Web Request: A presentation about caching techniques and optimizing Ruby code for speed (including a demo of RubyJS).
3. Lightning Talks:
1. A short talk about mock objects.
2. A presentation of the RFID tracking system used at eurucamp.
3. A presentation of the book "Deploying with JRuby".
4. About how to extend an engine's views.
5. A short introduction of an RSpec-like test framework in Python.
6. Pros and cons concerning MongoDB (cons: fragmentation by deletion, BSON, sharding and the global write lock; pros: replication, schemaless, secondary indexes).
7. A talk about learning and training in general.
4. Create your own tools (and share them)!: A eulogy about open source and sharing tools.
5. Monolithic vs Distributed Software: No Holy Grails: Pros and cons of modularization and how to decide when to use or not.
6. When Not to Use Object-Oriented Techniques: A comparison between object-oriented programming and functional programming by example.
7. Polyglot Rails Applications in Rubinius: An introduction into Rubinius and the motivation behind it.
8. Off the Tracks - Challenging the Rails Mindset: Various recipes for Rails projects like using POROs (plain old Ruby objects) or decorators.

You can find additional information (including some presentation slides) about the talks here.
The conference ended with a gig of Nomataras.