#pragmatic programming

We've partnered with over 80 independent publishers and retailers across the globe. All of them offer you our little Send to Readmill button, which transfers the books you buy to your iPad or iPhone in a single click. Andy Hunt, author and publisher at the Pragmatic Programmer, sat down with us and discussed his company and insights on reading in today's digital age. We hope you enjoy it!

Day 1 of Io has been rather interesting. The language feels different from everything I've had experience with so far, and I'm enjoying the fresh feeling. I think I may be comfortable with certain aspects of Io due to my many hours playing with JavaScript (mostly creating scripts to make certain browser games more trivial...) but the syntax feels different from anything I've dealt with yet, and whether that attests to Io's uniqueness or my own lack of experience with multiple languages, I'm unsure.

Evaluate 1 + 1 and then 1 + "one". Is Io strongly typed or weakly typed?

(1 + 1) asString println # 2 (1 + "one") asString println # Exception: argument 0 to method '+' must be a Number, not a 'Sequence'

The exception suggests "Strongly typed" to me.

Is 0 true or false? What about the empty string? Is nil true or false?

# Conditions are in parenthesis because # "false println" would print "false" for me, # but "true println" was throwing an exception # Is 0 true or false? (0 or false) println # true (0 and true) println # true # What about the empty string? ("" or false) println # true ("" and true) println # true # Is nil true or false? (nil or false) println # false (nil and true) println # false

From the minimal testing I ran against 0, "", and nil, I believe both 0 and the emptry string equate to true, while nil equates to false.

How can you tell what slots a prototype supports?

Object slotNames asString println # list(slotSummary, ownsSlots, and, apropos, foreachSlot, performWithArgList, coroWith, <, actorRun, removeAllSlots, for, isTrue, clone, become, !=, write, switch, setSlotWithType, method, ancestors, futureSend, resend, isActivatable, lazySlot, list, justSerialized, evalArg, uniqueId, @@, do, thisContext, deprecatedWarning, setProto, println, hasProto, writeln, setSlot, handleActorException, inlineMethod, ifNonNil, isKindOf, setIsActivatable, removeAllProtos, coroFor, pause, continue, ifNil, stopStatus, prependProto, ancestorWithSlot, print, protos, evalArgAndReturnSelf, doString, type, ?, return, break, >, message, ==, currentCoro, slotNames, hasLocalSlot, while, perform, serialized, ifNonNilEval, wait, asString, returnIfNonNil, getLocalSlot, or, getSlot, asSimpleString, compare, coroDoLater, hasDirtySlot, slotDescriptionMap, removeProto, appendProto, in, isNil, uniqueHexId, loop, lexicalDo, not, .., doRelativeFile, try, launchFile, , yield, isError, ifNilEval, init, evalArgAndReturnNil, doFile, serializedSlotsWithNames, argIsActivationRecord, returnIfError, isIdenticalTo, super, isLaunchScript, serializedSlots, cloneWithoutInit, hasSlot, contextWithSlot, thisLocalContext, >=, if, relativeDoFile, memorySize, <=, asyncSend, thisMessage, @, markClean, coroDo, slotValues, -, doMessage, proto, ifError, newSlot, updateSlot, removeSlot, shallowCopy, block, actorProcessQueue, raiseIfError, setProtos, argIsCall)

The slotNames slot gives a list of the slots a prototype directly supports, but doesn't list slots a prototype's parent may support.

The book also asks "What is the difference between = (equals), := (colon equals), and ::= (colon colon equals)? When would you use each one?" The book previously mentioned that := sets a slot, and = updates a slot, but doesn't mention what ::= does. Googling suggests ::= creates a slot and a setter as well as assigning a value, while := just creates a slot and assigns the value, and = will only assign a value to an already created slot. I'm not exactly sure yet when you would choose to use ::= over :=, but := is useful for creating a new slot, while = would be used to update any already existing slot.

The book also asks the reader to run an Io program from a file, which—similar to the last langauge—I've been doing all along, in order to upload my solutions to Github. Running an Io program from a file works similar to runnin a Ruby program from a file: from the command line, call Io, passing it the file to run.

Execute the code in a slot given its name.

Greeter := Object clone Greeter sayHello := method("Hello, world!" println) Greeter perform("sayHello") # Hello, world!

