Thinking in Code

Struts and JSF Creator is a Rails advocate now!

2007-09-29T10:39:00.000-07:00

Most people who have worked with me are familiar with my distain for Struts (though it had provided a paycheck for many years) and my fanatical love for Rails. It seems that Creig McClanahan, the creator of Struts is now in agreement. The money quote from David, posting about Craig's talk at RailsConf Europe 2k7, "He even went as far as to say that developing web applications in Java after working with Rails would probably not be a particularly pleasant experience for him.".

This from David Heinemeier Hansson, the creator of Ruby on Rails.

The biggest surprise at RailsConf Europe 2007 was hearing Craig McClanahan from Sun speak. Craig is the creator of Struts, the original blockbuster web framework for Java, and more recently Java Server Faces. Not exactly an obvious advocate for Ruby on Rails, but he sure played the part well.

And not just on a superficial level because Sun was a diamond sponsor of the conference, but from months of experience developing Rails applications using the latest techniques and frameworks (like pushing the envelope with Active Resource). He even went as far as to say that developing web applications in Java after working with Rails would probably not be a particularly pleasant experience for him. Wow.

See more from David's blog

ri in irb

2007-08-14T15:19:00.000-07:00

The shortest route to accessing ri from you irb session.

add the following to your .irbrc file


def ri(str); y `ri #{str}`;end

This is all that I require, but for more (much more), see
here.

has_one :through

2007-07-20T07:24:00.000-07:00

Rails is missing the capability to have a has_one association via a link table. I created this implementation that adds methods to add basic "has_one" support through a habtm association.

The following method defines a new type of association that is currently
missing in rails. There is currently no way to have a
has_one association when a join table is used.

This association requires that a has_and_belongs_to_many
association exists and adds methods to access the first
element of the resulting array.

Example: Enrollments have one registration, but is
modeled through the enrollments_registrations join table.
There is already a "has_and_belongs_to_many :registrations"
and the following operations are added
(and perform as expected):

enrollment.registration => enrollments.registrations.first

enrollment.registration_id => enrollments.registrations.first.id

enrollment.registration= will set the assocation, erasing any existing registration.
This method will take an id or a registration object

enrollment.registration_id= like registration=, but takes an id

enrollment.has_registration? => true or false as the case may be


def self.has_one_through_join_table(class_name)
  class_name = class_name.to_s
  has_many_association_name = class_name.pluralize
      
  # def registration
  define_method(class_name) do
   send(has_many_association_name).first
  end
  
  #def registration_id
  define_method(class_name+"_id") do
    send(class_name) ? send(class_name).id : nil 
  end

  # def registration=(id_or_object)
  define_method(class_name+"=") do |id_or_object|
    clazz = eval(class_name.classify)
    # the has_and_belong_to_many association (i.e. registrations)
    habtm = send(class_name.pluralize)
    
    if id_or_object.nil?
       habtm.clear
       return
    end
    
    id_or_object = clazz.find(id_or_object) unless 
                              id_or_object.is_a?(clazz)
    if id_or_object
      habtm.clear  # can only have one object
      habtm << id_or_object
    end
  end
  
  #def registration_id=(id)
  define_method(class_name+"_id=") do |id| 
     send(class_name+"=", id)
  end

  # def has_registration?
  define_method("has_#{class_name}?") do
    ! send(class_name).nil?
  end
  
end # has_many_through_join_table

"The cheering can be heard not just in America itself but around the planet."

2006-11-08T19:16:00.000-08:00

Martin Kettle of London's Guardian newspaper

My Boy!

2006-10-29T14:38:00.000-08:00

, originally uploaded by bethhaught.

Beth keeps the photostream of Bran at her flickr site

Mom & Dad (last day at the hospital)

2006-10-29T14:21:00.000-08:00

Mom & Dad (last day at the hospital)
Originally uploaded by bethhaught.

Bran and Sleapytime Bear

