Unsere 1. App-Entwicklung wurde mit xCode 4 durchgeführt. Zuerst wurde ein Layout in Photoshop CS5 erstellt, wie die App im fertigen Zustand aussehen soll.

Das Grundgerüst hat der Entwickler dann in xCode nachgebaut. Jeder der App Beteiligten hat auf seinem Laptop mittels VCS Subversion V1.6 lokal einen Ordner angelegt, in diesem das Projekt samt Dateien und Bilder gespeichert wurde.

Nach und nach wurden aus dem Photoshop Layout einzelne Grafiken abgespeichert, diese im Images Ordner abgelegt und im xCode Projekt eingepflegt.

Was ist dabei zu beachten?
Die Grafiken müssen nach Abspeichern im lokalen Projektordner auch noch im xCode Projekt dem Projekt hinzugefügt werden, indem man im xCode mit Rechtsklick auf den Ordner “Images” klickt und dann “Add files to …”.

Danach müssen die neu hinzugefügten Daten noch commited werden, damit der Projektpartner die Änderungen auch auf seinem Arbeitsplatz sehen und damit arbeiten kann.

Farblehre für unsere xCode Anwendung
Die Farbangaben werden in xCode nicht in reinen RGB Werten angezeigt.
Hier ein Beispiel aus unserem Clock View: { 255.0/255.0f, 217.0/255.0f, 83.0/255.0f, 1.0f }  Das ist die Farbe Gelb vom Ziffernblatt.
Der 1. Wert von 255.0/255.0f ist beispielsweise der 1. RGB Wert = Rot
Der 2. Wert 217.0/255.0f ist Grün und der 3. Wert von 83.0/255.0f ist Blau.
Der 4. Wert steht für den Alpha Wert.

Wie kommen die Werte zustande?
Erklären ist das Ganze so, dass der Wert vor dem Slash der RGB Farbwert ist und man die 255.0f nach dem Slash erstmal nicht zu beachten braucht. Das f steht für den float. Ist der Alpha-Wert 0.0, so ist die Farbe vollkommen transparent, ist er 1.0, so ist die Farbe opak.

Wie sind die Grafiken abzuspeichern?
iPhone 3GS/iPad: reichen die 72dpi und die normale Größe des iPhones. Das heißt 320 x 480Pixel.
Für die 4. Generation des iPhones und alle Retina Displays ist die Auflösung von 72dpi auch noch ausreichend. Allerdings wird hier empfohlen die Grafiken mit der doppelten Pixelanzahl zu belegen. Das heißt wenn eine Grafik, zum Beispiel ein Logo für das iPhone 3GS/iPad eine Größe von 120 x 80 Pixel hat, ist die Größe für Retina Displays 240 x 160 Pixel.

Wenn der Entwickler nun etwas programmiert hat committed er die Dateien somit die anderen Personen, die an dem Projekt mitarbeiten, sich ein “Update” ziehen können.

Wozu ist das gut?
Somit sind beide Parteien immer auf dem aktuellen Stand. Entwickelt nun der Entwickler und der Gestalter an der selben Datei und beide wollen die Datei gleichzeitig committen wird gefragt, ob die Datei “gemerged” werden soll. Das heißt, die Änderungen der einzelnen Personen werden erst aufgezeigt und dann werden beide Änderungen in die eine Datei zusammengeführt und diese eine Datei wird dann abgespeichert. Wer das nun nicht verstanden hat kann sich hier zum Thema “Merge” noch einmal schlau lesen.

Wer kann die Apps verwalten?
Es kann pro Firma 1 Agent bei Apple angelegt sein. Das bedeutet, dass 1 Person die neu erstellte App im App-Store anmelden kann. Wenn man eine Entwickler ID hat (kostenlos) und von dem TeamAgent dann in das Entwicklerteam eingebunden/eingeladen wird, dann kann der Entwickler mit der kostenlosen ID auch Applikationen auf einem Testgerät ausführen, welches vom selben TeamAgent als Entwicklungsgerate für sein Team registriert wurde.