With little else to do today, I decided to read through and complete the third (and last) day of Ruby. This day was less enjoyable than the previous two, but more enlightening. The book started to cover meta-programming in Ruby, but I found this section slightly more difficult to follow along with: googling helped me power through the few parts I was stuck on, however.

This section only had one task to complete at the end, but its much longer and less trivial than the previous days' code. I commented this code more heavily than normal to help explain what was going on, since the book seemed to skim over a bit of the details. (Just to note, I don't think of this as a problem with the book. The author writes very early on that he won't be responsible for installation, that googling will be involved, and that the book is for competent programmers who want to learn. Given the task of going over each language with 3 days of content and focusing on pointing out just the highlights of the language, I think the book has done a great job so far with Ruby, and can't wait to see the other languages)

Modify the CSV application to support an each method to return a CsvRow object. Use method_missing on that CsvRow to return the value for the column for a given heading.

class CsvRow def initialize(array) @content = array end # "Use method_missing on that CsvRow to return the value # for the column for a given heading" def method_missing name, *args to_int = { :one => 0, :two => 1, :three => 2, :four => 3, :five => 4, :six => 5, :seven => 6, :eight => 7, :nine => 8, :ten => 9} return @content[to_int[name]] if to_int.has_key?(name) nil end end module ActsAsCsv # Is called automatically when module is included in a class def self.included(base) # Extend adds the given module as class methods, # while include adds the module as instance methods. base.extend ClassMethods end # Module to be loaded as class methods. # Is called via self.include module ClassMethods # "Macro" method to include instance methods def acts_as_csv include InstanceMethods end end # Module to be loaded as instance methods. # Is called via "Macro" method acts_as_csv module InstanceMethods def read @csv_contents = [] filename = self.class.to_s.downcase + '.txt' file = File.new(filename) @headers = file.gets.chomp.split(', ') file.each do |row| @csv_contents << row.chomp.split(', ') end end # "an each method to return a CsvRow object" def each filename = self.class.to_s.downcase + '.txt' file = File.new(filename) @headers = file.gets.chomp.split(', ') file.each { |row| yield CsvRow.new(row.chomp.split(', ')) } end attr_accessor :headers, :csv_contents def initialize read end end end class RubyCsv # no inheritance: mixed in via modules instead #including ActsAsCsv automatically extends ActsAsCsv::ClassMethods include ActsAsCsv #Call the "Macro" method from ClassMethods to include ActsAsCsv::InstanceMethodss acts_as_csv end csv = RubyCsv.new csv.each {|row| puts row.one}

While the original task says to modify the CSV application to "support an each method to return a CsvRow object," it is further requested that there be an API that works such as csv.each {|row| puts row.one}.

Today's tasks were a little tougher than the previous, but fun to work through. This section of the book went over hashes and arrays as well as code blocks and modules. The syntactic sugar that makes Ruby such a joy to work with started to shine through heavily this section. None of the tasks required just one line this time around, so there'll be a bit more code than the last entry.

Print the contents of an array of sixteen numbers, four numbers at a time, using just each.

numbers = (1..16).to_a output = [] numbers.each do |value| output.push(value) if output.length == 4 puts "[#{output[0]}, #{output[1]}, #{output[2]}, #{output[3]}]" output.clear end end

Now, do the same with each_slice in Enumerable

numbers = (1..16).to_a numbers.each_slice(4) { |value| p value }

The Tree class... did not allow you to specify a new tree with a clean user interface. Let the initializer accept a nested structure with hashes and arrays...

class Tree attr_accessor :children, :node_name def initialize(name, structure) @node_name = name @children = [] structure.each { |key, value| children.push(Tree.new(key, value)) } end def visit_all(&block) visit &block children.each {|c| c.visit_all &block} end def visit(&block) block.call self end end new_tree = Tree.new('family', { 'grandpa' => { 'dad' => { 'child 1' => {}, 'child 2' => {} }, 'uncle' => { 'child 3' => {}, 'child 4' => {} } } }) new_tree.visit_all {|node| puts node.node_name}

Write a simple grep that will print the lines of a file having any occurences of a phrase anywhere in that line...

puts "Please give me a file to search!" filename = gets.chomp #strip newline from the end! filepath = File.absolute_path(filename) if File.exists?(filepath) puts "Please give me a string to search for!" search = gets.chomp puts file = File.new(filepath, "r") results = file.grep(/#{search}/) puts "The following lines have '#{search}' in them!" puts "=============================================" results.each { |result| puts result } else puts "Sorry, #{filename} doesn't exist!" end

