CodeMash V2.0.1.2

Technology/Platform: Ruby

Difficulty Level: Intermediate

Start Time: Thursday January 12, 2012 @ 11:00 AM

Location: Cypress

Abstract: Welcome to the world of Ruby: where the gems are deep, rough, and rarely documented! No need to fear though, in this presentation you'll learn what a RubyGem is, how they're used in Rails and Ruby applications, and of course, how to make your own. You'll see just how easy it is to share your code with others in the Ruby universe, and why creating packages is a joy instead of a burden thanks to the tools and ecosystem of RubyGems.

Presented By: Nick Quaranto

About the Speaker: Nick is a firm believer in open source software, a proud member of Ruby community, and has been doing web development for as long as he can remember. He cut his teeth on classic ASP and ASP.NET at first, but discovered Ruby on Rails through his university and dove in head first. Nick pretends he's a bassist with famous prog rock bands when not coding.

Technology/Platform: Ruby

Difficulty Level: Beginner

Start Time: Friday January 13, 2012 @ 9:30 AM

Location: Cypress

Abstract: A Code Kata is a simple programming exercise, practiced repeatably by a developer. Much like a musician practices scales and finger exercises to develop his musical skills, a developer will practice code katas to develop his programming skills. This talk will be a live performance of a simple TDD-based code Kata, followed by an analysis of the forces and choices involved in the feedback loop between the code and the tests encountered during the kata. By examining this interaction of tests and code, we come to a better understanding of how to use tests to actively affect the direction of our design. By reflecting on the process, we understand how to pick "what to test next". This talk is targeted for developers who have started using Test Driven Design (TDD) and feel that they don't quite "get it" yet, and are looking for guidance in the technique.

Presented By: Jim Weirich

About the Speaker: 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 EdgeCase, but you can also find him strumming on his ukulele as time permits.

Technology/Platform: Ruby

Difficulty Level: Beginner

Start Time: Thursday January 12, 2012 @ 4:50 PM

Location: Cypress

Abstract: There are many ways to consider on how to design and execute effective automated tests and continuously keep the pulse on quality of product delivery. However when it comes to leveraging existing CI pipeline for functional and performance testing many may not realize that main ingredients are already built-in. This presentation will share the recipes on how to propel automated testing with immediate feedback to the entire team. This presentation is based on: • Hudson/Jenkins CI engine • Ruby and Rake to setup, execute and tear-down test environments • Hpricot (Ruby gem) and Hudson plug-ins to report and trend graphical results dynamically • .NET test tools (Visual Studio MS Team System and Telerik WebAii)

Presented By: Leonard Fingerman

About the Speaker: I'm a passionate software test professional who continuously strives to find better ways to improve software quality. Through various test automation methods and techniques I was able to demonstrate effectiveness and progress for a number of software projects - large and small. I have presented various test automation topics at IASA conference, Agile Atlanta user group as well as Atlanta Java user group.

Technology/Platform: Ruby

Difficulty Level: Intermediate

Start Time: Thursday January 12, 2012 @ 1:45 PM

Location: Salon D

Abstract: Configuring development, staging and production environments from scratch can be and extremely boring and time consuming task that only grows as your company grows. Chef is a tool that helps you deal with configuring any number of environments that can be as easy as a single click. In this talk I will show the basics of starting out with Chef and talk about my experiences of creating Chef scripts for both Linux and Windows environments that make it a breeze to scale your infrastructure, or just rebuild your development environment when you delete that all important system file.

Presented By: Colin Gemmell

About the Speaker: Colin Gemmell is Web/Application Developer from Glasgow, Scotland. He has gained a wide range of experience in his time as a developer working on everything from enterprise applications to small promotional web-sites. Starting out first Borland Delphi before graduating to .NET he made the jump to Ruby on Rails and hasn’t yet looked back. A constant presence in the in the Glasgow tech community Colin has spoken a numerous programming and tech events and conferences covering the length and breadth of the UK. He also current runs the Glasgow Ruby User Group.

Technology/Platform: Ruby

Difficulty Level: Intermediate

Start Time: Thursday January 12, 2012 @ 1:45 PM

Location: Cypress

Abstract: We'll illustrate how much a RESTful architecture buys you when building a Rails application with respect to topics such as: reduced application code, clean client-side interaction, cacheability and scalability, and crafting great public APIs. If you haven't looked at the theory of REST in detail or just need a refresher, we'll cover the essence of the theory as a means of illustrating just how low-friction this approach makes building web applications with rich client experiences. This talk will feature examples and code in Ruby on Rails on the server and Backbone.js on the client, but the ideas are applicable to the design of any web application.

Presented By: Matt Yoho

About the Speaker: Matt Yoho is a developer and agile enthusiast with a love for Ruby and the web who works for EdgeCase, LLC in Columbus, OH. He is a supporter of the Software Craftsmanship movement and is the Apprenticeship coordinator at EdgeCase. He likes comic books, karaoke, Free Software, and sweet potato fries. He is one fairly hep cat.

Technology/Platform: Ruby

Difficulty Level: Beginner

Start Time: Friday January 13, 2012 @ 10:45 AM

Location: Salon F

Abstract: Cucumber is a great tool for writing executable specifications. When written well they provide the basis for a team's understanding of the specification. When they run successfully they provide a confirmation that a feature is done and working properly. The problem is that most Cucumber features are written poorly. They often include technical terms or a lot of unnecessary details that hide the behavior we are trying to describe. This problem is so profound and pervasive in the industry that some are beginning to believe that is is not possible to describe behavior well with Cucumber. This talk and hands on demonstration will bring attention to typical smells found in cucumber scenarios. Once we discuss a smell, we'll look at an example that exhibits that problem and then refactor the code and feature to clean it up. Along the way we'll also introduce some common design patterns that can be applied to keep your code nice and d.r.y.

