*Quick update on Day One before we jump into Day Two: We're psyched to have David Meyer of OneLogin opening the conference!
Sounds like we'll be starting the conference on the right foot!
And now, a few more scintillating snippets of the talks you'll enjoy on Thursday, Day Two of MagmaConf:
"Have you ever wonder what it takes to turn your SaaS into an On-Premise project? At GitHub, we've developed a series of tools to help us build, test and release GitHub Enterprise in a matter of minutes. This talk is about the internal infrastructure that we've built to support GitHub Enterprise. We'll talk about our testing cloud and how we do continuous integration for an on-premise product. We'll also talk about patterns that we've found useful and things that didn't work out that well. We'll show the tooling that makes all this possible and how it integrates with Hubot to allow the Enterprise team to collaborate."
"'That's stupidly awesome' or 'You're such a jerk :)'"
The above is obviously positive, but how would you train a computer to figure that out? So much of our language is contextual and has subtle hints of sentiment that this is a tough problem in natural language processing.
Though there is an algorithm called Support Vector Machines that can find a close solution! And there's a great Ruby library for you to use as well.
Join us for this talk where we'll go detecting sentiment in tweets using support vector machines. At least join us for the various bouts of swear words and confusing lexicon of the English language."
"Object-oriented programmers can have a dogmatic approach to language patterns. Whether it is analyzing, debating or criticizing various implementations, the passion for patterns emerges from the need to both communicate intent and categorize code. The patterns do more than define code, they describe it. So, what happens when we lose objects? When state fades away? When paradigms shift far more than a change in languages?
In steps Elixir. With syntax similar to Ruby but firmly grounded in the functional paradigm, it represents an easy transition for Rubyist into functional programming. But what about the beloved patterns? It turns out that understanding how functional languages implement some of the common object-oriented patterns can demystify this new paradigm. Plus learning new functional patterns can provide new solutions to old problems."
We want to produce reliable, functioning software... but we often don't. The cliched cry of "but it works on my machine" demonstrates the myopia that most web developers (including me) suffer from: we spend almost all of our time working with a development environment. This leads us to think of production as "like development, with people using it". Then, when things go wrong, we think "oh, I see now, production is like development except this one thing that went wrong". This is exactly the opposite of the mindset we need. Production is fundamentally different from development, and it's important to keep that in mind. This talk discusses some of those fundamental differences, including load balancing, metrics, data store reliability, and network partitions. Don't get stuck rebuilding your servers at 3AM because you went with the option that was easiest during development!
"The best advice I ever received about code was to never get attached to it, because eventually it will need to change. Things always change; and a robust system must be able to respond to these changes to survive and grow. You might be able to manage the small changes along the way, but eventually as your application gets older, there will come a day where you're going to have to make a big change -- a change so big that you're not just changing a piece of the system anymore, you're rewriting it.
The scariest thing about a rewrite is that usually the old system is very complicated and its behavior isn't completely documented, so it's hard to be sure that any new system you create replaces the functionality of the old system completely. This might be good enough for certain rewrites -- it might even be a good opportunity to rethink some behavior -- but there are other cases where you can't afford to be unsure about the correctness of the system you're replacing because it's too important.
At GitHub, we found ourselves at a point where we needed to rewrite the system that models our permissions in order to be able to build new features and improve performance. This talk will cover the strategies we developed to rewrite this critical piece of the app side-by-side with the existing code, specifically how we used our open-source science and analysis libraries to rewrite small pieces at a time and ensure that everything worked when we finally flipped the switch."
"We take for granted the wealth of knowledge and wisdom that goes into each library we use within our programs. Many of the them we use today are built on top of libraries that have existed much longer than most of us have been programming in Ruby.
Allow me to guide you through some of these unusual and mysterious libraries that are made available in every Ruby installation. I'm talking about the standard library, which has largely been apart of the Ruby ecosystem since before gems were available.
There's around ~70MB of code in every installation, and it's just waiting for those eager to explore and discover what the pioneers of Ruby have provided for us."
And to end the day with a bang, our second keynote by Sandi Metz! Can't wait to see what she has in store for us.