Tags

20 videos are tagged with refactoring

0 thumb
Rating: Everyone
Viewed 6,641 times
Recorded at: March 13, 2015
Date Posted: April 10, 2015

Our code is full of hidden assumptions, things that seem like nothing, secrets that we did not name and thus cannot see.
These secrets represent missing concepts and this talk shows you how to expose these concepts with code that is easy to understand, change and extend.
Being explicit about ideas will make your code simpler, your apps clearer and your life better. Even very small ideas matter. Everything, even nothing, is something.

1233 aloharuby2012 refactoring from good to great thumb 0004 thumb
Rating: Everyone
Viewed 19,707 times
Recorded at: October 8, 2012
Date Posted: October 26, 2012

Most developers know enough about refactoring to write code that's pretty good. They create short methods, and classes with one responsibility. They're also familiar with a good handful of refactorings, and the code smells that motivate them.

This talk is about the next level of knowledge: the things advanced developers know that let them turn good code into great. Code that's easy to read and a breeze to change.

These topics will be covered solely by LIVE CODING; no slides. We'll boldly refactor right on stage, and pray the tests stay green. You might even learn some vim tricks as well as an expert user shows you his workflow.

Topics to cover include:
* The Open-Closed Principle
* The types of coupling, and their dangers
* Why composition is so damn great
* A powerful refactoring that Kent Beck refers to as "deep deep magic"
* How to destroy conditionals with a NullObject
* The beauty of the Decorator pattern
* Testing smells, including Mystery Guest and stubbing the system under test
* The stuff from the last halves of Refactoring and Clean Code that you never quite got to :) organizers')
Obviously, my credibility relies entirely on this talk being awesome, so come ready to laugh, learn, and enjoy yourself.

2290 larubyconf2013 refactoring fat models with patterns thumb 0000 thumb
Rating: Everyone
Viewed 5,860 times
Recorded at: February 23, 2013
Date Posted: April 13, 2013

“Fat models” cause maintenance issues in large apps. Only incrementally better than cluttering controllers with domain logic, they usually represent a failure to apply the Single Responsibility Principle (SRP). “Anything related to what a user does” is not a single responsibility. Early on, SRP is easier to apply. ActiveRecord classes handle persistence, associations and not much else. But bit-by-bit, they grow. Objects that are inherently responsible for persistence become the de facto owner of all business logic as well. And a year or two later you have a User class with over 500 lines of code, and hundreds of methods in it’s public interface. Callback hell ensues. This talk will explore patterns to smoothly deal with increasing intrinsic complexity (read: features!) of your application. Transform fat models into a coordinated set of small, encapsulated objects working together in a veritable symphony.

1071 cascadiaruby2012 therapeutic refactoring thumb 0002 thumb
Rating: Everyone
Viewed 19,155 times
Recorded at: August 3, 2012
Date Posted: August 17, 2012

Enter deadline center stage, exit best practices, quietly, rear stage left.

The results are rarely pretty.

Refactoring can pry panic’s fingers away from your poor, overburdened adrenal glands and restore your sanity. Not that it went missing, of course. Never that!

This talk will cover the two reasons why refactoring works as well as (or better than) whiskey, sky diving, and massages as therapy, explore a handful of effective strategies to ensure that the rubber meets the road, and contains gory before shots and slick after shots of ruby code that has served therapeutic purpose.

Rating: Everyone
Viewed 1,928 times
Recorded at: September 20, 2012
Date Posted: December 1, 2012

Most developers know enough about refactoring to write code that's pretty good. They create short methods, and classes with one responsibility. They're also familiar with a good handful of refactorings, and the code smells that motivate them.

This talk is about the next level of knowledge: the things advanced developers know that let them turn good code into great. Code that's easy to read and a breeze to change.

Topics include:

