Hello, world

I was amused at some of the archetypal "Hello Worlds" for various Java frameworks. For reference, I'll include an assembly version first:


; This program displays "Hello, World!" in a windows messagebox and then quits.
;
; Written by Stewart Moss - May 2006
;
; Assemble using TASM 5.0 and TLINK32
;
; The output EXE is standard 4096 bytes long.
; It is possible to produce really small windows PE exe files, but that
; is outside of the scope of this demo.

.486p
.model flat,STDCALL
include win32.inc

extrn MessageBoxA:PROC
extrn ExitProcess:PROC

.data

HelloWorld db "Hello, world!",0
msgTitle db "Hello world program",0

.code
Start:
push MB_ICONQUESTION + MB_APPLMODAL + MB_OK
push offset msgTitle
push offset HelloWorld
push 0
call MessageBoxA

push 0
call ExitProcess
ends
end Start


Now, Java's Swing framework:


import javax.swing.JFrame; //Importing class JFrame
import javax.swing.JLabel; //Importing class JLabel
public class HelloWorld {
public static void main(String[] args) {
JFrame frame = new JFrame(); //Creating frame
frame.setTitle("Hi!"); //Setting title frame
frame.add(new JLabel("Hello, world!"));//Adding text to frame
frame.pack(); //Setting size to smallest
frame.setLocationRelativeTo(null); //Centering frame
frame.setVisible(true); //Showing frame
}
}


And my favorite, the very poorly-named tinystruct 2.0:


package tinystruct.examples;

import org.tinystruct.AbstractApplication;
import org.tinystruct.Application;
import org.tinystruct.ApplicationException;
import org.tinystruct.system.ApplicationManager;

public class hello extends AbstractApplication {

@Override
public void init() {
// TODO Auto-generated method stub
this.setAction("say", "say");
}

@Override
public String version() {
// TODO Auto-generated method stub
return null;
}

public String say(String words){
System.out.println(words);
return "<h1>"+words+"</h1>";
}

/**
* @param args
* @throws ApplicationException
*/
public static void main(String[] args) throws ApplicationException {
// TODO Auto-generated method stub
// Praise to the Lord!
ApplicationManager.install(new hello());

// to print 'Hello World'
ApplicationManager.call("say/Hello World", null); // Hello World

// or...
Application app=ApplicationManager.get( hello.class.getName());
app.invoke("say", new Object[]{"<h1>Hello, World!</h1>"}); // <h1>Hello, World!</h1>
app.invoke("say", new Object[]{"<h2>Bye!</h2>"}); // <h2>Bye!</h2>

// or...
// http://localhost:8080/?q=say/Hello World
// https://github.com/m0ver/tinystruct2.0
}

}


So there you have it: Java is so bloated that it can actually take more lines of code to do something than it would in x86 assembly. I guess eventually in theory it would pay off, but why the fuck does anyone use this language? I feel like it's some kind of joke.

>>6
It's all about the resume.

And JOptionPane.showMessageDialog(...) aside, comparing languages on this basis is rather silly, because the language in question isn't really being used^* - just the calling interface to a few functions in a library or such. Representative samples are fine, but at some point of triviality they stop being useful. For example, the equivalent in HQ9 (or CHIQRSX9+ for the ambitious among you) is just

H

, which is about as terse as you can get without resorting to languages that are made up on the spot, but I don't think any of you would take that as a serious argument in favor of the language.

IHNBT, this smells too much like pasta

^{* No mathematical operations, no flow control, no declaration of functions, in fact nothing I would call a variable at all besides a few spurious constructors on the Java side. I'd much prefer to see fizzbuzz or a couple of different-styled implementations of fib(n)}