André thinks Ruby is pretty cool. He designs and builds web applications at Cloud City Development by day, and works on Bundler and Rubygems by night… and also some days.
Extreme Makeover: Rubygems Edition
Rubygems.org provides every Rubyist with an amazing service: all the libraries in the Ruby world. As amazing as that is, installing gems can be a time-consuming and even error-prone process. (Just ask the Travis guys.) In this talk, you'll learn about the recent dramatic changes in Rubygems and Bundler to improve speed and reliability by rewriting the Rubygems client/server architecture. I'll show how the new system caches more information, makes fewer requests, and takes less time to install gems. Finally, I'll cover how the changes allow worldwide mirrors of rubygems.org, improving things for Rubyists around the globe.
Build your own Ruby-powered Arcade Machine!
Have you ever wished you could re-live the fun you had as a kid playing those arcade games? Have you ever wanted to learn 2D game programming with Ruby? Now is the time! The hardware is cheap. The libraries are easy to learn. This session will cover basic game programming techniques using Ruby, as well as the hardware and software you need in order to build and run your own Ruby-powered arcade machine.
Andy Pliszka (@AntiTyping) is a developer at Pivotal Labs and the organizer of AlgorithmsNYC Meetup. He worked on multiple projects ranging on financial exchange written in Erlang, web applications using Ruby on Rails, and computer vision using Python. He enjoys implementing computer algorithms in variety of computer language.
Extending CRuby with native Graph data type
Reading of the CRuby (MRI) source code provides unparalleled insight into the Ruby language. During the talk we will add new native Graph data type to CRuby. The new Graph data structure will be simple but on par with other native types such as Array or Hash. This talk will demonstrate that it is easy to experiment with CRuby and extend it in C. We will experience the speed advantage of using C to boost Ruby performance. We will implement a few of the greatest hits of graph algorithms: Breath First Search, Dijkstra, and Minimum Spanning Tree.
Based in Baltimore, Bryan Liles is the Senior Vice President of Thunderbolt Labs. Since 1993, Bryan has hacked into systems which he was then paid to protect; written more assembler than anyone should ever have to; worked with and against the government. Currently, Bryan is exploring the limits of Ruby and other trendy programming languages while building that next great product company. In his spare time, he trolls Twitter and grows miniature herb gardens.
Thinking about Machine Learning with Ruby
Not sure where to cluster or where to classify? Have you seen a linear regression lately? Every wanted to take a look into machine learning? Curious to what problems you can solve? Using Ruby to become familiar with machine learning and data-mining techniques is great way to get acclimated before diving in with both feet.
Casey Rosenthal is currently Director of Professional Services at Basho, where he installs and tests Riak clusters and provides training to clients so that they can do the same. As Chief Software Engineer for Port Forty Nine, Casey worked for NASA, Caltech, and JPL to engineer systems for storing and disseminating the image archives of space telescopes such as Hubble, Spitzer, Chandra, etc. He came in 4th place at the BotPrize 2K competition in Copenhagen for Discordia, a software bot written in Ruby that plays Unreal Tournament like a human based on a new artificial intelligence algorithm. He published a paper on that algorithm and spoke about it at GoRuCo '11. He created RubyGames, a learner-centered Ruby facilitation for groups, and ran it throughout user groups in New England in '09 and '10, and brought it to a warm reception at the New York Ruby Meetup in '11 where he was an Assistant Director for the user group. Casey was an Expert Panel Judge for the '09 RailsRumble and again in '12, and competed in the '10 RailsRumble. He won a seed grant from the Maine Institute of Technology to commercialize a discrete event simulation framework written in Ruby.
Fault Tolerant Data: Surviving the Zombie Apocalypse
Acute Zombielepsy has broken out, and the CDC has turned to you to store the first one million records of victims in the U.S. including the subject’s name, DNA sample, geo, etc. You must store this crucial data in a resilient manner in case one or more data centers are compromised by the outbreak. The CDC also needs to query the data in several ways; for example, they want to see the outbreak on a map to visualize geographic clusters. Naturally, you turn a fault-tolerant NoSQL database to store this data. But since you come from a relational background, you find it difficult at first to model the data properly for the types of queries that the CDC wants to run. Learn about advanced data modeling on a key-value database in Ruby -- distributed indexes, convergent data types, geohashes, and more -- on a truly fault tolerant database infrastructure. Keep calm; the fate of the human race depends on you.
Your Development Machine in the Cloud
Can you do your work anywhere? All you need is a laptop and internet, right? What if your laptop blows up? Can you work on your phone? ipad? When you reboot your computer, does it pick up where you left off?
What if your developer machine was just another machine in the cloud? Then all you need is a terminal and an internet connection. To get work done, all you do is connect remotely to your cloud machine.
What this allows you to do is:
- Pick up where you left off (using tmux and SSH)
- Work from any device that has a terminal or terminal emulator
- Make your work available from anywhere with an internet connection. (Clients like this.)
- Do only one setup (across multiple workstations). This makes replacing your machine easy.
- Use your friend's machine without compromising any security on the project
- Pair program using tmux in your normal working environment
- Use a cheap VPS on an inexpensive laptop
Software/Packages/Services I'm using to make this work:
- Database software (PostgreSQL/MongoDB)
I've been using this setup for about a year and it has made things VERY painless for me. I've paired with clients and subcontractors with it and traveled and picked up work on devices you can't normally do development on.
It also makes demo's a freaking breeze.
Conrad is a developer-tools fanatic. He's a co-maintainer of Pry, most of its plugins, the mail gem, and numerous other libraries in Ruby and beyond. His over-arching focus is on making developers better at their jobs, so when he's not writing open source he works on making Bugsnag the best hosted exception tracking tool around.
REPL driven development with Pry
Pry is a featureful irb replacement that provides Ruby programmers with a seriously souped-up REPL.
Using some real-life examples, I'll explain how to use Pry to program more effectively.
We'll start with the basics of exploring libaries and experimenting with code at lightning speed. Then we'll move up a level and discuss how to dig into, debug and even modify existing programs. Finally we'll cover a few of the plugins that make Pry a truly indispensible tool.
David Copeland is a programmer and author. He wrote "The Senior Software Engineer" and "Build Awesome Command-Line Applications in Ruby", and has over 16 years of professional development experience. He's managed high-performance, high-traffic systems at LivingSocial, helped build the engineering team at Opower, and worked consulting gigs both large and small. Currently, he's a lead engineer at fashion start-up Stitch Fix, building a platform that will change the retail shopping experience.
Eliminating branching, nil and attributes - let's get weird
Although "being OO" isn't an end unto itself, we can often learn a great deal about programming by taking things to the extreme. Branching, nil checks, and attributes are not very "OO" and are often the source of great complication in our code. What would our code look like if we did everything we could to avoid them?
In this talk, we'll create some odd-looking constructs and write some weird code in an attempt to understand just how useful branching, nil, and attributes really are. Do these constructs make our code easier to read and understand, or are they vestiges from our shared programming backgrounds like C, PHP, and Java?
Captain Eric Hodel be a long-time Rubyist with a strong interest in distributed programming. Besides maintaining RubyGems and RDoc, he has also contributed documentation to DRb and Rinda, reviewed The dRuby Book, implemented drbdump and added multicast support to Rinda’s service discovery (upcoming in Ruby 2.1).
Admiral Davy Jones^W Stevenson has used DRb to develop distributed systems for a number of years, and has been terrorizing the Ruby community into playing Spaceteam since early 2013. She encouragingly said ‘You should do that’ when Eric mentioned the idea of drbdump.
When he isn't busy buckling swashes or hauling keels, you can find First Mate Rein Henrichs building high-performance distributed systems in Ruby. When Davy told him she was building a pirate-themed Spaceteam with DRb, he said 'Can I help? I like yelling!'
Arrrr me hearty! Sailing the Seas of DRb in a Shoe
You insouciant scalawags will share the experience of a lifetime as you play a game built atop DRb and Shoes based generally upon the phenomenon known as Spaceteam! Except with Pirates!!
Join us as we skirt the treacherous shoals of DRb, learning techniques that will allow you to navigate it like you were born on the high seas!
Dig for the buried treasure of Rinda to discover the mysterious secrets of the RingProvider and TupleSpace!
Storm the fortress of Shoes and learn about it’s secret trapdoors and avoid the dungeons!
Team up with your fellow attendees to plunder the high seas and avoid the Curse of the Live Demo! Yarrrr….☠
Dirkjan Bussink is an independent software developer from a city called Enschede in Netherlands. For the last years he's been a contributor to Rubinius, an implementation of Ruby.
The tricky truth about parallel execution and modern hardware
Concurrency and parallelism in Ruby are more and more important in the future. Machines will be multi-core and parallelization is often the way these days to speed things up.
At a hardware level, this parallel world is not always a nice and simple place to live. As Ruby implementations get faster and hardware more parallel, these details will matter for you as a Ruby developer too.
Want to know about the pitfalls are of double check locking? No idea what out of order execution means? How CPU cache effects can lead to obscure crashes? What this thing called a memory barrier is? How false sharing can cause performance issues?
Come listen if you want to know about nitty gritty details that can affect your Ruby application in the future.
Ruby enthusiast !!
"Bioruby"...understanding the intricacies of 'Life' using Ruby
Learn about the genes, which controls everything you do and find out how you can ease the task of your similarity with a salamander using Bioruby!
Bioruby is great Bioinformatics tool which helps to process biological data and analyze it. 5 years after ruby programming language came into vogue(1995), bioruby came into existence in 2000, both developed in Japan. BioRuby project provides an integrated environment in bioinformatics for the Ruby language. This project is supported by University of Tokyo (Human Genome Center), Kyoto University (Bioinformatics Center) and the Open Bio Foundation.Welcome to the ruby in the living world, integrating ruby with the Bioinformatics and have fun.
On one hand we have the Bioinformatics, the large database of the huge genome sequences, the search algorithms to search the gene similarity between different organisms, gene-mutations using the popular search tool Blast, Fasta etc. BioRuby helps us to do the same searching thing using ruby programming language. As ruby is a pure object-oriented programming language(everything in ruby is an object) and being a easy to read and write, it's fun to use here without being lost in the plethora of genomic data.
One of the greatest contributions from Bioruby is Biogems, which like any other rubygems helps to perform modular approaches in order to perform specific functionality. One such gem is bio-ucsc-api gem, which helps to fetch record from UCSC DB and the best part is the gem has been implemented using the Actice Record Framework thereby easing the record fetch, instead of complex sql queries. We explained the basic concepts of Gene, DNA. RNA, Amino-acids, Human Genome Project and how these huge data are stored and analyzed by the famous Bioinformatics tools like BLAST, Fasta and how Bioruby interacts with the different biological databases like Genbank, Swissprot etc.
Emily is a software engineer at MongoDB where she co-maintains the Ruby driver and aids in Ruby community development. She previously worked as a Rails developer in NYC and at the Louvre Museum. She likes archery, running, and teaching Rails at Columbia University in her free time.
API design for gem authors (and users)
Ruby applications are becoming more complex and unwieldy (think MonoRails). An increasing number of us are trying to address this by separating our apps into gems without knowing best practices on how to write APIs or how to manage dependencies and versioning. The discussion we often have around good APIs should not stop with Ruby OO design, but should also consider the public APIs of gems.
This talk is intended for gem authors and users. It will share though many practical examples using the Ruby driver to MongoDB 1) Principles of good gem API design, 2) How to make your gem API optimal for users and how to best use the API of a gem, 3) Guidelines for introducing and anticipating gem API changes and managing dependencies.
Ernie's been writing code since he was 6 years old, but only getting paid to do so for the past 15 years or so. Sometimes he still can't believe people actually *pay us* to have this much fun.
He's the author of a bunch of Rubygems, some of which might even be useful, a contributor to Rails, a committer to Arel, and an ardent believer that all true first person shooters are played with a mouse and keyboard.
That's Not Very Ruby of You
How Ruby is your Ruby? As we've found our way to Ruby, we've all brought with us habits and idioms from the languages we know and love (or hate). Sometimes, these habits serve us well, and other times, they make our lives more difficult. More often, they make life difficult for our collaborators, who don't expect to see C, Java, or PHP in their Ruby codebase.
Not only that, as many new Rubyists have found their way to Ruby from Rails, they've brought along various Rails-isms, some of which aren't even a good idea in Rails-land (callbacks, anyone?), or dependencies on libraries like ActiveSupport which are overkill for their real needs.
We'll talk about some of the baggage we bring to our Ruby code, and some simple techniques that will help us leave it behind.
When not polishing his bio for conferences, Evan works as a developer advocate for Rackspace from the cradle of culture and beacon of brilliance that is Ocean City, MD. He also organizes, if it can be called organized, the annual Ruby DCamp unconference that has never, in fact, been run within the borders of Washington, D.C.
Recommendation Engines with Redis and Ruby
A couple of years ago, a client asked me to build a recommendation engine for them. Coming into this with a minimal knowledge of statistical math, I ultimately built a relatively simple recommendation engine in Ruby. The design made heavy use of Redis Sets, Lists, and Hashes in order to greatly reduce the number of SQL queries to provide recommendations.
This talk will be a case study discussing the object-oriented considerations in designing a scalable service, how Redis was a good fit for the project, and some of the painful lessons that I learned along the way so that you don't have to repeat them.
Forrest has been programming in Ruby since 2004. Before that he programmed in a number of different languages, C, C++, Lisp, Perl, Java. He loves Ruby and he wants you to be happy
Opal, A new hope (for Ruby programmers)
A short time ago, in an internet not far away ...
from an obscure repository, have won significant victories against
During the battle, Rebel Ruby coders have managed to duplicate the
Empire's ultimate weapon, the use of the same language on both server and
client sides, but this time with a language with enough meta programming
power to make the most elegant DSLs on the planet.
their repositories, custodian of the code that can save their people and
restore freedom to Ruby Coders everywhere.
truly exciting time with many options and opportunities.
- Yoda, if he were a coder
corelib and a runtime implementation that currently passes 1716
rubyspecs w/a reachable goal of passing them all.
You might be thinking, yet another language that compiles down to
Matz once wrote:
"For me the purpose of life is partly to have joy. Programmers often feel joy when they can concentrate on the creative side of programming, So Ruby is designed to make programmers happy."
As another Ruby, Opal is designed to make programmer's happy
Here's the top 8 reasons why Opal will make you, the Ruby programmer, happy
1. It's just Ruby, and a viable one
2. Greenspun's 10th Rule, Opal Edition
3. Solves things the Ruby way, making the programmer happy
4. Frameworks, we don't need no stinking frameworks (but we have some)
5. Tools you already know and love
6. Easy integration with Ruby web frameworks
7. Awesome In Browser tools
8. New possibilities
This talk will go over those 8 reasons and more. There will be live code demonstrations.
Opal, this might just be the droid you're looking for.
I fell in love with programming as a young boy watching my dad work in Clipper and dBase III (no, really). The obsession sparked there continues to this day. My current language crushes are Ruby and Haskell, and I work for New Relic on the Ruby Agent. When not at work, I enjoy experimenting with programming languages, cycling, homebrewing, and hanging out with my family.
Extending Gems - Patterns and Anti-Patterns of Making Your Gem Pluggable
One strength of the Ruby community is the simplicity of sharing code via gems. When a gem is popular enough, it can even develop an ecosystem of additional gems that build on it.
But extending a gem that wasn't built with that flexibility in mind isn't always easy. This talk highlights tips and techniques for making your gem simpler to plug into, and avoid mistakes that will have devs cursing under their breath.
We'll cover the highs and lows of interacting with others gems, from configuration to documentation and everywhere in between.
I run Jumpstart Lab and have spoken at many conferences including RubyConf, RailsConf, GoRuCo, GoGaRuCo, Rocky Mountain Ruby, RubyNation, and RubyConf Argentina.
Computing from First Principles...in Ruby
Writing good Ruby is all about creating abstractions. But there are amazing abstractions right beneath your fingertips: electrical signals abstracted into binary numbers into logic gates into flip-flops, registers, ALUs, on up.
Let's bring the world of low-level hardware into object-oriented Ruby and explore:
* Building foundational logic gates in Ruby to mimic the hardware
* Using those gates to construct flip-flops and multiplexers
* Using those components to create memory and adders
* Then building fundamental components like ALUs and CPUs
* Implementing fundamental instructions (like the 8088 set)
* Using those instructions to implement algorithms
* Visualizing the whole execution path while instructions are clocked through the system
High-level languages offer us the privilege of ignoring the hardware. But developing a deeper understanding of how the machine is constructed can influence how we design and abstract complex systems.
Jerry has been a professional programmer for almost two decades. He's also a husband, educator, Navy veteran, libertarian, contrarian, gamer, metal-head, vim enthusiast, and MMA fan. Jerry has worked professionally with numerous languages and has built software for industries as diverse as health care, education, banking, public broadcasting, civic engagement, and telecommunications. His current languages of choice are Ruby, Erlang, and R. Jerry lives and works in Akron, Ohio where he is the tech lead for the new product team at VHT (http://www.virtualhold.com/).
Advanced Concurrent Programming in Ruby
Rumor has it that you can't write concurrent programs in Ruby. People once believed that the world was flat and we all know how that turned out. Between the native threads introduced in MRI 1.9 and the JVM threading available to JRuby, Ruby is now a valid platform for concurrent applications. What we've been missing--until now--are the advanced concurrency tools available to other languages like Clojure, Scala, Erlang, and Go. In this session we'll talk about the specific challenges faced when writing concurrent applications; we'll explore modern concurrency techniques such as agents, futures, promises, reactors, and supervisors; and we'll use various open source tools to craft safe, reliable, and efficient concurrent code. We'll write most of our code using the Concurrent Ruby gem but we'll also explore EventMachine and Celluloid.
Jim loves writing code and exploring what can be done with it. His wife and 4 kids are what keep him going. He's also the author of Clean Ruby.
Unleash the Secrets of the Standard Library with SimpleDelegator, Forwardable, and more
With Ruby you have simple tools at your fingertips that make building powerful tools easy. Ruby's standard library comes with some helpful libraries like 'delegate' and 'forwardable' that will help make your code easier to maintain.
We'll dive into how SimpleDelegator is different from method_missing and how Forwardable differs still. Learn the basis of the ideas behind these and combine the features to build your own powerful patterns. See how these compare to libraries like ActiveSupport::Delegation and look at how popular presenter libraries like Draper and DisplayCase work.
Jim Weirich first learned about computers when his college adviser suggested he take a computer science course: "It will be useful, and you might enjoy it." With those prophetic words, Jim has been developing now for over 25 years, working with everything from crunching rocket launch data on supercomputers to wiring up servos and LEDs on micro-controllers. Currently he loves working in Ruby and Rails as the Chief Scientist at Neo, but you can also find him strumming on his ukulele as time permits.
The Big Picture
They say a picture is worth a thousand words. Does that mean a diagram is worth a thousand lines of code? Maybe.
Most Rubyists don't bother with drawing diagrams. We've found that our code is so expressive, that the need to explain the code in high level diagrams is greatly reduced. But greatly reduced doesn't mean never. There are times when a well drawn diagram can help us visualize the global properties of a program that are hard to see when looking at the individual source files.
Since Rubyists don't draw diagrams, we aren't aware of the rich meaning that a good diagram can convey. In this where we learn that UML is not a four letter word, but is just another tool in a well rounded developer's tool chest. Diagrams are not about big design up front, but about conveying meaning to other developers. Come join us and learn to see the big picture.
The renaissance man from Jacksonville, Johnny embarked on his computing curiosity during the eighties on a Commodore 64. However the road leading toward software craftsmanship has diverged down many paths. From musician to electrical engineer, chef to software developer, rugby player to local politician, the twist and turns have provided a wide range of experiences that have helped to shape him.
The Polyglot in the Code - An Elixir/Ruby Mashup
As programmers, change is our only constant. Whether it's innovations in our current stack or the emergence of new languages and frameworks, there is always a new technology to explore. For many of us, that is one of the reasons we were drawn to programming. There is a profound curiosity that drives us and it's that curiosity that can lead to a Polyglot lifestyle. However, just knowing multiple languages isn't enough to claim a Polyglot lifestyle, one must actually utilize their skills. A great example is using one language to explore another. Because of it's flexibility and dynamic nature, Ruby is a great fit for this role. But where to start? In this talk we are going to explore the new functional language Elixir by using Ruby to fill in the gaps. We will look at how Ruby can be used in conjunction with the primary language to handle some of the secondary tasks seamlessly. If your interested in propagating your polyglot potential, join me in embracing Polyglot lifestyle.
I've been an active ruby and rails developer for the past six years. I'm the co-founder of my local software developer group (www.meetup.com/Greater-Athens-Area-Software-Developers/), an active open source contributor, have given numerous presentations at meetups, have facilitated numerous code retreats, and continue to ply my trade as a nerd at http://www.bignerdranch.com.
I love sharing my love for efficiency and effective tool use with my fellow rubyists.
Debugging is an art. And to be an effective artist, an artist must be intimately familiar with their tools. In this talk, we'll start gently and finish strong to ensure that there's something for everyone. We'll cover when to use a debugger, which debugger to use, and how to use the debugger, and how to quickly configure your debugger for maximum utility. We'll touch briefly on pry and why pry is not a debugger, except when it is.
Developers are always looking for ways to boost productivity. Effective debugging allows one to more quickly discover inaccuracies between our expectations and how the software actually behaves.
Kinsey is an apprentice developer at thoughtbot, co-coordinator for Women Who Code Boulder/Denver, and Railsbridge advocate. She loves the Ruby language, pairing, learning everyday and the team she works with at thoughtbot. She enjoys the outdoors, camping, documentaries and is passionate about volunteering in third world countries.
Becoming a Software Engineer: Inspiring a New Generation of Developers
In my wildest dreams, I never thought that I would become a software developer. I thought that I wasn't smart enough, that I needed a computer science degree and to have been writing code since I was young. But, the traditional path to becoming a developer is changing. This talk will focus on alternative and untraditional paths to becoming a developer such as programs like Railsbridge, mentorship and apprentice programs. These alternative paths ultimately foster a more diverse and inclusive community, which drives economic growth and produces more innovative solutions.
The objectives of the talk are:
- to bring awareness to the educational alternatives to computer science degrees
- to encourage empathy when mentoring a beginner
- to get the audience to see a different perspective and embrace differences in the industry
Koichi Sasada is a member of Matz team in Heroku, Inc. Now he is working on development of Ruby 2.1, especially for new generational GC.
Object management on Ruby 2.1
We are working on development of Ruby 2.1 to improve its quality. Ruby 2.1 will be released with several new features, especially with new *generational* garbage collection. In this talk, I will show you a brief introduction of new GC algorithm and other new features of Ruby 2.1.
Loren Segal is an avid open source hacker, writing and contributing to tools like YARD, a Ruby documentation tool, RubyCorrect, a static analysis and automatic test case generation tool, and Seahorse, a web service API modeling library.
A Peek Inside The Ruby Toolbox
Luca Bonmassar is an entrepreneur and technical savant. In 2011, Gild, a company that brings meritocracy to tech hiring through big data, acquired his startup Coderloop and brought him on as CTO. Prior to joining Gild, Luca worked for Nokia and Vodafone, where he led product and software development projects.
Mastering Elasticsearch With Ruby
Users have come to expect state-of-the-art search features in every part of their online experience. The good news for developers is that features like autosuggest, spell-correct, and personalized search are becoming easier to develop thanks to services like Elasticsearch. Integrating Elasticsearch into ruby apps is now relatively straightforward thanks to the Tire wrapper library. The talk will examine how to build an Elasticsearch cluster, create indexes, load data, and format and execute robust search features using the ruby Tire library.
I'm a freelance developer. Wanting to do things right leads me into all sorts of trouble, including becoming a CRuby committer in 2009 as well as other contributions to open source projects.
Ruby-core is where Ruby features are born and bugs gets squashed. Get a glimpse of what this entails and test your Ruby knowledge and intuition at the same time.
How surely can you differentiate unexpected behavior from normality? How in tune is Matz's principle of least surprise with yours? Can you distinguish bugs from features?
We will figure it out through a series of questions inspired by actual bug reports and feature requests, spiced up with a couple of trick questions. Each question is a dilemma and everyone gets to pick if they think it's a bug or a feature.
To uncover the answers, we'll have to explore unchartered territories. We'll dig deep in recursion, battle failing specs, encounter exotic Floats and other infinities, and decipher arcane C code.
Rubyists of all levels, from beginners to hardcore pros are invited in this informal challenge. Be sure to check your ego at the door, as no-one will escape unscathed; even top notch ruby-core committers don't always get right answers! Let's discover what can lie under the apparent simplicity of Ruby without forgetting to have fun.
Mark Bates is the founder and chief architect of the Boston, MA based consulting company, Meta42 Labs. Mark spends his days focusing on new application development and consulting for his clients. At night he writes books, raises kids, and occasionally he forms a band and “tries to make it”. In 2009 Mark’s first (surprisingly not his last!) book, “Distributed Programming with Ruby”, was published by Addison-Wesley. In 2012 Addison-Wesley published Mark’s second book, “Programming in CoffeeScript”.
Mangling Ruby with TracePoint
Introduced in Ruby 2.0, TracePoint is meant to help developers better instrument their code for debugging and performance reasons, but there's more to TracePoint than that!
In this talk we'll learn about TracePoint while building several example projects. Once we know the basics we'll use TracePoint to do things to Ruby that we couldn't have done otherwise.
By the end of this talk you'll be able to frighten and amaze your friends when you show them things like true abstract classes and interfaces in Ruby, just like Java! Yikes!
I'm the co-founder of Splice.com, a music platform that redefines the music creation process. When I'm not coding, I'm chilling in Southern California with my family.
Bad Ruby code doesn't exist
Ruby is a rich language with dark corners. Over the years, we have been exploring more and more of these corners. But taking a step back, it's now obvious to me that there is no such thing as bad Ruby code. As programmers, we have a natural tendency to focus on code syntax, concepts and tools. But maybe we are missing the point. My talk will be in two parts: First, I will present my opinion on "bad" Ruby code and in the second, Bryan Helmkamp and Bryan Liles will join me on stage to discuss their own experience and share concrete recommendations.
Matthew Kirk is a partner at Modulus 7, specializing in software development and strategy. The basis of his career has been around utilizing science to improve businesses. He started his career at Parametric working as a quant to help develop an Enhanced Income strategy consisting of closed end funds. After leaving Parametric he became entrenched in the startup industry applying his love of bringing technology and science together with profit and customer happiness. He has worked with many businesses since including Wetpaint, SocialVolt, Civilization, City of Bellevue, The Clymb and Ritani.
Matthew holds a B.S. in Applied Mathematics and a B.S. in Economics from the University of Washington, and has spoken at technology conferences around the world. In his spare time, he enjoys traveling and adding to his 2000+ vinyl record collection.
Test Driven Neural Networks with Ruby
Neural networks are an excellent way of mapping past observations to a functional model. Many researchers have been able to build tools to recognize handwriting, or even jaundice detection.
While Neural Networks are powerful they still are somewhat of a mystery to many. This talk aims to explain neural networks in a test driven way. We'll write tests first and go through how to build a neural network to determine what language a sentence is.
By the end of this talk you'll know how to build neural networks with tests!
Michael Fairley is a developer at Braintree Payments, where he uses Ruby to make it easy for businesses around the world to accept credit card payments online. He’s an active open source contributor, and maintains a handful of side projects including mincemeat.py and bestintrobook.com.
Rapid Game Prototyping with Ruby
Just as Ruby is great for getting a new web project off the ground and into production, Ruby is equally awesome for quickly building games up from scratch and continuing to iterate on them. This talk explores the basics of how computer games work, shows the tools available for building games in Ruby, and has a live demonstration of creating a simple game.
Nathaniel enjoys making things go at Spreedly, tickling his seven kids, and taking long walks in the mountains with his wife. He is the original author of Test::Unit and is a maintainer on the ActiveMerchant project.
I stumbled into being a maintainer on a big open source project pretty much by accident; I was contributing patches a lot and didn't want to be a nuisance, so I asked for commit privileges. At first I was just expediting my own patches, but then there were all these outstanding issues, and before I knew it I was a top committer on the project.
Being a maintainer is fun, but it can also be annoying and exhausting. I'll talk about the things that I've struggled with as a maintainer and the workflow I've developed over time to keep myself sane. There will be Git tips gleaned from kernel maintainers, ideas on encouraging contributions without feeling the need to accept every patch, straight talk on avoiding burnout, and most importantly I'll try to get across the joy that comes from being instrumental in moving a useful piece of software forward.
Not an open source maintainer and have no plans to ever be one? You should still come, since everything I talk about will also help you be a better open source contributor as well!
Nell Shamrell works as a Software Development Engineer for Blue Box. She also sits on the advisory board for the University of Washington Certificate in Ruby Programming. She specializes in Ruby, Rails, Regular Expressions, and Test Driven Development. Prior to entering the world of software development, she studied and worked in the field of Theatre. The world of Theatre prepared her well for the dynamic world of creating software applications. In both, she strives to create a cohesive and extraordinary experience. In her free time she enjoys practicing the martial art Naginata.
Beneath The Surface: Harnessing the True Power of Regular Expressions in Ruby
Many of us approach regular expressions with a certain fear and trepidation, using them only when absolutely necessary. We can get by when we need to use them, but we hesitate to dive any deeper into their cryptic world. Ruby has so much more to offer us. This talk showcases the incredible power of Ruby and the Onigmo regex library Ruby runs on. It takes you on a journey beneath the surface, exploring the beauty, elegance, and power of regular expressions. You will discover the flexible, dynamic, and eloquent ways to harness this beauty and power in your own code.
Nicolas Viennot is a PhD candidate at Columbia University. He focuses his research on operating systems, distributed systems, databases and software reliability. He is an experienced Linux kernel developer that fell in love with Ruby three years ago. He is the maintainer of several open source projects, such as tmate.io, an instant terminal pairing tool.
Kareem Kouddous is a startup addict with over 13 years years of battle scars. He's currently the CTO and Founder at Crowdtap and he co-organizes the NYC Lean Startup Meetup. He's an active open source contributor believing firmly in paying it forward.
Promiscuous: A robust service-oriented architecture framework
Splitting applications is challenging for numerous reasons. One of the biggest challenge is to keep all the applications’ data in sync. We introduce Promiscuous, an open source replication framework that facilitates data replication across applications in a safe and consistent manner. Unlike traditional approaches such as Stripe’s MoSQL and LinkedIn’s Databus, which operate at the database level, Promiscuous transparently instruments the ActiveModel interface to replicate model operations by using Redis and RabbitMQ. This makes it a great solution for separation of concerns, heterogeneous database replication, and asynchronous triggers in the datacenter.
We’ll dive into the mechanics of Promiscuous and how we used it to split our monolithic application into eight small, single purpose applications. We will also show our findings in scalability, deployment, migration, unit/integration testing, and general architecture best practices laced with real world examples.
 Promiscuous: http://github.com/crowdtap/promiscuous
 MoSQL: https://github.com/stripe/mosql
 Databus: https://github.com/linkedin/databus