The Open-Closed Principle
The types of coupling, and their dangers
Powerful refactorings like the Method Object
The beauty of the Decorator pattern
Testing smells, including Mystery Guest and stubbing the system under test
The stuff from the last halves of Refactoring and Clean Code that you never quite got to :)
These topics will be covered solely by LIVE CODING; no slides. We'll boldly refactor right on stage, and pray the tests stay green. You might even learn some vim tricks as well as an expert user shows you his workflow.

1283 rubyconf2012 refactoring from good to great thumb 0003 thumb
Rating: Everyone
Viewed 2,812 times
Recorded at: November 1, 2012
Date Posted: December 1, 2012

Most developers know enough about refactoring to write code that's pretty good. They create short methods, and classes with one responsibility. They're also familiar with a good handful of refactorings, and the code smells that motivate them.

This talk is about the next level of knowledge: the things advanced developers know that let them turn good code into great. Code that's easy to read and a breeze to change.

These topics will be covered solely by LIVE CODING; no slides. We'll boldly refactor right on stage, and pray the tests stay green. You might even learn some vim tricks as well as an expert user shows you his workflow.

Topics include:

The Open-Closed Principle
The types of coupling, and their dangers
Why composition is so damn great
A powerful refactoring that Kent Beck refers to as "deep deep magic"
How to destroy conditionals with a NullObject
The beauty of the Decorator pattern
Testing smells, including Mystery Guest and stubbing the system under test
The stuff from the last halves of Refactoring and Clean Code that you never quite got to.

  cascadia ruby 2013 fluent refactoring by sam livingston gray   youtube thumb
Rating: Everyone
Viewed 2,361 times
Recorded at: October 22, 2013
Date Posted: November 29, 2013

Fluency is "what you can say without having to think about how to say it." "Refactoring" is a language that describes ways to make your code suck less. I want to inspire you to become more fluent in that language, so you can make your code suck less without having to think about it.

I'll walk you through the process of reworking a 50-line Rails controller action that's hard to comprehend, let alone refactor. We'll tease apart fiendishly intertwined structures, embrace duplication until we grok what it's telling us, use evil hacks to our advantage, and uncover responsibilities—and bugs!—that weren't obvious at first glance.

Lib2 01 nicksieger thumb
Rating: Everyone
Viewed 1,523 times
Recorded at: April 9, 2011
Date Posted:

While JRuby makes all kinds of sense as integration glue for enterprise Java applications, introducing Rails into an existing application without doing any significant rewriting may not be obvious. We'll present and demonstrate several strategies for incrementally moving portions of the application to Ruby and taking advantage of the productivity of Rails in a legacy Java environment.

Jake scruggs thumb
Rating: Everyone
Viewed 551 times
Recorded at: September 11, 2010
Date Posted: December 17, 2012

Metric_fu makes it easy to generate reports that measure code quality. Once you’ve created the reports, what do you do next? You know your code could be better. Now what? As lead developer of metric_fu, Jake Scruggs is in a great position to make recommendations about the best ways to leverage the tool.

Ben orenstein thumb
Rating: Everyone
Viewed 1,029 times
Recorded at: February 21, 2013
Date Posted: February 26, 2014

Most developers know enough about refactoring to write code that's pretty good. They create short methods, and classes with one responsibility. They're also familiar with a good handful of refactorings, and the code smells that motivate them.

This talk is about the next level of knowledge: the things advanced developers know that let them turn good code into great. Code that's easy to read and a breeze to change.

These topics will be covered solely by LIVE CODING; no slides. We'll boldly refactor right on stage, and pray the tests stay green. You might even learn some vim tricks as well as an expert user shows you his workflow.

Topics include:
* The Open-Closed Principle
* The types of coupling, and their dangers
* Why composition is so damn great
* A powerful refactoring that Kent Beck refers to as "deep deep magic"
* How to destroy conditionals with a NullObject
* The beauty of the Decorator pattern
* Testing smells, including Mystery Guest and stubbing the system under test
* The stuff from the last halves of Refactoring and Clean Code that you never quite got to :)