Safely evaluating user-defined formulas and calculations Learn how to use Dentaku to evaluate Excel-like formulas in Ruby programs (w. Solomon White)



Problem discovery comes before problem solving A brief story about why you should play around with problems before trying to solve them.



The anatomy of information in software systems Explore the tradeoffs involved in designing message formats, and the messy boundary between humans and computers.



A self guided course on streams, files, file formats, and sockets Explore UNIX-style stream processing, binary file formats, the Racc parser generator, and socket programming.



Sustainable maintenance: Focus on quality first Learn three useful practices for maintaining high quality open source projects (w. Eric Hodel)



Hunt the Wumpus: An exercise in creative coding Build Gregory Yob's classic text-based game from scratch, using the provided test suite as a guide.



Infrastructure automation by example Discover why infrastructure automation matters by exploring real Chef recipes. (w. Mathias Lafeldt)



Exploring low-level computing concepts with Ruby Implement a minimal simulator of the classic 6502 processor using nothing but JRuby.



Making incremental improvements to legacy systems Experience the challenge of overhauling one of Practicing Ruby's oldest features. (w. Jordan Byron)



Using data to explore questions about our lives Aggregate and analyze 500+ data points from a SMS-based mood study using R and Ruby. (w. Jia Wu)



Implementing a minimal HTTP server in Ruby Build just enough HTTP functionality from scratch to serve up static files. (w. Luke Francl)



Simulating tiny worlds for fun and profit Practice exploratory programming by modeling forest fires, rabbit populations, and diseases.



A low cost approach to working on side projects Save time by building a standalone feature before designing a complete product.



Avoiding brittleness in data munging projects Process data and generate reports without writing unmaintainable spaghetti code.



From adhoc script to object-oriented program Gradually convert a "throwaway" procedural program into a well-defined domain model.



The Law of Demeter: Some archaeological notes Explore the history of a classic design principle and how it relates to Ruby. (w. David A. Black)



Cleaning up bloated method interfaces Tame a complex method interface using keyword arguments and parameter objects.



Debugging without the doom and gloom Use stack traces, the Pry console, and tests to hunt bugs with confidence. (w. Carol Nichols)



Code reuse in Ruby: It's complicated! Learn the costs and benefits of the many ways that Ruby lets you reuse code.



A gentle introduction to actor-based concurrency Solve "Dining Philosophers" using mutex locks, then do it again using actors. (w. Alberto F. Capel)



A self-guided tour of an interesting codebase Practice your code reading skills by walking through a small GUI client to the GNU Go game engine.



Parsing JSON the hard way Learn about low-level parser and compiler tools by implementing a JSON parser. (w. Aaron Patterson)



An adventure in prototypes Build a text adventure game and a prototype-based object model, at the same time! (w. Avdi Grimm)



Simulating the emergent behavior of ant colonies Explore how simple rules for individuals can yield complex group behavior by simulating an ant colony.



Expanding your code reading horizons See how much even a few dozen lines of code can tell you about a programming language.



Understanding the relationships between objects Learn how to model dependencies, notifications, adjustments, and internal object relationships.



Guidelines for growing a stable codebase Discover the process we use for continuously improving practicingruby.com. (w. Jordan Byron)



Process spawning patterns Implement Ruby's system and backticks methods using the fork/exec pattern. (w. Jesse Storimer)



Building the rstat.us API: Choices and challenges Consider the design tradeoffs between the JSON API and hypermedia API styles. (w. Carol Nichols)



Event loops demystified Build a Node.js/EventMachine-style event loop in roughly 150 lines of Ruby code. (w. Magnus Holm)



Temporal coupling and the Law of Demeter See how NASA JPL's take on the Law of Demeter simplifies building robust asynchronous code.



A practical application of basic statistical methods Crunch some numbers to see how Olympic medal wins relate to GDP and population. (w. Jia Wu)



Spiking is not cowboy coding Search for the boundary lines between organized chaos and wild, unstructured hacking.



Mock objects deeply influence design Learn the rules that you need to follow in order to use mock objects as an effective design tool.



Refactoring is not redesign Discover how the differences between refactoring and redesign affect testing strategies.



End-to-end testing is essential Build acceptance tests that reflect application behavior, rather than implementation details.



Lessons learned from my TDD self-study Revisit the reasons for Gregory's 90-day self-study on TDD, and see the results.



Responsibility-centric vs. data-centric design Work through two approaches to object modeling and examine their tradeoffs. (w. Greg Moeck)



Implementing the Active Record pattern, Part 2 Consider using "object-oriented mixins" to reduce inheritance-related problems in ActiveRecord.



The hidden costs of inheritance Think through some problems with inheritance-based modeling and then try a few related exercises.



Implementing the Active Record pattern, Part 1 Build a basic foundation to serve as the groundwork for implementing an ActiveRecord-style ORM.



Writing confident code Develop intention-revealing code that is confident about its responsibilities. (w. Avdi Grimm)



Persisting relations in a polyglot world Explore some non-traditional persistence mechanisms and their uses. (w. Piotr Szotkowski)



Solving the "Scoring Predictions" kata Work through a coding puzzle and learn some fun tricks along the way. (w. James Edward Gray II)



Tricks for working with text and files Tear apart a minimal clone of the Jekyll blog engine in search of helpful Ruby idioms.



What are the costs and benefits of TDD? Think through how to evaluate the impact of test-driven development on your work.



