Mais um blog inútil.

hpux$ cat arvorezinha.S
        .LEVEL 1.1							; cenas gays do hpux
        .SPACE $PRIVATE$						; o HPPA funciona por spaces, ler arch book
        .SUBSPA $DATA$,QUAD=1,ALIGN=8,ACCESS=31				; pra mais informacoes ou esquizofrenia antecipada
        .SUBSPA $BSS$,QUAD=1,ALIGN=8,ACCESS=31,ZERO,SORT=82
        .SPACE $TEXT$
        .SUBSPA $LIT$,QUAD=0,ALIGN=8,ACCESS=44
        .SUBSPA $CODE$,QUAD=0,ALIGN=8,ACCESS=44,CODE_ONLY
        .IMPORT $global$,DATA
        .IMPORT $$dyncall,MILLICODE
        .IMPORT write,CODE						; eh mais simpatico fazer imports
        .IMPORT exit,CODE
        .IMPORT __main,CODE
        .SPACE $TEXT$
        .SUBSPA $LIT$

        .align 4
STAR
        .STRING "\x2a\x00"
LF
        .STRING "\x0a\x00"
        .SPACE $TEXT$
        .SUBSPA $CODE$

        .align 4
        .NSUBSPA $CODE$,QUAD=0,ALIGN=8,ACCESS=44,CODE_ONLY
        .EXPORT main,ENTRY,PRIV_LEV=3,RTNVAL=GR				; a cena dos privilege levels eh funny
main
        .PROC
        .CALLINFO FRAME=64,CALLS,SAVE_RP,SAVE_SP,ENTRY_GR=3
        .ENTRY
        .CALL
        xor     %r4,%r4,%r4						; aka meter %r4 a zero :)

arewedoneyet
        comib,=,n 5,%r4,kk10xbai					; se %r4 for 5, BAI NAO!
        nop
        xor     %r3,%r3,%r3						; inicializar o counter do segundo loope

letsdothis
        comb,<=,n %r3,%r4,estrela					; se o %r3 for menor ou igual a %r4
        xor %r1,%r1,%r26						; sim, isto eh um nop							

        ldi 1,%r26							; escolher o fd (1 eh stdout)
        ldil LR'LF,%r19							; copiar a stringue com
        ldo RR'LF(%r19),%r25						; paneleirices...
        ldi 1,%r24							; length da stringue
        .CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
        bl write,%r2
        xor %r1,%r2,%r3							; sim, isto eh um nop

        addi    1,%r4,%r4						; incrementar o %r4
        b       arewedoneyet
        shladd %r4,2,%r8,%r15						; sim, isto eh um nop

estrela
        ldi 1,%r26							; ver outro write
        ldil LR'STAR,%r19						; eh a mm merda
        ldo RR'STAR(%r19),%r25
        ldi 1,%r24
        .CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
        bl write,%r2
        add %r13,%r14,%r15						; sim, isto eh um nop

        addi    1,%r3,%r3
        b       letsdothis
        nop								; adivinha...

kk10xbai
        ldi 0,%r26
        .CALL ARGW0=GR
        bl exit,%r2
        shrpw %r8,%r7,8,%r9     ; nop nop nop
        subi,OD  42,%r3,%r12    ; nop nop nop nopppppp! :D
        .EXIT
        .PROCEND
hpux$ gcc arvorezinha.S
*
**
***
****
*****
hpux$

solaris$ cat arvore.S
.section  ".rodata1"
.align    4
.L0:
        .ascii           "*\0"
.L1:
        .ascii          "\n\0"

.L2:
        .ascii          "bla\n\0"

        .section        ".text"
        .global         main
main:
        save            %sp,-96,%sp
        mov 0,%g2

arewedoneyet:
        cmp %g2,5       ! comparar com RFC_MAX pois claro, n eh preciso registry pra isto
        be weredonefaggot

        mov 0,%g3       ! inicializar counter1

