[Question]
  [
**Closed.** This question is [off-topic](/help/closed-questions). It is not currently accepting answers.
 
 
---
 Questions without an **objective primary winning criterion** are off-topic, as they make it impossible to indisputably decide which entry should win.
Closed 7 years ago.
[Improve this question](/posts/5760/edit) 
**Puzzle:**
Write a short, three-line program which:
* has 5/7/5 syllables per line when read aloud
* outputs a haiku when run.
An example of a program having the correct structure, but non-haiku output, is (Python):
```
>>> for x in range(3):
...     print "EXTERMINATE HUMANS"
... # I am a Dalek.
... 
EXTERMINATE HUMANS
EXTERMINATE HUMANS
EXTERMINATE HUMANS
```
(The comment is a bit of a cop-out.)
This reads aloud as:
> 
> for x in range three
> 
> 
> print EXTERMINATE HUMANS!
> 
> 
> I am a Dalek.
> 
> 
> 
Any language is acceptable. For the purposes of reading aloud, symbols like `!@#$%^&*()_+` can be ignored if you want, or pronounced aloud, admitting something like [Waka Waka Bang Splat](http://babek.info/libertybasicfiles/lbnews/nl123/fun.htm). (I'm sure there will be a Perl entry like `!***(!:, )(*@@@#, )_(*)!.`)
Extra points if either the code or the output is especially funny, or especially zen.
---
Edit: If your language requires boilerplate before it can do anything interesting (`#include <iostream>`?) then I'm happy to ignore the boilerplate.
---
I've accepted Paul Richter's Common Lisp haiku on the grounds that it made me laugh for a good five minutes.
Honorable mention for Timwi's creative rule-bending (*compiler* output?!) and for the extremely memorable line `"Static void. I long for you."`
> 
> Now this question ends;
> 
> 
> Many more haikus await.
> 
> 
> **Continue posting!**
> 
> 
> 
  
[Answer]
# C#
Program:
```
#warning Lonesome
class _{
    static void Eye(long forYou='
        ){ /* My program ends here. */ ;}}
```
Read:
```
Warning: Lonesome class.
Static void. I long for you.
My program ends here.
```
*Compiler* output:
```
#warning: 'Lonesome'        (read: hash warning lonesome)
Empty character literal     (read: empty character lit’ral)
Newline in constant
```
[Answer]
## Piet, 867 executing color blocks
Grand Prize, you say? This has codel size of 2.
![a haiku that prints itself](https://i.stack.imgur.com/22e5A.png)
Output: 
```
SPRING EVER RETURNS
NEVER EXACTLY THE SAME
THIS IS NOT A QUINE
```
This challenge was fun! I've written a [Piet instruction encoder](http://meta.codegolf.stackexchange.com/a/374/2180) that takes instructions and translates them into a Piet script. It's short work from there to generate code to print a given string. I put a small (but effective) amount of effort into golfing the Piet code while only using single-codel instructions.
I then made a pixel font. For every pixel in a character, I blow it up into 4 codels: 2 black, and 2 executed. The first codel encountered is non-executing, so if a segment of a character has *n* pixels, for example, that corresponds to 2\*n\*-1 instructions.
The lines down the sides reverse the direction pointer and move it down by 2 pixels, taking it to the next row. Thus, instructions are reversed on every other line.
Once I had code to produce "text embedded in text", it gets fun. I probably wrote 20 haiku along the way, but I eventually settled. By tweaking the font; adding / removing serifs, rounding corners, changing height / width, etc., I was able to alter the total number of nonwhite pixels in the image such that the Piet code fit exactly into the image text.
Bonus! You can make your own quinelike haiku! <http://pastebin.com/zxc9V3UX>
[Answer]
## Common Lisp
Parentheses are silent!
Program:
```
((lambda (&rest foo) 
   (list foo (cons 'truly foo) foo))
 'this 'is 'lisp 'haiku)
```
Read as:
```
lambda and rest foo
list foo cons truly foo foo
this is lisp haiku
```
Output:
```
((THIS IS LISP HAIKU) (TRULY THIS IS LISP HAIKU) (THIS IS LISP HAIKU))
```
[Answer]
## Perl
```
$_
= "Repeating myself"
;print"$_\nis like $_.\n$_.\n";
```
How to read it out loud:
```
dollar underscore
equals repeating myself
print nis like line noise.
```
Output:
```
Repeating myself
is like Repeating myself.
Repeating myself.
```
[Answer]
## INTERCAL
INTERCAL has limited output capabilities, but "limited capabilities" has never stopped me from writing an INTERCAL program!
```
DO READ OUT #18
+#3301
+#214
PLEASE GIVE UP
```
Please read [out] this as:
```
Do read out eighteen,
Three thousand three hundred one,
Two hundred fourteen.
```
(Note that my boilerplate is at the end of the program instead of at the beginning.) 
The program produces the output:
```
XVIII
MMMCCCI
CCXIV
```
Which, when spoken aloud, goes:
```
Ex vee eye eye eye,
Em em em cee cee cee eye,
Cee cee ex eye vee.
```
[Answer]
## CoffeeScript
With tongue firmly in cheek, I present CoffeeScript:
```
here = "my haiku"
were_doomed() unless 1 is 1
alert Date.now()
```
Pronounced:
```
Here is my haiku
We're doomed unless one is one
alert date dot now
```
If your timing is right (!), your output might be e.g. 1337181872717, pronounced:
```
one three three seven
one eight one eight seven two
seven one seven
```
Considering my first run at this was one microsecond out from a valid haiku response, I think that's zen enough to qualify!
NB: I'd be happy to hear sufficiently zen alternatives for my first two (admittedly weak) lines.
[Answer]
# J
Program:
```
p:i.4
*:*:*:i.3
!8
```
Read (substituting verb names):
```
Prime Integers Four
Square Square Square Integers 3
Factorial Eight
```
Output (read numbers out loud):
```
2 3 5 7
0 1 256                          (Read: Zero One Two-Fifty-Six)
40320                            (Read: Forty Three-Twenty)
```
[Answer]
## Python
Code:
```
for _ in range(1,3):
    print 'Hi ' * 5, 'there ' *  2 * (-1+_) 
print 'I now', 'go ' * 3
```
How to read:
```
for in range one three
print hi five there two one plus
print i now go three
```
Output:
```
Hi Hi Hi Hi Hi  
Hi Hi Hi Hi Hi  there there 
I now go go go 
```
Working sample: <http://ideone.com/hDniW>
[Answer]
## logo
Here's a Haiku procedure that's also a quine procedure (easy because of logo's introspection capability)
```
to better_yourself
  printout "better_yourself
end ; as you began
```
Read as
> 
> To better yourself  
> 
>  Print out quote better yourself  
> 
>  End as you began
> 
> 
> 
[Answer]
# JavaScript (doesn't work in Firefox)
```
             (function haiku() { with (
console) log ((('' + haiku). // output
replace)     (/[ !-@{-~[-^]+/gim, ' ')); void haiku })()
```
works except for mozilla  
javascript engine and shows  
spelling after ran
[Answer]
## Ruby
```
"A ruby haiku.
Why, yes, it is."; print open(
__FILE__).read #this now, please.
```
Read as:
```
A ruby haiku.
Why, yes, it is. Print open
file. Read this now, please.
```
It doesn't flow very well, unfortunately. In my defense, it *is* 12:50am...
[Answer]
# Python
(Only read the first level of parentheses (not the second)).
Code and how to read:
```
for e in range(3):                      # for e in range three
    if True is False: what = then       # if true is false, what is then?
    print "oh " * (5 + 2 * (e & 1))     # print oh times _seven_
```
Output, probably most basic haiku in the world:
```
oh oh oh oh oh
oh oh oh oh oh oh oh
oh oh oh oh oh
```
[Answer]
# Python (2 entries)
## Entry 1: A haiku in time
You need to save this in a file and run it from the same directory. This haiku very slowly prints itself out to screen, a poem in words and time.
```
from time import sleep
for line in open(__file__):
  print line; sleep(len(line))
```
## Entry 2: A haiku without symbolism
This is similar to the above, but was an attempt to write a Python haiku that used just keywords and minimal brackets or substitutions of symbols (eg. `=` pronounced as "is").
```
if __file__ is not None:
 for line in open(__file__):
  print not False and line
```
[Answer]
# Tcl
Here's a self-documenting, self-outputting, example:
```
catch {me as I make}
proc unknown args {puts [read $args]}
[open [info script]]
```
[Answer]
# Vim
```
ia0 <esc><c-x>
YpA-<esc>
px5<c-x><c-x>
```
read as
```
i a zero x
Y p A hyphen escape
p x five x x
```
Writes:
```
a-1
a-1-
-7
```
read as:
```
a negative one
a minus one negative
negative seven
```
[Answer]
# Python 3
```
print(print.__doc__[:15])
print(print.__doc__[13:][:13])
print(print.__doc__[32])
```
Read as:
```
print print doc one five
print print doc one three one three
print print doc three two
```
Prints:
```
print(value, ..
..., sep=' ',
\
```
Read as:
```
print value dot dot
ellipses, sep equals blank
reverse solidus
```
]