The history of programming is filled with examples of bugs that actually turned out to be features and limitations that pushed developers to make an even more interesting product. We’ll journey through code that was so ‘bad’ it was actually good. Then we’ll learn to tame our inner perfectionists so our code will be even better than it is today.
Picking an encryption algorithm is like choosing a lock for your door. Some are better than others - but there's more to keeping burglars out of your house (or web site) than just the door lock. This talk will review what the crypto tools are and how they fit together with our frameworks to provide trust and privacy for our applications. We'll look under the hood of websites like Facebook, at game-changing exploits like Firesheep, and at how tools from our application layer (Rails,) our protocol layer (HTTP,) and our transport layer (TLS) combine build user-visible features like single sign-on.
"That's not very RESTful." As a Rails developer you've probably heard or even spoken that proclamation before, but what does it really mean? What's so great about being RESTful anyway?
RESTful architecture can narrow the responsibilities of your Rails controllers and make follow-on refactorings more natural. In this talk, you'll learn to refactor code to follow RESTful principles and to identify the positive impact those changes have throughout your application stack.
For some, making web applications accessible is a must; Government websites fall under Section 508 and retail sites need to reduce legal risk.
But for others it seems like a luxury; Consultants are expensive, and so are the developer hours spent trying to parse the notoriously hard-to-read WCAG 2.0 docs.
There is an easier way to start!
In this session, we will demystify the WCAG 2.0 basics. We’ll use Chrome Accessibility Dev Tools to discover and fix common issues. You will leave with a set of free and easy-to-use resources to start improving the accessibility of your application today.
Ever wonder why applications use sessions and APIs use tokens? Must there really be a difference? JSON Web Tokens are an emerging standard for portable secure messages. We'll talk briefly about how they're built and how they earn your trust, then dig into some practical examples you can take back and apply to your own majestic monolith or serious services.
Once upon a time, Goldilocks had a couple extra minutes to spare before morning standup. She logged into Github and saw that there were three pull requests waiting for her to review.
We've probably all heard that peer code reviews can do wonders to a codebase. But not all type of code reviews are effective. Some of them seem to go on and on forever, while others pick at syntax and formatting but miss bugs. This talk explores what makes a strong code review and what makes a painful one. Join Goldilocks as she seeks to find a code review process that's neither too long nor too short, but just right!
We have amazing skills and abilities, but for a lot of us the missing piece is finding a way to give back. We have an amazing panel of people who have used their skills and talents from both previous careers and current to make the world a better place. Learn how they got involved, and in turn what you can do to get involved in areas you’re passionate about to fill this missing piece that will keep you happy throughout your career.
It’s what everyone is talking about: cyber security, hacking and the safety of our data. Many of us are anxiously asking what can do we do? We can implement security best practices to protect our user’s personal identifiable information from harm. We each have the power and duty to be a force for good.
Security is a moving target and a full team effort, so whether you are a beginner or senior level Rails developer, this talk will cover important measures and resources to make sure your Rails app is best secured.
What if your Rails app couldn’t tell who was visiting it? If you had no idea that the same person requested two different pages? If all the data you stored vanished as soon as you returned a response? The session is the perfect place to put this kind of data.
But sessions can be a little magical. What is a session? How does Rails know to show the right data to the right person? And how do you decide where you keep your session data?
Tests try to observe change. But are some systems too big to observe them all? What if we need to test a function with a very complex output?
In this talk, we'll explore a Gold Master test– a special test for evaluating complicated legacy systems. We'll look at how this test takes an input, such as a production database, runs it through a transformative function, and then compares the output to an approved version of the output.
Testers of every experience level will leave this talk with a new technique for evaluating complex environments, and a broader conception of what a test can be.
Let's take a peek under the hood of the magical "sort" method, learning algorithms... by sorting audience members wearing numbers! Intimidated by the word "algorithm? Not sure what performance means? Confused by "Big O Notation"? Haven't even heard of best-, worst-, and average-case time complexities? No problem: we'll learn together! You can expect to come out knowing new things and with Benny Hill stuck in your head.
Come on a journey backward through time from the present all the way to August 2005 to see how a living and evolving Rails application started, changed, and continues.
Find out some of the challenges and temptations in maintaining this application. See how different influences have coursed through the application as the team changed, the business grew and as Rails and Ruby evolved.
We'll explore history through code and learn from some of the developers involved in the application over its lifecycle to build an understanding of where the application is now and how it became what it is.
Why are there are so many disagreements in software? Why don’t we all converge on the same beliefs or technologies? It might sound obvious that people shouldn't agree, but I want to convince you it’s weird that we don't. This talk will be a philosophical exploration of how knowledge converges within subcultures, as I explore this question through the worlds of software, online fraud, and poker.
Board games are great, but who has time to keep track of what's going on when you just want to have fun? In the spirit of over-engineering we'll look at PitchCar -- probably one of the simplest games in the world -- and see how far we can go with web tech, image processing, and a bunch of math. Expect to see plenty of code, some surprising problems and solutions, and of course: A live demo.
Spoon theory is a metaphor about the finite energy we each have to do things in a day. While a healthy, advantaged person may not have to worry about running out of ‘spoons,’ people with chronic illnesses or disabilities and members of marginalized communities often have to consider how they must ration their energy in order to get through the day. Understanding how 'spoons' can affect the lives of your developers and teammates can help companies lessen the everyday burdens on their underrepresented employees, leaving them more spoons to do their best work, avoid burnout and lead fulfilling lives.
Programming is a deeply mental art. As programmers, we invest large amounts of time in mastering new languages, new techniques, and new tools. But all too often, we neglect our understanding of the most important tool in the developer's toolbox: the programmer's brain itself.
In this talk, we will combine the art of programming with the science of cognitive psychology, and emerge with a deeper understanding of how to leverage the limits of the human mind to sustainably craft software that is less buggy, easier to understand, and more adaptive in the face of change.
Chatbots, ActionCable, A.I. and you. And many more buzzwords will enthral you in this talk.
We'll learn how to create a simple chatroom in Rails using ActionCable, then how to talk to your colleagues in the office or remote locations using text to speech and Amazon Voice Service.
Using the power of ActionCable we will explore how its possible to create an MMMOC: massively multiplayer online chatroom, that you can use TODAY to see your; Travis Build status, or deploy code to your favourite PAAS, let you know when the latest release of Rails is out. Using nothing but your voice and ActionCable.
Are you ready to begin building applications with Ruby on Rails? It's very easy to follow a tutorial and learn how to build a blog in 15 minutes, but there's a lot more to it in real life when you try to code a big web app.
During this talk I will give you a bunch of tips and tricks for Rails development that almost everyone follows but rarely anyone talks about.
If you are about to join this fantastic community, this talk is for you.
At the 2014 RailsConf DHH declared system testing would be added to Rails. Three years later, Rails 5.1 makes good on that promise by introducing a new testing framework: ActionDispatch::SystemTestCase. The feature brings system testing to Rails with zero application configuration by adding Capybara integration. After a demonstration of the new framework, we'll walk through what's uniquely involved with building OSS features & how the architecture follows the Rails Doctrine. We'll take a rare look at what it takes to build a major feature for Rails, including goals, design decisions, & roadblocks.
You care deeply about code quality and constantly strive to learn more. You devour books and blogs, watch conference talks, and practice code katas.
That's excellent! But immaculately factored code and clean architecture alone won't guarantee quality software.
As a developer, your job isn't to write Good Code. It's to deliver value for people. In that light, we'll examine the effects of a host of popular coding practices. What do they accomplish? Where do they fall short?
We'll set meaningful goals for well-rounded, high-quality software that solves important problems for real people.
With complexity comes errors, and unexpected errors lead to unexpected unhappiness. Join us and learn how to add contextual data to errors, design error hierarchies, take charge of control flow, create re-usable error handlers, and integrate with error reporting solutions. We'll talk about recoverable versus irrecoverable errors and discuss how and how not to use exceptions. From internationalization to background jobs, we'll cover the gamut. Regardless of your Rail proficiency, you'll learn why expecting the unexpected makes for happier developers, happier businesses and happier users.
Ruby on Rails is a widely used web framework, using HTTP to serve users web pages and store data to databases. But what about serving different types of clients? Is it possible to integrate Rails with other protocol types to talk to other machines? Is it efficient? How would it work? I'm going to share my team's approach integrating a Ruby on Rails application with automation and warehouse hardware, such as barcode scanners and Zebra printers.
Open source projects like Rails are intimidating, especially as a beginner. It’s hard to look at the code and know what it does. But Ruby on Rails is more than just code. Written into it are years of research, discussions, and motivations. Also written into it are bugs, typos, and all of the pieces that make the code human. This talk outlines steps you can take to explore the inner workings of Rails and gain context on its design. Understanding how Rails works will allow you to write better Rails applications and better Ruby code. You will leave with many resources and tips on perusing Rails.
While Rails is the most common Ruby web framework, it’s not the only option. Rack is a simple, elegant HTTP library, ideal for microservices and high performance applications.
In this talk, you’ll see Rack from top to bottom. Starting from the simplest app, we’ll grow our code into a RESTful HTTP API. We’ll test our code, write reusable middleware, and dig through what Rack provides out of the box. Throughout, we’ll balance when Rack is a good fit, and when larger tools are needed.
If you’ve heard of Rack but wondered where it fits in the Ruby web stack, here’s your chance!
Forms are a crucial part of every app and Rails has good defaults for building them—unless you need something complicated. Maybe you want a multi-step wizard? Or maybe you'd like to pluck attributes from any model? Validation becomes a pain point. So you introduce a state machine, or nest your models, or do some other calisthenic to get everything working. Thankfully there's a better way! This talk takes a complicated wizard and converts it into a few simple form objects—it's a deep dive on decoupling models and how you can leverage Trailblazer's Reform gem to make it even easier.
The average American worker will have 10 jobs before the age of 40. There's a great deal of opportunity and mobility in our industry, and yet, our hiring process is anything but pleasant or streamlined. The hiring process is time consuming for both candidates and employers, but we can do better! Let's explore the ways we can improve the hiring process by writing better job descriptions, utilizing systems that free us from unconscious biases, focusing beyond culture fit, and using better (more fun) technical interviewing methods.
We live in a world where you can schedule a meeting by talking to your watch or turn off your lights by asking Alexa as if she were your roommate. But would voice dictation work for something more intensive, like a web app used for hours of data entry?
In this talk, I’ll show you how to implement the Web Speech API in a few simple steps. I’ll also walk through a case study of using the API in a production Rails app. You’ll leave with an understanding of how to implement voice dictation on the web as well as criteria to evaluate if voice is a viable solution to a given problem.
People give ruby a bad reputation for speed, efficiency, weak typing, etc. But one of the biggest benefits of an interpreted language is the ability to debug and introspect quickly without compilation. Oftentimes developers reach for heavy-handed libraries to debug their application when they could just as easily get the information they need by using tools they already have.
In this talk you will learn practical techniques to make debugging easier. You will see how simple techniques from the ruby standard library can greatly increase your ability to keep your codebase clean and bug-free.
This is a sponsored talk by Engine Yard.
Containers have gained popularity the past few years but they have been around much longer than that. In this talk, we'll dive into the internals of a container. If you have used or heard about Docker containers but are unsure how they work, this talk is for you.
You’ll also learn how to run Rails in production-ready container environments like Kubernetes.
Steve Jobs. Linus Torvalds. Alan Turing.
Been there, done that.
The interesting stories often aren’t the ones we grew up with; they’re the ones we’ve left behind. When it comes to tech, that means its women, and especially its women of color. And while there’s been a greater emphasis lately on rediscovering women’s contributions to technology, we need to expand our focus beyond just Grace Hopper and Ada Lovelace.
From Radia Perlman to Sophie Wilson to Erica Baker, let's explore both tech’s forgotten heroes and its modern-day pioneers, and help end the silent erasure of women in technology.
RSpec gives you many ways to test your Rails app. Controller, view, model, and so on. Often, it's not clear which to use. In this talk, you'll get some practical advice to improve your testing by understanding how RSpec integrates with Rails. To do this we'll look through some real world RSpec bugs, and with each one, clarify our understanding of the boundaries between RSpec and Rails.
If you're looking to level up your testing, understand RSpec's internals a little better, or improve your Rails knowledge, this talk will have something for you. Some knowledge of RSpec's test types will be assumed.
00:00 Benjamin Flacier
01:23 Heather Herrington
06:39 Casey Maucaulay
10:56 Kirsten Ruben
17:44 Lucas Fittl
18:40 Justin Collins
19:36 Ernesto Tagwerker
20:55 Chris Sexton
24:07 Michael toppa
29:55 Isaac Sloan
34:39 Ried Morrison
38:14 Alejandro Corpeño
43:44 Michael Hartl
50:09 Ariel Caplan
55:08 Alex Wood
05:50 Jingyi Chen
01:03:12 Lew Parker
Just because you don't have lead / senior / manager / owner in your title, doesn't mean there isn't plenty of opportunity to lead. No matter where you are in your career, come discover how to communicate more effectively, embrace self-awareness, and influence those leading you. Don't wait for a title to tell you to lead. Take responsibility where you are, and let the titles come to you.
Machine Learning is no longer just an academic study. Tools like Tensorflow have opened new doorways in the world of application development. Learn about the current tools available and how easy it is to integrate them into your rails application. We'll start by looking at a real-world example currently being used in the wild and then delve into creating a sample application that utilizes machine learning.
Woodworking has experienced quite a renaissance as of late, and a very popular style involves using power tools for rough work and hand tools for detail and precision work. Using both defines each woodworker's speed and ability to produce beautiful/functional pieces. The same can be true of developers. Automation, convention, powerful IDEs, generators and libraries can make each developer go from nothing to something very quickly, but what about diving deeper to get the precision, performance and beauty you need out of your applications? Come find out.
What's a better way to understand machine learning than a practical example? And who hasn't watched the 1997 classic with Jack and Rose? In this talk we will first take a look at some real historical data of the event. Then we will use amazing Python libraries to live code several of the most well known algorithms. This will help us understand some fundamental concepts of how machine learning works. When we're done, you should have a good mental framework to make sense of it in the modern world.
Elixir has rapidly developed into a mature language with an ever-growing library of packages that excels at running web apps. And because both Elixir and Phoenix were developed by Ruby / Rails programmers, the ease with which you can learn Elixir as a Ruby developer, is much greater than many other languages. With numerous code examples, this talk will discuss how learning a functional approach to handling web requests can improve what we do every day with Rails. This talk is aimed at people who have some familiarity with Rails but no experience with Elixir is necessary.
Are you a Rails expert? To someone just learning Rails, yes, you are. And you can mentor the next generation of experts. What new skills will you develop by mentoring? And how does one find a mentee or mentor? In this talk, you'll learn how to establish effective, quality mentoring relationships where both parties grow their skills—and their career. Mentoring accelerates your personal and career growth. Come learn how much you'll grow by sharing your knowledge and experience using practices like inquiry based learning, differentiated learning, and active listening.
Over the past year, I’ve spoken at several conferences, lost 30 pounds, and worked up to running my first 5K, all while leading an engineering team and spending significant time with my family. I also have less willpower than just about everyone I know. So how’d I accomplish those things?
Let’s talk about how to build goals the right way so that you’ll be all but guaranteed to hit them. We’ll work through the process of creating systems and nurturing habits to turn your brain into your biggest ally, no matter what you want to accomplish!
The ideal workplace, with motivated employees, supportive managers and a clear vision in the "C-suite", is where we'd all like to work, isn't it? The question then, is, how do we create it? How do managers walk the fine line of "micromanaging" and "anarchy"? How can we, as employees, maximize our contribution to our company and love what we do at the same time?
The secret is in the big band.
Inspired by Max Dupree's Leadership Jazz, this talk will show you how to apply the principles of improvisation to your company/team and make your workplace more efficient, effective and fun!
Eighteen months ago, our fairly typical Ruby on Rails app had some mundane client side interactions managed by a tangle of untested JQuery spaghetti.
Today, new features are built with React, CSS modules, and a far better UX. With ES6 front end code, processed with Babel, compiled (and hot-reloaded in development) with Webpack, and tested with Jest – all within the same Rails application.
Come along to this talk to hear how we migrated our app a piece at a time to use technologies that don’t always sit naturally alongside Rails. I will cover technical implementations and lessons learned.
Each minor release of Rails brings shiny new features and mild headaches for developers required to upgrade their applications and gems.
In this talk, I will cover the improvements brought by Rails 5.1, explain the Core team’s motivations behind each feature, and illustrate the upgrade process to smoothly transition gems and apps from Rails 5.0 to Rails 5.1.
As the stigma of speaking out about mental health conditions declines, leaders in the programming community are are being given many new opportunities to support their teams. In this session you will learn about the issues some of your team may face both in dealing with their own potential mental health difficulties and that of other team members. We will go over ways to support both the individual and team, how to advocate for team members with mental health conditions, and resources for further information and outreach for you and your team.
Before programming, before formal probability there was Bayes. He introduced the notion that multiple uncertain estimates which are related could be combined to form a more certain estimate. It turns out that this extremely simple idea has a profound impact on how we write programs and how we can think about life. The applications range from machine learning and robotics to determining cancer treatments. In this talk we'll take an in depth look at Bayses rule and how it can be applied to solve problems in programming and beyond.
Postgres has powerful datatypes and a general emphasis on correctness which makes it a great choice for apps small and medium. Growing to very large sizes has been challenging—until now!
First you'll learn how to take advantage of all PG has to offer for small scales, especially when it comes to keeping data consistent. Next you'll learn techniques for keeping apps running well at medium scales. And finally you'll learn how to take advantage of the open-source Citus extension that makes PG a distributed db, when your app joins the big leagues.
Rails made building CRUD apps efficient and fun. React Native, for the first time, does this for mobile Apps. Learn how to create a single React codebase for Android, iOS and Mobile Web, backed by a common Rails API.
In this talk we would take a look in different strategies to upgrade Rails application to the newest version taking as example a huge monolithic Rails application. We will learn what were the biggest challenges and how they could be avoided. We will also learn why the changes were made in Rails and how they work.
Leading an open source or community project means dealing with people challenges in addition to technical challenges -- how do we take a scattering of interested people and build a team with them? Turns out, we can adapt a bunch of practices we already use! Using a collaboration between a nonprofit and a civic group as a case study, we'll talk about ways to apply best practices from community organizers to our work. In particular, we'll talk about similarities between contemporary organizing and agile models, ways to build relationships with other team members, and making our work more sustainable.
Natural Language Processing is an interesting field of computing. The way humans use language is nuanced and deeply context sensitive. For example, the word work can be both a noun and a verb. This talk will give an introduction to the field of NLP using Ruby. There will be demonstrations of how computers fail and succeed at human language. You'll leave the presentation with an understanding of both the challenges and the possibilities of NLP and some tools for getting started with it.
Mutation testing is a silver bullet for assessing test quality. Mutation testing will help you:
Write better tests
Produce more robust code that better handles edge cases
Reveal what parts of your legacy application are most likely to break before you dive in to make new changes
Learn about features in Ruby and your dependencies that you didn’t previously know about
This talk assumes a basic knowledge of Ruby and testing. The examples in this talk will almost certainly teach you something new about Ruby!
Many seemingly simple "real-world" things end up being much more complicated than anticipated, especially if it's a developer's first time dealing with that particular thing. Classic examples include money and currency, time, addresses, human names, and so on. We will survey a number of these common areas and the state of best practices, or lack thereof, for handling them in Rails.
Are you a new manager? Have you been asked to lead a project? Do you want to see change in your company but don't feel you have the position to enact it? Are you terrified or nervous or unsure where to start? Has a recent situation left you questioning what you did wrong and how to be a better leader?
Software development doesn't prepare us for taking on everyday or official leadership and yet, leadership is what every team and company desperately need.
Let talk with a group of folks at various stages of the leadership hierarchy about what they have and want to learn.
As developers we spend hours optimizing our code, often overlooking a simpler, more efficient way to make quick gains in performance: application server configuration.
Come learn about configuration failures that could be slowing down your Rails app. We’ll use tooling on Heroku to identify configuration that causes slower response times, increased timeouts, high server bills and unnecessary restarts.
You’ll be surprised by how much value you can deliver to your users by changing a few simple configuration settings.
Tuft & Needle is a bootstrapped, Phoenix-based company that pioneered the disruption of a the mattress industry using a software startup’s mindset when it was founded in 2012 and has grown to over $100 million in annual revenue. A commitment to skill acquisition has led to a happier and more productive team, and is a core to the company’s success. In this session, learn how to cultivate a culture of continuous learning and skill acquisition through apprenticeships and group learning sessions.
Bad data breeds like Tribbles. Coddle even one bit of it, and your entire database will fill up with junk. And it's got so many causes! Weird user input. Data races under load. Changing business needs. We can't fully prevent data corruption, so how can we recover from it? In this talk, you'll learn how to fix bad data at every level of your system. You'll learn UX techniques for incremental, mistake-reducing input. You'll get a rubric for validation design that accomodates new features. And you'll learn auditing techniques to catch bad data early, before your database fills up with evil Tribbles.
The attempted rewrite is over, the dust has settled, and the monolith isn’t going away. After all, it’s still the app that makes all the money. On the other hand, nobody wants to work on it, every new feature takes forever, and your entire team is afraid of making any change for fear of the whole thing collapsing in on itself.
In this session, we’ll walk through some of the technical and social problems that arise from difficult codebases. We’ll learn to stop making things worse, to measure what we need to change, and start making progress.
In the thousand mile journey, here are the first steps.
Distributed teams can have big benefits for both employers and employees. But there are many challenges. Being successful requires changes to work practices, communication, and style — and not just from the remote people. Everyone will experience changes. It helps to be prepared … and most of what we see being written and discussed is focused on remote workers, not the organization that supports them.
In this talk, we will look at the challenges and rewards of working in a distributed team setting based on several years of experience growing large distributed engineering teams.
What makes Ruby so wonderful? The Community.
The community around Ruby is really what sets it apart, and the cornerstone of it is the small local meetups. Come learn how to get involved, help out, or step up and start a local group of your own. We will discuss how to develop and nurture the group. Share our experiences in expanding a small group to larger events like unconferences or workshops. Find out how community leaders can help everyone build a solid network, assist newbies in kick-starting their career, and most importantly ensure that everyone feels welcome and safe.
You've added background jobs. You have calls to external services that perform actions asynchronously. Your data is no longer always in one perfect state-- it's in one of tens or hundreds of acceptable states.
How can you confidently ensure that your data is valid without validations?
In this talk, I’ll introduce some data consistency issues you may see in your app when you begin introducing background jobs and external services. You’ll learn some patterns for handling failure so your data never gets out of sync and we’ll talk about strategies to detect when something is wrong.
Shopify has taken Rails through some of the world's largest sales: Superbowl, Celebrity Launches, and Black Friday. In this talk, we will go through the evolution of the Shopify infrastructure: from re-architecting and caching in 2012, sharding in 2013, and reducing the blast radius of every point of failure in 2014. To 2016, where we accomplished running our 325,000+ stores out of multiple datacenters. It'll be whirlwind tour of the lessons learned scaling one of the world's largest Rails deployments for half a decade.
Our company is traditional in many ways, one of which being the need to come into the office each day. Our team of software developers bucks that trend, spreading across 6 states and 4 countries. Dev teams consider themselves "Remote First", while DevOps and Application Support are "Local First." Each has adopted tools, habits, and practices to maximize their configuration. Each style has learned valuable lessons from the other. This presentation is about how our teams have evolved: the tools, the compromises, the wins and losses, and how we successfully blend Distributed and Concentrated teams.
Help! Despite following refactoring patterns by the book, your aging codebase is messier than ever. If only you had a key architectural insight to cut through the noise.
Today, we'll move beyond prescriptive recipes and learn how to run a Context Mapping exercise. This strategic design tool helps you discover domain-specific system boundaries, leading to highly-cohesive and loosely-coupled outcomes. With code samples from real production code, we'll look at a domain-oriented approach to organizing code in a Rails codebase, applying incremental refactoring steps to build stable, lasting systems!
Hired open-sources some useful abstractions from our Majestic Monolith® and we've learned a lot. Some tough lessons, and some cool knowledge. We'll cover: When & where should you pull something out of the code? Does it really help? What things are important to think about? What if it never takes off? We'll also look at some design patterns from our open-source work.
There are a lot of database index and query best practices that sometimes aren't best practices at all. Need all users created this year? No problem! Slap an index over created_at! What about this year's active OR pending users, sorted by username? Are we still covered index-wise? Is the query as fast with 20 million users? Common rules of thumb for indexing and query crafting aren’t black and white. We'll discuss how to track down these exceptional cases and walk through some real examples. You'll leave so well equipped to improve performance, you won't be able to optimize fast enough!
Being on a distributed team, working from your home or coffee shop isn't easy, but it can be incredibly rewarding. Making it work requires constant attention, as well as support from your team and organization. It's more than just setting up Slack and buying a webcam.
We'll learn what you can do to be your best self as a remote team member, as well as what you need from your environment, team, and company. It's not about technical stuff—it's the human stuff. We'll learn how can you be present and effective when you aren't physically there.
Using a standard Rails stack is great, but when you want to process streams of data at a large scale you'll hit the stack's limitations. What if you want to build an analytics system on a global scale and want to stay within the Ruby world you know and love?
In this talk we'll see how we can leverage Kafka to build and painlessly scale an analytics pipeline. We'll talk about Kafka's unique properties that make this possible, and we'll go through a full demo application step by step. At the end of the talk you'll have a good idea of when and how to get started with Kafka yourself.
This is a sponsored talk by Procore.
Building a consistent API for a large and long-running monolithic API on a tool-segmented engineering team can sometimes feel like herding cats. REST, serializers, and Swagger: Oh my! Learn what worked (and didn’t!) as we go behind the scenes building Procore’s first open API.
As our applications grow, we start thinking of better ways to organize and scale our growing codebases. We've recently seen Microservices start to emerge as a prominent response to Monoliths, but is it all really worth it? What about our other options? We often romanticize leaving our current architecture situation because we believe it will cure what ails us. However, architecture certainly has no silver bullet . Beam up with me as we explore the past, present, and future of reconsidering architecture.
It'll happen eventually. Someone will come down with a feature request for your app to "create dashboards and reporting on our data". So how do you go about doing it? What parts of your database should you start thinking about differently? What is "reporting" anyway? Is ActiveRecord enough to pull this off?
Let's go on a journey through the world of Relational Online Analytical Processing (ROLAP) and see how this can apply to Rails. We'll also look at database considerations and finish with looking at a light DSL that works with ActiveRecord to help make your data dance.
Application performance monitoring is great for debugging inside a single app. However, as a system expands into multiple services, how can you understand the health of the system as a whole? Distributed tracing can help! You’ll learn the theory behind how distributed tracing works. But we’ll also dive into other practical considerations you won’t get from a README, like choosing libraries for Ruby apps and polyglot systems, infrastructure considerations, and security.
When background job processing needs arise, Sidekiq is the de facto choice. It's a great tool which has been around for years, but it doesn't provide recurring job processing out of the box. sidekiq-scheduler fills that gap, it's a Sidekiq extension to run background jobs in a recurring manner.
In this talk, we'll cover how sidekiq-scheduler does its job, different use cases, challenges when running on distributed environments, its future, how we distribute capacity over open source initiatives, and as a bonus, how to write your own Sidekiq extensions.
Bernie Sanders popularized crowdfunding in politics by raising $220 million in small donations.
An example of the challenges with handling a high volume of donations is the 2016 New Hampshire primary night, when Sanders asked a national TV audience to donate $27. Traffic peaked at 300K requests/min and 42 credit card transactions/sec.
ActBlue is the company behind the service used not only by Sanders, but also 16,600 other political organizations and charities for the past 12 years.
This presentation is about the lessons we learned building a high performance fundraising platform in Rails.
With Rails being over ten years old now, we know that the Rails way works well. It's battle tested and successful. But not all problems we try to solve fit into its idea on how our application should be structured.
Come along to find out what happens when you don't want to have an app directory anymore. We will see what is needed in order to fight parts of the Rails convention and if it's worth it.
Is your application running too slow? How can you make it run leaner and faster? Is Ruby 2.4 going to make anything faster or better? Should you be upgrading to the latest version of Rails? Is your Rails application being weighed down by a large swarm of dependencies?
In this panel the panelists will discuss their favorite performance related tools and guidelines. Expect to learn about changes in Ruby 2.4 and beyond that may help make your applications snappy and lean.
When your Rails app begins serving public traffic, your users will make it behave in mysterious ways and find code paths you never knew existed. Understanding, measuring, and troubleshooting its behavior in production is a tough but crucial part of running a successful Rails app. In this talk, you’ll learn how to instrument, debug, and profile your app, using the capabilities of the Rails framework and the Ruby VM. You'll also study techniques for safely instrumenting a live running system, keeping latency to a minimum and avoiding side effects.
As systems get more complex they inevitably fail. Many of those failures are preventable.
We’re not lazy, stupid, or careless. The complexity of our systems simply exceeds our cognitive abilities. Thankfully, we’re not alone. People have successfully managed complex systems long before software came along.
In this session, we’ll see how surgeons, pilots, and builders have developed techniques to safely manage increasingly complex systems in life and death situations. We will learn how simple checklists improve communication, reduce preventable errors, and drive faster recovery time.
The logical place to put view-related logic is... inside your view, right? "A little logic here... a little logic there..." but all of a sudden we hardly recognize our views. A quick glance through our code and we can't tell our Ruby apart from our HTML. Don't worry; this is a fun opportunity for some refactoring! Come see several approaches you can start using today to clean up your views.
This is a sponsored talk by Shopify.
Conversations around code consistency seem to spark either cheers or jeers from developers. In this talk, I'll explore the good, bad, and the ugly of code style consistency as illustrated by the (sometimes drama-filled) history of Shopify's 10-year-old codebase. Highlighting strategies to help you evaluate when to push for better code consistency; you will hear about our techniques, tools and guides to enrich developer experience without compromising productivity and how to ultimately make code consistency important across the organization.
This is a sponsored talk by Skylight.
We got a good productivity boost by writing the original Skylight agent in Ruby, but over time, we couldn't implement all the desired features with its overhead. Ruby is fast enough... until it isn't.
Introducing Helix — an open-source toolkit for writing native Ruby extensions in Rust, extracted from our Featherweight Agent's DNA. Fast, reliable, productive — pick three. Come join us to find out how you can leverage this power in your Ruby apps and even help make Rails faster!
(This is not a re-run of Godfrey's talk from last year.)
Ruby developers welcome! Our dedicated Google Cloud Platform Ruby team has built a great experience for Ruby developers using GCP. In this session, we'll walk through the steps to deploy, debug and scale a Ruby on Rails application on Google App Engine. You'll also learn about some of the exciting Ruby libraries available today for adding features to your app with GCP services like BigQuery and Cloud Vision API.