estrelitas:
        cmp %g3,%g2     ! ah e tal, compara-me a pissa, less or equal?
        ble estrela

        set .L1,%o0     ! meter LF no output register, e mandar printar
        call printf

        inc %g2         ! increasar o counter2
        ba arewedoneyet

estrela:
        set     .L0,%o0 ! printar estrelinha
        call    printf

        inc %g3
        ba estrelitas

weredonefaggot:
        nop
        restore

solaris$ gcc arvore.S -o arvorezinha
solaris$ ./arvorezinha
*
**
***
****
*****
solaris$

true64> gcc arvore.S -o arvorezinha
true64> ./arvorezinha
*
**
***
****
*****
true64> cat arvore.S
.data
LF:             .ascii          "\n\0"
GAY:            .ascii          "*"

.text
        .align  4
        .set    noreorder
        .arch   ev4
        .globl  main
        .ent    main

main:
        ldgp    $gp,0($27)		# load ao global pointer
        stq     $26,0($sp)			# inicializar o stack pointer (só naquela)

        lda $10,5                       	# RFC_MAX para o loop principal
        lda $9,0				# counter do loop1

loop1:
        cmpeq $9,$10,$7			# se $9 igual $10, branchar para o final
        bne $7,final

        lda $11,0				# counter para o loop2

loop2:
        cmple $11,$9,$7			# se $11 menor ou igual q $9, estrelar!
        bne $7,estrela

        lda $16,LF				# new line pl0x
        jsr $26,printf
        ldgp $gp,0($26)

        lda $9,1($9)			# uma maneira gay de incrementar
        br loop1

estrela:
        lda     $16,GAY			# printar estrelinha...
        jsr     $26,printf			# é sempre preciso fazer reset ao $gp
        ldgp    $gp,0($26)		# depois de usar uma função

        addq $11,1,$11			# outra maneira gay de incrementar :p
        br loop2

final:
        mov     $31,$0                  # return = 0
        ldq     $26,0($sp)              # limpar a stacka, se bem q nao foi usado mas pronto..
        ret     $31,($26),1             # returnarrrrrrrrr
        .end    main

true64>

#include <iostream>

enum
{
	LIMIT = 5+1
};

template <int x>
void inner(void)
{
	std::cout << '*';
	inner<x-1>();
}

template <>
void inner<0>(void){}

template <int x>
void outer(void)
{
	inner<x>();
	std::cout << std::endl;
	outer<x+1>();
}

template<>
void outer<LIMIT>(void){}

int main(int argc, char **argv)
{
	outer<1>();
	return 0;
}

/* this script can never fail */
MAX = 5
do i = 1 to MAX by 1
	linha = ""
	do x = 1 to i by 1
		linha = linha || "*"
	end
	say linha
end

/* this crap can never fail */

package main

import "os"

func main() {
	var RFC_MAX int = 5
	for i := 1; i <= RFC_MAX; i++ {
		for x := 0; x < i; x++ {
			os.Stdout.WriteString("*")
		}
		os.Stdout.WriteString("\n")
	}
}

* -------------------------------------------can never fail-
* Program    : arvorezinha
* Written by : Pedro de Oliveira
* Date       : 16/05/2010
* Description: Implementação da arvorezinha em 68K assembly 
*-----------------------------------------------------------
        ORG     $1000
START:                          ; first instruction of program

main:
        MOVE.B  #5,d7           ; maximo de linhas/asteriscos
                                ; está a usar o RFC standard 5
        MOVE.B  #0,d5           ; inicializa o counter1 (d5) a 0

ciclo1:
        CMP.B   d5,d7           ; verifica se chegamos o fim
                                ; comparando o counter1 ao maximo
        BEQ     final           ; se for igual salta para o fim
	
        MOVE.B  #0,d6           ; inicializa o counter2 (d6) a 0

ciclo2:
        CMP.B   d5,d6           ; compara o counter1 com o counter2
        BEQ     estrela         ; se for igual
        BLT     estrela         ; ou menor imprime um asterisco
	
        LEA     newline,a1      ; imprime uma newline
        JSR     print
	
        ADD     #1,d5           ; incrementa o counter1
        JMP     ciclo1          ; salta para o ciclo1

