Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Browse files

no more weblog.raganwald.com!

commit 9b1c9fe19c8689b1c106111c9dfa8fe44e9e14e9 1 parent ebeda01
@raganwald raganwald authored
Showing with 49 additions and 49 deletions.
  1. +1 −1  2008-10-27/unfold.markdown
  2. +2 −2 2008-10-27/unfold.rb
  3. +2 −2 2008-10-30/thrush.markdown
  4. +1 −1  2008-11-03/with_unhygienic_and_call-by-name_semantics_in_rewrite.markdown
  5. +1 −1  2008-11-04/unary_ampersand_in_ruby.markdown
  6. +1 −1  2008-11-07/README.md
  7. +1 −1  2008-11-07/from_birds_that_compose_to_method_advice.markdown
  8. +1 −1  2008-11-26/string_to_proc.rb
  9. +1 −1  2008-11-28/string_to_proc.rb
  10. +1 −1  2008-11-28/you_cant_be_serious.md
  11. +1 −1  2008-12-12/fibonacci.md
  12. +1 −1  2008-12-17/another_fibonacci.md
  13. +1 −1  2008-12-18/called_by_name.md
  14. +1 −1  2009-01-02/flight_of_the_phoenix.md
  15. +1 −1  2009-01-13/maybe.md
  16. +2 −2 2009-01-21/old.md
  17. +1 −1  2009-02-02/hopeless_egocentricity.md
  18. +1 −1  2009-04-08/sick.md
  19. +1 −1  2009-05-25/rubyjobfair.md
  20. +1 −1  2009-08-29/returning.md
  21. +1 −1  2009-09-22/anaphora.md
  22. +1 −1  2009-10-08/metalinguistic.md
  23. +2 −2 2010/02/difficult_distraction.md
  24. +1 −1  2010/03/significant_whitespace.md
  25. +2 −2 2010/08/final.md
  26. +1 −1  2010/08/ouch.md
  27. +2 −2 2011/01/anything_to_declare.md
  28. +2 −2 2011/10/i_make_dreams_come_true.md
  29. +2 −2 2012/02/Literate-Programming-Matters.md
  30. +1 −1  2012/03/garbage_collection_in_coffeescript.md
  31. +1 −1  2012/05/anaphora.md
  32. +2 −2 2012/11/refactoring_to_jquery_combinators.md
  33. +1 −1  README.markdown
  34. +2 −2 dumping_ground/against_final.md
  35. +1 −1  dumping_ground/revised_revised_ruby_rewrite_ruby_select.md
  36. +1 −1  dumping_ground/string_to_proc.rb
  37. +1 −1  dumping_ground/vapours.md
  38. +1 −1  dumping_ground/worst_of_raganwald_i.md
  39. +1 −1  homoiconic.markdown
