"Hello Ubuntu" in every programming language

[bgs100]

Common Lisp

(format t "Hi! What's your name?~%")
(defvar *name* (read-line))
(format t "Hello, ~a! Welcome to Ubuntu!~%" *name*) 

[Ariel David Moya Sequeira]

Some more Linux Assembly code:

GNU Assembly (GAS) - Linux x86

// Segment for initialized data (contents and size of all strings needed)
.section .data
    question:
        .ascii "Hi! What's your name? "
        .equ question_length, . - question
    greeting:
        .ascii "Hello, "
        .equ greeting_length, . - greeting
    welcome:
        .ascii "! Welcome to Ubuntu!\n"
        .equ welcome_length, . - welcome

// Segment for uninitialized data (the user's name, up to 256 characters)
.section .bss
    .lcomm name, 256

// A macro definition to output a string 'string' of size 'string_size' to console.
.macro write string, string_size
    movl  $4, %eax                  // 'Write to buffer' kernel service in EAX
    movl  $1, %ebx                  // Standard output buffer handle in EBX
    movl  \string, %ecx             // String address in ECX
    movl  \string_size, %edx        // String size in EDX 
    int   $0x80                     // Linux kernel software interrupt
.endm


.section .text
.globl _start

    _start:
        write $question, $question_length
        
        movl  $3, %eax              // 'Read from buffer' kernel service in EAX
        movl  $0, %ebx              // Standard input buffer handle in EBX
        movl  $name, %ecx           // Destination string address in ECX
        movl  $256, %edx            // String size in EDX
        int   $0x80                 // Linux kernel software interrupt
        pushl %eax                  // The amount of bytes actually read is returned in EAX.
                                    //   It has to be pushed in order to use it later.
        
        write $greeting, $greeting_length
                
        popl %edx                   // The size of 'name' is retrieved in EDX.
        decl %edx                   // 'name' includes a newline character at its end.
                                    //   So, it has to be excluded from output.
        write $name, %edx           // The name is output to console, without the newline.
        
        write $welcome, $welcome_length
        
        movl $1, %eax               // 'Terminate program' kernel service in EAX
        xorl %ebx, %ebx             // Return code in EBX.
                                    //   0 usually means the program succesfully terminated.
        int $0x80                   // Linux kernel software interrupt

[Ariel David Moya Sequeira]

Sample of a dialect of the seemingly forgotten LOGO...

TurtleScript

$name = ask "Hi! What's your name?"
message "Hello, " + $name + "! Welcome to Ubuntu!"

[Krupski]

"Hello Ubuntu" in every programming language

Motorola 68HC11 assembler:

regbs   equ     $1000           ;register base
scsr    equ     regbs+$2e       ;sci status reg
scdr    equ     regbs+$2f       ;sci data reg


        org     $2000           ;stick it in sram


start   clrb                    ;b=0
        stab    curpos          ;init cursor position to 0

        ldx     #msg1           ;point to prompt
        jsr     outstrg         ;display it


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; this is the main user input loop
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

main    jsr     input           ;read serial term
        beq     main            ;wait for a key

        cmpa    #3              ;ctrl-c?
        beq     exit            ;yes, exit
        cmpa    #27             ;escape?
        bne     main2           ;no, run program

exit    swi                     ;quit received, exit!

main2   cmpa    #13             ;c/r?
        beq     finish          ;yes, finish up

        cmpa    #8              ;backspace?
        beq     do_bs           ;yes, do it

        ldx     #buffer         ;point to buffer
        ldab    curpos          ;get cursor position
        cmpb    #bufsiz         ;at end?
        bhs     chrout          ;at end, can't do anything

        abx                     ;x points to current char
        staa    0,x             ;write char to buffer

        incb                    ;move fwd 1 position
        stab    curpos          ;update cursor position

        jsr     output          ;echo char to term

chrout  jmp     main            ;return to main loop


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; got the user string - print req'd stuff & exit
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


finish  clra                    ;a=0
        staa    1,x             ;null last char

        ldx     #msg2           ;"Hello..."
        jsr     outstrg         ;display it

        ldx     #buffer         ;point to input buffer
        jsr     outstrg         ;display it

        ldx     #msg3           ;"..welcome to ubuntu"
        jsr     outstrg         ;display it

        swi                     ;return to monitor



;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; do backspace
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

do_bs   ldx     #buffer         ;point to buffer
        ldab    curpos          ;get cursor position
        beq     dobsout         ;at beginning, can't do anything

        decb                    ;backup 1 position
        stab    curpos          ;update cursor position

        abx                     ;x points -> current char in buffer

        ldaa    #$ff            ;a = $ff
        staa    0,x             ;erase char in buffer

        ldaa    #8              ;load backspace
        jsr     output          ;print backspace to term

        ldaa    #' '            ;load a space
        jsr     output          ;erase char on term

        ldaa    #8              ;load backspace
        jsr     output          ;backup cursor on term

dobsout jmp     main            ;return to main loop



;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; input (read) data from serial port
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

input   ldaa    scsr            ;read status reg
        anda    #%00100000      ;check rdrf flag
        beq     input2          ;exit w/a=0 if no data

        ldaa    scdr            ;read serial data

input2  rts                     ;return


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; output (write) data to serial port
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

output  psha                    ;save a
        ldaa    scsr            ;read sci status register
        coma                    ;invert bits
        bita    #%11000000      ;test tdre & tc
        pula                    ;restore a
        bne     output          ;sci busy, check again

        staa    scdr            ;send character
        rts


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; out string (print) string to serial port
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