Fazit
Das Zusammenspiel zwischen Entwickler und Gestaltung war sehr spannend, da immer kleine Neuerungen vom Entwickler kamen, wie in unserem Fall zum Beispiel das Erscheinen eines Wasserdampfes. Und für mich, die Gestalterin war es super anzusehen wie meine Grafiken langsam in der App Gestalt annahmen.

Nutzer der Apple Mac OS X Betriebssystemfamilie greifen dabei gerne auf das Softwarepaket GPGTools zurück. Eine deutsche Installationsanleitung erlaubt selbst technischen Laien eine problemlose Installation der Software.
Unabhängig davon, ob man einige der Funktionen nun direkt aus irgendwelchen Anwendungen nutzen will, kann ein gewöhnlicher Anwender unter Mac OS 10.7 (Lion) weder ent- noch verschlüsseln. Und das sollte generell schon möglich sein!

Schaut man in der Konsole Anwendung, fallen einem Meldungen der Art

08.10.11 09:43:30,335 org.gpgtools.macgpg2.gpg-agent: gpg-agent[5844]: 
    error binding socket to `/Users/myuser/.gnupg/S.gpg-agent': Invalid argument

ins Auge. Und man stellt fest, daß der persönliche GPG Agent nicht läuft.

$ ps uxw | grep gpg

bzw.

$ launchctl list | grep gpg
	-	(2) org.gpgtools.macgpg2.gpg-agent

Die Zahl in Klammern ist die Fehlernummer, welcher beim Startversuch des Agenten auftritt.

Nun gut, sucht man im Internet … dann findet man zu diesem Thema einige Konversationen direkt mit den Entwicklern der Software.
1. Diskussion vom Januar 2011
2. Diskussion vom Juni 2011
Und siehe da, man erkennt sofort es werden bei Mac OS 10.7 (Lion) viel häufiger als in den vorhergehenden Versionen dieser Betriebssystemfamilie sogenannte ACLs (= Access Control Lists, zu deutsch sind damit erweiterte Zugriffsberechtigungen auf Dateiebene gemeint) verwendet werden.

Beheben wir zunächst das Problem, und schauen uns dieses Phänomen danach noch etwas genauer an (in einem meiner nachfolgenden Beiträge).

So nimmt man alle ACLs vom benutzereigenen GnuPG Verzeichnis weg …

$ cd ~
$ chmod -R -a# 0 .gnupg

… dann startet man den Agenten erneut und schaut, ob er diesmal läuft …

$ launchctl start org.gpgtools.macgpg2.gpg-agent
$ launchctl list | grep gpg
213	-	org.gpgtools.macgpg2.gpg-agent

Die Zahl vorne ist die Prozeßkennung des Agenten.

Bei Interesse kann man sich Details zum Agenten anzeigen lassen …

$ launchctl list org.gpgtools.macgpg2.gpg-agent

… und das sollte etwa so aussehen.

{
	"Label" = "org.gpgtools.macgpg2.gpg-agent";
	"LimitLoadToSessionType" = "Background";
	"OnDemand" = true;
	"LastExitStatus" = 0;
	"PID" = 213;
	"TimeOut" = 30;
	"ProgramArguments" = (
		"/usr/local/MacGPG2/bin/gpg-agent";
		"--launchd";
		"--write-env-file";
	);
};

Und jetzt klappt auch die Ent- und Verschlüsselung wieder, bspw. …

$ gpg -d -o decoded.file encoded.file 
Sie benötigen eine Passphrase, um den geheimen Schlüssel zu entsperren.
Benutzer: "Martin Rastetter <martin@baden.de>"
1024-Bit ELG Schlüssel, ID EE827F34, erzeugt 2005-01-09 (Hauptschlüssel-ID D94AFAD0)
gpg: verschlüsselt mit 1024-Bit ELG Schlüssel, ID F3D63379, erzeugt 2008-11-03
      "Fritz Fuchs <fritzle@schwaben.de>"
gpg: verschlüsselt mit 1024-Bit ELG Schlüssel, ID EE827F34, erzeugt 2005-01-09
      "Martin Rastetter <martin@baden.de>"
gpg: Signatur vom Mi 27 Mai 12:01:06 2009 CEST mittels DSA-Schlüssel ID 63525EE3
gpg: Korrekte Signatur von "Fritz Fuchs <fritzle@schwaben.de>"
Haupt-Fingerabdruck  = CA62 6DD9 CE88 4D3D 0621  1343 6806 7B58 6352 5EE3

Bestens, ab jetzt können wir wieder mit GnuPG arbeiten wie wir es bisher gewohnt waren.

Wir erstellen ein kleines und bekanntes Script:

und speichern dies als “Script” auch ab.

Jetzt öffnen wir eine neues Realbasic-Projekt und ziehen unter “Projekt” einfach per Drag and Drop das Script hinein.

Nun fügen wir einfach unter “Window1 -> Open” den Namen des Scriptes ein

und schon können wir das Realbasic-Projekt starten.

Kaum ist das Fenster geöffnet, hört man schon wie iTunes seine Playlist abspielt.

Das unverständliche dabei ist: einige User sagen bei ihnen funktioniert alles einwandfrei. Andere haben – genau so wie ich – noch nie eine Verbindung herstellen können.

Was ist zu beachten?

- Der iPhone-User muss in einem WiFi Netz angemeldet sein
- Der MacUser sollte eigentlich nur Internet brauchen (einige User raten trotzdem zum WiFi nutzen, man weiß ja nie wo der Hase liegt)
- Der erste Verbindungsaufbau muss immer über die Telefonnummer passieren!
- Manche User schreiben, man sollte nicht mit der Nummer 0 für Deutschland, sondern mit +49 beginnen

So, und wenn man alle diese Punkte berücksichtigt hat?

Alles ist erledigt, selbst das Betriebssystem hat keinerlei neuen Updates zur Verfügung.
An dieser Stelle hatte ich nun cirka nach 3 Stunden aufgegeben.

Aber…

nun hatte ich irgendwo im Netz von einem Lokalitätsproblem von FaceTime gelesen.

Lokalitätsproblem?
Ja!
Riecht ihr schon den Hasenbraten?

Eine Umstellung der Sprache im Betriebssystem ist die Lösung!

Klingt zu simpel, funktioniert aber!

Wer alle anderen technischen Aspekte (wie dokumentiert und gewünscht) befolgt hat und trotzdem keine Verbindung aufbauen konnte, dem sollte mit einem Wechsel der Sprache seines MacOSx geholfen sein!

Dies könnt ihr übrigens unter “Einstellungen > Sprache & Text” vornehmen.
Im Regelfall ist hier “Deutsch” an oberster Stelle der Liste, zieht hier einfach per Drag & Drop das “English” an erste Stelle!

Alles schließen, Abmelden (neustart ist nicht nötig, Abmelden & frisch anmelden reichte bei mir).

Und schon klappts!!

PS:

Wer nicht sein komplettes Betriebssystem auf englisch umstellen möchte, der sollte sich mal den Language Switcher ansehen. Mit diesem Tool kann man wohl einzelne Programme in ihrer Sprache ändern und ist nicht gezwungen das komplette Betriebssystem auf englisch zu stellen.

Dieses Tool habe ich allerdings weder verwendet noch getestet!

Um dieses Problem zu beheben, musste ich bei der Erstellung der virtuellen Maschine folgende Einstellung vornehmen:

Man musste in den Einstellungen des Prozessors den Modus unter “Virtualization engine” ändern. Mit dem Modus “Intel VT-x ord AMD-V” läuft nun das 64 Bit System.

Verschlüsselung ist ein extrem wichiges Thema – ja, lebenswichtig!

Wer weiß was passiert wäre, wenn Alan Turing die deutsche Enigma nicht geknackt hätte. Oder im Gegensatz dazu, das japanische Kaiserreich es geschafft hätte den Navajo Kode der Amerikaner zu entschlüsseln.

Trotz alledem schicken selbst erfahrene Geschäftsleute und Regierungsbeamte bis dato immer noch heikle Informationen durch die Welt, ohne zu wissen was damit passiert. Getreu dem Motto: Was ich nicht weiß, das macht mich nicht heiß.

Dabei ist es gar nicht besonders schwer, wichtige Informationen vor anderen zu schützen. Und in der heutigen Zeit nehmen sowieso Computer den beschwerlichen Teil dem Anwender ab.

Wie so oft gibt es sehr viele Möglichkeiten, welche sich einem Computernutzer bieten. In diesem Artikel soll eine Möglichkeit vorgestellt werden, welche für die meisten Anwender ohne großes technisches Verständnis einfach nachvollziehbar sein dürfte. Und dabei kostet es absolut nichts!

Fangen wir mit einem Anbieter für PKI (=public key infrastructure) an – StartSSL. Es gibt derer viele, aber dieser Anbieter überzeugt durch eine extrem einfache Bedienung und Geschwindigkeit!
Wenn man zum ersten mal dort ankommt, muß man sich selbstverständlich registrieren. Demnach wählt man sign up (engl. sich einschreiben) und ergänzt dann seine privaten Daten …

… irgendwann bestätigt man noch eine E-Mail, welche sicherstellt daß man keinen solchen Blödsinn eingegeben hat, wie hier im Beispiel, und man kann sich dann richtig anmelden.

Dort angelangt wählt man in der Rubrik Tool Box (engl. Werkzeugkasten) den Punkt Retrieve Certificate (engl. Zertifikat abholen).

Dieses Zertifikat wird dann in den Web-Browser übertragen. Je nachdem kann man sich diesen Schritt sparen, weil vielleicht schon durch durch die Bestätigung der E-Mail bei der Registrierung bereits das persönliche Zertifikat gespeichert wurde.

Mit dem Web-Browser kann man sich dann schon bei diesem Anbieter mit seinem Zertifikat ausweisen und anmelden. Um es mit anderen Computerprogrammen verwenden zu können muß man es lediglich exportieren und dort, wo man es verwenden will (vielleicht ein E-Mail Programm oder ein anderer Web-Browser) wieder importieren.

Exportieren aus Mozilla Firefox

In den erweiterten Einstellungen (engl. advanced preferences) wählt man die zur Verschlüsselung (engl. encryption) wie folgt aus.

Und läßt sich durch das Betätigen eines der Knöpfe im unteren Bereich des Dialoges seine Zertifikate anzeigen (engl. view certificates).

Nachdem man es, wie hier dargestellt, mit der Maus ausgewählt hat kann man sich die Details zu seinem Zertifikat anzeigen lassen (engl. view details). Oder das Zertifikat sichern (engl. backup). Dazu vergibt man ein Paßwort, an welches man sich bis zum Import in ein anderes Programm wieder erinnert.

Die Datei wird im PKCS12 Format gespeichert, welches aus dem X.509 Standard stammt. Der X.509 Standard umfaßt spezielle Datenstrukturen und Verfahren mit dem Themenschwerpunkt Datensicherheit.

Wer sich mit Programmen wie openssl auskennt, oder es lernen möchte, kann sich die Inhalte dieser Datei mit folgendem Befehl ansehen. Um wie hier die Korrektheit zu überprüfen.

[martin@sequoia:startssl]? openssl pkcs12 -in mycert.p12 -info
...

Damit hat man sein Zertifikat auf ein Speichermedium exportiert.

Importieren in Mozilla Thunderbird

Auf dem gleichen Weg wie man sein Zertifikat aus dem Mozilla Firefox Browser exportiert hat, kann man es im Mozilla Thunderbird E-Mail Programm importieren.

Dort wählt man in den erweiterten Einstellungen (engl. advanced preferences) die Rubrik Zertifikate (engl. certificates).

Dort auf den Knopf Zertifikate anzeigen (engl. view certificates) klicken und man gelangt in die Zertifikatsverwaltung. Ein Benutzer kann auch mehrere verschiedene Zertifikate haben und damit verwalten.

Wir wollen ein neues importieren und wählen den dafür vorgesehenen Knopf unten aus. Dann wählt man die vorher exportierte Datei aus und kann den Inhalt bei korrekter Eingabe des Paßwortes einlesen.

Das neue Zertifikat wird nach erfolgtem Import in der Zertifikatsverwaltung angezeigt.

Und jetzt wird verschlüsselt und signiert

Um etwas verschlüsseln zu können benötigt man die öffentlichen Zertifikationsinformationen seines Kommunikationspartners. Dies ist der Hauptgrund warum Nachrichten nicht verschlüsselt werden. Ich mache nichts, mein Pendant macht auch nichts, und deswegen bleibt eben alles für jeden offen zugänglich.

Wenn sich jeder ein bißchen Mühe gibt, dann klappt aber alles wie am Schnürchen. Und zwar wie folgt.
Man besorgt sich ein Zertifikat wie oben beschrieben und schickt eine signierte Nachricht an seinen Kommunikationspartner. Der speichert sich dann die Signatur …

… importiert diese und schickt seine Daten im Gegenzug an den Absender ….

War der Import erfolgreich, kann man ab sofort verschlüsselte oder signierte Nachrichten austauschen. Dabei schützt Verschlüsseln vor dem Lesen des Inhalts und Signieren vor dem Ändern bzw. Verfälschen. Wie das technisch funktioniert kann man in den Literaturempfehlungen (s.u.) nachlesen.

Eine verschlüsselte und signierte Nachricht wird im folgendermaßen gekennzeichnet.

Wenn man die erste verschlüsselte Nachricht mit einem Kommunikationspartner ausgetauscht hatte, wird man bestätigen müssen, daß der eigentliche Vorgang kein Hexenwerk war. Und dann beginnt man sich die Frage zu stellen, warum das nicht jeder andere auch so macht.

Diese Frage stellen sich jedoch leider viel zu wenige der Menschen auf diesem Planeten!

Literaturempfehlungen

Es gibt ein riesige Auswahl von Büchern, Diplom- und Doktorarbeiten, Web-Seiten, Vortragsreihen, Lehrgänge usw. Ganze Lehrstühle von Universitäten, wohl jeder Geheimdienst dieser Welt und alle Verbrechersyndikate beschäftigen sich mit diesem Thema.

Um mit dem Thema vertraut zu werden:

Bruce Schneier, Secrets and Lies: Digital Security in a Networked World
Simon Singh, The Code Book: The Secret History of Codes and Code-breaking

Für die Fortgeschrittenen:

Bruce Schneier, Practical Cryptography

Für die Experten:

Douglas Stinson, Cryptography: Theory and Practice (Discrete Mathematics and Its Applications)
Helen Fouché Gaines, Cryptoanalysis

Einige weiterführende Hinweise

Will man sich den Zertifikatsinhalt bspw. in leserlicher Form speichern …

Dazu klickt man im Mozilla Firefox Zertifikats-Manager auf den Knopf links unten und wählt die Dateilansicht (engl. view details) zum Zertifikat aus. Dort angelangt kann man die Daten exportieren. Das dafür vorgesehene Datenformat nennt sich PEM (= privacy enhanced mail) und stammt wie vorhin schon erwähnt ebenfalls aus dem X.509 Standard

Wer sich mit Programmen wie openssl auskennt, oder es lernen möchte, kann sich den Inhalt dieser Datei mit folgendem Befehl ansehen. Nichts anderes zeigt einem der Web-Browser nämlich auch an.

$ openssl x509 -in mycert.pem -noout -text
...

Dieses Feature ist standardmäßig schon unter Windows 7 installiert. Wie Sie dieses Feature unter Windows Server 2008 R2 hinzufügen, wird Ihnen in folgenden Schritten erklärt.

1. Öffnen Sie die bereits installierte Windows PowerShell.

2. Importieren Sie mit folgendem Befehl das Server Manager Modul: Import-Module ServerManager.Dieses wird für die Installation von Features benötigt.

3. Um zu sehen welche PowerShell-Features Ihnen zur Verfügung stehen, geben Sie folgenden Befehl ein: Get-WindowsFeature -Name *powershell*

4. Mit folgendem Befehl installieren Sie nun die PowerShell ISE: Add-WindowsFeature PowerShell-ISE

ABAP
REPORT HELLO_WORLD.
WRITE ‘Hello, world!’.

Ada
with Ada.Text_IO; use Ada.Text_IO;
procedure Hello is
begin
Put_Line (“Hello, world!”);
end Hello;

ALGOL
HELLO: ‘Begin’
‘COMMENT’ CDC ALGOL 60: “Hello, world!” ;
‘END’ HELLO

Ant
< project name=”Hello” default=”hello”>
<target name=”hello” description=”Greeting”>
<echo message=”Hello, world!” />
</target>
</project>

APL
APL: Hello, world!
‘Hello, world!’

AppleScript
display dialog “Hello, world!”

ASP
<% @ Language=”VBScript” %>
<% ‘ASP: “Hello, world!”
Response.Write(“<html><body> Hello, world!</body></html>”) % >

Assembler
: NASM Intel 8086 Assembler (DOS); “Hello, world!”
org 100h
start:
MOV AH,09h
Lea DX,[msg]
Int 21h
MOV AX,4Cooh
INT 21h
msg: DB ‘Hello, world!$’

awk
# awk: “Hello, world!”
BEGIN {print “Hello, world!”}

B
main() {
extrn a, b, c:
putchar (a); putchar(b); putchar(c); putchar(‘!*n’);
}
a ‘hell’ ;
b ‘o, w ‘ ;
c ‘orld’ ;

BASH
# Bash: “Hello, world!”
echo Hello, world!

BASIC
10 REM BASIC: “Hello, world!”
20 PRINT “Hello, world!”

BRAINFUCK
“HelloKOMMA World!” [-]++++++++++[>++++++
+>++++++++++>++++>+++>+<<<<<-]>++.>+.+++++++..+++.>+
+++.>++.<<++++++++.——–.+++.——.——–.>>+.

BS2000
/BEGIN-PROCEDURE LOGGING=N
/REMARK BS2000 (SDF): “Hello, world!”
/ASSIGN-SYSDTA TO-FILE =*SYSCMD
/WRITE-TEXT ‘Hello, world!’
/SET-JOB-STEP
/ASSIGN-SYSDTA TO-FILE =*PRIMARY
/END-PROCEDURE

C
#include <stdio.h>
#include <stdlib.h>
int main(void) {
puts(“Hello, world!”); return EXIT_SUCCESS;
}

C#
using System:
class HelloWorld{
public static int Main(string[] args) {
Console.WriteLine(“Hello, world!”);
return 0;
}
}

C++
#include <iostream>
int main() {
std::cout << “Hello, world!” << std:: endl;
}

COBOL
IDENTIFICATION DIVISION.
PROGRAMM-ID. HELLO.
ENVIRONMENT DIVISION.
MAIN SECTION.

DISPLAY”Hello, world!”
STOP RUN.

Common Lisp
(defun helloworld()
(print “Hello, world!”)
) (helloworld)

dBase
?”Hello, world!”

Dylan
define method hello-world()
format-out(“Hello, world!\n”);
end method hello-world;
hello-world();

ECMA-/JavaScript
alert(‘Hello, world!’);

Eiffel
indexing
description: “Eiffel: Hello, world!”
class HELLO
creation
run
feature
run is
do
print (“Hello, world!%N”);
end — run
end — HELLO

Erlang
-module(hello).
-export([hello/0]).
hello() ->
io: format (“Hello, world!~n”, []).

Forth
s” world!” s” Hello, “
type type CR
bye

Fortran
PROGRAMM HALLO
WRITE (*, 100)
STOP
100 FORMAT (‘Hello, world!’)
END

Groovy
println “Hello, world!”

Haskell
main :: IO ()
main = putStrLn “Hello, world!”

HPGL
IN0;
PA0,0;
PR1000,1000;
SP1;
PD;
DT!;
LBHELLO WORLD;
PU;
Pa 0,0;
SP0;

HTML
<html><head><title>Greeting</title>
<meta http-equiv=”Content-Type” content=”text/html: charset=UTF-8″>
</head><body><p>Hello, World!</p></body></html>

INTERCAL
PLEASE DO , 1 <- #13
Do, 1 SUB #1 <-#238
DO , 1 SUB #2 <- #112
DO , 1 SUB #3 <- #112
DO , 1 SUB #4 <- #0
DO , 1 SUB #5 <- #64
DO , 1 SUB #6 <- #238
DO , 1 SUB #7 <- #26
DO , 1 SUB #8 <- #248
DO , 1 SUB #9 <- #168
DO , 1 SUB #10 <- #24
DO , 1 SUB #11 <- #16
DO , 1 SUB #12 <- #158
DO , 1 SUB #13 <- #52
DO READ OUT ;1
PLEASE GIVE UP

Java
class HelloWOrld {
public static void main/String args[]) {
System.out.println(“Hello, world!”);
}
}

JSP
<%@ page language=’java’ %>
<%=”Hello, world!” %>

LATEX
\documentclass{Article}
\begin{document}
Hello, world!
\end{document}

Logo
PRINT [Hello, world!]
BYE

Maschinencode
B4 09 8D 16 0D 01 CD 21 B8 00 4C CD 21 48 65 6C
6C 6F 2C 20 77 6F 72 6C 64 21 24

make
all:
@echo “Hello, world!”

Modula-2
MODULE HelloWorld;
FROM InOut IMPORT WriteString, Writeln;
BEGIN
WriteString(“Hello, world!”);
WriteLn;
END HelloWorld.

MS-DOS Batch
@ECHO OFF
REM DOS batch: “Hello, world!”
ECHO Hello, world!

Mumps-M
w !, “Hello, world!”

Oberon
MODULE Helloworld;
IMPORT Write;
Begin
WriteLn(‘Hello, world!’);
end.

Pascal
programm HelloWorld(output);
begin
WriteLn (‘Hello, world!’);
end.

Perl
print “Hello, world!\n”;

PHP
<?php echo “<html><body>”.”Hello, world!”.”</body></html>”;?>

PL/1
Hello: procedure options(main);
put skip list(‘Hello, world!’);

end Hello;

Plankalkül
R1.1(V0[:sig]) => R0
R1.2(V0[:m x sig]) => R0
0 => i |m + 1 = > j
[W [ i < j-> [R1.1(V0[i: m x sig]) 0> R0 | i + 1 0> i ] ] ]
END
R1.3() => R0
‘H’;'e’;'l’;'l’;'o’;',’;’ ‘;’w';’o';’r';’l';’d';’!’ => Z0[: m x sig]
R1.2(Z0) 0> R0
END

PostScript
/Courier findfont 24 scalefont setfont
100 100 moveto (Hello, world!) show showpage

PowerShell
Write-Host “Hello, world!”

Prolog
?- write(‘Hello, world!’) , n1 .

Python
print “Hello, world!”

REXX
say ‘Hello, world!’
exit

Ruby
puts “Hello, world!”

Scheme
(define h (lambda()(display “\nHello, world!”) (newline)()))(h)

sed
echo s | sed -ne ‘ls/.*/Hello, world!/p’

Self
‘Hello, world!’ print.

Simula
Begin
OutText(“Hello, world!”); OutImage;
End of program;

Smalltalk
‘Hello, world!’ out.

SQL
SELECT ‘Hello, world!’ AS message;

TEX
Hello, world!
\bye

troff/groff
\f(CW
Hello, world!

Velocity
<html><body>#set( $foo = “Hello, world!” ) $foo
</body></html>

XML
<greet><how>Hello, </how><who>world</who<wmark>!</mark></greet>

XUL
<?xml versions=”1.0″?><!– XUL: “Hello, world!” –>
<window xmlns=
“http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul”>
<label value=”Hello, world!”/></window>

Danke an Frank Hildebrandt  für Nr. 65
Natural
WRITE`Hello, world!´