I've been busy with University and dog sitting for a friend, so it has taken me longer than expected to get around to Day 1, but I finally managed to tackle it. I've had more than a little experience with Ruby already, so these problems took little time to solve, but helped remind me what features I really like about the language.

The first assignment was to Print the string "Hello, world," which was already accomplished in my previous post that I had made to test Syntax highlighting, so I skipped that to get to the others faster.

For the string "Hello, Ruby," find the index of the word "Ruby."

puts "Hello, Ruby".index('Ruby')

Print your name ten times.

10.times { puts "James Thomason, Jr" }

Print the string "This is sentence number 1," where the number 1 changes from 1 to 10.

(1..10).each { |n| puts "This is sentence number #{n}" }

The fifth task was to run a Ruby program from a file, which I was doing along the way, anyway. (I made a separate file for each task for the purpose of uploading them to Github)

Bonus problem: If you're feeling the need for a little more, write a program that picks a random number. Let a player guess the number, telling the player whether the guess is too low or too high.

class NumberGame def initialize(max) @max = max end def start puts "Guess a number between 1 and #{@max}" result = rand(@max) + 1 3.times do input = gets.to_i if result == input puts "Congratulations! You guessed correctly!" return else puts "Sorry! Your guess was too #{input > result ? 'high' : 'low'}!" end end puts "The correct answer was #{result}!" end end game = NumberGame.new(10) game.start

In an attempt to program more and have something to actually blog about, I'm going to make my way through "7 Languages in 7 Weeks," a pragmatic programming book I bought awhile back but never actually read. For those unaware, the book gives brief introductions to Ruby, Io, Prolog, Scala, Erlang, Clojure, and Haskell, attempting to present the best features of each language and give the reader a bit more insight and knowledge to apply in their future programming endeavors. Rather than the title's "7 weeks," I'll most likely be excited to have some sort of direction and a chance to learn new languages, and finish the book in less than 5 weeks, or busy with school work and bored of writing "Hello, World!" in yet another language, and slowly drudge through the book over a period of time greater than 12 weeks.

Our Send to Readmill news gets even better! Not only have we got extensions for Chrome and Firefox in the wild, today we're announcing another great partner to our roster - Pragmatic Programmers! If there's one thing we're proud of, it's the amount of designers and developers reading books with Readmill. 

One of our favourite places to pick up code-orinetated reads is from Prag Prog, and we're honoured to have them support our little button, and the bigger cause behind it. We had a chat with Andy Hunt, co-founder of Pragmatic Programmers, about its history, today's partnership with Readmill, and their plans for the future.

For those not familiar, what is The Pragmatic Programmer?

The Bookshelf is our publishing imprint that we started almost 10 years ago after writing our flagship book, The Pragmatic Programmer. We (Dave and I) wanted to see more book titles that were truly focused on the needs of working developers. Not just reference books, and not flighty theory books, but useful titles on subjects we're interested in. We wanted books that read like a good conversation with a knowledgable friend over lunch. No existing publisher provided that sort of thing, so we started our own imprint.

Now our books are available worldwide, through regular retail channels as well as direct from our website, pragprog.com. When you buy an ebook from us, you get access to it in all flavors: PDF for laptops, epub for iThingies, mobi for Kindle. We can email the Kindle file directly to your device, and sync your purchases on your Dropbox account.  We update books frequently, and those changes get pushed out to readers as well (which is something you can't get from the regular retail ebook stores).

What type of person would enjoy the books you have to offer?

Someone involved with software development, either as a developer, tester, manager, or other capacity, who wants to really learn and further their career. We cover a wide swath of current development technologies and methods, from iOS and Android devices to Ruby and Rails, lessor-know languages such as Clojure and Scala, things like Behaviour-Driven-Development (BDD), project and portfolio management, the growing Arduino movement, and more.

Why did you choose to offer the Send to Readmill button?

Even though we often do it alone, reading really is a social activity. Sharing good finds and discussing ideas and techniques is key to being a Pragmatic Programmer, so Readmill complements our titles nicely. We'd love to see folks get into the action and offer comments on what works for them and what doesn't. That's how our industry improves. Send to Readmill makes it easy to get our titles into the hands of the Readmill community, and for that social activity to take place.

Any exciting news on the horizon?