View
2  2008-10-27/unfold.markdown
@@ -1,7 +1,7 @@
unfold
---
-Here's a little something from my old blog that I found myself using again. If you want the background, you might like my old posts [Really simple anamorphisms in Ruby](http://weblog.raganwald.com/2007/11/really-simple-anamorphisms-in-ruby.html) and [Really useful anamorphisms in Ruby](http://weblog.raganwald.com/2007/11/really-useful-anamorphisms-in-ruby.html).
+Here's a little something from my old blog that I found myself using again. If you want the background, you might like my old posts [Really simple anamorphisms in Ruby](http://raganwald.com/2007/11/really-simple-anamorphisms-in-ruby.html) and [Really useful anamorphisms in Ruby](http://raganwald.com/2007/11/really-useful-anamorphisms-in-ruby.html).
This week-end, I found myself thinking about `#unfold` in a new way: it's a way of turning an iteration into a collection. So anywhere you might use `for` or `while` or `until`, you can use `#unfold` to create an ordered collection instead. This allows you to use all of your existing collection methods like `#select`, `#reject`, `#map`, and of course `#inject` instead of writing out literal code to accomplish the same thing.
View
4 2008-10-27/unfold.rb
@@ -1,10 +1,10 @@
# unfold.rb
#
# see Really simple anamorphisms in Ruby:
-# http://weblog.raganwald.com/2007/11/really-simple-anamorphisms-in-ruby.html, and:
+# http://raganwald.com/2007/11/really-simple-anamorphisms-in-ruby.html, and:
#
# Really useful anamorphisms in Ruby:
-# http://weblog.raganwald.com/2007/11/really-useful-anamorphisms-in-ruby.html
+# http://raganwald.com/2007/11/really-useful-anamorphisms-in-ruby.html
#
# The MIT License
#
View
4 2008-10-30/thrush.markdown
@@ -14,7 +14,7 @@ The thrush is written `Txy = yx`. It _reverses_ evaluation. In Ruby terms,
thrush.call(a_value).call(a_proc)
=> a_proc.call(a_value)
-In [No Detail Too Small](http://weblog.raganwald.com/2008/01/no-detail-too-small.html), I defined `Object#into`, an implementation of the thrush as a Ruby method:
+In [No Detail Too Small](http://raganwald.com/2008/01/no-detail-too-small.html), I defined `Object#into`, an implementation of the thrush as a Ruby method:
class Object
def into expr = nil
@@ -75,7 +75,7 @@ Much better, Ruby 1.9 creates a new scope inside the block and `x` is local to t
# ...
end
-`let` creates a new scope and defines your block local variable inside the block. This [signals](http://weblog.raganwald.com/2007/11/programming-conventions-as-signals.html "Programming conventions as signals") that the block local variable is not used elsewhere. Imperative methods can be easier to understand when they are composed of smaller blocks with well-defined dependencies between them. A variable local to the entire method creates a dependency across the entire method. A variable local to a block only creates dependencies within that block.
+`let` creates a new scope and defines your block local variable inside the block. This [signals](http://raganwald.com/2007/11/programming-conventions-as-signals.html "Programming conventions as signals") that the block local variable is not used elsewhere. Imperative methods can be easier to understand when they are composed of smaller blocks with well-defined dependencies between them. A variable local to the entire method creates a dependency across the entire method. A variable local to a block only creates dependencies within that block.
Although Ruby 1.8 does not enforce this behaviour, it can be useful to write code in this style as a signal to make the code easier to read.
View
2  2008-11-03/with_unhygienic_and_call-by-name_semantics_in_rewrite.markdown
@@ -217,7 +217,7 @@ What just happened is that `our_and` is defined as a lambda, with `called_by_nam
There are some important implications of this approach. First, with unhygienic, `our_and` disappears. There is no `our_and` function or method, invocations are replaced by whatever `to` expression you provide. Whereas, `called_by_name` actually defines a lambda for `our_and` and defines it in scope for our block of code.
-> Note: Caleb asked about the fetish for lambdas. In Ruby 1.8 MRI, it makes no difference. In other implementations, these constructs will by hygienic. Yet, these implementations do not exist yet. So, either I don't understand YAGNI, or perhaps I have spent too much time with languages like JavaScript that [actually get this right](http://weblog.raganwald.com/2007/08/block-structured-javascript.html "Block-Structured JavaScript"), or I am from the future and I know that Ruby will get this right.
+> Note: Caleb asked about the fetish for lambdas. In Ruby 1.8 MRI, it makes no difference. In other implementations, these constructs will by hygienic. Yet, these implementations do not exist yet. So, either I don't understand YAGNI, or perhaps I have spent too much time with languages like JavaScript that [actually get this right](http://raganwald.com/2007/08/block-structured-javascript.html "Block-Structured JavaScript"), or I am from the future and I know that Ruby will get this right.
Second, even though `temp` is still around and still could shadow some variable where it is defined, it doesn't shadow any definition inside your block. So you could define rewriters with `called_by_name` at the top level or inside of a method somewhere and be assured that you are making 100% hygienic code.
View
2  2008-11-04/unary_ampersand_in_ruby.markdown
@@ -172,7 +172,7 @@ So that's it: When you want to convert a block to a `Proc`, define an extra para
When you want to convert any object to a block, pass it to a method expecting a block and preface it with an ampersand. Ruby will call the `#to_proc` method if need be, then convert the `Proc` into a block.
-p.s. *This post originally appeared on [weblog.raganwald.com](http://weblog.raganwald.com/2008/06/what-does-do-when-used-as-unary.html "The unary ampersand in Ruby")*
+p.s. *This post originally appeared on [raganwald.com](http://raganwald.com/2008/06/what-does-do-when-used-as-unary.html "The unary ampersand in Ruby")*
---
View
2  2008-11-07/README.md
@@ -1,7 +1,7 @@
Aspect-Oriented Programming in Ruby using Combinator Birds
---
-In [Combinatory Logic](http://en.wikipedia.org/wiki/Combinatory_logic), the bluebird is one of the most important and fundamental combinators, because the bluebird *composes* two other combinators. Although this is usually discussed as part of [functional programming style](http://weblog.raganwald.com/2007/03/why-why-functional-programming-matters.html "Why Why Functional Programming Matters Matters"), it is just as valuable when writing object-oriented programs. In this post, we will develop an [aspect-oriented programming](http://en.wikipedia.org/wiki/Aspect-oriented_programming "") (or "AOP") module that adds before methods and after methods to Ruby programs, with the implementation inspired by the bluebird.
+In [Combinatory Logic](http://en.wikipedia.org/wiki/Combinatory_logic), the bluebird is one of the most important and fundamental combinators, because the bluebird *composes* two other combinators. Although this is usually discussed as part of [functional programming style](http://raganwald.com/2007/03/why-why-functional-programming-matters.html "Why Why Functional Programming Matters Matters"), it is just as valuable when writing object-oriented programs. In this post, we will develop an [aspect-oriented programming](http://en.wikipedia.org/wiki/Aspect-oriented_programming "") (or "AOP") module that adds before methods and after methods to Ruby programs, with the implementation inspired by the bluebird.
> As explained in [Kestrels](http://github.com/raganwald/homoiconic/tree/master/2008-10-29/kestrel.markdown#readme), the practice of nicknaming combinators after birds was established in Raymond Smullyan's amazing book [To Mock a Mockingbird](http://www.amazon.com/gp/product/0192801422?ie=UTF8&tag=raganwald001-20&linkCode=as2&camp=1789&creative=9325&creativeASIN=0192801422). In this book, Smullyan explains combinatory logic and derives a number of important results by presenting the various combinators as songbirds in a forest. Since the publication of the book more than twenty years ago, the names he gave the birds have become standard nicknames for the various combinators.
View
2  2008-11-07/from_birds_that_compose_to_method_advice.markdown
@@ -1,7 +1,7 @@
Aspect-Oriented Programming in Ruby using Combinator Birds
---
-In [Combinatory Logic](http://en.wikipedia.org/wiki/Combinatory_logic), the bluebird is one of the most important and fundamental combinators, because the bluebird *composes* two other combinators. Although this is usually discussed as part of [functional programming style](http://weblog.raganwald.com/2007/03/why-why-functional-programming-matters.html "Why Why Functional Programming Matters Matters"), it is just as valuable when writing object-oriented programs. In this post, we will develop an [aspect-oriented programming](http://en.wikipedia.org/wiki/Aspect-oriented_programming "") (or "AOP") module that adds before methods and after methods to Ruby programs, with the implementation inspired by the bluebird.
+In [Combinatory Logic](http://en.wikipedia.org/wiki/Combinatory_logic), the bluebird is one of the most important and fundamental combinators, because the bluebird *composes* two other combinators. Although this is usually discussed as part of [functional programming style](http://raganwald.com/2007/03/why-why-functional-programming-matters.html "Why Why Functional Programming Matters Matters"), it is just as valuable when writing object-oriented programs. In this post, we will develop an [aspect-oriented programming](http://en.wikipedia.org/wiki/Aspect-oriented_programming "") (or "AOP") module that adds before methods and after methods to Ruby programs, with the implementation inspired by the bluebird.
> As explained in [Kestrels](http://github.com/raganwald/homoiconic/tree/master/2008-10-29/kestrel.markdown#readme), the practice of nicknaming combinators after birds was established in Raymond Smullyan's amazing book [To Mock a Mockingbird](http://www.amazon.com/gp/product/0192801422?ie=UTF8&tag=raganwald001-20&linkCode=as2&camp=1789&creative=9325&creativeASIN=0192801422). In this book, Smullyan explains combinatory logic and derives a number of important results by presenting the various combinators as songbirds in a forest. Since the publication of the book more than twenty years ago, the names he gave the birds have become standard nicknames for the various combinators.
View
2  2008-11-26/string_to_proc.rb
@@ -4,7 +4,7 @@
# Portions Copyright (c) 2006 Oliver Steele
# <http://braythwayt.com> except as otherwise noted.
#
-# See http://weblog.raganwald.com/2007/10/stringtoproc.html
+# See http://raganwald.com/2007/10/stringtoproc.html
#
# Ported from the String Lambdas in Oliver Steele's Functional JavaScript
# http://osteele.com/sources/javascript/functional/
View
2  2008-11-28/string_to_proc.rb
@@ -4,7 +4,7 @@
# Portions Copyright (c) 2006 Oliver Steele
# <http://braythwayt.com> except as otherwise noted.
#
-# See http://weblog.raganwald.com/2007/10/stringtoproc.html
+# See http://raganwald.com/2007/10/stringtoproc.html
#
# Ported from the String Lambdas in Oliver Steele's Functional JavaScript
# http://osteele.com/sources/javascript/functional/
View
2  2008-11-28/you_cant_be_serious.md
@@ -88,7 +88,7 @@ The other way is to say that I want to compose `.inject` and `+` together. Witho
".inject(&'+')"
-Meaning "*I want a new lambda that does an inject using plus*." Point-free style does require a new way of thinking about some things, but it is a clear win for simple cases. Proof positive of this is the fact that Ruby on Rails and Ruby 1.9 have both embraced point-free style with `Symbol#to_proc`. That's exactly how [`(1..100).inject(&:+)`](http://weblog.raganwald.com/2008/02/1100inject.html "(1..100).inject(&:+)") works!
+Meaning "*I want a new lambda that does an inject using plus*." Point-free style does require a new way of thinking about some things, but it is a clear win for simple cases. Proof positive of this is the fact that Ruby on Rails and Ruby 1.9 have both embraced point-free style with `Symbol#to_proc`. That's exactly how [`(1..100).inject(&:+)`](http://raganwald.com/2008/02/1100inject.html "(1..100).inject(&:+)") works!
`String#to_proc` supports fairly simple cases where you are sending a message or using a binary operator. So if we wanted to go all out, we could write our example as:
View
2  2008-12-12/fibonacci.md
@@ -1,7 +1,7 @@
A program to compute the nth Fibonacci number
===
-Since [I'm looking for a job](http://braythwayt.com/reginald/RegBraithwaite20120423.pdf "Reginald Braithwaite's Resume") and people often like to ask for a [fizzbuzz](http://weblog.raganwald.com/2007/01/dont-overthink-fizzbuzz.html "Don't Overthink FizzBuzz") program to weed out the folks who can't string together a few lines of code, I thought I'd write up a program to compute the nth Fibonacci number. There's an intriguing bit of matrix math involved, so I learned something while implementing it.
+Since [I'm looking for a job](http://braythwayt.com/reginald/RegBraithwaite20120423.pdf "Reginald Braithwaite's Resume") and people often like to ask for a [fizzbuzz](http://raganwald.com/2007/01/dont-overthink-fizzbuzz.html "Don't Overthink FizzBuzz") program to weed out the folks who can't string together a few lines of code, I thought I'd write up a program to compute the nth Fibonacci number. There's an intriguing bit of matrix math involved, so I learned something while implementing it.
*Reminder: This was written in 2008, it does not necessarily reflect my employment situation today.*
View
2  2008-12-17/another_fibonacci.md
@@ -54,7 +54,7 @@ In this version, `Fibonacci` is an entity in Kernel namespace. You do not call `
Also, the class `Fibonacci::Matrix` explicitly defines `*` and `^` so that we can write arithmetic operations on matrices the way we write them on integers. This is one of the prime motivations for languages like Ruby to permit operator overloading. A comparison of this point to the first version is inconclusive to my eyes. `*` and `^` are terser than `times` and `power`.
-However, defining them as operators means making them methods in Ruby. This is a little suspect because our code isn't truly polymorphic. It's not like we write `x = y * z` and are oblivious to the implementation of `*` that `y` provides at run time. This is a failing of many OO programs: They look like OO, but they are really written procedurally or functionally, however the OO mechanisms hamper rather than support the program. [Not all functions should be object methods](http://weblog.raganwald.com/2007/10/too-much-of-good-thing-not-all.html "Too much of a good thing: not all functions should be object methods"). The original version was blatant about its behaviour: `times` and `power` were written as lambdas, and it was very obvious that they did one thing only without presenting the facade of polymorphism.
+However, defining them as operators means making them methods in Ruby. This is a little suspect because our code isn't truly polymorphic. It's not like we write `x = y * z` and are oblivious to the implementation of `*` that `y` provides at run time. This is a failing of many OO programs: They look like OO, but they are really written procedurally or functionally, however the OO mechanisms hamper rather than support the program. [Not all functions should be object methods](http://raganwald.com/2007/10/too-much-of-good-thing-not-all.html "Too much of a good thing: not all functions should be object methods"). The original version was blatant about its behaviour: `times` and `power` were written as lambdas, and it was very obvious that they did one thing only without presenting the facade of polymorphism.
`Fibonacci::Matrix` also takes advantage of `Struct`. You can read [all about Struct](http://blog.grayproductions.net/articles/all_about_struct) if you are not familiar with this handy tool. Note that `Struct.new` returns a class, not an instance of a Struct. This is a very handy paradigm for Ruby programs.
View
2  2008-12-18/called_by_name.md
@@ -311,7 +311,7 @@ Now, `called_by_name` is not a replacement for macros. There are lots of things
Of course, `called_by_name` does so with lots of anonymous functions, and that is a much more expensive implementation than using a hygienic macro to rewrite code inline. But it feels like a move in an interesting direction: if it is a win to sometimes meta-program Ruby's syntax with DSLs, it ought to also be a win to sometimes meta-program Ruby's semantics with call-by-name functions.
-*(This material was originally published [June, 2008](http://weblog.raganwald.com/2008/06/macros-hygiene-and-call-by-name-in-ruby.html "Macros, Hygiene, and Call By Name in Ruby on raganwald.com"))*
+*(This material was originally published [June, 2008](http://raganwald.com/2008/06/macros-hygiene-and-call-by-name-in-ruby.html "Macros, Hygiene, and Call By Name in Ruby on raganwald.com"))*
Update (December 18, 2008)
---
View
2  2009-01-02/flight_of_the_phoenix.md
@@ -27,7 +27,7 @@ Whither Rewrite?
So, the Rewrite Gem broke when ParseTree and Ruby2Ruby changed some of their representations. I thought about either freezing the versions Rewrite needed or upgrading the gem, but then I had a remarkably stupid idea: Why not try to make it a little more useful than a proof-of-concept?
-So, I started [RewriteRails](https://github.com/raganwald-deprecated/rewrite_rails/tree). The idea is remarkably simple: You are writing a Rails project. You want to use things like [`andand`](http://weblog.raganwald.com/2008/01/objectandand-objectme-in-ruby.html "Object#andand & Object#me in Ruby") and [`String#to_proc`](http://weblog.raganwald.com/2007/10/stringtoproc.html "String#to_proc"). But you either have a fastidious disdain for opening core classes and slinging proxy objects around, a fanatical need for speed, or you want to be able to rip all that stuff out if you grow bored with it.
+So, I started [RewriteRails](https://github.com/raganwald-deprecated/rewrite_rails/tree). The idea is remarkably simple: You are writing a Rails project. You want to use things like [`andand`](http://raganwald.com/2008/01/objectandand-objectme-in-ruby.html "Object#andand & Object#me in Ruby") and [`String#to_proc`](http://raganwald.com/2007/10/stringtoproc.html "String#to_proc"). But you either have a fastidious disdain for opening core classes and slinging proxy objects around, a fanatical need for speed, or you want to be able to rip all that stuff out if you grow bored with it.
RewriteRails solves all of these problems I invented that nobody is complaining about.
View
2  2009-01-13/maybe.md
@@ -90,7 +90,7 @@ One of the most provocative implementations suggested for handling `nil` objects
Now you can write things like `@person.name` and know that if `@person` is `nil`, you will always get `nil`. Always. Everywhere. Interesting! In fact, it's another implementation of the Maybe Monad, only in a very clever, OO way. That being said, here's why it doesn't work for me.
-Right off the bat, [semantics like this really should not be implemented as methods](http://weblog.raganwald.com/2007/10/too-much-of-good-thing-not-all.html "Too much of a good thing: not all functions should be object methods"). Why does `nil + 1` produce `nil`, but `1 + nil` produce `TypeError: coerce must return [x, y]`? There's a real problem trying to make anything involving `nil` commutative.
+Right off the bat, [semantics like this really should not be implemented as methods](http://raganwald.com/2007/10/too-much-of-good-thing-not-all.html "Too much of a good thing: not all functions should be object methods"). Why does `nil + 1` produce `nil`, but `1 + nil` produce `TypeError: coerce must return [x, y]`? There's a real problem trying to make anything involving `nil` commutative.
In fact, I would go so far as to say that `:foo == nil` should be `nil`, as should `:foo != nil`. That makes sense, because as given:
View
4 2009-01-21/old.md
@@ -16,7 +16,7 @@ The voice that says "Putting several programmers in an open room where they can
Mammalian Thinking
---
-I was trading a few ideas with Pete Forde of [unspace](http://www.unspace.ca/ "Unspace") this morning, and I trotted out a metaphor. I apologise for this, I am not trying to turn this little note into one of those blog posts that tries so hard to explain that software is like a soap bubble or whatever. I despise the idea of saying that "[Building software is just like X](http://weblog.raganwald.com/2007/08/bricks.html "Bricks")" _for any value of X_. But the metaphor was that of Mammals during the Great Extinction that wiped out the Dinosaurs.
+I was trading a few ideas with Pete Forde of [unspace](http://www.unspace.ca/ "Unspace") this morning, and I trotted out a metaphor. I apologise for this, I am not trying to turn this little note into one of those blog posts that tries so hard to explain that software is like a soap bubble or whatever. I despise the idea of saying that "[Building software is just like X](http://raganwald.com/2007/08/bricks.html "Bricks")" _for any value of X_. But the metaphor was that of Mammals during the Great Extinction that wiped out the Dinosaurs.
Prior to the extinction, the story goes, Mammals were insignificant players. Dinosaurs were superior in every way until something happened--possibly the creation of the Gulf of Mexico--and the Dinosaurs were wiped out. This created a huge, world-wide opportunity for something, anything to replace them, and mammals happened to be better than everything else at taking over a vacant ecological space.
@@ -24,7 +24,7 @@ Great story. And? Old makes me great at telling stories? No. The idea here is th
But you have them in your head, and sometimes you can look at a new situation and say, "You know, this idea was [a loser in 1989](http://en.wikipedia.org/wiki/Apple_Newton "Apple Newton"), but [it just might work today](http://www.apple.com/iphone/ "Apple iPhone")." Experience with stuff that didn't work can be way more valuable than experience with ideas that worked at the time.
-This would be how Ruby got its `yield` keyword. Matz knew about a language called [CLU](http://en.wikipedia.org/wiki/CLU_programming_language "CLU (programming language) - Wikipedia, the free encyclopedia"), invented in 1974-5 by Barbara Liskov and her students (Yes, she is the Liskov of the [Liskov Substitution Principle](http://weblog.raganwald.com/2008/04/is-strictly-equivalent-to.html "IS-STRICTLY-EQUIVALENT-TO-A")). Matz borrowed yield from CLU. Was CLU a success in 1975? Perhaps not in the popularity contest. But knowing about this "old failure" allowed Matz to use its ideas in a new way to help make Ruby a "new success."
+This would be how Ruby got its `yield` keyword. Matz knew about a language called [CLU](http://en.wikipedia.org/wiki/CLU_programming_language "CLU (programming language) - Wikipedia, the free encyclopedia"), invented in 1974-5 by Barbara Liskov and her students (Yes, she is the Liskov of the [Liskov Substitution Principle](http://raganwald.com/2008/04/is-strictly-equivalent-to.html "IS-STRICTLY-EQUIVALENT-TO-A")). Matz borrowed yield from CLU. Was CLU a success in 1975? Perhaps not in the popularity contest. But knowing about this "old failure" allowed Matz to use its ideas in a new way to help make Ruby a "new success."
This is a key benefit of being "older" and "experienced:" You know about old stuff that was ahead of its time, good ideas that didn't pan out for one reason or another. Recycling those is often worth far more than recycling things that everyone knew were successful back then.
View
2  2009-02-02/hopeless_egocentricity.md
@@ -117,7 +117,7 @@ Dubious, but let's go with it. If this makes sense, we ought to be able to write
"Mister " + person.name
=> TypeError: can't convert nil into String
-[Why is this an error?](http://weblog.raganwald.com/2007/10/too-much-of-good-thing-not-all.html "Too much of a good thing: not all functions should be object methods") Things don't get any better using a hopelessly egocentric nil to handle UNKNOWN. Even if we can get past the issue of update methods, we have another problem that is much more difficult to resolve. UNKNOWN introduces tri-value logic:
+[Why is this an error?](http://raganwald.com/2007/10/too-much-of-good-thing-not-all.html "Too much of a good thing: not all functions should be object methods") Things don't get any better using a hopelessly egocentric nil to handle UNKNOWN. Even if we can get past the issue of update methods, we have another problem that is much more difficult to resolve. UNKNOWN introduces tri-value logic:
UNKNOWN == Object.new
=> UNKNOWN
View
2  2009-04-08/sick.md
@@ -15,7 +15,7 @@ The problem here, the thing that irritates me, is that we are using these mediev
Likewise over in La-la-lisp land we have moved from naked recursion to recursive combinators. Combinators make our programs easier to understand and reason about. Naked recursion is GOTO dressed up in a scholar's mortar and gown. Likewise naked monkey-patching is GOTO dressed up in... Well, it isn't really dressed up, it's more baggy pants performing a frontside grab.
-[Metaprogramming is beautiful.](http://weblog.raganwald.com/2008/07/my-analyst-warned-me-but.html "My analyst warned me, but metaprogramming was so beautiful I got another analyst") Now that we have embraced its beauty, let's invest some time and energy taking it to the next level, finding ways to apply abstractions and constraints to it so that we can benefit from it without falling into these entirely avoidable contretemps. I've taken one swing at the bat: I think many of the extensions people have added to core classes (including #andand) ought to be syntactic abstractions rather than methods, so I wrote [RewriteRails](http://github.com/raganwald-deprecated/rewrite_rails).
+[Metaprogramming is beautiful.](http://raganwald.com/2008/07/my-analyst-warned-me-but.html "My analyst warned me, but metaprogramming was so beautiful I got another analyst") Now that we have embraced its beauty, let's invest some time and energy taking it to the next level, finding ways to apply abstractions and constraints to it so that we can benefit from it without falling into these entirely avoidable contretemps. I've taken one swing at the bat: I think many of the extensions people have added to core classes (including #andand) ought to be syntactic abstractions rather than methods, so I wrote [RewriteRails](http://github.com/raganwald-deprecated/rewrite_rails).
Now its your turn. Dazzle me.
View
2  2009-05-25/rubyjobfair.md
@@ -5,7 +5,7 @@ I will be "presenting myself" at Unspace's [Ruby Job Fair](http://rubyjobfair.ca
The Ruby Job Fair format is like a science fair: You have a "poster" to display your work, and absolutely no computers are allowed. This can be intimidating to people. What do you put on the poster? Let's read this famous story about Richard Hamming:
-> Over on the other side of the dining hall was a chemistry table. I had worked with one of the fellows, Dave McCall; furthermore he was courting our secretary at the time. I went over and said, "Do you mind if I join you?" They can't say no, so I started eating with them for a while. And I started asking, "What are the important problems of your field?" And after a week or so, "What important problems are you working on?" And after some more time I came in one day and said, "If what you are doing is not important, and if you don't think it is going to lead to something important, why are you at Bell Labs working on it?" I wasn't welcomed after that; I had to find somebody else to eat with! That was in the Spring. --Richard Hamming, as I quoted in [You and Your Research](http://weblog.raganwald.com/2005/04/you-and-your-research.html)
+> Over on the other side of the dining hall was a chemistry table. I had worked with one of the fellows, Dave McCall; furthermore he was courting our secretary at the time. I went over and said, "Do you mind if I join you?" They can't say no, so I started eating with them for a while. And I started asking, "What are the important problems of your field?" And after a week or so, "What important problems are you working on?" And after some more time I came in one day and said, "If what you are doing is not important, and if you don't think it is going to lead to something important, why are you at Bell Labs working on it?" I wasn't welcomed after that; I had to find somebody else to eat with! That was in the Spring. --Richard Hamming, as I quoted in [You and Your Research](http://raganwald.com/2005/04/you-and-your-research.html)
Hmmm, there's something to think about: Put together a poster that answers the following three "Hamming Questions:"
View
2  2009-08-29/returning.md
@@ -95,7 +95,7 @@ Another answer is to suggest that the implementation of #returning is at fault.
# ...
end
-You intended to change what you are returning from #returning. So #returning should be changed to do what you meant. I'm on the fence about this. When folks argue that designs should cater to programmers who do not understand the ramifactions of the programming language or of the framework, I usually retort that you cannot have progress and innovation while clinging to familiarity, [an argument I first heard from Jef Raskin](http://weblog.raganwald.com/2008/01/programming-language-cannot-be-better.html "A programming language cannot be better without being unintuitive"). The real meaning of "The Principle of Least Surprise" is that a design should be *internally consistent*, which is not the same thing as *familiar*.
+You intended to change what you are returning from #returning. So #returning should be changed to do what you meant. I'm on the fence about this. When folks argue that designs should cater to programmers who do not understand the ramifactions of the programming language or of the framework, I usually retort that you cannot have progress and innovation while clinging to familiarity, [an argument I first heard from Jef Raskin](http://raganwald.com/2008/01/programming-language-cannot-be-better.html "A programming language cannot be better without being unintuitive"). The real meaning of "The Principle of Least Surprise" is that a design should be *internally consistent*, which is not the same thing as *familiar*.
Ruby's existing use of variables and references is certainly consistent. And once you know what #returning does, it remains consistent. However, this design decision isn't really about being consistent with Ruby's implementation, we are debating how an idiom should be designed. I think we have a blank canvas and it's reasonable to at least *consider* a version of #returning that handles assignment to the parameter.
View
2  2009-09-22/anaphora.md
@@ -229,7 +229,7 @@ Anaphora allow us to abbreviate code, hiding parameters and temporary variables
**More**
-* [String#to\_proc](http://github.com/raganwald/homoiconic/blob/master/2008-11-28/you_cant_be_serious.md "You can't be serious!?") and its original [blog post](http://weblog.raganwald.com/2007/10/stringtoproc.html "String#to_proc").
+* [String#to\_proc](http://github.com/raganwald/homoiconic/blob/master/2008-11-28/you_cant_be_serious.md "You can't be serious!?") and its original [blog post](http://raganwald.com/2007/10/stringtoproc.html "String#to_proc").
* [Methodphitamine](http://github.com/jicksta/methodphitamine "jicksta's methodphitamine at master - GitHub") and its original [blog post](http://jicksta.com/posts/the-methodphitamine "The Methodphitamine at Adhearsion Blog by Jay Phillips")
* [Anaphoric macros](http://www.bookshelf.jp/texi/onlisp/onlisp_15.html "Onlisp: Anaphoric Macros")
* [rewrite_rails](http://github.com/raganwald-deprecated/rewrite_rails "raganwald's rewrite_rails at master - GitHub") contains an improved implementation of String#to\_proc.
View
2  2009-10-08/metalinguistic.md
@@ -59,7 +59,7 @@ Thus, metalinguistic abstractions have two flavours. The first is the creation o
Quite obviously programming in almost every programming language involves naming things. You name classes, modules, attributes, variables and many other things in Ruby. In a sense you are creating an ad hoc vocabulary as your program even if you aren't deliberately attempting to create a vocabulary.
-However, most forms of software design formalize this with a little more ceremony. For example, a common analysis strategy is to start by listing all of the entities in the problem domain the program is intended to address. An analyst might write down nouns like "Employee" and "Hire Date" when designing an HR application, then later come up with verb phrases like "Issue Pay" or "Dehire" (an amusing digression is to note that the modern style of programming [subordinates verbs to nouns](http://weblog.raganwald.com/2007/10/too-much-of-good-thing-not-all.html "Too much of a good thing: not all functions should be object methods")).
+However, most forms of software design formalize this with a little more ceremony. For example, a common analysis strategy is to start by listing all of the entities in the problem domain the program is intended to address. An analyst might write down nouns like "Employee" and "Hire Date" when designing an HR application, then later come up with verb phrases like "Issue Pay" or "Dehire" (an amusing digression is to note that the modern style of programming [subordinates verbs to nouns](http://raganwald.com/2007/10/too-much-of-good-thing-not-all.html "Too much of a good thing: not all functions should be object methods")).
Even though many domain entities are named, simply choosing names for nouns and phrases for verbs on an ad hoc basis is not metalinguistic programming. Metalinguistic programming involves designing a complete vocabulary much as one would design a complete piece of software. To conduct metalinguistic programming, vocabularies should have consistent layers just as software should have consistent layers. At each layer of abstraction there should be a complete set of verbs and nouns. Programmers should never need to mix verbs and nouns from different levels of abstraction to express themselves.
View
4 2010/02/difficult_distraction.md
@@ -172,7 +172,7 @@ My recent work:
[kestrel]: http://github.com/raganwald/homoiconic/blob/master/2008-10-29/kestrel.markdown "Kestrels"
[ls]: http://www.asana.com/luna
[matz]: http://casperfabricius.com/site/2008/04/02/ruby-fools-matzs-keynote/ "Matz’s keynote"
-[mousetrap]: http://weblog.raganwald.com/2008/02/mouse-trap.html "The Mouse Trap"
+[mousetrap]: http://raganwald.com/2008/02/mouse-trap.html "The Mouse Trap"
[mp]: http://jicksta.com/posts/the-methodphitamine "The Mthodphitamine"
[node]: http://nodejs.org/
[proggit]: http://www.reddit.com/r/programming/comments/ay2bn/a_difficult_distraction_my_experience_creating_a/
@@ -180,7 +180,7 @@ My recent work:
[returning]: http://github.com/raganwald-deprecated/rewrite_rails/blob/master/doc/returning.md#readme
[rewrite]: http://rewrite.rubyforge.org/
[rf]: http://www.infoq.com/presentations/braithwaite-rewrite-ruby "Video of the Ruby.rewrite(Ruby) presentation"
-[rhino]: http://weblog.raganwald.com/2007/07/javascript-on-jvm-in-fifteen-minutes.html "How to Run JavaScript on the JVM in Just Fifteen Minutes"
+[rhino]: http://raganwald.com/2007/07/javascript-on-jvm-in-fifteen-minutes.html "How to Run JavaScript on the JVM in Just Fifteen Minutes"
[rr]: http://github.com/raganwald-deprecated/rewrite_rails
[s2p]: http://github.com/raganwald/homoiconic/blob/master/2008-11-28/you_cant_be_serious.md "You Can't be Serious!"
[source]: http://github.com/raganwald-deprecated/rewrite_rails/blob/master/lib/rewrite_rails/block_anaphora.rb "block_anaphora.rb"
View
2  2010/03/significant_whitespace.md
@@ -145,7 +145,7 @@ This isn't exactly what I want but I'll take it. The final two calls to `end` ar
It may seem like perhaps I should break this up into smaller methods to make it easier to understand. I am thinking that we want to break long functions up into short functions *because our languages don't give us a good way to express a verbose idea clearly in a single function*. We are not talking about 20+ lines of conditional execution here, we are talking about manipulating something that can naturally be expressed as a tree. Why not express the idea in code that looks like a tree?
-I like [writing programs for people to read](http://weblog.raganwald.com/2007/04/writing-programs-for-people-to-read.html). Code that resembles what it consumes (sass), what it produces (haml), or what it manipulates (my hypothetical significant whitespace variation of JavaScript) is easy to read.
+I like [writing programs for people to read](http://raganwald.com/2007/04/writing-programs-for-people-to-read.html). Code that resembles what it consumes (sass), what it produces (haml), or what it manipulates (my hypothetical significant whitespace variation of JavaScript) is easy to read.
As it happens, [the last time I asked about a language feature](http://github.com/raganwald/homoiconic/blob/master/2010/01/beautiful_failure.markdown "Beautiful Failure"), I was told that Smalltalk did it in 1981. Well, this time I happen to know that Smalltalk already does this. In Smalltalk, you can write:
View
4 2010/08/final.md
@@ -298,11 +298,11 @@ NEW! [Kestrels, Quirky Birds, and Hopeless Egocentricity](http://leanpub.com/com
[Reg Braithwaite](http://braythwayt.com) | [@raganwald](http://twitter.com/raganwald)
[p2p]: http://www.yes-minister.com/ypmseas2b.htm
-[raf]: http://weblog.raganwald.com/2006/05/ready-aim-final.html
+[raf]: http://raganwald.com/2006/05/ready-aim-final.html
[leaks]: http://steve-yegge.blogspot.com/2010/07/wikileaks-to-leak-5000-open-source-java.html
[clothes]: http://scifac.ru.ac.za/cspt/hoare.htm
[template]: http://en.wikipedia.org/wiki/Template_method_pattern "Template method pattern - Wikipedia, the free encyclopedia"
-[liskov]: http://weblog.raganwald.com/2008/04/is-strictly-equivalent-to.html "IS-STRICTLY-EQUIVALENT-TO-A"
+[liskov]: http://raganwald.com/2008/04/is-strictly-equivalent-to.html "IS-STRICTLY-EQUIVALENT-TO-A"
[inference]: http://en.wikipedia.org/wiki/Type_inference "Type inference - Wikipedia, the free encyclopedia"
[elharo]: http://www.elharo.com/ "Elliotte Rusty Harold"
[hn]: http://news.ycombinator.com/item?id=1592556
View
2  2010/08/ouch.md
@@ -16,7 +16,7 @@ SmallTalk had a syntax for this in the *Last Freakin' Century*:
elementSelector: '#main';
get: '#/' handledWith: ((application at: 'controllers') at: 'home').
-I do think that a language's syntax should support cascades like this, but I also like the idea of [significant whitespace](http://github.com/raganwald/homoiconic/blob/master/2010/03/significant_whitespace.md). There's something sloshing around my hindbrain that thinks this can be combined with combinators to produce [code that resembles the structure of the data it consumes and/or generates](http://weblog.raganwald.com/2007/04/writing-programs-for-people-to-read.html "Writing programs for people to read").
+I do think that a language's syntax should support cascades like this, but I also like the idea of [significant whitespace](http://github.com/raganwald/homoiconic/blob/master/2010/03/significant_whitespace.md). There's something sloshing around my hindbrain that thinks this can be combined with combinators to produce [code that resembles the structure of the data it consumes and/or generates](http://raganwald.com/2007/04/writing-programs-for-people-to-read.html "Writing programs for people to read").
ttfn...
View
4 2011/01/anything_to_declare.md
@@ -232,8 +232,8 @@ My recent work:
[Reg Braithwaite](http://braythwayt.com) | [@raganwald](http://twitter.com/raganwald)
-[q]: http://weblog.raganwald.com/2006/06/my-favourite-interview-question.html
-[ww]: http://weblog.raganwald.com/2007/03/why-why-functional-programming-matters.html
+[q]: http://raganwald.com/2006/06/my-favourite-interview-question.html
+[ww]: http://raganwald.com/2007/03/why-why-functional-programming-matters.html
[f]: https://github.com/unspace/faux
[jg]: https://github.com/jamiebikies
[b]: http://documentcloud.github.com/backbone/
View
4 2011/10/i_make_dreams_come_true.md
@@ -30,8 +30,8 @@ As a user, I had this experience looking at a Macintosh in 1985. The GUI seems o
Speaking of drawing things, when I started to learn object-oriented programming, I bought a book that walked me step-by-step through writing a vector drawing program using Object Pascal. I won't say that Objects were an Aha! for me: I grokked the style and my response leaned towards "Oh, fine, that's how we'll do it." Polymorphism was more of a "Neat-o" than an "I must be dreaming." To this day, I'm [reserved][6] [about][7] [OOP][8]. But something else blew my mind: The book explained how to implement an Undo Stack using what is now called the [Command Pattern][9].
-[6]: http://weblog.raganwald.com/2007/10/too-much-of-good-thing-not-all.html
-[7]: http://weblog.raganwald.com/2008/04/is-strictly-equivalent-to.html
+[6]: http://raganwald.com/2007/10/too-much-of-good-thing-not-all.html
+[7]: http://raganwald.com/2008/04/is-strictly-equivalent-to.html
[8]: https://github.com/raganwald/homoiconic/blob/master/2010/12/oop.md
[9]: http://en.wikipedia.org/wiki/Command_pattern
View
4 2012/02/Literate-Programming-Matters.md
@@ -16,7 +16,7 @@ What this suggests to me is that while David presents the concepts of literate p
Of late, I've been working on a completely useless project: [Conway's Game of Life][life]. My implementation is called [Cafe au Life][cafe], and the interesting thing here is that it uses Bill Gosper's [HashLife][hl] algorithm to compute the future of a life pattern. This matters greatly to the question of writing readable code.
-> An easy question: How well does the design document the actual game of Monopoly? If someone were to read the source code, do you think they could learn how to play the actual game?--[My favourite interview question](http://weblog.raganwald.com/2006/06/my-favourite-interview-question.html)
+> An easy question: How well does the design document the actual game of Monopoly? If someone were to read the source code, do you think they could learn how to play the actual game?--[My favourite interview question](http://raganwald.com/2006/06/my-favourite-interview-question.html)
Life is an extraordinarily simple zero-player game. Quoting Wikipedia verbatim:
@@ -221,7 +221,7 @@ I don't know whether we need a literate programming tool that transforms the sou
[YouAreDaChef]: https://github.com/raganwald/YouAreDaChef
[1]: https://github.com/raganwald/homoiconic/blob/master/2010/12/oop.md "OOP practiced backwards is "POO""
-[2]: http://weblog.raganwald.com/2007/10/too-much-of-good-thing-not-all.html "Too much of a good thing: not all functions should be object methods"
+[2]: http://raganwald.com/2007/10/too-much-of-good-thing-not-all.html "Too much of a good thing: not all functions should be object methods"
[docco]: http://jashkenas.github.com/docco/
[ll]: http://www.conwaylife.com/wiki/Cellular_automaton#Well-known_Life-like_cellular_automata
[williams]: https://github.com/raganwald/homoiconic/blob/master/2011/11/COMEFROM.md
View
2  2012/03/garbage_collection_in_coffeescript.md
@@ -298,7 +298,7 @@ First, we need a helper function that can map a simple function over a hash of v
We'll also need some translations that transform a map with one structure to a map with another. If we were Java programmers we'd [break out the XSLT][mousetrap], but we'll keep them simple:
-[mousetrap]: http://weblog.raganwald.com/2008/02/mouse-trap.html?showComment=1203629040000
+[mousetrap]: http://raganwald.com/2008/02/mouse-trap.html?showComment=1203629040000
```coffeescript
View
2  2012/05/anaphora.md
@@ -298,7 +298,7 @@ Anaphora allow us to abbreviate code, hiding parameters and temporary variables
## More to read
-* [String#to\_proc](http://github.com/raganwald/homoiconic/blob/master/2008-11-28/you_cant_be_serious.md "You can't be serious!?") and its original [blog post](http://weblog.raganwald.com/2007/10/stringtoproc.html "String#to_proc").
+* [String#to\_proc](http://github.com/raganwald/homoiconic/blob/master/2008-11-28/you_cant_be_serious.md "You can't be serious!?") and its original [blog post](http://raganwald.com/2007/10/stringtoproc.html "String#to_proc").
* [Methodphitamine](http://github.com/jicksta/methodphitamine "jicksta's methodphitamine at master - GitHub") and its original [blog post](http://jicksta.com/posts/the-methodphitamine "The Methodphitamine at Adhearsion Blog by Jay Phillips")
* [Anaphoric macros](http://www.bookshelf.jp/texi/onlisp/onlisp_15.html "Onlisp: Anaphoric Macros")
* [rewrite_rails](http://github.com/raganwald-deprecated/rewrite_rails "raganwald's rewrite_rails at master - GitHub") contains an improved implementation of String#to\_proc.
View
4 2012/11/refactoring_to_jquery_combinators.md
@@ -62,8 +62,8 @@ built-in operations.
[Here] is an implementation of [Conway's Game of Life][life] written with jQuery Combinators (and here's the [annotated source code][code]).
[life]: https://en.wikipedia.org/wiki/Conway's_Game_of_Life
-[Here]: http://weblog.raganwald.com/JQuery-Combinators/life/index.html
-[code]: http://weblog.raganwald.com/JQuery-Combinators/life/life.html
+[Here]: http://raganwald.com/JQuery-Combinators/life/index.html
+[code]: http://raganwald.com/JQuery-Combinators/life/life.html
![Life with jQuery Combinators](http://i.minus.com/ibt7pqptCtmRHb.png)
View
2  README.markdown
@@ -18,7 +18,7 @@ Of course, you can simply read the archives. They're organized by date, so the m
**is there anything else to read?**
-When I want to write about something that doesn't have any code in it, I try to resist the temptation. When resistance is futile, my words appear on [posterous](http://raganwald.posterous.com). I used to write a traditional blog called [raganwald](http://weblog.raganwald.com).
+When I want to write about something that doesn't have any code in it, I try to resist the temptation. When resistance is futile, my words appear on [posterous](http://raganwald.posterous.com). I used to write a traditional blog called [raganwald](http://raganwald.com).
**can I subscribe?**
View
4 dumping_ground/against_final.md
@@ -24,11 +24,11 @@ NEW! [Kestrels, Quirky Birds, and Hopeless Egocentricity](http://leanpub.com/com
[Reg Braithwaite](http://braythwayt.com) | [@raganwald](http://twitter.com/raganwald)
[p2p]: http://www.yes-minister.com/ypmseas2b.htm
-[raf]: http://weblog.raganwald.com/2006/05/ready-aim-final.html
+[raf]: http://raganwald.com/2006/05/ready-aim-final.html
[leaks]: http://steve-yegge.blogspot.com/2010/07/wikileaks-to-leak-5000-open-source-java.html
[clothes]: http://scifac.ru.ac.za/cspt/hoare.htm
[template]: http://en.wikipedia.org/wiki/Template_method_pattern "Template method pattern - Wikipedia, the free encyclopedia"
-[liskov]: http://weblog.raganwald.com/2008/04/is-strictly-equivalent-to.html "IS-STRICTLY-EQUIVALENT-TO-A"
+[liskov]: http://raganwald.com/2008/04/is-strictly-equivalent-to.html "IS-STRICTLY-EQUIVALENT-TO-A"
[inference]: http://en.wikipedia.org/wiki/Type_inference "Type inference - Wikipedia, the free encyclopedia"
[elharo]: http://www.elharo.com/ "Elliotte Rusty Harold"
[hn]: http://news.ycombinator.com/item?id=1592556
View
2  dumping_ground/revised_revised_ruby_rewrite_ruby_select.md
@@ -13,7 +13,7 @@ I'm writing today to share some of my ideas in writing for those who weren't the
]
]
-The most important thing I am asking you to do is to **Think about Thinking about Programming**. Programming may sometimes seem like a [clerk's job](http://weblog.raganwald.com/2008/01/no-disrespect.html "No Disrespect"). But whether you are writing tests for loan state flow or writing infrastructure to distribute computation across thousands of machines, you are engaging almost all of the planning and analysis and problem solving parts of our brains that make us human, that distinguish us from other organisms on this planet.
+The most important thing I am asking you to do is to **Think about Thinking about Programming**. Programming may sometimes seem like a [clerk's job](http://raganwald.com/2008/01/no-disrespect.html "No Disrespect"). But whether you are writing tests for loan state flow or writing infrastructure to distribute computation across thousands of machines, you are engaging almost all of the planning and analysis and problem solving parts of our brains that make us human, that distinguish us from other organisms on this planet.
Thinking about programming is being human. And thus "thinking about thinking about programming" is examining what makes us human and why. I am about to explain why studying programming languages is a very fruitful way of thinking about what makes us human, but I really think that all areas of thinking about programming are interesting ways to think about being human. Debating BDUF vs. Agile methodologies is really a way of analyzing human behaviour. Debating the organization of components and modules into an architecture is a way of discussing the way our minds make sense of complicated things.
View
2  dumping_ground/string_to_proc.rb
@@ -1,6 +1,6 @@
# String#to_proc
#
-# See http://weblog.raganwald.com/2007/10/stringtoproc.html
+# See http://raganwald.com/2007/10/stringtoproc.html
#
# Ported from the String Lambdas in Oliver Steele's Functional JavaScript
# http://osteele.com/sources/javascript/functional/
View
2  dumping_ground/vapours.md
@@ -3,7 +3,7 @@ From interview questions to production code
Things are a little slow with me career-wise, so I have some cycles to eat a little of my own [dog food](http://en.wikipedia.org/wiki/Eating_one%27s_own_dog_food "Eating one's own dog food - Wikipedia, the free encyclopedia"). Specifically, I'm writing a server for playing [Go](http://github.com/raganwald/homoiconic/blob/master/2009-10-20/high_anxiety.md "High Anxiety") online. What does this have to do with dogfooding? Two things. First, I'm using [rewrite_rails](http://github.com/raganwald-deprecated/rewrite_rails "raganwald's rewrite_rails at master - GitHub"). That's great and I'm actually filing issues as I run into them.
-Second, and this is the point of my quick post here, I have a chance to write a game you play online. If you've been reading some of my early dreck, this will sound familiar: It is the subject of [my favourite interview question](http://weblog.raganwald.com/2006/06/my-favourite-interview-question.html "My favourite interview question")! Mind you, my favourite interview question is allegedly about Monopoly, and this is Go. There are some important differences. First, Go is way easier: The rules are not poorly defined for the game itself. The rules are much smaller, simpler, and more elegant. But second, just like Monopoly there is the challenge of writing the program such that it documents the rules of the game. To quite myself liberally:
+Second, and this is the point of my quick post here, I have a chance to write a game you play online. If you've been reading some of my early dreck, this will sound familiar: It is the subject of [my favourite interview question](http://raganwald.com/2006/06/my-favourite-interview-question.html "My favourite interview question")! Mind you, my favourite interview question is allegedly about Monopoly, and this is Go. There are some important differences. First, Go is way easier: The rules are not poorly defined for the game itself. The rules are much smaller, simpler, and more elegant. But second, just like Monopoly there is the challenge of writing the program such that it documents the rules of the game. To quite myself liberally:
> Now let’s ask a question about Monopoly (and Enterprise software). Where do the rules live? In a noun-oriented design, the rules are smooshed and smeared across the design, because every single object is responsible for knowing everything about everything that it can ‘do’. All the verbs are glued to the nouns as methods.
View
2  dumping_ground/worst_of_raganwald_i.md
@@ -1,7 +1,7 @@
Some writing about writing "raganwald"
===
-When I was writing [weblog.raganwald.com](http://weblog.raganwald.com), I kept a list of ideas for blog posts. That way, when I needed to write a post and I didn't have any inspiration, I could go to my list and write something. Why, you may ask, did I do this? Why didn't I simply write a post when I had an idea, and not write a post when I didn't have an idea?
+When I was writing [raganwald.com](http://raganwald.com), I kept a list of ideas for blog posts. That way, when I needed to write a post and I didn't have any inspiration, I could go to my list and write something. Why, you may ask, did I do this? Why didn't I simply write a post when I had an idea, and not write a post when I didn't have an idea?
The answer, of course, is that I had heard that writing on a schedule is important for building an audience. If you have four ideas one day, you shouldn't write four posts on that day, you should spread them out. And if you don't have an idea on a particular day, you should write a post anyways, that's how you build an audience. Or so the story goes. That's what Jeff Atwood seems to do, and it works for him.
View
2  homoiconic.markdown
@@ -34,7 +34,7 @@ The other reason there is no advocacy is that I am invoking the "Transit Cop Cop
> When you ride every day you get to know the cops well. One of them told me that he had a policy of letting people off Scot-free if they told him a story he hadn't heard before. He told me that the last novel excuse he had heard was from a woman who claimed her nails were too wet to reach into her bag, remove the ticket, and punch it before boarding. Nice. He said he let her off on the grounds of novelty and chutzpah.
-I have already said a number of things about [abstractions](http://weblog.raganwald.com/2007/07/abbreviation-accidental-complexity-and.html "Abbreviation, Accidental Complexity, and Abstraction"), [functional programming](http://weblog.raganwald.com/2007/03/why-why-functional-programming-matters.html "Why Why Functional Programming Matters Matters"), [meta-programming](http://weblog.raganwald.com/2008/07/my-analyst-warned-me-but.html "My analyst warned me, but metaprogramming was so beautiful I got another analyst"), [metaprogramming again](http://weblog.raganwald.com/2008/03/spaghetti-western-coding.html "Spaghetti-Western Coding"), [brevity](http://weblog.raganwald.com/2007/12/golf-is-good-program-spoiled.html "Golf is a good program spoiled"), and [much more](http://delicious.com/raganwald/raganwald.popular "Popular posts from weblog.raganwald.com"). But I don't want to say any more on subjects like these until I can think of something *novel*. It may be awhile. In the meantime, share and enjoy.
+I have already said a number of things about [abstractions](http://raganwald.com/2007/07/abbreviation-accidental-complexity-and.html "Abbreviation, Accidental Complexity, and Abstraction"), [functional programming](http://raganwald.com/2007/03/why-why-functional-programming-matters.html "Why Why Functional Programming Matters Matters"), [meta-programming](http://raganwald.com/2008/07/my-analyst-warned-me-but.html "My analyst warned me, but metaprogramming was so beautiful I got another analyst"), [metaprogramming again](http://raganwald.com/2008/03/spaghetti-western-coding.html "Spaghetti-Western Coding"), [brevity](http://raganwald.com/2007/12/golf-is-good-program-spoiled.html "Golf is a good program spoiled"), and [much more](http://delicious.com/raganwald/raganwald.popular "Popular posts from raganwald.com"). But I don't want to say any more on subjects like these until I can think of something *novel*. It may be awhile. In the meantime, share and enjoy.
**comments?**
Please sign in to comment.
Something went wrong with that request. Please try again.