Disqus - Latest Comments for jimweirich

Re: 167 Debugging in Gems | RubyTapas

jimweirich — Mon, 13 Jan 2014 16:22:04 -0000

Great episode. Don't forget about the "gem which" command that also tells you where your gem is loaded.

And now you have me curious … what as the issue in the Rake gem you were tracking down?

Re: When Constants Aren't - Courageous Software

jimweirich — Thu, 05 Dec 2013 10:47:47 -0000

Reminds me of the old adage: "Constants aren't, variables don't."

Re: 148 Rake Invoke | RubyTapas

jimweirich — Mon, 25 Nov 2013 16:57:26 -0000

Environment variables are kept in ENV, so are implicitly available.

If you meant task arguments, then yes, you need to supply them to invoke each time you use it.

Re: 152 Progress Bar | RubyTapas

jimweirich — Mon, 18 Nov 2013 09:54:48 -0000

Thanks for the info on Ruby ProgressBar. I'm questioning the trivia however. You mentioned it was the first RubyGem ever released. I always thought Rake had that honor. Rich Kilmer and I were sitting at the Austin airport after the RubyConf where RubyGems was written. We just got the RubyGems server working and I was running on my laptop over the Airport wifi. I got someone to download the Rake gem off the RubyGems server running on my laptop. Rake and one of Rich Kilmer's DSL libraries were the first ruby libraries to ever be packaged by RubyGems.

Re: 149 Sum | RubyTapas

jimweirich — Tue, 12 Nov 2013 15:11:32 -0000

It might be useful mentioning why you might want to include an explicit seed value. If the data array is empty, then data.reduce(0,:+) returns zero, but data.reduce(:+) will return nil. I always include the seed value unless I know for sure the data sample is not empty.

Re: 148 Rake Invoke | RubyTapas

jimweirich — Tue, 05 Nov 2013 17:36:38 -0000

I consider execute to be internal to Rake, and would prefer people not use it to do double invokes.

The canonical way to do a double invoke is:

Rake::Task["hello"].invoke
Rake::Task["hello"].reenable
Rake::Task["hello"].invoke

Re: Configuration Blocks - Courageous Software

jimweirich — Wed, 02 Oct 2013 10:54:54 -0000

I agree that method_missing is deeper in the bag of tricks. That's why I generally don't use this method and prefer the explicit passing technique for most things.

