|
Back In Your Head
Come Back To Me
Oasis Don T Look Back In Anger
Player Baby Come Back
Presenting for Presenters
<p style="padding-left:3em;"><em>If you are speaking at RubyConf this year, we have a special
opportunity for you.</em></p>
<h2>Are You Speaking at RubyConf 2008?</h2>
<p>If so, congratuations! And have we got a deal for you …</p>
<p>Wednesday evening, Nov 5, at 6:00 pm, (that’s the night before the
conference) we are inviting all speakers to a special training
session. I’m going to be sharing some ideas for putting together and
delivering a good presentation.</p>
<p>After my talk, Patrick Ewing and Adam Keys are geared up to do some
Powerpoint Karaoke with everyone there. I’m not even sure what
Powerpoint Karaoke is, but it sounds like fun.</p>
<p>I hope to see everyone there.</p>
<h2>Update (4/Nov/08)</h2>
<p>I’ve talked to Adam today. He says that Patrick isn’t going to
able to make RubyConf this year, but we will be ready to roll with
Powerpoint Karaoke anyways.</p>
<h2>Update (5/Nov/08)</h2>
<p>It looks like the speakers training will be in the Olympic Room
tonight. The Olympic Room is on the same floor as the registration
desk. Go to the left past the elevators and turn right down that hall
(or ask someone who looks like they know what they are doing).</p>
Articles are Back!
<p style="padding-left:3em;"><em>I’ve received a lot of requests for my old articles …</em></p>
<h2>The Article Section has been Restored</h2>
<p>When I changed to my new hosting machine, I moved all my blog posts
but didn’t move any of the articles. Of course I <em>intended</em> to move
them eventually but never got around to it.</p>
<p>A lot of people have been asking for this article or that
presentation, or pointing out that a number of old bookmarked links
are no longer any good. So due to popular demand the <b>Articles and
Presentations</b> section of onestepback.org is now restored.</p>
<p>Enjoy</p>
Comments Are Now Enabled
<p style="padding-left:3em;"><em>I’ve gone without comments on this blog for a long time …</em></p>
<h2>Comments via Disqus</h2>
<p>I’ve gone through several commenting systems for this blog over
time. First was the really cool
<a href="http://onestepback.org/index.cgi/Tech/Web/MoreWebApps.rdoc">TagSurf</a>
application that allowed commenting on about any web page on the
internet arbitrary tags. Unfortunately, TagSurf died a (in the words
of its creator) “well deserved” death.</p>
<p>Then I tried a wiki for comments. That worked pretty good (aside from
spam issues), but setting up a new page for comments for each new post
was just too much hassle.</p>
<p>Now I’m trying <a href="http://disqus.com/docs/about/">Disqus</a> for comments.
It only took an hour or so to integrate Disqus with my ancient
blogging engine (anyone else still using Rublog?).</p>
<p>Kick the tires and see how it works. If you have feedback … well,
just leave a comment.</p>
<p>I guess this means I’ll have to start writing some <em>real</em> content
here so there will be something worth commenting on … let’s see if
there is anything I feel like ranting about …</p>
<p>(Oh, and a hat tip to <a href="http://brionesandco.com/ryanbriones/">Ryan
Briones</a> for pointing out Disqus
when I was ready to go out and implement something from scratch.)</p>
RedMine For Rake
<p style="padding-left:3em;"><em>The is now a RedMine setup for Rake, FlexMock and Builder.</em></p>
<h2>RedMine</h2>
<p>As part of an effort to get better control of changes to the my open
source projects, I’ve setup a RedMine issue tracking site for Rake,
FlexMock and Builder. You can find it at
<a href="http://onestepback.org/redmine">http://onestepback.org/redmine</a>.</p>
Moving Blog Host
<p style="padding-left:3em;"><em>I am changing host for the One Step Back blog.</em></p>
<h2>It’s Time to Move</h2>
<p>This is just a quick little post to let you know that the One Step
Back blog is moving. In fact, it has already moved. But don’t worry,
we aren’t going far.</p>
<p>Originally this blog was hosted on a shared co-op system run by
<a href="http://www.n2net.net/">N2Net</a>. It was dirt cheap and easy to maintain.
The down side was that support was sporadic. As the hardware has aged,
the Co-op has decided to let the current system run until the hardware
dies, and then disolve the co-op.</p>
<p>Today there are tons more hosting opportunities available than there
were when the co-op was first formed. I’m now leasing a Linode
<a href="http://www.linode.com/">node</a> and running the blog and other
associated software from there. Its almost as inexpensive and the
co-op and uptime <em>should</em> be better.</p>
<p>Write now the blog has been moved. As time passes I’ll move the
article archive as well. Let me know if anything looks amiss.</p>
<p>—Jim Weirich</p>
How did you get started in software development.
<h2>Tagged</h2>
<p>Looks like <a href="http://objo.com/2008/6/7/how-did-you-get-started-in-programming">Joe
O’Brien</a>
tagged me for answers to the following questions. He, in turn, was
tagged by <a href="http://joshholmes.com/">Josh Owens</a>, who in turn was tagged
by <a href="http://www.jeffblankenburg.com/index.html">Jeff Blankenburg</a>. It
looks like <a href="http://www.codinggeekette.com">Sarah Dutkiewicz</a> and
<a href="http://michaeleatonconsulting.com/blog/archive/2008/06/04/how-did-you-get-started-in-software-development.aspx">Micheal
Eaton</a> started this.</p>
<p>OK, sounds like fun. Here goes.</p>
<h2>How old were you when you started programming?</h2>
<p>I was introduced to programming in high school by reading a book on
the topic. The book taught me how to write machine code for a strange
decimal-based machine. Unfortunately, there was no actual computer
involved in the process. Shoot, who had computers back then? Certainly
not our high school (the personal computers? not invented yet!)</p>
<p>In college, I learned a smattering of <span class="caps">FORTRAN</span>. Just enough to drive a
Calcomp plotter to plot data from my undergraduate physics courses.
But didn’t really get into programming until my junior year in
college. (Story continued in next question)</p>
<h2>How did you get started in programming?</h2>
<p>So, I was planning out the courses for my junior year in college and I
had a hole in my math courses. The math class I needed was not offered
that semester, so my adviser suggested taking a computer programming
course. He said it would be useful and, who knows, I might enjoy it.</p>
<p>So I signed up for an introduction to <span class="caps">FORTRAN</span> course, figuring it
would be easy because I already knew a little bit of <span class="caps">FORTRAN</span>. I show
up on the first day of class and after a few preliminaries the
instructor jumps right into some code, that looked like this:</p>
<pre>
(de member (pip deck) (cond
((null deck) nil)
((eq pip (car deck)) t)
(t (member pip (cdr deck)))))
</pre>
<p>I remember scratching my head and thinking this was the strangest
<span class="caps">FORTRAN I</span> had ever seen. I was totally confused for about three days,
then something clicked on the third day of class. I suddenly
“<em>got</em>” what the instructor was trying to get across and it all
made perfect sense.</p>
<p>If you haven’t figured it out yet, the instructor taught us Lisp as
part of an introduction to <span class="caps">FORTRAN</span>. The instructor turned out to be
Daniel Friedman, the author of <a href="http://www.amazon.com/Little-LISPer-Third-Daniel-Friedman/dp/0023397632"><em>The Little
Lisper</em></a>,
and was well known in the Lisp community. That small exposure to Lisp
hooked me on programming from that point on. I took as many CompSci
courses as I could in my remaining year and a half in college. I
eventually graudated with a BS in Physics, but had a strong background
in Computer Science as well.</p>
<h2>What was your first language?</h2>
<p>Technically, <span class="caps">FORTRAN</span> was my first language. But Lisp is the language I
fell in love with and is what got me hooked on programming.</p>
<h2>What was the first real program you wrote?</h2>
<p>I have a very clear memory of the very first program I wrote
professionally. The reason it is so clear is that this was the first
program I wrote that was intended for actual use by someone who wanted
it. Everything else up to that time was done for my own personal
enjoyment or to satisfy some course requirement.</p>
<p>The program calculated the “critical angles” of “pieces”. I was given
the requirements by Anne Exline, a senior programmer, and proceeded to
write the program to spec. It took a few days, but when I was done I
showed the result to Anne and she was pleased with the result.</p>
<p>The funny thing is that I had no idea what a “piece” was nor what was
so critical about the angles I was calculating. I was so excited about
writing an actual program that I did not ask until the software was
done. When asked, Anne just looked at me funny and said “Rocket
Pieces”. When Cape Canaveral lauches a rocket, they track it very
carefully to make sure it stays on course. If it strays, the range
safety officer is required to activate the self destruct. The critical
angles are those angles that would cause the “rocket pieces” to land
outside the safety area of the flight path.</p>
<p>So, my very first professional program was not only useful, it might
actually save lives.</p>
<h2>What languages have you used since you started programming?</h2>
<p>Languages I have used as part of my professional career (in roughly
chronological order) include <span class="caps">FORTRAN</span>, various assembly languages,
<span class="caps">FORTH</span>, C, PL/M, C++, Java, Ruby.</p>
<p>Languages I have used in addition to those mentioned above: Pascal,
Perl, Eiffel, and Lisp/Scheme.</p>
<p>Languages I can read, but never wrote anything significant in them:
Ada, Python, Erlang, Smalltalk, <span class="caps">SNOBOL</span>, Algol, Pascal.</p>
<h2>What was your first professional programming gig?</h2>
<p>I was hired by the <span class="caps">RCA</span> Missile Test project in Cape Canaveral, Florida
as a Near Real Time Analyst. Duties included programming various
launch related software (e.g. the critical angle program mentioned
above) and working launch support.</p>
<p>The launch support was the “Near Real Time” part of the job
description. From the moment a rocket is launched until it reaches
orbital velocity, any malfunction could cause it to fall back to
earth. During this initial portion of the launch, the launch is
monitored in “real-time” so that we know exactly where it would land
if the engines were to cut off <span class="caps">NOW</span>. Trajectory calculations had to be
done in fractions of a second and updated constantly in real time.</p>
<p>After the rocket reaches oribital velocity (usually somewhere between
8 and 14 minutes into its flight), it won’t fall back to earth. At
this point the real time trajectory program is shut down and the near
real time program is started. The near real time program can take a
few minutes to calculate a more exact orbital prediction and then send
that prediction to downrange radars (e.g. the the <a href="http://en.wikipedia.org/wiki/Ascension_Island">Ascension
Island</a> station) that
won’t see the rocket until about 20 minutes after launch. It was the
job of the Near Real Time analyst to run that program and provide
oribital predictions for downrange station.</p>
<h2>If there is one thing you learned along the way that you would tell new developers, what would it be?</h2>
<p>Find something that you enjoy and do that. Life is too short to work
in a job that you dislike.</p>
<h2>What?s the most fun you?ve ever had ? programming?</h2>
<p>Oh, the fun I have had. This story still makes me smile.</p>
<p>My first computer was a single board <span class="caps">Z80</span> microcomputer with 4 KB of
memory. I wrote a small <span class="caps">FORTH</span>-like interpreter for it and hacked a
version of the animal game in <span class="caps">FORTH</span>. The animal game is a program that
plays 20 questions to figure out what animal you are thinking of. It
constructs a binary tree where each node is a question and the
subtrees are the yes and no answers to the question. To play the game,
all the program does is walk the tree, ask the question at the current
node and follow either the <span class="caps">YES</span> branch or the NO branch as appropriate.</p>
<p>If the program guesses wrong, it will ask you for your animal and a
question that will distinguish your animal from the one it guessed. It
then adds your question to the tree. By this extremely simple
mechanism, it is able to expand its knowledge base. (see <a href="http://www.rubyquiz.com/quiz15.html">Ruby Quiz
#15</a> for more details).</p>
<p>I had just finished the program and had seeded it with a single
animal, a mouse. I turned to my wife and asked her to play the game.
She thinks of an animal and starts the program, which immediately
asked her “Is it a mouse?”. She turned to me with surprise and said
“How did it know?”. Of course, the animal she picked was a mouse.</p>
<p>I don’t think I have ever impressed anyone with my programming skills
as much as she was impressed with that game.</p>
<h2>Who’s up next?</h2>
<p>I’m tagging the following people. Remember, this is entirely
voluntary so don’t feel obligated to answer. But I’m betting the
answers are interesting:</p>
<ul>
<li><a href="http://mysterycoder.blogspot.com/">Chris Nelson</a></li>
<li><a href="http://clarkware.com/cgi/blosxom">Mike Clark</a></li>
<li><a href="http://gilesbowkett.blogspot.com/">Giles Bowkett</a></li>
<li><a href="http://railsstudio.com/">Mark Windholtz</a></li>
<li><a href="http://www.vanderburg.org/Blog">Glenn Vanderburg</a></li>
</ul>
Rails Conf 2008 Summary
<h2>Conference Summary Video</h2>
<p>Wow, what a great conference! There was a lot of energy flowing at
RailsConf this year. Overall I’d rate this year as head and shoulders
above last year. I’m not going cover much here, but will direct you
attention to a <a href="http://www.railsenvy.com/2008/6/2/Railsconf-videos">Rails Envy
VideoCase</a> that
Greg Pollack put together. The video is a series of very short
interviews with a number of presenters giving summaries of their own
talks. The only downside with the video is that I wish it was
available <em>before</em> the conference. I see there were a number of
interesting talks that I missed.</p>
<h2>Followup on the “Modelling Dialogue”</h2>
<p>Joe O’Brien, Chris Nelson and myself did a dialogue style presentation
on the difference between object modelling and data modelling. The
most common question I got after the talk was requests for book titles
to learn more about object oriented modelling. Here are the books
that Joe, Chris and I have recommended:</p>
<ul>
<li><em><a href="http://www.amazon.com/Domain-Driven-Design-Tackling-Complexity-Software/dp/0321125215/ref=pd_bbs_sr_1?ie=UTF8&s=books&qid=1212463473&sr=1-1">Domain Driven Design</a></em>—Eric Evans</li>
<li><em><a href="http://www.amazon.com/Software-Development-Principles-Patterns-Practices/dp/0135974445/ref=sr_1_1?ie=UTF8&s=books&qid=1212502027&sr=1-1">AgileSoftware Development, Principles, Patterns, and Practices</a></em>—Bob Martin</li>
<li><em><a href="http://www.amazon.com/Refactoring-Improving-Existing-Addison-Wesley-Technology/dp/0201485672/ref=pd_bbs_sr_1?ie=UTF8&s=books&qid=1212465268&sr=1-1">Refactoring: Improving the Design of Existing Code</a></em>—Martin Fowler</li>
</ul>
Artichoke Music Rocks
<p style="float: right; padding: 0.5em;"><a href="http://www.artichokemusic.com/index2.htm"><img border="0" src="http://www.artichokemusic.com/LogocommUnity-sm.jpg"/></a></p>
<p>The Musician’s Birds of a Feather gathering at RailsConf was great. We
had a room full people, two guitars, a ukulele, a flute, several
harmonicas and an improvised drum set. Unfortunately, one of the
guitars was an electric travel guitar which had a dead battery,
therefore no way to really hear it.</p>
<p>However, the other guitar was a nice Epiphone accoustic which was
passed from player to player. It became the quickly became the basis
for most of the music performed that night.</p>
<p>I want to thank <a href="http://www.artichokemusic.com/index2.htm">Artichoke Community
Music</a> for supplying the
guitar. Travelling with a guitar by plane is a big pain, so I arrived
with nothing to bring to the music <span class="caps">BOF</span>. I called several local music
stores looking for a guitar that I could rent for an evening.
Artichoke music said they had a “not-for-profit” guitar that they
would let me borrow for a day. Not many stores would do that for an
out-of-town stranger.</p>
<p>So, if you’re in Portland looking for a good guitar store, check out
the great people at <a href="http://www.artichokemusic.com/index2.htm">Artichoke Community
Music</a>.</p>
Test Driven Studio in June 2008
<p><em>Joe O’Brien and I will be leading another Test Driven
Studio in Denver, June 9-11.</em></p>
<p style="float: right; padding: 0.5em;"><a href="http://pragmaticstudio.com/images/studio/tdd-with-rails-icon.jpg"><img border="0" src="http://onestepback.org/images/pragstudio/studio-medium.gif"/></a></p>
<h2>Testing, Colorado, June … What’s not to like?</h2>
<p>About 8 years ago I come upon a technique that radically changed the
way I developed code. I was reading Martin Fowler’s “Refactoring”
book and came across this paragraph:</p>
<p style="padding-left:3em;"><em>“Whenever I do refactoring, the first step is always the
same. I need to build a solid set of tests for that section of code.
The test are essential because even though I follow refactorings
structured to avoid most of the opportunities for introducing bugs,
I’m still human and still make mistakes. Thus I need solid
tests.” </em>—Martin Fowler</p>
<p>Chapter 4 of “Refactoring” was my first introduction to JUnit and got
me interested in “Test First Design” (what we now tend to call “Test
Driven Development”). Although I wrote <em>good</em> code before, the
confidence I had in my code took a dramatic leap forward after I
started adopting <span class="caps">TDD</span> practices.</p>
<p>On June 9 through 11, <a href="http://objo.com">Joe O’Brien</a> and I will have
the pleasure of leading the next Pragmatic Programmer’s <a href="http://pragmaticstudio.com/testing-rails">Test-Driven
Development with Rails
Studio.</a> in Denver. We will
have an opportunity to share with you some of our experiences in using
<span class="caps">TDD</span> with Ruby and Rails.</p>
<p>There are still seats available, so its not too late to sign up. More
information is available
<a href="http://pragmaticstudio.com/testing-rails">here</a>.</p>
Lisp in Ruby
<p style="padding-left:3em;"><em>I stumbled across <a href="http://bc.tech.coop/blog/080101.html">this</a> and it got me thinking …</em></p>
<h3>Update</h3>
<p style="padding-left:3em;"><em>I’ve updated the Textile formatter on the site and the code
for this entry is now displaying correctly. The previous version was
swalling the == operators in the code.</em></p>
<h2>Lisp 1.5 Programmer’s Manual</h2>
<p>I stumbled across <a href="http://bc.tech.coop/blog/080101.html">this</a> in
Bill Clementson’s blog and remembered using the Lisp 1.5 Prgrammers
manual from the college years. I have strong memories of pouring over
that particular page in the manual and attempting to understand all
the nuances.</p>
<p>If you’ve never read the Lisp 1.5 Programamers Manual, page 13 is
the guts of a Lisp Interpreter, the “eval” and “apply” functions. It
is written in Lisp, although the notation used is a bit funky. The
entire interpreter (minus two utility functions) is presented on a
single page of the book. Talk about a concise language definition!</p>
<h2>In Ruby?</h2>
<p>I had often thought about implementing a Lisp interpreter, but back in
the “old days”, the thought of implementing garbage collection and the
whole runtime thing was a bit daunting. This was in the day before C,
so my implementation language would have been assembler … yech.</p>
<p>But as I was reviewing the page, I realized that with today’s modern
languages, I could problably just convert the funky M-Expressions used
on page 13 directly into code. So … why not?</p>
<h2>The Code</h2>
<p>Here is the complete Ruby source code for the Lisp interpreter from
page 13 of the Lisp Programmers manual:</p>
<pre>
# Kernel Extensions to support Lisp
class Object
def lisp_string
to_s
end
end
class NilClass
def lisp_string
"nil"
end
end
class Array
# Convert an Array into an S-expression (i.e. linked list).
# Subarrays are converted as well.
def sexp
result = nil
reverse.each do |item|
item = item.sexp if item.respond_to?(:sexp)
result = cons(item, result)
end
result
end
end
# The Basic Lisp Cons cell data structures. Cons cells consist of a
# head and a tail.
class Cons
attr_reader :head, :tail
def initialize(head, tail)
@head, @tail = head, tail
end
def ==(other)
return false unless other.class == Cons
return true if self.object_id == other.object_id
return car(self) == car(other) && cdr(self) == cdr(other)
end
# Convert the lisp expression to a string.
def lisp_string
e = self
result = "("
while e
if e.class != Cons
result << ". " << e.lisp_string
e = nil
else
result << car(e).lisp_string
e = cdr(e)
result << " " if e
end
end
result << ")"
result
end
end
# Lisp Primitive Functions.
# It is an atom if it is not a cons cell.
def atom?(a)
a.class != Cons
end
# Get the head of a list.
def car(e)
e.head
end
# Get the tail of a list.
def cdr(e)
e.tail
end
# Construct a new list from a head and a tail.
def cons(h,t)
Cons.new(h,t)
end
# Here is the guts of the Lisp interpreter. Apply and eval work
# together to interpret the S-expression. These definitions are taken
# directly from page 13 of the Lisp 1.5 Programmer's Manual.
def apply(fn, x, a)
if atom?(fn)
case fn
when :car then caar(x)
when :cdr then cdar(x)
when :cons then cons(car(x), cadr(x))
when :atom then atom?(car(x))
when :eq then car(x) == cadr(x)
else
apply(eval(fn,a), x, a)
end
elsif car(fn) == :lambda
eval(caddr(fn), pairlis(cadr(fn), x, a))
elsif car(fn) == :label
apply(caddr(fn), x, cons(cons(cadr(fn), caddr(fn)), a))
end
end
def eval(e,a)
if atom?(e)
cdr(assoc(e,a))
elsif atom?(car(e))
if car(e) == :quote
cadr(e)
elsif car(e) == :cond
evcon(cdr(e),a)
else
apply(car(e), evlis(cdr(e), a), a)
end
else
apply(car(e), evlis(cdr(e), a), a)
end
end
# And now some utility functions used by apply and eval. These are
# also given in the Lisp 1.5 Programmer's Manual.
def evcon(c,a)
if eval(caar(c), a)
eval(cadar(c), a)
else
evcon(cdr(c), a)
end
end
def evlis(m, a)
if m.nil?
nil
else
cons(eval(car(m),a), evlis(cdr(m), a))
end
end
def assoc(a, e)
if e.nil?
fail "#{a.inspect} not bound"
elsif a == caar(e)
car(e)
else
assoc(a, cdr(e))
end
end
def pairlis(vars, vals, a)
while vars && vals
a = cons(cons(car(vars), car(vals)), a)
vars = cdr(vars)
vals = cdr(vals)
end
a
end
# Handy lisp utility functions built on car and cdr.
def caar(e)
car(car(e))
end
def cadr(e)
car(cdr(e))
end
def caddr(e)
car(cdr(cdr(e)))
end
def cdar(e)
cdr(car(e))
end
def cadar(e)
car(cdr(car(e)))
end
</pre>
<h2>An Example</h2>
<p>And to prove it, here’s an example program using Lisp. I didn’t
bother to write a Lisp parser, so I need to express the lists in
standard Ruby Array notation (which is converted to a linked list via
the “sexp” method).</p>
<p>Here’s the ruby program using the lisp interpreter. The Lisp system
is very primitive. The only way to define the function needed is to
put them in the environment structure, which is simply an association
list of keys and values.</p>
<pre>
require 'lisp'
# Create an environment where the reverse, rev_shift and null
# functions are bound to an appropriate identifier.
env = [
cons(:rev_shift,
[:lambda, [:list, :result],
[:cond,
[[:null, :list], :result],
[:t, [:rev_shift, [:cdr, :list],
[:cons, [:car, :list], :result]]]]].sexp),
cons(:reverse,
[:lambda, [:list], [:rev_shift, :list, nil]].sexp),
cons(:null, [:lambda, [:e], [:eq, :e, nil]].sexp),
cons(:t, true),
cons(nil, nil)
].sexp
# Evaluate an S-Expression and print the result
exp = [:reverse, [:quote, [:a, :b, :c, :d, :e]]].sexp
puts "EVAL: #{exp.lisp_string}"
puts " => #{eval(exp,env).lisp_string}"
</pre>
<p>The program will print:</p>
<pre><code>$ ruby reverse.rb
EVAL: (reverse (quote (a b c d e)))
=> (e d c b a)</code></pre>
<p>All I need to do is write a Lisp parser and a <span class="caps">REPL</span>, and I’m in business!</p>
<h2>The Example in Standard Lisp Notation</h2>
<p>If you found the Ruby-ized Lisp code hard to read, here is the reverse
funtions written in a more Lisp-like manner.</p>
<pre>
(defun reverse (list)
(rev-shift list nil))
(defun rev-shift (list result)
(cond ((null list) result)
(t (rev-shift (cdr list) (cons (car list) result))) ))
</pre>
|
