Eleven topics for the London Ruby Unconference!

We have published on GitHub a Wiki Page for the London Ruby Unconference!

The Wiki Page can be edited by everyone to suggest topics to discuss on Saturday the 22nd of October.

The topics are varied and we may interview some of the people leading and participating in these sessions in future posts.

For the moment, we will introduce the subjects with a short description:

1. The Crystal Programming Language

The Crystal Programming Language has the following goals:

  • Have a syntax similar to Ruby (but compatibility with it is not a goal)
  • Statically type-checked but without having to specify the type of variables or method arguments.
  • Be able to call C code by writing bindings to it in Crystal.
  • Have compile-time evaluation and generation of code, to avoid boilerplate code.
  • Compile to efficient native code.

2. The Elixir Programming Language

Elixir also has a syntax similar to Ruby.

Elixir is a dynamic, functional language designed for building scalable and maintainable applications.

Elixir leverages the Erlang VM, known for running low-latency, distributed and fault-tolerant systems, while also being successfully used in web development and the embedded software domain.

3. GraphQL in Ruby

Simply put, GraphQL is an application layer query language from Facebook. You can describe your API using a schema (a graph). All your clients can then query your data through the schema. GraphQL tries to solve one of the biggest problems we have with REST APIs these days: Changing data requirements in the clients.

GraphQL can be used with rails, this post explores this option.

4. Volt Framework and Reactive frameworks

Volt is a Ruby web framework where your Ruby code runs on both the server and the client (via Opal). The DOM automatically updates as the user interacts with the page. Page state can be stored in the URL. If the user hits a URL directly, the HTML will first be rendered on the server for faster load times and easier indexing by search engines. Subsequent local page interactions will be rendered on the client.

5. Functional programming in Ruby

Ruby is an interesting language, in that it supports the use of multiple paradigms. One of these is the “functional paradigm”.

Using a language in a functional style implies you have access to a few key features: Immutable values, no side-effects, higher-order functions, currying, recursion, lazy-evaluation or delayed-evaluation.

This post explores functional programming techniques with ruby.

6. Microservices architectures with Ruby

Microservices are one of the latest trends in software design where multiple independent services communicate among themselves and have their own processes and resources. This approach differs from a typical client-server application design. The usual client-server application consists of one or more clients, a monolithic back-end which includes all domain data and logic, and an API which allows clients to access the back-end and its functionality.

This post shows how to set up a microservices architecture with ruby.

7. Internet of Things with Artoo: Ruby on Robots

Artoo is a micro-framework for robotics using Ruby.

Artoo provides a simple, yet powerful Domain-Specific Language (DSL) for robotics and physical computing

Artoo is conceptualy influenced by Sinatra ( Sinatra ) as well as borrowing some code from it.

Artoo provides a robust actor-based messaging architecture, that can support fully multi-threaded operation and high-concurrency, as long as it is supported by the Ruby version in which it is executing.

8. Domain-Driven Design with Ruby/Rails

Domain-driven design (DDD) is an approach to software development for complex needs by connecting the implementation to an evolving model.

The premise of domain-driven design is the following:

  • placing the project’s primary focus on the core domain and domain logic;
  • basing complex designs on a model of the domain;
  • initiating a creative collaboration between technical and domain experts to iteratively refine a conceptual model that addresses particular domain problems.

This post explores how to apply DDD concepts with ruby.

9. Ruby Book Review: 99 Bottles of OOP

As an example of a Book about Object Oriented Design with Ruby, the book from Sandi Metz titled 99 Bottles of OOP could serve as a good discussion topic.

This book explores:

  • Recognizing when code is “good enough”
  • Getting the best value from Test-Driven Development (TDD)
  • Doing proper refactoring, not random “rehacktoring”

10. Advanced shell scripting with ruby

Ruby has been used extensively in the administration of computer systems.

The DevOps community with Puppet and Chef use ruby to automate infrastructure management.

Ruby is a fantastic language that integrates really well with the Linux shell.

In this post proposes some advanced techniques of shell scripting with ruby.

If you want to submit your own topic, or participate in one of the topics above, please include your name in the Wiki Page for the London Ruby Unconference, alternatively leave a comment in this post!

Early bird tickets are on sale here! Please join us for a great day of Ruby!

Please help us make this event a success and share this event on Twitter here!

Like what you read? Give Codescrum a round of applause.

From a quick cheer to a standing ovation, clap to show how much you enjoyed this story.