Lessons learned from coding in the danger zone Establish a few survival skills for working in hostile programming environments.



Using games to practice domain modeling Learn about modeling non-trivial business logic by implementing Minecraft's crafting table.



Criteria for disciplined inheritance, Part 2 Discover how Barbara Liskov's concept of "behavioral subtypes" apply to object modeling in Ruby.



Criteria for disciplined inheritance, Part 1 See how M. Sakkinen's notion of "Disciplined Inheritance" in 1989 still applies to modern Ruby code.



Framework design and implementation, Part 2 Explore some lessons learned the hard way in developing the Newman mail framework.



Framework design and implementation, Part 1 Dig through the Newman mail framework's source code in search of useful patterns and practices.



Building a better Turing tarpit In this issue, we improve the design of the Brainf*ck interpreter that was introduced in Issue 3.3



Exploring the depths of a Turing tarpit Read the code for a simple Brainf*ck interpreter and think about how it might be improved.



Patterns for building excellent examples Learn how to write code samples that clearly communicate ideas to other programmers.



The qualities of great software See what ISO/IEC 9126 has to say about software quality, and how its metrics apply to Ruby code.



Thoughts on "Arguments and Results", Part 2 Work through result objects inspired by James Noble's classic "Arguments and Results" paper.



Thoughts on "Arguments and Results", Part 1 Work through argument objects inspired by James Noble's classic "Arguments and Results" paper.



Working with binary file formats Read and write bitmap files using only a few dozen lines of Ruby code.



Domain specific API construction Master classic Ruby DSL design patterns by ripping off well-known libraries and tools.



From requirements discovery to release Watch a small game project develop from the brainstorming phase to its first public release.



Building Unix-style command line applications Build a basic clone of the 'cat' utility while learning some Ruby idioms for command line applications.



Ruby and the singleton pattern don't get along Model the singleton pattern in seven different ways, without discovering an elegant solution.



"Unobtrusive Ruby" in Practice Explore ideas from Mike Burns's "Unobtrusive Ruby" blog post via practical code samples.



Learning new things step-by-step Build a simple arcade game in 13 tiny steps.



Thoughts on regression testing Benefit from two lessons about regression testing that were learned the hard way.



Building Enumerable & Enumerator in Ruby Learn about Ruby's powerful iteration tools by implementing some of its functionality yourself.



A closure is a double edged sword Discover why the closure property can sometimes lead to hard-to-spot memory leaks.



How to attack sticky problems Work through a few lessons that will help you find a starting point whenever you feel stuck.



Ways to load code Explore the strengths and weaknesses of the many code loading mechanisms in Ruby.



Structural Design Patterns Examine a use case for each of the classic structural design patterns laid out by the Gang of Four.



Creational Design Patterns Examine a use case for each of the classic creational design patterns laid out by the Gang of Four.



Connascence as a Software Design Metric Work through code samples inspired by Jim Weirich's "Building Blocks of Modularity" presentation.



SOLID Design Principles Work through code samples inspired by Sandi Metz's "SOLID Object-oriented Design" presentation.



How to practice, Part 2 See an example of how the practice methods outlined in Issue 1.21 can be applied to a real project.



How to practice, Part 1 Discover a new way to practice your coding skills by asking yourself the right questions.



Thoughts on Mocking, Part 2 Explore a few good uses of mock objects from a non-mockist's perspective.



Thoughts on Mocking, Part 1 Consider how the ideas from Martin Fowler's "Mocks aren't Stubs" can be applied to Ruby.



Dirty Little Secrets about Testing Take a look at some dark corners of the traditional testing dogma.



Interesting Ruby Hacker-Writers Find out which Ruby hackers consistently write great content worth reading.



Interesting Ruby Hackers Find out which Ruby hackers consistently write great code worth reading.



Duck Typing in Practice, Part 2 Examine real uses of Ruby's duck-typing capabilities in various open source projects and Ruby itself.



Duck Typing in Practice, Part 1 Investigate the three main ways of doing type checking in Ruby, then work on some related exercises.



Obfuscations of Christmas Past Tear apart an obfuscated Ruby program from Leah Neukirchen to learn some neat tricks.



Rapid Prototyping Build a tiny prototype of a tetris game on the command line.



Uses for Modules, Part 4 Explore the use of mixins for customizing individual objects.



Addendum to Uses For Modules, Part 3 Learn the subtle differences between "extend self", "def self.method", and "module_function".



Uses for Modules, Part 3 See how modules can be used as namespaced function bags, and as singleton objects.



Uses for Modules, Part 2 Use mixins as an alternative to multiple inheritance to augment class definitions.



Uses for Modules, Part 1 Use modules as namespaces for your libraries and applications.



Meditations on Bad and Good Code, Part 2 Read through a cleaned up version of the ugly "Tic Tac Toe" game created in Issue 1.5



Meditations on Bad and Good Code, Part 1 Build an ugly tic-tac-toe game by writing the entire implementation as a single procedural script.



Testing Private Methods Understand why testing private methods can be a code smell.



Writing Configurable Applications, Part 2 Build dynamic Ruby-based configuration objects.



Writing Configurable Applications, Part 1 Learn what not to do when configuring applications, then explore a simple YAML-based configuration.



Ruby's method lookup path, Part 2 Use your knowledge of Ruby's lookup path to determine where to add methods in a program.