2006-10-29T13:42:00.000-08:00

Originally uploaded by bethhaught.

A Great Patent Strategy

2006-07-05T13:05:00.003-07:00

Via reddit..

... Another instance of the “disappearing polymorph” may be the anti-depressant, Paxil (U.S. brand name for the chemical paroxetine hydrochloride). No, self-replicating Paxil doesn’t naturally spread into our brains and make people happy for free. It's not "happy goo." On the contrary, self-replicating Paxil converted, according to one of the parties in the ensuing lawsuit, an old, and now off-patent, form of Paxil into a new, patented form of Paxil. Once the new form, the hemihydrate form of Paxil, was created, its crystals started floating about, converting small fractions of the old form, anhydrous Paxil, into hemihydrate. Both forms of the drug work equally well as an anti-depressant, but it became impossible to manufacture the off-patent anhydrate without some of it being converted into the patented form. Call it "patent goo."

Unenumerated: Patent goo: self-replicating Paxil

Tim Berners-Lee on Net Neutrality

2006-05-03T07:32:00.000-07:00

The Internet is increasingly becoming the dominant medium binding us. The neutral communications medium is essential to our society. It is the basis of a fair competitive market economy. It is the basis of democracy, by which a community should decide what to do. It is the basis of science, by which humankind should decide what is true.

Let us protect the neutrality of the net.

Neutrality of the Net

Headless Apps - Using the Rails 1.1. Integration features as an API to your Rails app

2006-04-07T08:08:00.000-07:00

Here's a nice and straight-forward walkthrough of using the new integration test capabilities of Rails 1.1 to interact with your app from the console. I ran through my app (which has a similar login structure) and it really has the "It's just that easy!" feel..

Mike Clark's Weblog

Feynman the Explainer

2006-01-03T01:29:00.000-08:00

Richard Feynman, explaining what was going on at Thinking Machines Corporation..

"We have noticed in nature that the behavior of a fluid depends very little on the nature of the individual particles in that fluid. For example, the flow of sand is very similar to the flow of water or the flow of a pile of ball bearings. We have therefore taken advantage of this fact to invent a type of imaginary particle that is especially simple for us to simulate. This particle is a perfect ball bearing that can move at a single speed in one of six directions. The flow of these particles on a large enough scale is very similar to the flow of natural fluids."

From Danniel Hillis's excellent account.
Richard Feynman and The Connection Machine

Rails Migration Cheat Sheet

2005-12-15T14:43:00.000-08:00

I've added a simple cheat sheet for Rails Database Migrations to my 'backpack'..
Rails Migration Cheat Sheet

Adding options to rake tasks

2005-12-15T13:54:00.000-08:00

I've been wondering how to call a rake task and pass it arguments.... just found it:

the example is in the rails code source code (railties/lib/tasks/databases.rake) for migrations. Normally you just call 'rake migrate' to come up to the current version. But if you want to revert back to another database version, you would add "rake migrate VERSION=12" (or whatever version is appropriate).

A quick look at the rails codebase has the migrate task as:


task :migrate => :environment do

  ActiveRecord::Migrator.migrate("db/migrate/", ENV["VERSION"] ? ENV["VERSION"].to_i : nil)

  Rake::Task[:db_schema_dump].invoke if ActiveRecord::Base.schema_format == :ruby

end

It uses

ENV["VERSION"]

which is just accesses the environment.
So rake just uses the command line to set up environment variables. Good to know.

NEWSFLASH!!! ... Rails 1.0 is released! ... World Rejoices!

2005-12-14T09:05:00.000-08:00

Rails has a fancy new frontpage, new screencasts, and lots of giddy developers.

David's Announcement

Ruby Book Sales Surpass Python

2005-12-07T22:13:00.000-08:00

From the "What's Upcoming" Department:

I wish we could simply skip the annoying period of large companies dragging their feet on the adoption of Ruby as a post-Java language. Tim O'Reilly checked the numbers and found that Ruby books are up 1552% and now surpass Python.

This is important for people like me that waited a bit too long to switch from Java. I saw Python and Ruby both as good options and didn't fully jump into either. Learning a new language as a *primary language* is time and brain consuming enough that its not a lightweight matter. You learn to think in that language.

Luckily, with the popularity of Rails and the underlying "Zen Goodness" of Ruby, I'm hopefully optimistic that this stalemate will resolve itself on the side of Ruby. Don't get me wrong, I like Python, but to make inroads into the Post-Java World (ok, maybe the Alongside Java World) we need a good single contender.

Here's the O'Reilly Story:
Ruby Book Sales Surpass Python"

Why Ruby is an acceptable Lisp

2005-12-03T21:46:00.000-08:00

Eric Kidd has a very nice posting + discussion going on about Ruby in relation to Lisp. I frequently stare longingly at Lisp (and frolic now and again with the Little Schemer). My interest in Ruby (along with moving to Cambridge) have me thinking more and more about Lisp these days.

Eric thinks that Ruby's metaprogramming facilities give you power approaching macros - "80% of what you want from macros" - while the language syntax provides a "dense functional language", allowing the compact and clear description of the programming task. While I cringe a bit at the term 'dense' here, Ruby's expressive properties are formidable (something that I discuss briefly in a comment to the post itself).

The post is well worth reading, and the comments provide a nice range of opinion. Plus there are lots of yummy code snippets!

http://randomhacks.net/articles/2005/12/03/why-ruby-is-an-acceptable-lisp

Read/Write Web: Top Ten Web 2.0 Problems Amazon Mechanical Turk Can Solve For Me

2005-11-05T21:01:00.000-08:00

More Amazon Turk ideas from the Tongue/Cheek dept:

Read/Write Web: Top Ten Web 2.0 Problems Amazon Mechanical Turk Can Solve For Me

Amazon Mechanical Turk

2005-11-05T17:02:00.000-08:00

Ideas for Amazon Mechanical Turk

This is IMHO, a groundbreaking capability that I ranted and raved about in the Web 1.0 days, noting that (1) it is a pretty big project to do, but (2) it basically is second to government in being able to tax elements of work at each step in the ‘value creation chain’. In Amazon’s case, they get 10% of any work effort. In any case, if this is done right and they don’t blow it, it’s part of the “bigger picture” and a fundamental change. Anyway, here are some ideas for the operations/”chunks” of work (feel free to add to):

Book Chapter Audio Transcription: Read out loud and record this chapter.

Blog transcription. Text to Podcast

Does this image contain x? imageContains(“vehicle”, imageUri)

Convert this outline/xml/yaml/json to a textual description

paraphraseThis(text)Code Formatting/IV&V/Review:

Does this code follow these rules. Here, the checks are broken into chunks and distributed, as is the set of code. It is broken up like a text message over UDP, distributed to lots of people (who get it into their queue and check it in one-five minutes for a few cents. It’s then returned, possibly packaged up as another workitem and returned.

If language people are signed up, we could easily ask “what’s wrong with this bit of code” and get the hint that get us past it. (This one could also work more informally, with a ‘tip jar’ concept.

Blog comment verification!

For a general description:
Amazon's Mechanical Turk

Beyond Java

2005-11-02T03:24:00.000-08:00

There is a new O'Reilly book out called "Beyond Java" that questions if Java is about it be replaced by a newer generation of languages with Ruby being the current likely replacement:

http://www.oreilly.com/catalog/beyondjava/

I browsed it a few days ago, but Sam Ruby has more to say.

I'll just second his conclusion regarding metaprogramming and add that Ruby makes metaprogramming natural enough that it's easier to actually *do* metaprogramming than to sit and ponder it. Personally I'd like us to replace the word with something that doesn't sound quite so academic, though I've not thought of any good candidates yet.

evan_tech -- ruby on rails

2005-11-01T17:06:00.000-08:00

Evan has a very informative and straightforward description of what Ruby is, what Ruby on Rails is and how the two differ. If you're just coming into the Rails and Ruby world, or if you're just wondering what all the fuss is, then this is worth five minutes of your life.

I especially like Evan's description of the Ruby language:

I play with and write about a lot a lot of different programming languages here, and I'm happy to say that even this many years later I still regularly return to Ruby. It's not without its flaws, but for whatever reason* Matz managed to just nail a certain design space and aesthetic and make the language really work, really flow. The people who write about the language talk about how it's optimized for fun, and that really rings true for me.

evan_tech -- ruby on rails

I saw Ruby about five years back and I really liked what I saw at the time. Earlier this year though, I finally broke my personal stalemate over Python vs Ruby and really jumped into Ruby. It turns out that my initial 'pleasant' impression was only a taste of what to come. Ruby very much has gestalt going for it. While this is simplistic, I have frequently had the thought that Ruby is to Java what Java is to C++.

A VC: The Looming Attention Crisis

2005-11-01T15:37:00.000-08:00

A few months back I questioned what resources are truly limited. On a personal basis at least, my answer was 'attention'. We can spend unlimited amounts of money (a theory that I've yet to test), but we can only 'pay attention' and focus on a finite number of people or topics or fields. It's interesting to hear of Herb Simon discuss this way back in 1971.

A VC: The Looming Attention Crisis

RadRails - A Ruby on Rails IDE

2005-11-01T15:00:00.000-08:00

I've installed the of 0.4 version of RadRails. It seems to be a simplified version of the Eclipse IDE but customized toward Ruby & Rails development work. If you're a Java person and used to using Eclipse, this seems like a no-brainer to get up and running with Rails. My only caveat is that it may not be a good long term IDE for learning ruby and rails. This is not so much because of the IDE itself, as there hasn't been a Ruby IDE that competes. Rather it's that you may not break out of some Javathink as soon. But that's pure speculation on my part.

http://www.radrails.org/

Regarding upcoming IDE news for Ruby, ActiveState is doing quite a bit of work to support Ruby in their Komodo IDE. I'm looking forward to it.

http://blogs.activestate.com/activestate/2005/10/activestate_a_r.html

I've gotten fairly used to TextMate and VIM on my Powerbook, but it would be wonderful to have some intelligence helping me out with dynamic languages.

A Linguistic View of the Semantic Web?

2005-10-30T08:48:00.000-08:00

Danny Ayers considers alternatives to the current set of ideas known as "The Semantic Web". How else might we evolve a better web. What would it be a web of?

Alternatives to the Semantic Web?

What follows is largely half-baked, stream-of-consciousness thoughtstuff. You've been warned.

Lately, at least in the Ruby community, there's been discussion of a language based approach to programming. Domain Specific Languages are all the rage these days. See, for example, Martin Fowler's excellent article Using the Rake Build Language. (And from RubyConf, I've now got some more reading to do on the Forth language that I successfully sidestepped during college.)

The World as Language

Now, all of this has me thinking quite a lot about the world as language. Conversations, context of a discussion, verbs & nouns as implemented in code, "executable words", etc, etc. It would make Wittgenstein proud! (Actually, it would probably make him berate me until I was reduced to an illogical quivering mass, but I'll go with "proud" just the same).

Aside: Levels of Complexity

So in the context of the Semantic Web, I'm considering an analog of the physical world where, in considering the human brain for instance, we have something like:

Physics->Chemistry->Biology->Neurophysiology->Cognitive Neuroscience

(Note that this is not meant to be at all a rigorous taxonomy, just an example.)

Each of these fields looks at the physical world at differing levels of abstraction and they are all useful. While a physicist may quip that all of biology is reducable to physics, and while that may be true, it would be a notably bad idea to fire all the biologists. Biologists discuss their world at a level of abstraction correlating to complexity of the physical world at the biological level.

So what makes us think that as we build a "Semantic Web" that we wouldn't need similar levels of abstraction?

"But XML allows markup of any concept, no matter how concrete or abstract. I think we've got it covered."

Well yes, but that statement is quite similar to the statement that biology is reducable to physics. What are those intermediate concepts (or levels of complexity)?

Another way to say this in terms of contemporary programming is as follows:

We talk about stuff and meta-stuff these days. Programming and metaprogramming. Content and metacontent. But it seems that this is a relatively simplistic view of our programs, content and by extension our world. I think we need some intermediate (meta) levels.

Back to Language

And this brings me back to the current thought. Is a linguistic view of the world useful as a conceptual building block akin to biology in our example? Or is it an optional and orthogonal way of considering the content on the Web?

Well, until the content on the web looks like pure and granular semantic markup, we're left with language as a communication platform. I can imagine content directly in the form of object structures captured in XML (or it's more readable forms like YAML - see some of my other posts) and without sentences:

  
lent:
  from: Bob
  to: Sally
  thing:
     book:
       title: "A Tale of Two Cities"
       id: ...

Yet even in this form, the markup carries quite a lot of linguistic baggage. 'Lent' is a verb, but it can also be considered an operation. 'from' and 'to' are prepositions, but can be considered attributes of the type or "dynamically typed object" called 'lent'. Similarly, 'book' is the object of the structure, even if it isn't a sentence, but it is also an object in the OO sense.

We can't seem to extract the 'linguistic' from the structure, which brings up another possibility: that language is (a) already considered in the notions of the Semantic Web and (b) so deeply embedded that it's there but not explicit.

So for now I leave it as an interesting question as to where language fits in to the Semantic Web. (Mostly because I need to get on with my day.)

RubyPad

2005-10-30T08:31:00.000-08:00

So I'm doing a weird sort if integration between Ruby ("It's where objects want to be") and VoodooPad (_The_ OS X Personal Wikiware), currently called *RubyPad*.

Imagine that an IDE, and eBook and a Personal Wiki (on Speed) all got together for an orgy and had a *Freaky Voodoo Lovechild*. You can capture your thoughts and code in one place, sort of like how we have learned to co-mingle HTML and code in one place (ERb, JSP, etc.)

Presented for your consideration...

(And yes it's RubyConf, not RubyCon.. I know.. now.)

This next screenshot is - as they say - "where it's at". It's a standard page along with the results of hitting the _Magic Key_. When you press Cmd-R, you run whatever Ruby code is in the page. And it's this - and the blindingly quick SpeedWiki editing - oh, and the automatic hyperlinking to reference information - and the (pseudo)autocomplete, that makes this little fellow such an interesting Hack of Technologies.

In general though, the whole thing is fairly hard to grasp unless you're actually using it. It's research right now (and a lot of fun at that), but if you're interested, ping me (gsnider at pobox dot com) and I can send you a voodoo doc example. This is quite new, and pretty theory-laden, so I'm quite interested in feedback.

BTW, It's built on Flying Meat's "VodooPad":http://flyingmeat.com/voodoopad/, which is a wonderful OS X application - it's the "Personal Wiki on Speed" and has that 'oh so beautiful' OS X style. If the WikiWorld tickles your fancy at all - or if you're just anal about notes - I hightly recommend taking the next thirty seconds to get the demo and the next few hours after that being dazed and confused by the Wonder that is VoodooPad.

Back to RubyPad for a final thought... just keep in mind that:

* It's part of a Wiki, but one without separate edit and view modes - like a word processor with on-the-fly hyperlinks.
* You press Cmd-R to execute the code in the page
All pages can have code, though some are 'mere' documents (like the index page in the screenshot, or the pages in every wiki in existence. :)
* Navigation is weirdly simple. Think of a word (e.g. Regex) , type it, and *poof* becomes a hyperlink. You click and you're at all your notes and any ruby documentation in RubyPad for regular expressions.
* I've even got the text of Dave Thomas's Programming Ruby (v1) in there and am trying to organize it such that navigation is automatic (And Surreal).
* It's all in the phenomenology and the Gestalt, Baby! (Note to self: work on my catch phrases.)

Enterprise Ruby On Rails

2005-10-28T12:16:00.000-07:00

Online book about deploying Rails on a large scale:

Enterprise Ruby On Rails |

Note that if you're not familar with it, this is posted using the Hieraki, which describes itself as Wiki + Hierarchy.

The command line on steroids with Rails and YAML

2005-10-28T09:38:00.000-07:00

Here's a quickie app that I am using to play with YAML as an enhanced command line. Just as the command line is a "power user" interface, this just like a browser and a web server sending XML back and forth. Unlike XML though, YAML is very concise and results in a fairly natural presentation form. Here is a screenshot:

Now, YAML (and XML) is just a representation of a (static) object structure, so in essence, the user and the web server are communicating with a object structure. This provides a few new benefits:

(1) The yaml layout provides context to the user-server interface.

(2) You can do multiple things at once. The server can essentually ask for verification on multiple tasks, and the user can respond to those tasks _and_ specifies new commands and information to the server at once.

(3) The object structure can be "typed" to specific ruby classes, or it can map simply to hashes, ostructs, arrays, strings, numerics, etc. Using general types allows the user to actually define the object structure through use. This form of interaction is similar to the way tagging is being done to dynamically define "classes of similar things". Here though, we are extending that capability to define richer data types. (Like one might do in code with a language like Lisp.)

In general, I think this is a nice interface to have a "power user" interface that provides stateful and "conversational" form of cummunication between the user and the server.

More to come...

Metaclasses in Ruby

2005-10-28T09:35:00.000-07:00

Hints and discussion from Why the Lucky Stiff:

SeeingMetaClassesClearly

From Java to Ruby: 10 Things Every Java Programmer Should Know About Ruby

2005-10-28T09:30:00.000-07:00

You've heard about Ruby. You're a Java Peep. Read this article to get a grasp of the qualitative differences in the languages:

10 Things Every Java Programmer Should Know About Ruby

TextPander: System-level predefined text snippets for your Mac

2005-10-20T15:43:00.000-07:00

TextPander
(http://www.petermaurer.de/nasi.php?section=textpander)

Another Whooa! application for OS X.

It does tag expansion, but does it at the OS level. There is a system preferences panel that is the interface. Typing the keywords will auto expand then on the fly. many expansion are simple string replacements, though date and time expansionas are supported. It would be nice to have the ability to execute any script (including ruby) and return the result. This might allow things like code completion to be done.

In general, adding context awareness and the ability to execute anything would be nice.

It’s a beautiful example of what I have been thinking about in the way of using the full system to build an application, rather than trying to suck everthing into a “abstracted”, “change protected” and massively overcoded app.

As an example of it’s use, I use a context menu in VoodooPad to enter the crrent date and to add

"------ ----- ---- --- -- -"

The problem is that these items are on a sub-context menu. So I set up entries to replace those: ”==.” => ”
------ ----- ---- --- -- -
” “ddtt” => Tuesday; November 1, 2005 6:44 PM
plus, I added the convienient:
"uupdate" => (updated Tuesday; November 1, 2005 6:44 PM)
and now I don’t have to even right click and navigate down. It’s soo fast!

For code, I added (just as a starting point)

"cclass" =>
class XXX
def initialize(arg)
@attr = "val"
end
end

I would add similar stuff for java loops, if I typed many these days.
Best of all, it’s free.

2005-10-06T09:08:00.000-07:00

Collaborank, originally uploaded by -garrett.

Apparently, I'm the 813th most del.icio.us. Yay, I think.