estrela:
        LEA     _estrel,a1      ; imprime um asterisco
        JSR     print
	
        ADD     #1,d6           ; incrementa o counter2
        JMP     ciclo2          ; salta para o ciclo2

final:
        MOVE.B  #9,D0
        TRAP    #15             ; halt simulator

print:
        MOVE.B  #14,d0
        TRAP    #15
        RTS

* Variables and Strings

_estrel	DC.B    '*',0
newline DC.B    $0D,$0A,0

        END     START           ; last line of source

#!/bin/bash

ramo="*";
tam="7";
i="1";

while [ $i -lt $tam ]; do
j="1";
while [ $j -lt $i ]; do
printf "$ramo"
j=$[$j+1]
done
printf "\n"
i=$[$i+1]
done

printf "\n\n"

#!/home/diogo/Tea/tea-3.2.5/bin/tsh

#   Esta é uma arvorezinha escrita em Tea,
#   de acordo com o rfc da arvorezinha praticado
#   em http://www.blol.org/

#   version 0.1

#   This script can never fail!

define arvorezinha ""
define estrelinha "*"
define fiter 1

while { < $fiter 6 } {
define siter 0
while { < $siter $fiter } {
set! arvorezinha [str-cat $arvorezinha $estrelinha]
set! siter [+ $siter 1]
}
set! arvorezinha [str-cat $arvorezinha "\n"]
set! fiter [+ $fiter 1]
}

echo $arvorezinha

#!/home/diogo/Tea/tea-3.2.5/bin/tsh


#   Esta é uma arvorezinha escrita em Tea,
#   de acordo com o rfc da arvorezinha praticado
#   em http://www.blol.org/

#   version 0.2
#   Changes:
#	* now with an OOP paradigm



#   This script can never fail!



class LitleTree (
    _max_size
    _branch
)

method LitleTree constructor () {
    #Blol.org Arvorezinha RFC COMPLIANT
    set! _max_size 5
    set! _branch "*"
}

method LitleTree PleaseSaveSortelha () {
    echo "Por favor, salva a Sortelha!!!"
    echo "http://vamossalvarsortelha.blogspot.com/"
}

method LitleTree PlantLitleTree () {
    define small_tree
    set! small_tree ""
    define i 0

    while { < $i $_max_size  } {
	set! i [ + $i 1 ]
	define f 0
    	while { < $f $i } {
	    set! f [+ $f 1]
	    set! small_tree [str-cat $small_tree $_branch]
	}
	set! small_tree [str-cat $small_tree "\n"]
    }

    echo $small_tree
}




#serious business:
define litle_tree [ new LitleTree ]
$litle_tree PleaseSaveSortelha
echo "\n"
$litle_tree PlantLitleTree

  i i i i i i i       ooooo    o        ooooooo   ooooo   ooooo
  I I I I I I I      8     8   8           8     8     o  8    8
  I  \ `+' /  I      8         8           8     8        8    8
   \  `-+-'  /       8         8           8      ooooo   8oooo
    `-__|__-'        8         8           8           8  8
        |            8     o   8           8     o     8  8
  ------+------       ooooo    8oooooo  ooo8ooo   ooooo   8
Welcome to GNU CLISP 2.47 (2008-10-23) <http://clisp.cons.org/>
Copyright (c) Bruno Haible, Michael Stoll 1992, 1993
Copyright (c) Bruno Haible, Marcus Daniels 1994-1997
Copyright (c) Bruno Haible, Pierpaolo Bernardi, Sam Steingold 1998
Copyright (c) Bruno Haible, Sam Steingold 1999-2000
Copyright (c) Sam Steingold, Bruno Haible 2001-2008
Type :h and hit Enter for context help.
[1]> (loop
    (loop for i from 1 to 4 do
        (loop for j from 1 to i do
            (write-char #\*)
        )
        (terpri)
    )
    (return '*****)
)
*
**
***
****
*****