Work With Me

I work with teams who:

  • Break their code when they make changes
  • Struggle to add and update features as fast as the business needs
  • Stress cognitive load juggling multiple files for a single solution
  • Need to break down large and complicated classes

Want training to build better Ruby applications.

Your gears are grinding
instead of launching you forward.

All of a sudden things seemed to slow down.

You look back and realize that bit by bit it crept in without anyone even realizing how.

Your project features are taking longer to implement. Debugging has become a common impediment to doing the real work.

New code eventually becomes old and carries the weight of all the decisions made along the way. But your requirements still need to be met and time keeps ticking away.

Maybe there’s a tool that’ll help...
                      or
 another technology... 
                      or a better testing strategy...

Or maybe your team needs help beyond tools.

Often we’re so focused on quickly implementing features now that we don’t slow down to grease the wheels so we can go faster later.

You need more experience on your team. You need some fresh air in your engines. Maybe you need more senior engineers on your team.

But senior engineers can be hard to find, difficult to convince to join, and  expensive

Placing your bets on a single new senior engineer can put your energies on a single point, leaving your team and your code vulnerable.

Finding new team members brings with it the cost of recruiting and time spent finding, reaching out, and connecting with developers.

Adding another team member means added costs in salary and more time onboarding them with your developers and your code.

Your code will get better with new, shared ideas and collaboration.

If your current team had more experience and a better understanding you’d have what you need to move fast. You’d be knocking out features and killing those nagging bugs along the way. 

If your team already had the knowledge and experience to get past the difficult challenges, you wouldn't need to add more people. The developers you already have are experienced and knowledgeable about how your company and software works. You've already invested in those who spend every day solving your business problems.

If everyone:

  • gets better
  • becomes faster and more creative
  • developers their Object-oriented design skills
  • masters better testing strategies
  • improves their approach to problem solving
  • sees through the difficulty of technology to the power it provides

you'd cut out the costs of adding someone new.

Your existing team is your best bet for improvement.

If your entire team could become better together,  you'd magnify your investment and your productivity.

Your team is already eager to do well and growing the skills of developers who already have business knowledge and experience makes improvement faster.

I’ve worked with teams who are a lot like yours.

We’ve grown and shaped old and new code to better reflect the needs of the businesses we helped build. Together with teams like yours I’ve helped developers tackle difficult business rules, complicated code, and slow, brittle, and difficult test suites.

Dave’s team was facing challenges with two Rails applications and was eyeing the development of more. Architectural challenges aside, we needed to tackle the problem of having too few good tests to provide a feeling of confidence in the code. By building tests around the most important areas of the system, we uncovered difficulties made from circular dependencies and complicated procedural code. We worked to separate responsibilities in the code through better Object-oriented design. We rolled back from maintaining complete forks of our third-party dependencies to instead managing only the parts we needed to alter to fit our needs.

I've created books, videos, and other resources to help developers build better Ruby programs. 

  • Readers have learned from my experience and research in Clean Ruby where I’ve written about building software that better reflects your business.
  • Readers of my Ruby DSL Handbook are able to quickly understand the flexibility of Ruby by writing code that reflects the words and ideas their businesses use.
  • Students of my Metaprogramming Masterclass have used their knowledge to get a deeper understanding of how to make Ruby bend to their wills.

I’ve taught Object-oriented Design with Sandi Metz in her well-respected course along with Avdi Grimm, where I helped my students better grasp the steps necessary for practicing TDD, handling Refactoring and better understanding approaches like the Single Responsibility Principle, Liskov Substitution Principle, and more.

Let’s get you launching forward.

Your team can create better ways to manage and understand where and how your code controls business logic.

You can remove distractions from code by making it clear, concise, and focused on just enough to understand and solve the problem.

You can write better tests that test the right thing and learn when to not even test at all.

You can balance pair programming and individual work to effectively solve problems and spread knowledge throughout your team.

You can create Object-oriented design that makes your code expressive and simple.

Your team can manage code bloat and leaky responsibilities tackling application architecture with DCI. You'll be breaking problems into cohesive wholes that help you make sense of why code exists and how to manage changes.

You'll know when and how to apply functional programming ideas.

Get your team on a deliberate course toward controlling the outcome of your projects.

Tune up your team

Get your developers to level up and give them the autonomy, mastery, and purpose to make decisions that impact the long term success of your project.

In three intensive days of training we'll transform your approach to get over your toughest challenges. After on-site training, you'll have recurring support that suits your team's needs.

Your team will level up their technical skills:

  • Create small and easy to manage objects
  • Use East-Oriented Code and how to Tell, Don't Ask
  • Build DSLs that use your common business language
  • Clean up complex views with decorators and presenters
  • Manage logic branching and too many if/else statements
  • Use DCI to manage business rules and keep feature context in focus

After our work your team will:

  • Add and update features faster
  • More easily read and understand the system
  • Collaborate on complex problems
  • Recognize patterns and come up with ways to handle repetitive code
  • Build what you truly need

And go home happy.

 

 

My Customers

I’ve served many happy customers with design, development, and strategy. Here’s a quick list of some recent clients.

 
 
 
Get a FREE sample chapter

Get a sample chapter of Clean Ruby and you'll be added to my periodic newsletter of helpful Ruby tips.