outstrg pshx                    ;save x

outs2   ldaa    0,x             ;get a char
        beq     outs3           ;done

        bsr     output          ;send character out
        inx                     ;increment buffer ptr
        bra     outs2           ;send next

outs3   pulx                    ;restore x
        rts                     ;return

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; text messages for terminal
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

msg1    dc.b    $0d,$0a
        dc.b    "Hi!  What's your name? "
        dc.b    0

msg2    dc.b    $0d,$0a
        dc.b    "Hello, "
        dc.b    0

msg3    dc.b    "! Welcome to Ubuntu!"
        dc.b    $0d,$0a,0

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; buffers & vars in 'hc11 sram
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

        org     $100            ;evbu ram

buffer  ds.b    32              ;incoming data buffer
bufsiz  equ     *-buffer        ;size of buffer
curpos  ds.b    1               ;cursor position

Program running under HC11 EVBU BUFFALO Monitor:

>load

OK-2000 
>g 2000

Hi!  What's your name? Roger Ramjet
Hello, Roger Ramjet! Welcome to Ubuntu!

P-204C Y-FFFF X-20B9 A-00 B-0C C-D5 S-003F CC-nZvC
>

-- Roger

[Natilator3]

C++/Gtkmm

// compile with g++ helloubuntu.cpp -o helloubuntu `pkg-config gtkmm-2.4 --cflags --libs`

#include <gtkmm/main.h>
#include <gtkmm/window.h>
#include <gtkmm/button.h>
#include <gtkmm/label.h>
#include <gtkmm/entry.h>
#include <gtkmm/box.h>

class HelloUbuntu : public Gtk::Window
{
	protected:
	// signal handlers:
	virtual void on_button_click();
	// widgets:
	Gtk::Button button;
	Gtk::Entry entry;
	Gtk::Label label;
	Gtk::VBox box;
	public:
	HelloUbuntu();
};

HelloUbuntu::HelloUbuntu()
{
	set_title("Hello Ubuntu!");
	set_border_width(10);
	button.set_label("Okay");
	label.set_text("Please enter your name.");
	
	button.signal_clicked().connect(sigc::mem_fun(*this, &HelloUbuntu::on_button_click));
	
	box.pack_start(label, Gtk::PACK_EXPAND_PADDING, 5);
	box.pack_start(entry, Gtk::PACK_EXPAND_PADDING, 5);
	box.pack_start(button, Gtk::PACK_EXPAND_PADDING, 5);
	
	add(box);
	
	show_all();
}

void HelloUbuntu::on_button_click()
{
	label.set_text("Hello, " + entry.get_text() + ", welcome to Ubuntu!");
}

int main(int argc, char *argv[])
{
	Gtk::Main kit(argc, argv);
	HelloUbuntu helloubuntu;
	Gtk::Main::run(helloubuntu);
	return 0;
}

[Can+~]

MIPS Assembly
(emulated on SPIM)

.data
.align 0
	hwrld:	.asciiz  "Hello Ubuntu!\n"
.text
.globl main

main:
	li $v0, 4	# I/O instruction
	la $a0, hwrld	# Copy memory address to argument registry.
	syscall		# System Call
	
	j	quit	# Jump to quit

quit:
	li $v0, 10
	syscall

(Old post is old)

[leedrew]

#Hi Ubuntu
def main():
name = raw_input("enter your name, ")
print ('Hello welcome to the Ubuntu forrum,'), name

main()

enter your name, drew
Hello welcome to the Ubuntu forrum, drew
>>>

This one worked.

[Tech2077]

import javax.swing.*;

public class HelloUbuntu extends JFrame {
     JLabel Hello = new JLabel("Hello Ubuntu");
     
     public HelloUbuntu() {
           super("Hello Ubuntu!");
          setSize(250,50);
          setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
          JPanel pane = new JPanel();
          pane.add(Hello);
          add(pane);
          setVisible(true);
     }
     
     public static void main(String[] args) {
           HelloUbuntu hu = new HelloUbuntu();
     }
     
}

Java Swing Frame With "Hello Ubuntu!" Label

[vexorian]

Zinc
:

library HelloUbuntu
{
    function onInit()
    {
        BJDebugMsg("Hello ubuntu");
    }
}

/* Feature creep version */
// shows Hello Ubuntu every 0.2 seconds
//
library HelloUbuntu requires TimerUtils
{
    type stringFunc extends function(string);
    struct stringDoer
    {
        string s;
        stringFunc func;
        method do()
        {
            timer t = NewTimer();
            SetTimerData(t, this);
            TimerStart(t, 0.2, true, function(){
               thistype this = GetTimerData(GetExpiredTimer());
               func.evaluate(s);
            });
        }
    }

    function onInit()
    {
        stringDoer sd = stringDoer.create();
        sd.s = "Hello ubuntu";
        sd.func = function(string msg){
            BJDebugMsg(msg);
        };
        sd.do();
    }


}

[shadowh511]

LOLCODE 1.3

http://www.icanhaslolcode.org/ I used that interpreter to write this gem

HAI 1.3
 VISIBLE "WELKUM 2 UBUNTU!, WHAT R YR NAEM?:)"
 I HAS A NAME ITZ A YARN
 GIMMEH NAME
 VISIBLE "HEY THERE :{NAME} WELKUM 2 UBUNTU"
KTHXBYE