Presented By: Jeff Morgan

About the Speaker: Jeff Morgan has spent 25 years writing software, holding various roles including Senior Developer, Manager of Application and Enterprise Architect, Director of Technology and most recently Chief Technology Officer at LeanDog. He has been an evangelist for the Agile Software Development movement since 2003 and has spoken at several organizations, conferences, and technical events. He has coached agile teams for the past seven years with an emphasis on the engineering practices like TDD, Pair Programming, and ATDD. He is also the author of several popular Ruby gems. He is passionate about the Cleveland IT community and his company, LeanDog, currently sponsors and hosts 6 technology group meetings each month in downtown Cleveland. His company also sponsors GiveCamps to build and donate software to local non-profit organizations.

Technology/Platform: Ruby

Difficulty Level: Intermediate

Start Time: Friday January 13, 2012 @ 10:45 AM

Location: Cypress

Abstract: Rong is a client-server Pong implementation written in Ruby that hopes to take a whack at your office productivity. Though Pong itself is a relatively uncomplex game, it allows a variety of interesting game programming problems to be explored when constructing the game in a robust manner as a client-server application. We'll talk through the structure of the implementation, the involved libraries, including libraries supporting 2-D game development in Ruby, and the techniques involved in creating a responsive network-based game.

Presented By: Matt Yoho

About the Speaker: Matt Yoho is a developer and agile enthusiast with a love for Ruby and the web who works for EdgeCase, LLC in Columbus, OH. He is a supporter of the Software Craftsmanship movement and is the Apprenticeship coordinator at EdgeCase. He likes comic books, karaoke, Free Software, and sweet potato fries. He is one fairly hep cat.

Technology/Platform: Ruby

Difficulty Level: Advanced

Start Time: Thursday January 12, 2012 @ 3:35 PM

Location: Cypress

Abstract: Ruby can't scale. Tell that to LivingSocial, GroupOn, Gowalla, Sony, and the rest of our community pushing millions of requests per day. Scaling an application isn't about piling up hardware and dropping in the newest database fad, it's the combination of design and refinement. In this session, we'll look at refining Ruby code using tools to: * Measure memory and object allocation * Find CPU-intensive hotspots * Isolate data-store bottlenecks * Evaluate code complexity This is not about info-porn. It's about finding the 1% of your code that, through optimization, can dramatically improve performance.

Presented By: Jeff Casimir

About the Speaker: Jeff Casimir has been writing Ruby and Rails applications since 2005 and started Jumpstart Lab in 2009. He currently travels the world teaching the best Ruby/Rails classes on earth.

Technology/Platform: Ruby

Difficulty Level: Beginner

Start Time: Friday January 13, 2012 @ 3:35 PM

Location: Cypress

Abstract: I started programming Rails on Windows in 2008. The experience was not the best but I still made the best of it. Fast-forward to 2011 and because of tools like RailsInstaller, Windows users have things almost easier than Mac/Linux. This talk will focus on some of the best-practices that I've found when using Windows for Ruby on Rails development.

Presented By: Evan Machnic

About the Speaker: Evan Machnic is a PANDA at Engine Yard and individual Rails Developer. He is also an occasional Rails on Windows masochist.

Technology/Platform: Ruby

Difficulty Level: Intermediate

Start Time: Friday January 13, 2012 @ 1:45 PM

Location: Cypress

Abstract: CANCELLED -- Automated tests are a foundation of agile software development. Many experts teach that developers should write unit tests and testers should write higher-level tests. However, many of the practices, such as test-driven development and pair programming, say little about how these practices fit into the development process. Shannon Code (a developer) and Dawn Code (a tester) describe and demonstrate ATDD (acceptance test driven development), from discussing the story to considering it done done. Early in the process they agree on story scope and develop a shared vocabulary. The tester and developer discuss the approach to solving the problem and begin to work out a test approach. Together, they write a series of acceptance tests to pin down the details of how the story will work. These team members agree up front on what will be tested, resulting in more solid production code from the beginning. Come and watch how this process unfolds when supported by an environment that is set up to execute tests and provide feedback and quickly as possible.

Presented By: Dawn Code

About the Speaker: Dawn Code is a software test evangelist who has been working to integrate testers as members of software development teams and improving the working relationships between testers, developers, and everyone else for the past 9 years. When not speaking at testing and agile conferences and user group meetings, she spends her time working in the open source community. She also writes actively, publishing articles and posting to her blog at passionatetester.com

Technology/Platform: Ruby

Difficulty Level: Intermediate

Start Time: Thursday January 12, 2012 @ 9:45 AM

Abstract: Do you always seem to be fixing bugs in your software project? Are you spending more time fixing defects that actually implementing new behavior? If so, this talk is for you. In the mid-90s, Steve Maquire wrote a book that strongly effected the way I developed software. Primarily writing in C and C++ in those years, the struggle to deliver bug free software was especially a challenge. In the book "Writing Solid Code", Steve gives sage advice on the problems of developing large software projects and the challenges that go with making sure your softare actual does what you think it should. Although as Ruby developers we are no longer using C to deliver our large projects, the challenge of writing solid, reliable code is still before us. Based on Maquire's advice and my own years of Ruby experience, this talk will show developers tools, techniques and practices that they can use to improve their software and begin writing solid code.

Presented By: Jim Weirich

About the Speaker: 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 EdgeCase, but you can also find him strumming on his ukulele as time permits.