Would you like to stroll into the office to your own dramatic theme music? We can arrive in style with an epic score. Learn how to use RubyMotion, a Raspberry Pi and iBeacon Technology to play the Imperial March when the CEO walks in.
The ability for mobile devices to detect their proximity to beacons is relatively new. We will learn how they work, the common gotchas, and how to integrate with a bigger system.
Let's build something fun with Ruby and Beacons. Plus, who doesn't want an awesome theme song?
Whether you are using a 3rd party or custom JSON API service, integration into an existing application can be time consuming: Where do you start? How can you build an object relational model that can adapt to changes in the schema?
In this talk we'll start with an existing JSON schema and build a Ruby adapter to provide a pure Ruby interface to: consume, modify and re-export that schema into JSON and XML.
Let's peek under the hood of the the Enumerable module, a goldmine of examples of the power and flexibility of Ruby. Although some of Enumerable's methods are familiar from workhorse Ruby data structures such as Array and Hash, there are tons of hidden gems, including cycle, lazy, partition, and grep. Mastering the ins & outs of Enumerable will save you time, avoid bugs, and help you write clearer and more concise code. Join the author of the Ruby on Rails Tutorial on a journey through one of the most captivating and illuminating modules in Ruby's Standard Library.
Ruby is used for a lot of things, but for some reason, only a few people are using it for music. In a language that is meant to make programming fun, the lack of such creative code is scary. Let's fix the current landscape by learning how to use the tools available in Ruby (and some not) to let those creative juices flow. We will be focusing on how to build sounds from the ground up (the powerful amplitude, and the majestic waveform), so you don't need any prior audio wizardry. Just bring yourself and a Ruby console and we just might create some beautiful music in a beautiful language.
One of the greatest challenges to developing an API is ensuring that your API lasts. After all, you don't want to have to release and manage multiple versions of your API just because you weren't expecting users to use it a certain way, or because you didn't anticipate far enough down the roadmap. In this session we'll talk about the challenge of API Longevity, as well as ways to increase your API lifecycle including having a proper mindset, careful design, agile user experience and prototyping, best design practices including hypermedia, and the challenge of maintaining persistence.
It's 2015... your stakeholders have decided that PayPal is out and Stripe is in. Fortunately, you're a planner. You have all of your PayPal interactions isolated in an adapter gem and your interface is clearly defined, easy to re-implement and enforce. Rewriting your adapter isn't small, but it is surmountable and can be estimated accurately so it won't lead to surprises. You win.
This talk will cover a collection of best practices for defining, enforcing and test-driving the adapter for your 3rd party service to provide easier flexibility in the future.
Ruby makes it easy to prototype a new data model or codepath in your application and get it into production quickly to test it out. At GitHub, we've built on top of this concept with our open source dat-science gem, which helps measure and validate two codepaths at runtime. This talk will cover how we used this gem and its companion analysis gem to undertake (and complete!) a large-scale rewrite of a critical piece of our Rails app -- the permissions model -- live, side-by-side, and in production.
Ruby has never been renowned for its performance. We choose to love Ruby for its more admirable traits, like simplicity and expressiveness. But it turns out that we can have the best of both worlds by kicking the single-threaded model to the curb and using tried and true concurrency abstractions.
We will take a look at the building blocks Ruby offers for concurrency and how Rubyists have used these to build scalable, performant libraries just dying to be used. You’ll walk away with an understanding of concurrency and how you can leverage it in your applications today.
We use Strings. A lot. We use them for pretty much everything that isn't a number (it's jokingly referred to as "stringly-typed").
It ends up creating unnecessary complexity in our applications, making the boundaries between classes and modules hard to understand.
What if we used Ruby's power to create richer data types? These types would define clearer boundaries in our system, and make our code much easier to understand.
As software becomes less monolithic and more service-oriented, log collection becomes a real problem. How can we stop hacking together brittle log parsing scripts and start building a unified logging layer?
Fluentd is a data collector written in Ruby to solve this problem. Unlike other log management tools that are designed for a single backend system, Fluentd aims to connect many input sources into several output systems.
This talk surveys Fluentd's architecture and shows real-world use cases of how different users extend it to do more with their logs with less code.
Consultants divide projects between greenfield and brownfield projects, and talk about this evolution from green to brown as inevitable. It's not true. Large evolving software projects can stay easy to change, easy to grow, easy to reimagine throughout their long lives. This talk explores the code and social practices that make this kind of project succeed.
Spies are a relatively new feature in RSpec. In this tutorial-style talk: we'll look at what spies are, how spies work in RSpec and how one can write better tests with spies. We'll work through some of examples of writing new tests with spies, improving old tests with spies and the reasons why spying is a useful tool for your testing practice.
If you're new to RSpec and looking for ways to improve your testing practice, understand the library better or just ask some questions, this session will be great for you.
As a language, Ruby plays fast and loose with the type system. Developers rely on duck typing to check that the things they want to do with an object are permissible. Whilst this freedom makes writing code frictionless and often a whole lot of fun, it doesn't always scale up well to writing larger systems.
I can't promise that strong duck typing - adding automated checking to inter-object interfaces - will make writing complex systems easy but it will help you think about how to structure code in new ways and bring some of the lessons learned from other languages to the Ruby community.
Idioms are some of the smallest patterns that we use in our programming languages. Learning the idioms of a language helps you more quickly understand commonly used patterns. Over time, some idioms fall out of favor, and new idioms are developed and adopted.
In this talk, we'll explore a few idioms that are relatively new to the Ruby community. These include:
Fetch with default block
Software engineering pushes us to our limits, not only of cognition, but, perhaps surprisingly, of character. Using the cardinal virtues as a framework, we can see that developers need courage to learn, temperance to prioritize goals, a sense of justice by which to discern, and wisdom to act. By being honest about where we lack virtue, and implementing steps to develop character, we can perform TDD on ourselves. This process can help us grow not only as coders, but as human beings.
Roda is a new Ruby web framework designed around the concept of a routing tree. Roda gives you the simplicity of Sinatra for simple cases, while being able to scale well to handle larger, complex cases. It provides performance very close to a pure Rack application, with a flexible plugin system powerful enough to handle almost any needs. Come learn about routing trees, how they make web development better, and how Roda adds a twist on the routing tree concept to avoid the scope pollution problem inherent in many other Ruby web frameworks.
Bugs and mess-ups are serious problems in software. Mistakes are inevitable - but the stakes can be high. If you're writing a hospital management system, they can cost lives. In a payments system, they can cost money. Since we can't eliminate bugs, this talk will cover strategies, hacks and monkey patches in Ruby to prevent bugs from leading to disaster. This isn't a traditional testing talk, but rather a thinking outside-of-the-box approach to busting bugs and building more robust software.
A good design communicates the intended use of the object. In the physical world, this communication is accomplished by "affordances" as discussed by Donald Norman in "The Psychology of Everyday Things".
Programming languages also have affordances, and they influence the kinds of solutions we develop. The more languages we know, the more we "expand our design space" so that we can come up with better solutions to the problems we face every day.
We will look at a few example problems and show how they can be solved using the affordances provided by different languages.
Developers are lazy! So we are great in creating tooling for our daily work. But it has its weaknesses, we are creating a tons of scripts on our local maschine, sometimes we share them via git or other vcs systems. But all over all this tooling sucks when it comes to collaboration. We developers also love hanging out in chat rooms like campfire or jabber.
Why not combine this via chat robots. Our tooling would be available to everyone without installing wired shell scripts plus we can get rid if questions like:
Do you have the deploy lock?
There's more to being a successful developer than simply being great at programming. The gotchas that slow us down or trip us up are often outside of the code we write, manifesting instead in our process or how we work with our peers. Whether you're new to programming or a veteran of many projects, these 5 things can improve your code, your career, and your team, and is a refresher course on what goes into the day-to-day, reminding us to have some empathy for individuals new to our community.
Ruby is notoriously difficult to optimize, but there is a solution: deoptimization. This means jumping from compiled code back to an interpreter, and it allows Ruby implementations to take shortcuts, make guesses and pretend Ruby is simpler than it is, but at the same time still be ready to handle the full language if it’s needed.
You’ve seen talks about what makes Ruby slow: monkey patching, bindings, set_trace_func, object space & so on. We’ll show how with a Ruby implementation using deoptimization, such as JRuby+Truffle, you can use these features without any runtime overhead at all.
The transition from working in advertising agencies to becoming a full-time developer was something I never thought I could do. 6 months into it, I found myself working for one of the best Ruby consultancies. There are 8 things that I wish I would have known before jumping head first into a career as a software engineer, especially coming from a non-technical background. You will leave this talk not only feeling inspired to enter the Ruby world as an engineer, but have concrete action items on how to make it a successful transition.
Ruby's full of nice little metaprogramming tricks. Learning a new one's always the same cycle: 1. scared & tentative; 2. drunk on power; 3. woefully repentant; 4. mature & reasonable. Using my own history (of poor choices), I'll take you through stages 1-4 for: mazes of twisty little send calls, all alike! replacing def with method_missing! hook method indirection "magic!" Ill-timed define_methods! Sure, you could skip to the end - stage 4 is mostly "obey SRP; extract service objects" and "anonymous module inclusion's your BFF" - but getting there is half the point and all the fun.
Sequential workflows are easy to write (top down), but hard to write well. State machine workflows start to feel hacky, when complex; presenter patterns can be very heavy. Promises are a beautiful way to define and execute progressive routines while allowing access to independent steps for things like logging, exception handling, and picking up where you left off.
Haskell is a functional programming language that cleanly separates pure algorithms from messy real-world concerns. To learn how it ticks, I've translated an algorithm for Simulated Annealing from Haskell to Ruby. It also gave me an excuse to play with ruby-processing, a toolkit for graphics processing ;). Come learn about Functional Programming and how it can make your Ruby better!
Life's demands are such that it's easy to get lost in the day-to-day, trapped inside your own private world, expecting today to repeat endlessly and the future to remain a distant, untroubling land. The future is coming, however, whether you are ready or not, and when it does everything will change.
This talk is a history lesson that covers 3,000 years of technology. It uses the past to lend perspective to the present and give guidance for the future. It reminds us where we come from and suggests how technology can help us to choose where we’ll go next.
In this presentation, I will talk about incremental GC algorithm for Ruby interpreter.
Ruby 2.1 has Generational GC algorithm, which improves GC performance dramatically. However, long application pause time problem on major GC is not solved.
To overcome this problem, we Matz team at Heroku, Inc. implemented a well-known incremental GC algorithm into MRI/CRuby interpreter to reduce application pause time without any compatibility issues, with our "write-barrier-unprotected" objects technique. In this talk, I will explain the algorihtnm, implementation and evaluation results about new GC.
What happens to Ruby when Rails dies?
Ruby rode the Rails rocketship to worldwide renown. While a handful of us were writing Ruby code before Rails came along, most of us owe Rails a debt of gratitude for taking Ruby mainstream, allowing us to make a living writing code in a language we love.
But opinions codified in Rails are falling out of favor. We're not writing apps that do heavy server-side rendering. Our apps have complex domain logic that grates against "The Rails Way."
Is that it, then? Has Ruby entered its twilight years?
Do you know how addition works in Ruby? It's simple right? You just add 2 and 2 and out pops 4. But what if you add 2 to cats? That makes no sense, but how does Ruby know it makes no sense? And what if you had a Really Good Business Reason for adding 2 and cats. To achieve the needed degree of cuteness, you're going to need to be positively cat-like yourself. In this talk you'll learn about the magic of the coerce method, and that can't be coerced into Fixnum isn't a warning, but a dare, and what you can do to make your coworkers, collaborators and future self regret it.
mruby forum released mruby 1.0.0 in Feb. 2014. It's been stable to use. However, because mruby is used on small boards or in application programs, it's hard to debug mruby applications. When we develop mruby application, we should write not only Ruby code, but also C code. So we need to debug both codes. To make debugging mruby application easier, we are writing prototype of mruby debugger. Current mruby distribution has no debugger, but there are some useful API sets to implement own debugger. In this talk, we introduce their API and how to use them to write a debugger.
Ever type 'next' into your debugger and then realize you should have used 'step'? Or perhaps invoked a method that you wish you could take back? Regret no more! Just turn the clock back a few ticks and begin again! With only a few restrictions and side-effects we will learn how to construct and use a time machine.
WARNING: Time travel may cause zombies.
There are gems out there solving very common problems that could easily be contributed back to Ruby itself. Suggesting a new Ruby feature isn't as daunting as it sounds. As long as you're diligent, you too can push ruby forward.
What do you do when your Ruby startup takes off and you realise that Ruby might not be best suited for everything? This talk covers our initial attempts to use Ruby as a data analytics platform, and how we ultimately ended up solving the problem using ideas from LISP and ActiveRecord scopes to bring the power and performance of data science languages to Ruby. We will also cover how Ruby can learn from other languages, and why Ruby is still our language of choice.
In Ruby, assignment is our primary tool. By contrast, functional programming makes much less use of assignment and mutation. Instead techniques like function composition, recursion, and anonymous functions are used.
Despite being OO, Ruby accommodates pure functional approaches. This talk will demonstrate how tasks can be accomplished without assignment. Ruby and Scheme will be used for examples. I'll also discuss some of the great resources available for those interested in digging deeper into functional programming.
This is the story of how I built an all-seeing eye with Ruby, and how I use it to defend the sanctity of my suburban home.
Using a Raspberry Pi and some homemade motion detection software I've developed a home security system that can send me notifications on my phone and photograph intruders. It uses perceptual hashes to detect image changes and archives anything unusual. I can even set a custom alerting threshold and graph disturbances over time.
If you've ever had the desire to be an evil wizard with a glowing fireball of an eye this talk is perfect for you. Come play with Sauron.
The learn to code movement has popularized the idea that coding is a skill everyone can and should learn. It's the American dream: learn the desirable skill and you'll succeed financially. Those who master the skill and achieve the goals are held up as prime examples of just how easy it was. But if it was that easy, why are there so few victors encouraging hoards of hopefuls? I'll discuss the history of the American Dream, how new programming education endeavors have repackaged it, and how the lack of awareness and analysis of this privileged rhetoric is damaging our culture and workforce.
JRuby 9000 is the largest update to the JRuby platform during its lifetime. We will support Ruby 2.1 (or perhaps 2.2) features, replace our execution pipeline with a new optimizing compiler, support true native IO and Process logic, and finally bring character transcoding in line with MRI. At the same time, people are building more and more amazing things with JRuby. In this talk, we'll unveil JRuby 9000 and talk about the future of JRuby and Ruby.
The fact that Ruby has different implementations is both strange and powerful. Writing an extension for the language can be a daunting task but there's no better way to get to the heart of what exactly Ruby objects are and the reason for some of the language's quirks.
In this talk, we'll use an example of writing a C extension for Ruby to use a third-party C security library. We'll peel back the layers of Ruby objects to deepen our knowledge of MRI and to understand in a little more detail what it really means to write object-oriented code.
In this end-to-end discussion about the challenges with civic data, from no-documentation & incomplete government code to figuring out how to scale data-driven SOA, we'll show you how two Ruby newbies managed to create an awesomely useful parking app in just four weeks. For those new to coding, or experienced devs looking to work with civic data, we'll show you our roadmap as well as what we learned pairing as two junior developers just starting out in the big bad world of programming.
In the 1980's, Nintendo had plans for a knitting add-on to the NES, with an interface that resembled Mariopaint, but with patterned sweaters as output. Sadly, this product never saw the light of day. Devastated on hearing this, a group of Airbnb engineers (who knew nothing about machine knitting) set out to hack a knitting machine from the 1980's to be computer-controlled. Learn about how we wrote our own yarn printer API in ruby and printed our first doge meme in yarn. And watch us as we send knit requests to our yarn server, and behold as it knits ugly sweaters from those images!
Did you know that inject() and especially all?() iterator nested in another loop can really slow you down? Or that bigdecimal and string comparison is unbelievably slow in Ruby < 2.0? Or that parsed CSV is 13x larger in memory than on disk? Want to know these and other performance hints with in-depth explanations? Want to learn how to use profilers to find what's slow by yourself? Then this session is for you.
When I found Ruby several years ago, I had no idea how strong an influence it would be in my life.
It made my life happier and I was eager to share this new found happiness with other developers.
Then by the way of MagLev - I found the magical world of Smalltalk - and my joy was complete.
Come hear about this journey, how Ruby.is_a? Smalltalk and appreciate the following quote on another level:
I always knew that one day Smalltalk would replace Java. I just didn't know it would be called Ruby. -- Kent Beck
This talk is about Elixir – a functional, meta-programming aware language built on top of the Erlang VM.
I introduce some of Elixir's more interesting language features. Then I will demonstrate some of the features that Erlang gives Elixir for free, such as the OTP framework, that let's you build fault tolerant and distributed systems.
So come along and join me to experience programming joy.
Rsense brings the kind of static analysis tooling to Ruby that programmers in other languages take for granted. The kind of tooling I kept hearing was impossible to implement for Ruby. Accurate type inference, code completion, definition finding, and eventually so much more. How about a real refactoring tool, or the ability to find whole classes of bugs without executing the code? This is where Rsense is headed.
Learn how Rsense does its magic, find out how you can use it to improve your daily coding experience, where it's going next and where you can pitch in to make rsense even better.
The view of an outsider – What I have learned over the past 2 years from attending nearly 40 programming conferences on 3 different continents (with most of them being Ruby Conferences) and working on just under 1000 presentations.
Have you ever felt like you were on the outside...
What programming looks like to an outsider.
Connections that are created. A better community experience. Superheroes are human too. Why an outsider loves the Ruby Community.
I didn't know squat about C or building extensions in Ruby. But I did want a Ruby-controlled Lego Mindstorms robot to get kids excited about Ruby. We'll dive into the basics of building C extensions, build a Ruby DSL to teach kids to drive cool Lego robots, and show off the amazing things you can do when you pull up Ruby's floorboards and look at the actually-not-too-scary C code underneath.
Lightning Talks by Many People
00:00:00 - Vektra
00:03:45 - Claudio Baccigalupo
00:07:27 - Richard Schneeman
00:11:58 - Shannon Skipper
00:15:34 - Sean Culver
00:20:36 - Steven Talcott Smith
00:25:28 - Brandon Rice
00:30:21 - Alex
00:34:32 - Phillip Ante
00:38:26 - Jeramy Couts
00:42:32 - Ray Hightower
00:46:33 - Tim Schmelmer
00:53:05 - Aaron Patterson
00:58:32 - Bobby Matson
01:03:17 - Jason Clark
01:08:25 - Chris Sexton
01:10:52 - Jonathan Slate
01:15:05 - Amanda Wagner
01:20:44 - Costi
01:27:03 - Colin Kelley
01:32:01 - Michael Hartl
01:36:42 - Pamela Assogba
Social coding revolutionized how we share useful code with others. RubyGems, Bundler, and Github made publishing and consuming code so convenient that our dependencies have become smaller and more numerous. Nowadays, most projects quickly resemble a Jenga tower, with layer upon layer of poorly understood single points of failure.
As we celebrate a decade of RubyGems, let's reflect on our relationship with open source. Convenience and ego drive most open source adoption, but these shortsighted motivations raise long-term problems we need to clearly identify if we can ever hope to solve them.
If you've ever misspelled a word while searching on Google, you've benefitted from decades of distance algorithm development. In this talk we'll break down some popular distance measurements and see how they can be implemented in Ruby. We'll look at real world applications with some live demos. It won't matter if you get your kicks "Hamming" it up, if you drink your coffee in a "Levenshtein", or if you're new to Ruby: this talk is Rated R, for "all Rubyists". You'll be guaranteed to walk away with O(n^n) expectations met.
Data streams (ex: logs) are becoming larger, while analytics in (semi-) real time is also becoming more important today. Moreover, there are many non-programmers who wants to write queries in this big data era.
Norikra is an open source server software that provides "Stream Processing" with SQL, written in JRuby, runs on JVM. We can write and add queries for stream easily on Norikra, without any editors, compilers or deployments. I will talk about implementation of Norikra and its application in LINE corporation.
Docker’s lightweight virtualization may supplant our hypervisor-backed VMs at some point in the future, and change the way that tomorrow's Ruby applications are architected, packaged and deployed. Using Docker, your Ruby applications will sit atop an excellent platform for packing, shipping and running low-overhead, isolated execution environments. You will get a brief intro to the Docker ecosystem, get to know the tools and processes needed to create containerized Ruby applications, and learn best practices for interacting with the Docker API from Ruby.
Well no need to switch languages/platforms, Jubilee could be your new best friend.
Jubilee, a rack server on top of Vert.x gives you
Easy Websockets support
Access to the JVM ecosystem
Ability to reuse your existing Ruby knowledge and gems
"Say Hello to your new friend" - Al Pacino
Messy code often begins with a simple "if". Continuing down that path is a road to ruin, but there's a simple way to avoid it. East-oriented Code is an approach that helps you follow Tell, Don't Ask. It guides you away from Feature Envy and toward better encapsulation. See before and after code and walk through easy to repeat steps that will make your Ruby programs better and easier to maintain.
HTML template engine is one of the most important library to build a web application. But who actually knows how it works? Who can explain how the engine parses the given template and finally composes the HTML body?
In this session, I will dig into implementation details of several Ruby libraries such as ERB, Haml, Slim, Tilt, Temple, etc. and give you a quick tour into the world of template engines!
If you are working on a serious project, you want it to scale. The thing about scale is, you only focus on it once you really need it. I’m the CTO of an soccer social network based in Brazil. To put it mildly, soccer is big in my country. This summer, we focused our marketing on the World Cup, preparing our application to support as many users as possible. To do that, we had to benchmark and improve, but how could we load test? What tool should we use? Those are just some questions that I'll go through in this talk, that will show youhot to address this challenge so stress test you app.
Testing is firmly ingrained in our culture, and many of us rely on a network of services to test, evaluate and profile our code. But what about benchmarking?
Learn tips and tricks about how to approach benchmarking and the variety of gems that are available. Learn about tools to help determine algorithmic complexity of your code, as well as how this information can help you make development choices. Learn how to properly set up your benchmarking experiments to ensure that the results you receive are accurate. More importantly, discover that benchmarking can be both fun and easy.
We will explain the introduction of the Smalruby and the Ruby Programming Shounendan, For more information about the implementation of the smalruby-editor of the Ruby programming visual editor.
Nobuyoshi Nakada is the most prolific contributor to Ruby. He is the all time leader in commits to the CRuby source code. With over 10,000 commits, he leads second place by double the number of commits. Leading to his psuedonym "Patch Monster".
Allow me to introduce you to the man, the myth, and the legend that is nobu.
You will learn the true story of how nobu came to be, and witness exactly how he earned that psuedonym and why everyone loves nobu.
We will also show you what it takes to make it in ruby-core using nobu as an example.
Our brains are great at social interaction and pattern matching, but terrible at reasoning about the complicated non-human systems which dominate our world. Abstraction is the adapter between the fearsome complexity of the universe and our simple primate minds; when the real world is too intricate for us to manipulate directly, abstraction gives us big friendly levers to pull instead.
I’ll explain how this single powerful idea underlies computers, mathematics, language and everything else we rely on in our daily work as computer programmers, and then show you how to use it effectively.
If you're developing webapps, I guess you deploy sometime using tools like Capistrano. We think existing tools slow for huge apps and a lot of servers.
We serves cookpad.com, which is a huge Rails app, and the largest recipe site in Japan. It's backed 120+ app servers. We've used Capistrano + SSH + rsync, but it became a bottleneck, slower and slower, as well as server increases. Our developer have wanted to focus on development. Deployments should be done in short time.
In this talk I'll introduce about our new deploy tool Mamiya, and will talk about how we deploy webapp in a minute.
Hi, I'm [NAME] and I'm an introvert. But contrary to what you might think, it's not a problem and I am not working on it. In fact, I've embraced it.
In this session, we'll explore the strengths of introversion within the realm of programming and software development. We'll discuss how it plays a role in your interactions with other developers, your preferred work environment, and yes, even your code.
As single page apps become common, more and more of our logic becomes duplicated between the front and back-end. We also spend more time writing API glue code to move data between each side. With isometric development you can remove the boilerplate of web development and the cognitive load of switching between languages.
Large scale and fast production Ruby applications are not a myth. As we've continued to scale out our infrastructure and our application, we've been able to keep things fast and reliable. We do this by building and using tools that take advantage the great improvements that have come in Ruby 2. I'd like to share some of the lessons we've learned in scaling our app as well as show off the latest and greatest in open source performance tooling.