“Every time I start a project, I swear to myself that this time I will keep my code spotless and write tests…”
You’re afraid to make changes to your Ruby app. You don’t have enough tests, and the codebase is tangled by poor design choices. You’ll spend half the day just tracking down a simple mistake. You’ve been cowboy-coding your way to frustration… and now it’s time for a change.
What if your code had good test coverage, and a clean design?
You could add new features with ease. You’d find and fix problems quickly. You could apply a professional development process… and deliver professional results, every time.
You can achieve a clean, well-tested codebase, and it’s not magic.
The three critical skills for producing professional code
What distinguishes professional code from amateur code? Professional code works, and is neatly organized. Amateur code breaks, and is poorly organized. So how do you turn amateur code into professional code?
First, you need to understand and apply object-oriented design. You need to create clearly-defined interfaces, encapsulate behavior, and use polymorphism where appropriate. Of course, that would be easy if you knew all the design elements upfront – but in the real world, you need to evolve your design over time…
By refactoring, you do exactly that. You take an existing design, and make improvements to it, without changing the externally visible behavior. But changing code is risky business, unless…
You write tests. You build a safety net of tests that you can run any time you make a change, automatically alerting you to any breaking changes.
There you have it: object-oriented design, refactoring, and testing. That’s all you really need to know. But how do you learn those skills?
RubySteps shows you how:
You’ll start off with object-oriented design. You’ll learn:
- how messages clarify your design
- how Ruby’s runtime composition works, so you can make intelligent decisions for organizing your code
- the East principle, which will be your shortcut to creating object-oriented designs
- how to design interfaces that support encapsulation and polymorphism, leading to robust, maintainable code
- how to create Domain-Specific Languages, creating the perfect balance between simplicity and power
With a solid grasp of object-oriented design, you’ll move on to refactoring. You’ll learn:
- how to work in small steps, so you can safely make changes without breaking your code
- the two simple rules that will help you improve any design
- my favorite technique for working with legacy code
Now that you know what makes for clean design, and can safely improve your design, you’ll accelerate your design and development process with tests. You’ll learn:
- how to write tiny tests – and get detailed feedback when something goes wrong
- Approval Testing, which lets you quickly test any piece of code
- how to isolate behavior with tests, so you can create clean designs
- how to test at different layers, maximizing the usefulness of your tests
With the skills you learn in RubySteps, you’ll create clean, well-tested, professional code. You never have to waste another day working with sloppy, untested code. Buy RubySteps, and you’ll be enjoying clean, professional code in no time.
Is RubySteps right for me?
If you’ve read this far… then probably! But let me help you out a bit more…
RubySteps covers intermediate-to-advanced topics that are important for professional Ruby developers to understand and apply.
What happens when I buy?
You will receive an email from SendOwl with a link to download the RubySteps pdf.
Do you guarantee your work?
Of course :)
Who the heck are you, anyway?
Well my name’s Pat, and I’m a regular guy that loves programming Ruby. I’ve been doing it professionally for over ten years (I stopped counting a few years ago), and have been teaching people Ruby pretty much as long as I’ve been programming it. I love to cook, and play with my dogs.
What if I need help, or have more questions?
Just send me an email – I read and respond to every email I get.