Rubyist at Big Nerd Ranch, coffee snob, and distributed computing enthusiast.
Raft: Consensus for Rubyists
Consensus. It's not anything new. In fact, there have been great papers and discussions on the topic since the late 80's. But this year, a new consensus algorithm was written up in a paper titled, "In Search of an Understandable Consensus Algorithm". This is actually pretty rare in academia -- a paper, about a complex topic, that takes a systems approach to describing an algorithm. Not only do they give you a cheat-sheet on what RPC calls you'll need, but the entire algorithm is focused on being understandable first, which is something I think a lot of rubyists can appreciate.
I've always thought one of the major themes in the community was to focus on making software fun. Not only telling whimsical stories about foxes who like bacon or naming gems named after 90's cartoon characters, but making an effort to break problems down into small, digestible pieces and delivering them in the most practical way possible. Describing the Raft algorithm is a chance to get rubyists excited about what's going on in the distributed computing world and academia in general.
So what all do I want to teach everyone? The core concepts behind consensus, the three parts that make up the raft algorithm (consensus, state machine, and replicated log) with a toy implementation in ruby, and, most importantly, where to apply it in the real world (replacing redis, distributed configuration, and database failover). But I also have an ulterior motive, to use this unique paper to bridge the gap between academia and ruby, both making understandability more important in the education community and bringing more interesting complex projects to ruby.
Pat Shaughnessy is a Ruby developer working at McKinsey & Co., a global management consulting firm. Author of Ruby Under a Microscope, Pat loves diving into the details of a technology, learning how it works, and then explaining it in simple terms that everyone can understand. Pat's blog articles and conference presentations have been featured multiple times on the Ruby Weekly newsletter, the Ruby5 podcast and the Ruby Show.
Visualizing Garbage Collection in Rubinius, JRuby and Ruby 2.0
In this talk we’ll dive into Ruby internals and take a close look at an ugly topic: garbage collection. How do these Ruby VM’s allocate memory for new objects? How do they identify unused objects? How do they reclaim memory from garbage objects, allowing it to be used again?
You can learn a lot about someone from their garbage. Using a series of diagrams, we’ll visually compare and contrast the complex algorithms these very different Ruby implementations use. What computer science research is behind each garbage collector? We’ll also look at the GC changes planned for the upcoming Ruby 2.1 release.
PJ is a developer, a dad, and is currently a Community Engineer with Engine Yard.
Katie is a coder, dancer, writer, 6th grader who loves to code and wants to learn everything there is to know.
My KidsRuby Journey
About a year ago, we started a journey to see if kids can code. Guess what?
This talk will be a review of the journey itself and a discussion between parent and child on what happened, what's next, and what you should be doing to encourage the next generation of developers.
Ron Evans is a well-known software developer who has been very active in the free and open source community for over 20 years. As ringleader of The Hybrid Group, he has been helping clients solve some of their most difficult technical and business problems. Ron has been a very active speaker, presenting at conferences such as Golden Gate Ruby Conference, RubyConf, FutureRuby, Ignite, Los Angeles Ruby Conference, Conferencia Rails, and MagmaConf. He was featured in Computerworld Magazine in the article "Rock Star Coders" for his popular blog post "I'd Rather Be A Jazz Programmer", as well as having written articles for MSNBC, BYTE Magazine, and the Direct Marketing Association, Ron is an active code contributor to many open source projects, including being the creator of the award-winning KidsRuby, free software to help teach Ruby programming to kids
Ruby On Robots Using Artoo
The robotics revolution has already begun. You can buy drones and robotic devices at local retail stores. Unfortunately, it’s hard to develop code for robots, and nearly impossible to create solutions that integrate multiple different kind of devices.
Introducing Artoo (http://artoo.io), a new robotics framework written in Ruby. Artoo can communicate with many different kinds of hardware devices, and integrate them together. With surprisingly few lines of code, you can write interesting applications that tie together Arduinos, ARDrones, Spheros, and more... even all at the same time!
Artoo is based on Celluloid, giving it the ability to support the levels of concurrency that are required for industrial-strength robotic applications. Artoo has a built in API-server, debugging console, and even shows you how to do Test-Driven Robotics (TDR).
The time has come for Ruby-based robotics, and Artoo can help lead the way!
I've been programming Ruby for over 6 years now, first at IBM, writing command-line tools, then at the University of Arizona, writing support tools for IT development and operations teams, and now finally at Google for the Wildfire group, working on mature Rails applications. Last year I was awarded a grant by the Ruby Association to work on Mathematics gems that help the Ruby language progress into the realms of scientific research and high-performance computing. I'm very excited to see the Ruby community grow to the point where our applications are so powerful that performance and garbage-collection are among our primary concerns.
New Ruby 2.1 Awesomeness: Fine-grained Object Allocation Tracing
Ruby 2.1 is coming out soon with an amazing new feature under ObjectSpace: #trace_object_allocations. We are now able to trace the file and line number (as well as method) where any Ruby object is allocated from. This is a very welcome feature, as object-level tracing has been very difficult in Ruby, especially since the memprof gem could not support Ruby past 1.8.x.
This new Ruby 2.1 feature is really just exposing some raw (and vast) data, so it can be difficult to tease out meaningful information. Two gems are introduced in this talk to solve just that problem. The objspace-stats gem allows us to view and summarize new object allocations in meaningful ways. We'll look at how to filter, group, and sort new object allocations. The second gem is rack-objspace-stats. We'll see how this tool can intercept requests to a Rack stack, and measure new object allocations taking place during the request. (For those familiar, this works very similar to the rack-perftools_profiler gem.)
We'll look at various examples of how this new Ruby 2.1 feature, and these tools can help an organization reduce unnecessary memory allocations, and speed up their code, especially mature Rack applications.
I do Ops for CardSpring in San Francisco, in my previous lives I have been a Frontend Engineer before earning my backend chops in Rails. Whatever I'm doing I know that testing matters and I always strive to make my tests as close to production as possible, whether that means making assertions in browsers or live on cloud hardware.
How To Roll Your Own Ops Framework In Ruby (If You Really Have To)
There are currently a great crop of tools out that for doing Ops in Ruby, but when you need real certainty about your infrastructure for a specific provider the only way to test is through provisioning actual resources and making assertions about them. Currently the tools aren't quiete there.and you might be better off rapidly developing your own deployment framework with integration testing in mind. This talk will discuss what we've done at CardSpring to develop our own Ops as a Service and provide developers with a stress free deployment API using Ruby, Chef, and AWS and backed by full RSpec coverage.
Stephen Henrie has been professionally working in the field of Software Engineering for over twenty-five years. He is currently a Manager of Software Engineering at Sony Playstation helping to host the online functionality for many of the games. He previously worked for places such as Scripps Institute of Oceanography, Leadfusion, Inc, a technology provider for the financial industry, Arizona State University and Bell Laboratories way back in the day. Stephen holds a BS in Electronic Engineering Technology from Southern Illinois University and an MS in Electrical Engineering and Computer Science from the University of Illinois-Chicago.
A Lightweight SOA Framework using Ruby, Apache Thrift and AMQP
Service-oriented architecture (SOA) is an evolution of distributed computing based upon the request/response design pattern (aka RPC) for communication between independent system components. These components modularize system functionality and encapsulate their business logic that is presented as Services to be consumed by client applications or other services.
The key to these Services is their loosely coupled nature; i.e., the service interface is independent of the implementation and developers can build applications by composing one or more services without knowing the services' underlying implementations. The use of messaging to connect distributed Service components provides a consistent communication platform to ensure a scalable, decoupled and reliable system that can grow over time with minimal impact on an existing system.
This talk will demonstrate one approach to implementing just such a system; focusing on a Ruby implementation of Service functionality and a lightweight RPC framework based on the Apache Thrift protocol specification and AMQP for messaging transport.
We’ll show just how easy it can be to build such a complex and highly distributed SOA system using Ruby and a couple of other open source projects.
Preferring Object-Orientation to Metaprogramming
Metaprogramming in Ruby is a mixed blessing: it makes many impossible things possible. This quicker, easier, more seductive path, however, can lead to contorted code that's difficult to maintain and can be hard to understand. So what's the alternative? For many uses of metaprogramming, good object-orientation, or a well-chosen design pattern, can provide just as much power without the challenges to intelligibility. This talk aims to (re)introduce several key Object Orientation concepts, and a few critical design patterns, then present them as superior alternatives to metaprogrammatic approaches.
Team Yamanekko is a developer group of Yurie Yamane and Masayoshi Takahashi.
We are using mruby for micro controllers, with the slogan "tanoshii mruby(mruby for fun)".
Yurie Yamane is a programmer who is interested in embedded systems,
and a member of asakusa.rb.
Masayoshi Takahashi is an old-time Rubyist and the founder of Nihon
Ruby no Kai, the non-profit Ruby community in Japan. He is also the
founder of Tatsu-Zine Publising, the e-book publisher for IT engineers
How to control physical devices with mruby
Let's control physical devices using mruby on your board!
mruby has not been released yet, but you don't have to wait for it.
Current mruby is good enough for prototyping or learing.
If you have cheap microcontroller boards like STM32F4Discovery or Raspberry Pi,
you can run mruby on them and control physical devices, without other computers
to control them. And if you have right mrbgems, what you need is writing
small Ruby code, neither C nor assembler.
In this session, we will talk about how to use mruby and how to create
and use mrbgems so as to controll LEDs, buttons, accelerometer and so on.
Thomas Enebo is co-lead of the JRuby project and an employee of Red Hat. He has been a practitioner of Java since the heady days of the HotJava browser, and he has been happily using Ruby since 2001. Thomas has spoken at numerous Java and Ruby conferences, co-authored "Using JRuby", and was awarded the "Rock Star" award at JavaOne. When Thomas is not working he enjoys biking, anime, and drinking a decent IPA.
The Future of JRuby
JRuby is a fast, compliant Ruby implementation which can make use of many features of the Java platform. What more is there to do? Can it be made faster? Will it ever load faster? Any plans on making cross-implementation native C extension API?
This presentation will answer questions like this and give some examples of exciting future projects involving JRuby. If you want a good insight into where JRuby is going then this talk is for you.
Tom is a computer scientist and Ruby programmer. He has lectured on optimizing compilers at the University of Cambridge, co-organizes the Ruby Manor conference, and is a member of the London Ruby User Group. His new book, Understanding Computation, was published by O’Reilly in May.
Compilers For Free
Partial evaluation is a powerful tool for timeshifting some aspects of a program's execution from the future into the present. Among other things, it gives us an automatic way to turn a general, abstract program into a faster, more specialized one.
This math-free talk uses Ruby to explain how partial evaluation works, how it can be used to make programs go faster, and how it compares to ideas like currying and partial application from the world of functional programming. It then investigates what happens when you run a partial evaluator on itself, and reveals some surprising results about how these techniques can be used to automatically generate compilers instead of writing them from scratch.
Tony is a member of the Infosec team at Square where he works on Platform Security. He's also the creator of Celluloid, a concurrency library for Ruby based on the Actor Model. When he's not working on cryptography or concurrency, Tony is probably poking around with synthesizers or at a local karaoke bar.
Being Boring: A Survival Guide to Ruby Cryptography
We all know that security is hard, and that math is hard, but what happens when you put them together? Cryptography is an increasingly essential tool for building secure systems, but also a perilous minefield where any number of mistakes can lead to insecure systems.
This talk will take you step-by-step through the difficulties of building secure cryptosystems on top of Ruby's existing OpenSSL bindings and contrast that with RbNaCl, a next generation Ruby cryptography library specifically designed to be more mistake-proof and put cryptography "on Rails". Attendees will hopefully learn that the best approaches to cryptography rest in making systems simple, straightforward, and boring... in a good way.
Xavier is an Engineering Manager in the Production Engineering group at Square, based in San Francisco. He is a contributor to RSpec, a Bundler core team member, and has over fifty published repositories on GitHub. He has been working professionally with Ruby since 2006. Also, Xavier is just an all-around great guy.
Profiling Ruby: Finding 10x Gains In RSpec and CRuby
In this detective story we'll start by identifying and fixing easy performance problems in Ruby, before working our way down to the guts of the interpreter itself. Using concrete examples from RSpec and CRuby we'll cover all the necessary tools including benchmark, ruby-prof, gnuplot, and more, and show how you can tie them all together to solve real problems yourself.
CRuby committer, contributor to sinatra, rails, rdoc, etc
Under The Influence
What inspires you?
Hopefully you can answer this question without too much hesitation. If it weren't for several very important influences, our beloved Ruby would be drastically different. Could you imagine?
This talk will open your eyes to archiac forms of writing software. We will expand your mind with new ideas in light of what we already know and are familiar with.
Let's explore Ruby's programming roots with some accidental code written in languages both incluenced by and influential to the language we know and love.