My dividing line is this: If the library is mainly for programmers, then the explicit yield(self) works fine (that's the route my Builder library went).

If the library is more of a DSL and I was really concerned about making it pretty, then I would probably use the method_missing technique.

I'm not overly found of the flexible either/or trick because it just moves cognitive load to the user of the library.

Re: Configuration Blocks - Courageous Software

jimweirich — Tue, 01 Oct 2013 21:18:00 -0000

Two ccomments:

(1) The reason "libraries_to_link_with" isn't found is because it isn't defined at the time the project method is executed. Define "libraries_to_link_with" before calling project and both versions will work. Because "libraries_to_link_with" is a top level method, it is available in all objects.

(2) However, your point is correct, if project were invoked in a different object's scope, it would not be able to pick up objects defined in the invoking object if you use the non "p." version of the DSL.

Here is another way to get flexible DSLs: https://gist.github.com/jim...

This relies on method_missing to reissue the command on the context object if the configuration object does not defined it.

Re: 131 Rake Rules | RubyTapas

jimweirich — Thu, 05 Sep 2013 10:50:24 -0000

Excellent episode! Thanks.

Just a couple of notes:

(1) You can use --rules on the command line rather than setting trace_rules in the Rakefile.

(2) You can use .ext (with no args) rather than .ext("")

(3) Rather than use the lambda in the rules, in real life I would have probably just looped over the two rules (see below) and let Rake sort it out. However, I understand introducing the lambda for pedagogical reasons.

# Looping over rules
%w(.md .markdown).each do |ext|
rule ".html" => ext do |t|
sh "pandoc -o #{t.name} #{t.source}"
end
end

I'll say again: Great episode.

Re: Connascence - Courageous Software

jimweirich — Sun, 01 Sep 2013 20:59:32 -0000

I too have noticed the strange CoN/CoP nature of Smalltalk's parameter passing. In the end, I think its just really CoN in that the name of the method is "replace:with:from:to:". I tend to look at that as a single name that encodes the positions of the arguments.

At least that's my current thinking on the topic.

Re: 092 Coincidental Duplication Redux | RubyTapas

jimweirich — Fri, 03 May 2013 10:46:09 -0000

Thanks for the example, but I'm not sure agree with the analysis. There are many differences between the original and the refactored.

(A) Different interface. The original had four methods: whats the date for mothers/fathers day for a given year, and what's the next fathers/mothers day. The refactored had two methods, and it wasn't clear from the name which methods from the original were implemented.

(B) Inexplicable switch from using dates to using times (and yet the variables are still called dates although now they are time values).

Here's an example that just extracted the common code from next_mothersday/next_fathersday: https://gist.github.com/jim....

I also marked the incidental methods as private to make it clear what is the public part of the module (that's mainly for documentation purposes, since it's a module that's included rather than an object that is called).

I think you can still make an argument that the complexity introduced by the DRY refactoring may outweigh the minor benefit of dry, but the balance is much closer in the revised refactoring than the original refactoring.

Anyways, that's my two cents. Thanks for the example.

Re: Seeing double: how Ruby shares string values

jimweirich — Tue, 05 Mar 2013 15:30:09 -0000

RE: "Creating any other long substring, 24 or more bytes, is slower."

Actually, it seems that any substring is shared, even if it doesn't go to the end of the original.

Re: The art of speaking at conferences

jimweirich — Wed, 18 Jul 2012 14:16:04 -0000

Actually, the instance I was thinking about was not at SRC, but I'm sure the scenario has repeated itself over and over in various venues.

Re: Practicing Ruby - Issue #24: Connascence as a Software Design Metric

jimweirich — Tue, 11 Oct 2011 11:17:42 -0000

I have no idea why I'm not pronouncing the "n". I usually pronounce it. In fact, I recall practicing saying the word before the talk. It's kinda annoying now that you pointed it out.[1]

Your question about Forth is a good one. In Forth, you rarely find long words doing a lot of manipulation on the positional stack elements. When a word gets too big, you break it down into smaller, named words. I think the force to lots of small, named words is exactly the force to move to CoN over CoP. BTW, I think Forth is a great language to learn how to factor to small words (i.e. methods).

[1] Now I'm going to have to check all the other recordings of this talk to see how I pronounce it there. :)

Re: Null Objects and Falsiness

jimweirich — Tue, 31 May 2011 01:25:35 -0000

Since NullObjects are stateless, I typically create only one of them.

NULL_OBJECT = NullObject.new

and then use NULL_OBJECT rather than NullObject.new in the rest of my code. Add appropriate layers of convenience as needed.

Re: QR Code Fun - { |one, step, back| }

jimweirich — Mon, 22 Nov 2010 09:15:06 -0000

The GitHub page with the QR codes is no longer available. I don't know what happened to it. Sorry.

Re: QR Code Fun - { |one, step, back| }

jimweirich — Tue, 02 Nov 2010 13:34:08 -0000

UPDATE:

If you want to see a cool use of QR codes on GitHub, go to http://github.com/downloads...

Re: http://localhost:4000/2010/08/30/coming-soon.html

jimweirich — Tue, 07 Sep 2010 14:10:35 -0000

This is a test comment.

Re: Why Whyday - { |one, step, back| }

jimweirich — Mon, 16 Aug 2010 12:19:02 -0000

I should also mention that EdgeCase is fully supporting Whyday by encouraging its developers to pick and Whyday project and work on it this Thursday.

Thanks @objo and @kend.

Re: Line Noise - { |one, step, back| }

jimweirich — Sat, 02 Jan 2010 22:29:39 -0000

$ linenoise animal.io
animal.io (25): :=(:=("")):=(:=(""))(,)()

Re: Braces Vs Do/End - { |one, step, back| }

jimweirich — Thu, 24 Dec 2009 09:16:23 -0000

The difference is where in the operator precedence table they fall. { } binds tighter than do/end. For example:

f g { }

is parsed as f(g { }), where the braces belong to the method g. On the other hand,

f g do end

is parsed as f(g) do end, where the braces belong to the method f. It only matters when you omit parenthesis and create ambiguities.

Re: The Ruby Draft Specification

jimweirich — Mon, 07 Dec 2009 09:26:51 -0000

Standards should be used to codify existing practices, not be a test bed for new ideas. (I think the Emperor's Old Clothes by C.A.R.Hoare makes a good argument for that).

Standardizing Ruby 1.8.7 makes good sense.

Re: Now Using Pivotal Tracker - { |one, step, back| }

jimweirich — Mon, 30 Nov 2009 14:01:08 -0000

Most of the issues I get from third parties are either transcribed from emails or taken from GitHub pull requests. I suspect this will continue in the future. If there is a small number of frequent issue reporters, we can probably deal with that. Otherwise, I'll take another look at the problem.

Re: What Are Metaclasses? - { |one, step, back| }

jimweirich — Wed, 18 Nov 2009 05:32:37 -0000

(1) "A singleton class is a class" -- Yes
(2) "Its one instance is also a class" -- Only for singleton classes of classes. Obviously singleton classes of regular objects have regular objects for their instance. Also, there is some debate on whether singleton classes have instances in the normal sense, since the objects themselves are created from the original class, continue to report the original class as its type, and return false when asked if they are "instance_of?" the singleton class.

But certainly singleton classes of classes fulfill a part of the role of metaclasses in that they define the behavior of classes.

Re: What Are Metaclasses? - { |one, step, back| }

jimweirich — Mon, 16 Nov 2009 16:44:29 -0000

Granted, the metaclass capability of Ruby is limited wrt Smalltalk or CL. Maybe its best to say that Class + eigenclasses of classes provide a subset of metaclass capability.