We spend a large portion of our time thinking about code and technical project issues. What about the people side of things? The majority of project failures occur because of people, not technology. What we need are guides that help us navigate the waters between the people around us.
People Patterns introduces my latest effort to capture the subtleties and nuances of interpersonal relations. I'm distilling a lot of experience, a bit of psychology and a substantial amount of research and have come up with a series of patterns that can help everyone be more successful in teams and at work. How do you have those critical conversations? How do you get your point across when you think the other person is incompetent? Come and help me reveal these and join a lively discussion.
As of Rails 3.2, plugins are officially deprecated. They have been replaced by Rails Engines, a class of public methods for hooking into Rails applications. This session will explain how to write a Rails Engine from scratch or convert your existing plugin to an engine. It will also cover best practices for making your engine play well with others, and when to factor pieces of your existing Rails application code into an engine for reuse across multiple applications.
Ruby has a lot of syntax to come to terms with. In an effort to reduce learning overhead we often restrict what we teach by avoiding serious coverage of objects in early lessons. Yet objects are what make Ruby great. Rather than sacrifice Object Oriented Mechanics, Sugar-free ruby uses a minimum of syntactic sugar to reinforce the message-passing objective semantics of Ruby until the pupil understands and then can assimilate new syntactic elements with greater ease. This talk explores the advantages and pitfalls of the technique as well as other ways to teach Ruby.
Some of the most interesting challenges programmers face today are found at the intersection of natural and computer languages. Natural languages don't have documented source code, well-defined APIs or stable release versions. There is no spec (unless it's French), and even native speakers of the same dialects disagree all the time. How, then, can you internationalize a web application without introducing significant overhead to your development process? This talk will explore some practical strategies for maintaining speed, flexibility, quality, and focus by letting your users handle localization for you.
For years, the JVM has been the runtime to beat when it comes to runtime optimization and garbage collector performance. While statically-typed languages built atop the JVM have been able to leverage those capabilities, dynamic languages have often had a more difficult time. But the times they are a'changing.
Java 7 brings to the JVM a new and powerful feature called invokedynamic. With invokedynamic, dynamic languages no longer have an automatic performance penalty. The optimizations that make Java and other statically-typed JVM languages run fast now apply to dynamic languages just as well. Imagine a world where Ruby runs as fast as Java, with nearly zero GC overhead, true parallel threads, massive heap sizes, and rock-solid stability. That's the potential of invokedynamic, the JVM, and JRuby, and I'm going to show you how it all fits together.
Once the realm of shadowy government organizations, cryptography now permeates computing. Unfortunately, it is difficult to get correct and most developers know just enough to be harmful for their projects. Together, we’ll go through the basics of modern cryptography and where things can go horribly wrong.
Secure password storage
Subtle flaws that can leave you insecure
Why you should use TLS/SSL and GPG instead
Software is always a mess. You can't avoid this mess, and if hubris goads you into attempting to achieve perfection, you'll just make things worse. Perfection is a distant, dim land on the unreachable horizon. You'll not be going there today.
What you can do, however, is use the techniques of object-oriented design (OOD) to make your messes manageable. OOD is good at messes. It understands their origins, predicts their courses, and foresees their outcomes. It shines a light down the dusty nooks and crannies of your app, showing you what to do and what to avoid.
This talk shows you how to use OOD to create the best kinds of messes, those that let you get software out the door today without regretting your actions tomorrow.
Breaking concepts down into logical chunks, tackling them in isolation. Sound familiar? This is how we write tests, but it's also how a mathematician writes proofs. Exploring the similarities and differences between the two can bring us back to our profession's mathematical roots. In this talk, we will look at mathematical proofs and ruby code side-by-side in an effort to uncover why these sorts of puzzles are appealing. I'll explain a few mathematical methods through Ruby code, but don't worry, no math background is required. We'll examine summation notation—the mathematical loop, as well as the multiple ways of defining the Binomial Coefficient. (Refresher: remember n choose k?) After that, I'll translate a basic proof by induction into pseudo-RSpec in order to highlight the similarities between writing a test and writing a proof, such as the existence of stubs. When you leave this talk, you'll have a better understanding of what you love about test driving, and perhaps you'll learn some math in the process.
The modern browser is not the black box it used to be. We can peek inside and see how it really works—we have the source code for WebKit, Chromium, and Firefox! In this talk we'll disassemble the basic architecture of WebKit / Chromium and see how it all comes together: from receiving the HTML bytes on the wire, to constructing the DOM, fetching the resources, performing the layout, and finally painting the pixels to the screen. Armed with this knowledge, we can then dismantle some of the web performance myths found in most every "performance top 10" list, and see how we can build better and faster web apps, regardless of the framework you're using.
Clean code, pragmatic code, confident code, beautiful code. There are many coding ideals worth pursuing. I want to talk about joyful code—those techniques and idioms that surprise and delight us with unexpected elegance.
I got into Ruby because writing it made me happy, and after all these years it still finds ways to make me grin. Join me for a random walk through the Ruby language and standard library, stopping in to visit some of my favorite tools, hacks and implementation patterns. Some you may know. Others may be more obscure. My goal: to rekindle in you the joy of code, to inspire you to share that joy with your peers and with the next generation of developers, and most importantly, to bring a smile to your face!
JRuby deployments have fewer moving parts and consume less memory than traditional Ruby deployments, but to deploy your apps on the JVM, you need to learn some new approaches. This talk will introduce you to three JRuby deployment strategies that will give you the performance and scalability you need while letting you use the language you love.
You'll learn how Warbler can be used to create a binary file from a Ruby web application. Then we'll discuss how the light-weight Trinidad web server can be used to create a flexible, modular deployment that still feels friendly and familiar. Finally, you'll learn how to power an application with TorqueBox, an all-in-one environment that includes built-in support for messaging, scheduling and daemons.
You want to improve the performance of your app, or you want to keep your system composed of small, easy to understand services. You start using background jobs, REST calls, and cron. And then weird things happen.
Designing services from the start can be tricky, but there is guidance out there. Extracting services can be even trickier, and whenever there's a message queue or job processing system, it becomes very difficult to truly understand the order in which things happen in your system. If you're lucky, you've got alerting when things go wrong, but even then, what do you do about it?
This talk will go through an increasingly frustrating set of circumstances that I've seen on a regular basis at LivingSocial as we extracted code from a monolithic app into a set of services. I'll then show the solutions to these issues that make our payment processing system more or less bullet-proof, and generalize these lessons into what you can do when extracting and designing services.
App development, especially for social, challenges us to evaluate how to code for the complexity of modern life. Examples include the growing range of labels people ascribe to their important relationships, sexual orientation, and gender. Users are giving push-back to questions that carry ill-fitted assumptions or constrain their responses.
Facebook, Google+, and developers in many other industries are grappling with these issues. The most resilient approaches will arise from an app's own foundations. We'll look at schemas' influence on product scope, UX, and analytics. Then we'll check out a range of approaches for bringing modern realities into any app's schema, views, and logic.
Cruft is inevitable. Whether you're working around a bug in Internet Explorer, Heroku or Ruby 1.8, our libraries and applications quickly diverge from the platonic ideal of software. In the short-term, there's no point in fretting. Rather than an indication of a development process gone awry, the technical debt merely reflects the messy reality of the surrounding ecosystem that our code lives in.
For projects that last for years, though, this can lead to a resistance to re-evaluating the original assumptions that introduced the cruft to begin with. In this talk, I will give some examples of good and bad attempts to deal with this issue in the world of open source, and make some suggestions for how you can make your projects, both open-source and proprietary, more able to cope with the slow but steady long-term shifts that surround our projects.
One session, three talks.
Tony Arcieri – A Crash Course on Celluloid: This talk will provide a quick overview of how to use Celluloid, covering the basics of how to add Celluloid to your program and begin leveraging its concurrent features.
Chris Eppstein – Naiveté: Stepping outside your comfort zone.
Sarah Mei – MRI Internals: How does a language become a language? We'll take a peek into the internals of the MRI, and explore how it came to be.
We programmers think of complexity as our enemy, and we train ourselves to avoid it. When algorithms are too complex, we know we've sacrificed performance; when code is too complex, the code is brittle and fragile. But sometimes, complexity is unavoidable, especially in the real world filled with people, laws, complex systems, and things we don't fully understand. And if we try to adopt a simple view of a complex situation, that makes things worse. But there are techniques for making sense of that kind of complexity, and for making smart decisions in complex situations.
RubyMotion has revolutionized native app development for iOS devices. I would like to share some best practices/lessons learned building apps using RubyMotion. These include:
Using external Ruby libraries and gems
DSL for views
ActiveRecord-like CoreData for iOS
Testing storyboard interface (Rspec and TestUnit)
Outlets and Actions
XCode integration - is it possible?
Releasing to AppStore
Square manages big data, high uptime, secure payment info and large teams in an agile Rails environment. It's hard. Our system has outgrown the patterns of a young Rails app and some of what used to help has started to hurt. It's painful to have your email templates in the same project as your API backend. It's agonizing to use your main datastore for analytics, and it hurts to throw code into ./lib or require unnecessary gems. This talk is about how we've turned individual Rails pieces into separate services and scaled our codebase, data, and integration testing practices to support multiple big teams efficiently.