Executable haiku that outputs a haiku

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

Piet, 867 executing color blocks

Grand Prize, you say? This has codel size of 2.

Output:

SPRING EVER RETURNS
NEVER EXACTLY THE SAME
THIS IS NOT A QUINE

This challenge was fun! I've written a Piet instruction encoder 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

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))