# Hello, world? (#158)

**URL:** <https://www.ruby-forum.com/t/hello-world-158/131274>\
**Category:** Ruby\
**Created:** [March 7, 2008, 4:00pm UTC](https://www.ruby-forum.com/t/hello-world-158/131274 "2008-03-07T16:00:52Z")\
**Posts on this page:** 4\
**Page:** 1

<div class="post-metadata">

**Author:** ![mansfiem](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/m/fbc32d/32.png) [@mansfiem](https://www.ruby-forum.com/u/mansfiem)\
**Post date:** [March 7, 2008, 4:00pm UTC](https://www.ruby-forum.com/t/hello-world-158/131274/1 "2008-03-07T16:00:52Z")

</div>

A simple problem deserves a simple answer… except when you explicitly  
ask  
for something _other_ than the simple answer. Which I did ask. And I got  
answers… lots of them, with a wide variety of techniques, though a few  
of  
the methods were repeated, each with slight variations.

First, we have the _joining letters_ technique. Array’s join method  
makes  
it easy to create a string from parts, and a number of solutions used  
this  
or string concatenation to build up the “Hello, world!” string. Often  
the  
primary difference in these solutions was from where the individual  
letters  
were taken.

Here is one example of the joining letters technique, from Robert D.:

puts [?H, ?e, ?l, ?l, ?o, ?, ?\s, ?W, ?o, ?r, ?l, ?d, ?!].  
inject(“”) { |s, char| s \<\< char }

Remember that a ? in front of a character returns the ASCII value of  
that  
character. Robert joins these values from his array not with the join  
method,  
but with Enumerable’s inject method and String’s concatenation operator,  
which  
will convert an argument between 0 and 255 to a character before  
concatenation.

Second, there were a lot of applications of the _method\_missing_  
technique.  
Usually this involved taking the name of the call and using it as part  
of the  
output. There were a number of solutions that looked similar to Jesse  
Merriman’s first-in method\_missing solution:

class Hello  
def method\_missing m; print m; self; end  
end

Hello.new.H.e.l.l.o.send(', ').w.o.r.l.d!.send(“\n”)

Since the Hello class doesn’t define any methods except method\_missing,  
any  
attempt to call a method (except, of course, those defined by Object)  
will  
end up in this method\_missing call with the argument m containing the  
attempted method name, which then is immediately printed to standard  
output.  
For the few characters that can’t be used as identifiers, the send call  
defined on Object accomplishes the same trick.

Third, a few people tried the _grep_ technique; that is, extracting the  
string from the midst of other text or data. Gaspard B. presented  
a solution that looked like a maze, but simply extracted the letters  
from  
the ASCII maze and joined them appropriately. (Unlike Bill K.'s  
_actual_ maze solver, which gathers up the letters of the target string  
in  
the process of solving the maze.)

A couple folks got “lazy”, so to speak, and decided that rather than  
generate  
the “Hello, world!” string on their own, they would get it from  
somewhere  
else. Here is elof’s solution for this variant of the grep technique,  
_web scraping_:

require ‘net/http’  
require ‘uri’

gke\_url = URI.parse(“[http://www.google.com](http://www.google.com)”)  
gke = Net::HTTP.start(gke\_url.host, gke\_url.port) { |http|  
http.get(“/search?q=ruby%20quiz%20158”)  
}  
puts gke.body.match(‘[**QUIZ\</b\>]\s(\w+, \w+).+as often as you  
can(\W)’)[1…2].join(“”)**

 

elof uses standard Ruby net libraries to perform a search on Google and  
grab  
the text from the first match. At the time, that first match was  
suitable to  
use with the regular expression he employs to pull out the words “Hello  
world”  
from the text. While I picked this solution to show off the interaction  
with  
the Net::HTTP class, this solution has a good chance of breaking if  
Google’s  
page ranking changes for the supplied search string.

Fourth, there were a few _self referencing_ techniques, those solutions  
that  
referred to themselves in one way or another to get the answer. Some  
relied  
on the **FILE** constant, requiring that the filename of the Ruby script  
was named “Hello, world!”. Then there was an interesting solution from  
Jesse M. that loaded its own source code into a variable, and then  
accessed individual characters from the source via 2-dimensional  
coordinates.  
Take a look at Jesse’s solution to see how he got the capital H in  
there.

To me, the most interesting of these self referencing techniques was the  
very  
simple solution from Jari W.:

puts DATA.read  
**END**  
Hello, World!

This was a new technique that I had not seen before. The **END** token  
essentially breaks the file into two parts: code (before) and data  
(after).  
The data can be accessed from code by way of the DATA identifier, which  
is  
a global IO object. Calling read on that object gets everything after  
the  
**END** token, which Jari immediately dumps to standard out. Very  
simple,  
very nice.

Even after all of these techniques, there were still some more things  
going  
on. Number conversions where the string was extracted from a large  
base-256  
number… Use of Array’s pack method to convert binary data back into  
strings… Meta-programming techniques to generate code and methods…  
Make  
sure to look at Joel VanderWerf’s solution that, with a few tricks,  
makes  
the original B language solution from Kernighan work. A few  
probabilistic  
solutions, including Bill K.'s gladiator arena.

There are even a few solutions I still haven’t figured out yet. I need  
to  
break down the dense code from \_why to get a handle on what’s going on.  
And I’m somewhat frightened to even contemplate the mind of Rubén Medellín,  
whose solution is some bizarre, palindromic mirror image of Ruby  
insanity.

There were a lot of creative solutions going on for this quiz. I highly  
recommend you peruse them, if not for technique, at least for  
entertainment.  
But I do believe most folks will learn some technique here; I certainly  
did.

My final comment on this quiz… It’s interesting to note that few  
people  
actually printed output to spec. The quiz asked for “Hello, world!”  
while  
I’d say the majority provided “Hello, World!”. Had I written a unit test  
to  
verify the solutions, most would have failed. Granted, I’m getting a  
little  
silly in mentioning this, but it made me wonder about two things.

First, why was everyone capitalizing both words? Was “Hello, World!” the  
more  
traditional response than “Hello, world!”? Or, perhaps, by having both  
words  
capitalized, did it allow some folks to keep the code simpler?

Second, if so few actually nailed the specification exactly, what  
happens when  
the specification is much deeper, more involved, more complex? How often  
do  
we as developers make minor changes or decisions about non-explicit  
details  
rather than confirming the desired behavior with client or customer?

Yeah, I realize this is just a silly “Hello, world” program, and I  
wasn’t about  
to hold people to such a strict specification… I just wanted to point  
out  
the thinking this inspired in my mind.

Thanks to all who participated in this week’s quiz. There will be no  
quiz this  
week, as I will be out of town, hunting for a new apartment in  
preparation for  
a move coming at the end of this month. Ruby Q. 2 will return next  
Friday.

---

<div class="post-metadata">

**Author:** ![mansfiem](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/m/fbc32d/32.png) [@mansfiem](https://www.ruby-forum.com/u/mansfiem)\
**Post date:** [March 7, 2008, 4:48pm UTC](https://www.ruby-forum.com/t/hello-world-158/131274/2 "2008-03-07T16:48:23Z")

</div>

On Mar 7, 2008, at 9:00 AM, Matthew M. wrote:

> There are even a few solutions I still haven’t figured out yet. I  
> need to break down the dense code from \_why to get a handle on  
> what’s going on.

I assume we’re talking about this:

require ‘rbconfig’  
bui = /^bui(.{2})$/  
$stdout \<\< “#{{}.class}”[0,1] \<\<  
("#{{}.methods}"[/c(\w{4})c/] && $1.reverse) \<\<  
(([0]\*2).inspect[2,2]) \<\<  
Config::CONFIG.keys.grep(bui).first.gsub(bui,  
“#{Kernel.methods.grep(/^th/)[0][2,3].reverse}\1”) \<\<  
ObjectSpace.\_id2ref(338)

Yeah, that’s crazy. Let’s see if we can figure it out.

require ‘rbconfig’

Require Ruby’s configuration details. That gives us a bunch of fresh  
Strings to work with.

bui = /^bui(.{2})$/

Define a regular expression that matches words like “build.”

$stdout \<\< “#{{}.class}”[0,1] \<\<

From here on out, it’s all output. This creates a Hash, and pulls  
the first character off of that class name.

("#{{}.methods}"[/c(\w{4})c/] && $1.reverse) \<\<

Now it starts to get tricky. This code pulls the methods for a Hash,  
joins them into a giant String, uses a Regexp to find “collec” from  
the collect() method, and reverses and prints the “olle” portion.  
That gets us the rest of “Hello.”

(([0]\*2).inspect[2,2]) \<\<

This makes an Array, grabs the code for it from Ruby’s inspect(), and  
indexes into that String to pull out the comma and space.

Config::CONFIG.keys.grep(bui).first.gsub(bui,  
“#{Kernel.methods.grep(/^th/)[0][2,3].reverse}\1”) \<\<

This uses the Regexp built a while back to match the “build” key out  
of Ruby’s configuration Hash. It then replaces the letters “bui.” To  
get the replacement, the code hunts for the throw() method on Kernel,  
pulls the last three letters and reverses them. That gives us “wor” +  
“ld” or “world.”

ObjectSpace.\_id2ref(338)

I have no idea how reliable this is, but in \_why’s build of Ruby, and  
my own, the object with the ID 338 is the Symbol :"!", the last  
character needed.

Clever code as always from \_why.

> And I’m somewhat frightened to even contemplate the mind of Rubén  
> Medellín, whose solution is some bizarre, palindromic mirror image  
> of Ruby insanity.

It was freaking awesome. I’ll leave it to someone else too spoil that  
one… 😉

James Edward G. II

---

<div class="post-metadata">

**Author:** ![mansfiem](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/m/fbc32d/32.png) [@mansfiem](https://www.ruby-forum.com/u/mansfiem)\
**Post date:** [March 7, 2008, 6:52pm UTC](https://www.ruby-forum.com/t/hello-world-158/131274/3 "2008-03-07T18:52:18Z")

</div>

On Fri, 07 Mar 2008 10:47:13 -0500, James G. wrote:

> $stdout \<\< “#{{}.class}”[0,1] \<\<  
> Require Ruby’s configuration details. That gives us a bunch of fresh
> 
> indexes into that String to pull out the comma and space.  
> ObjectSpace.\_id2ref(338)
> 
> It was freaking awesome. I’ll leave it to someone else too spoil that  
> one… 😉
> 
> James Edward G. II

```
              def method_missing(a = p, *c); return ; nruter ;(c* p 

```

= a);gnissim\_dohtem fed  
end ; dne

These first two lines define method\_missing (in Object context) to do  
nothing. The code returns immediately (at return),  
so none of the addional reversed names are executed. The dne after the  
end of method\_missing calls method\_missing, since no  
method named dne is defined. We can now delete most mangled names that  
we don’t understand. The equivalent code for this  
is:

def method\_missing (a=p, \*c); return; end

The p is never evaluated (it would point to nowhere, or cause infinite  
recursion), because method\_missing  
is always called with the name of an argument

```
                             alias m method_missing ; gnissim_dohtem 

```

m; saila

```
                                     class NilClass ; ssalCliN ssalc
                                 alias inspect to_s ; s_ot tcepsni 

```

;saila  
end ; dne

NilClass.inspect now returns an empty string. Everything to the right of  
the semicolons is a call to method\_missing.  
This can be safely removed since it’s never called anyway.

```
                                      class Integer ; regetnI ssalc

```

def method\_missing(a=chr,_b);print chr;return a.to\_s[0] ; [0];s\_ot.a  
nruter;rhc tnirp;(b_rhc=a);gnissim\_dohtem fed  
end ; dne

Supposing we call 63.method\_missing directly. Then a will be ascii  
character 63 (’?’), and the function will print ‘?’ and  
return 63. Supposing we call 72.e. Then a will be the letter ‘e’. The  
function will print ascii character 72 (‘h’) and return  
the ascii code for ‘e’ (101). We can now call (for example) puts  
72.e.l.l.o.chr and get the output ‘Hello’

```
                      def d! ; return(d.e and puts) ; (stup dna; 

```

e.d);nruter ; !d fed  
dne ; end ; dne ; end

Still operating on the integer context, this prints the previous letter,  
then a ‘d’ (through two missing methods)  
and uses puts to place a blank line after the d.  
The 2 end calls close the method p, and close the Integer class.

```
                           def p(p = a, *b) ; begin ; nigeb ; (b* a 

```

= p); p fed  
rescue ; print p.to\_s ; return ; nruter ;  
s\_ot.p tnirp ; eucser  
dne ; end ; dne ; end

Sorting out some of the method\_missing calls:

def p(p=nil, \*b)  
begin  
a=p #evalutes p as a variable  
p fed #evaluates p as a function, causing a SystemStackError  
rescue #catches the SystemStackError  
#this is caught at the innermost level of the stack  
overflow  
print p.to\_s #evaluates p as a variable, which at the inner level is  
nil, so this prints nothing  
return  
end  
end

The whole function definition can be safely removed, as called, it does  
the same thing as method\_missing anyway.

```
                       dne def a b = c ; return nil ; lin nruter ; c 

```

= b a; fed end

Defines a method a which returns nil. dne calls method\_missing with a  
nil argument. Since “def” to define a method is an  
expression that returns nil, its return value can be passed to a  
function. This line can be safely removed since it  
defines a method that does the same thing as method\_missing.

```
                                          a = a def fed a = a
                                             return nruter
                                    a = p end ; fed ; def dne p = a
                                                p a ; a p
                                                end ; dne

```

He breaks palindrome with a single semicolon here.

Sets the variable a to nil, (because the second a is a method call), and  
defines the method fed to return  
the return value of nruter (which at this moment is a method\_missing  
call, and stays that way for the rest of the program)  
The line  
a = p end  
is acutally two statements: an a=p, followed by an end.  
He then goes to immediately define dne to call the p function we saw  
before, which prints nothing, and  
the a function which returns nil. So dne is now defined, but does  
nothing.

These 5 lines can actually all be safely removed, since they define  
methods which do the same thing as method\_missing anyway.

```
  def h ax0=0xa;return 0xa unless ax0;dne;y=x p;fed = def p x=y;end; 

```

0xa;sselnu ax0;nruter ax0=0xa;h fed  
bx0, dx0 = 0xd, 0xb  
bx0 + dx0 + 0xb + bx0 + 0xd +  
0xb  
end ; dne

def h ax0=10  
return 10 unless ax0  
y=nil  
fed = nil  
def p x=y  
end  
bx0=13  
dx0=11  
bx0 + dx0 + 11 + bx0 + 13 + 11 # equals 13 + 11 + 11 + 13 + 13 + 11  
which is 72  
end

In short, if nil is explicitly passed to h, it returns 10. If anything  
else (or nothing) is passed to h,  
it defines p (in the global context) to do nothing, then returns 72  
(ascii for ‘H’).

```
                         def Object.const_missing a ; a 

```

gnissim\_tsnoc.tcejbO; fed  
return send(a.to\_s.downcase) ;  
(esacnwod.s\_ot.a);dnes nruter  
end ; dne

All the stuff on the right side of the semicolons does nothing. The  
const\_missing is intended to  
convert the H constant reference on the next line to a call to the h  
method we just defined. (This will  
return the ascii code for ‘H’, which is what we need to start the  
sequence of Integer.method\_missing calls  
on the next line.

```
                             H.e.l.l.o._.w.o.r.l.d! ; 

```

!d.l.r.o.w.\_.o.l.l.e.H

The left side prints out the string “Hello\_world” using the integer  
method\_missing chaining that I mentioned above. (The last  
call to d! prints out the letter “d”, as mentioned above.)  
The right side calls the global method\_missing repeatedly, which does  
nothing.

In other words, all of this code actually translates to:  
(Everything else is calls method\_missing which returns nil,  
or calls a method which is functionally equivalent to method\_missing.)

class Integer  
def method\_missing a, \*b  
print chr  
return a.to\_s[0]  
end  
def d!  
return (d.e and puts)  
end  
end

def h  
return 72  
end

def Object.const\_missing a  
return send(a.to\_s.downcase)  
end

H.e.l.l.o.\_.w.o.r.l.d!

---

<div class="post-metadata">

**Author:** ![mansfiem](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/m/fbc32d/32.png) [@mansfiem](https://www.ruby-forum.com/u/mansfiem)\
**Post date:** [March 8, 2008, 12:11am UTC](https://www.ruby-forum.com/t/hello-world-158/131274/4 "2008-03-08T00:11:06Z")

</div>

Hi,

On Sat, Mar 8, 2008 at 2:00 AM, Matthew M. [removed\_email\_address@domain.invalid](mailto:removed_email_address@domain.invalid)  
wrote:

> traditional response than “Hello, world!”? Or, perhaps, by having both  
> words  
> capitalized, did it allow some folks to keep the code simpler?

I think, as far as my own experience goes, that many people - despite  
perhaps being grammar sticklers - still are used to seeing “Hello,  
World!”  
from many test programs while learning to code. Just the way things  
turned  
out, maybe. 🙂

Arlen