HTTP/(X)HTML/CSS/JS/Flash/whatever muss weg!

Wie ja bereits vor einiger Zeit mal geschrieben (und steht ja auch noch immer im #Zanzibar-Topic), beschäfftigt mich seit längerer Zeit der Gedankengang dass man diesen ganzen HTTP und HTML-Müll durch etwas sinnvolles ersetzen müsste.

Ich habe in den letzten Tagen dann endlich mal angefangen meine Gedankengänge zu notieren und hier habt ihr jetzt die Ergebnisse:

Schon alleine bei der Idee ein Dateiübertragungsprotokoll so weit aufzubohren dass man darüber interaktive Funktionen auf der Client-Seite mit dem Server koordinieren will, zieht es mir die Schuhe aus vor Ekel.
Wenn dann noch so hunderttausende Erweiterungen dazu kommen, von denen keine wirklich sinnvoll Standardisiert ist und jede komplett auf einer neuen Sprache aufbaut, dann renn ich endgültig zum Klo.

Der derzeitige Standard ist ja wohl folgender:
Wir erzeugen mit einer interpretierten Sprache je nach Aufruf eines virtuellen Verzeichnisses (z.B. /user/id/1) eine Markup-Datei, diese wird zusammen mit massig statischen Bildern, anderen Interpreterscripten in verschiedensten Sprachen (das natürlich dann wieder statisch angelegt) mit einem Dateiübertragungsprotokoll an den Client gesendet.
Ein einziger Seitenaufruf erzeugt also nicht nur 10-20 neue HTTP-Requests, der Client darf sich dann auch noch damit rumschlagen HTML zu formatieren, danach CSS zur Gestaltung drüber zu rechnen, diverseste Bildformate anzuzeigen, Javascript zu interpretieren, Flash einzubinden, Java-Applets anzuzeigen, ...

Es gibt einfach keine Grenzen mehr für diesen Blödsinn. Neuerdings haben es sich einige Dienste sogar zur Aufgabe gemacht dieses pervertierte Dateiübertragunsprotokoll endgültig zu vergewaltigen. So gibt es da draußen Leute, die via Polling einer virtuellen Datei etwas echtzeitähnliches auf die Beine stellen wollen. Andere versuchen neuerdings sogar eine HTTP-Verbindung permanent offen zu halten um so je nach Bedarf Daten nachladen zu können (siehe z.B. Friendfeeds Realtime-Variante).

Gleichzeitig wollen wir übrigens natürlich jedes Design pixelgenau angeordnet haben, während es aber auf jedem Browser seit Netscape Navigator 1 fehlerfrei laufen soll. Erkenne nur ich was hier für ein Blödsinn verbrochen wird?

Für pixelgenaues Layout gibt es sicher viele sinnvolle Möglichkeiten, aber eine XML-Variante, die darauf ausgelegt ist erstmal Inhalte semantisch zu übertragen und die via Stylesheets dann noch mehr schlecht als recht in ihrer Darstellung angepasst werden kann, zählt sicher nicht darunter.

Selbst andere Dokument-Strukturen wie PDF oder SVG würden sich bei weitem besser eignen um sowas zu realisieren... aber das macht nichts, wird halt alles etwas aufwändiger und teuer.

Vorüberlegungen


Warum bauen wir nicht endlich etwas neues? Meine Idee wäre ja eine beliebige Variante von ausführbarem Code zu übertragen und diesen dann auf beiden Seiten (Client und Server) ausführen zu lassen. Beide Seiten könnten permanent miteinander reden, da das Socket ja nicht geschlossen werden muss.. wir müssen ja eh nach den Anweisungen noch alle möglichen Bilder und andere statische Inhalte übertragen.
Die Clientseite des Programmes bekommt dann einfach noch die Anzeigefähigkeiten des Clients mitgeteilt und darf dann selbst entscheiden was gezeichnet wird und was nicht.
Dabei sollte eine reine Textausgabe als Minimalversion selbstverständlich sein (das kann man ja auch durch strukturierdende Funktionen in der API erleichtern -> writeTextHeading() oder so) und je nachdem welche Klasse von Standardisierten Fähigkeiten der Client noch so anbietet, kann auch der Nutzer dann entscheiden was er genau sehen will.
So kann jeder dann in seinem Client auch einstellen ob er lieber OpenGL-Ausgaben hat oder doch besser nur eine Konsolenvariante.

Die Sprache könnte auch ziemlich beliebig wählbar sein, ideal wäre für die Übertragung ja eine Art zwischencompilat oder VM-Code. Wenn es wirklich sehr optimiert sein soll, kann der Server ja auch bereits für bestimmte Clientklassen compilierten Code bereitstellen (z.B. freiwillige Identifikation als x86 mit Linux 2.6.).
Wenn ich also als Client übertrage dass ich Betriebssystem X auf CPU Y verwende, dann bekomme ich Code den ich nur noch ausführen muss, für alle Systeme bei denen kein solcher Code vorliegt oder Clients die lieber die volle Kontrolle behalten wollen wird weiter der Zwischencode übertragen.

Ideen zur Realisierung


Ein erster Beispielentwurf sieht eine Grundstruktur folgender Objekte vor:

  • Back

  • Front

  • General

  • Client

Back


wird immer auf dem Server ausgeführt
enthällt unterobjekte für db-api und anderes beim Client nicht benötigtes
jeder Aufruf einer Front-Funktion oder Eigenschaft von hier aus bedeutet eine Kommunikation mit dem Client
Back-Datenstrukturen und Funktionen werden nicht an den Client gesendet

Front


wird auf dem Client ausgeführt
enthällt unterobjekte für komplexere Zeichenfunktionen (drawFrontpageHeading), Eingabeevents und alle sonstigen Dinge die nur auf Clientseite benötigt werden.

general


Alle Funktionen die sowohl auf Client als auch auf Server-Seite benötigt werden, werden hier definiert.
Typisches Beispiel wäre z.B. md5()
Änderungen nach der Übertragung werden NICHT synchron gehalten

client


Das einzige Objekt das überhaupt nicht geändert werden kann
wird direkt vom Client-Programm bereit gestellt und liefert alle Client-Api-Funktionen

Beispielhafter Ablauf in python-ÄHNLICHEM Pseudocode:



class foBack extends genericBack:
function __init__(self):
soc = getPortOnServer(12345)
self.gen = new foGeneral()
soc.setCallbackNewConnection(self.newConn)

function newConn(self, parameters):
parameters.client.sendApplication(foFront)

function userClicked(ident, x,y):
text = ''
if (!ident.loggedIn):
text = 'un'
print(text+"angemeldeter Nutzer klickte auf die Koordinaten %s, %s\r\n" % (x,y))

class foFront extends genericFront:
function __init__(self, parameters):
self.client = parameters.client
self.client.setDrawCallback(self.redraw)
self.back = parameters.back

function redraw(self, changes):
c = self.client.config
if (c.ableTo('draw' 'event_onClick', 'showMsg')):
box = new self.client.drawBox(0, c['maxX'], 0, c['maxY'])
text = new self.client.drawText('Hello World', 20, c['maxX']-20,20, c['maxY']-20)
box.setOnClick(self.save)
else:
print('Hello World')
self.destroy()

function save(x,y):
self.back.userClicked(self.client.ident,x,y)
self.client.showMsg('EXIT!')
self.destroy()

Abschließende Bemerkungen


Selbstverständlich ist diese Struktur noch bei weitem nicht ideal. So gehe ich im Beispielcode z.B. davon aus dass jede Fähigkeit einzeln abgefragt wird und dann parallel komplett unterschiedliche Vorgänge stattfinden.
Sinnvoller wäre es jedoch Funktionen ala "drawHeading" zu definieren und diese dann je nach Anwendungsstatus (der nach dem Vorhandensein von 2-3 Klassen an Fähigkeiten) umgeschalten wird verschiedene Funktionen ausführt.

Es ist natürlich auch klar dass dieses Vorgehen für viele kleine Websites die nur mal eben schnell ihre 2-3 Statusmeldungen und Texte ins Web posten wollen und das dann via irgendwo "geklautem" Stylesheet einfärben, erheblich mehr Aufwand bedeutet.
Für große Seiten/Projekte hingegen, denke ich dass der Aufwand im Gegensatz zu HTML/JS/CSS/... erheblich sinkt. Auch sollte sich auf diese Art nicht nur der Netzwerkoverhead (eine Connection statt hunderter Requests) erheblich reduzieren lassen, auch die Ausführungsgeschwindigkeit sollte stark steigen (gerade via OpenGL-Zeichenfunktionen lässt sich einiges an Performance erreichen).
Weiterhin sollte auch der Lernaufwand für die Entwickler und damit der Gesamtpreis für ein Projekt geringer werden. Man muss nicht mehr dutzende Markupsprachen koordinieren, man zeichnet nur noch ein Interface wie man es vlt. auch lokal tun würde.

Natürlich geht damit der Grundgedanke von HTML verloren.. wir haben keine Sprache mehr die auf jeder Platform lauffähig sein soll und überall für jeden lesbar dargstellt wird. Aber wenn wir ehrlich sind: das haben wir auch so schon lange nicht mehr.
Bereits seit Jahren wird massiv auf verschiedene Browser optimiert, werden Clients ohne JS oder Flash komplett ausgesperrt oder Textsysteme und Screenreader für Blinde komplett vernachlässigt.
Dieses neue Protokoll würde all dies zur selben Fleißaufgabe machen, die es eigentlich schon seit Jahren ist.. es würde nur den Anreiz diesen Aufwand zu betreiben erheblich erhöhen und gleichzeitig den Aufwand verringern.

So, das wars erstmal von meiner Seite... jetzt hätte ich gerne von euch ein paar Kommentare/Verbesserungsvorschläge/gefundene Fehler dazu.

Importierte/Alte Kommentare:

#1226: 04.Apr.2009 02:04 von madda

äh ... dafür bin ich zuviel DAU um mich sinnvoll ins Thema einzuklinken ^^'

Ich kann vielleicht nur soviel dazu beisteuern, das es wirklich mal schön währe, wenn alles in irgendeiner Weise strukturierter und standardisierter währe.

#1227: 05.Apr.2009 10:04 von SirSnookie

Das Problem dabei sehe ich einfach in der Anwendbarkeit. Du müssstest sämmtlichen Frontpage (jetzt Dreamweaver) Jünger die Tools weg nehmen. WYSIWYG Editoren müssen glühen damit sie solch einen Code erzeugen. Die Designer, welche sich teilweise jetzt schon sehr schwer mit HTML tun müssten umschwenken. Selbst Photoshop und Illustrator würden auf die Müllhalde fliegen weil sie "nur" HTML Code aus den Slices erzeugen könnten.

Der Ansatz ist gut, nur zu Revolutionär. Da würde niemand mitziehen weil man wieder viel Geld investieren müsste. Sei es auf der Browser Seite (Dann gehts gezanke wieder los) und auf der Serverseite, wo ja scho seit Jahren der IIS mit dem Häuptling kämpft.

Wie gesagt, das wichtigste da bei ist das Geld, die Firmen wollen es nicht investieren in Mitarbeiterschulungen, die Mitarbeiter haben keins für Schulungen und der normalsterbliche User schaltet gleich ganz ab.

#1228: 05.Apr.2009 12:04 von noqqe

Ich bin mir bei dem Konzept noch nicht ganz sicher an welchem der mögichen Problempunkte sich das ganze letzendlich aufhängen wird.
Ob es nun sicherheit wird(durch die dauerhafte Verbindung wirds bestimmt lustige Man-in-the-Middle-Möglichkeiten geben, bzw das direkte Schadcode einschleußen durch pöhse Websites :) ) oder einfach nur die Komplexität ^^

Prinzipiell ist das aber eine Idee in die richtige Richtung.. Super Artikel. Genauso wie das ganze ge-Emaile mal revolutioniert gehört! flo schlägt sich täglich mit MailServer bzw Mail-Anwenderproblemen herum

  • #1229: 05.Apr.2009 12:04 von Dr. Azrael Tod

    Einer der möglichen Problempunkte ist sicher dass der Server massig Verbindungen offen halten muss... Das mag jetzt nicht grundsätzlich schlimmer sein als erheblich mehr Verbindungen permanent zu öffnen und zu schließen, benötigt aber halt andere Optimierungen als es bisher der Fall war.

    Derartige Angriffe kann man relativ einfach ausschließen: Man macht einfach eine Verschlüsselung zur Pflicht und gibt ordentlice Fehlermeldungen aus wenn Zertifikate beim Verbindungsaufbau irgendwelchen Blödsinn beinhalten (abgelaufen, falscher Hostname, schwache Verschlüsselung, Blacklisted ...)
    Das wäre gleich noch ein Fehler mit dem wir momentan zu kämpfen haben.. allerdings weniger ein Designfehler, als vielmehr ein Fehler den fast jeder Client aufs Neue nachbauen muss: Wenn ich eine https-Verbindung aufbaue und die Authentifizierung ist gefärdet, dann soll das der Nutzer gefälligst richtig groß und deutlich sehen. Da hilft es nicht ein kleines Schloss irgendwo versteckt anzuzeigen. Lieber eine Große fehlerseite aufrufen und erst wenn der Nutzer bestätigt dass es ihm klar ist, gehts weiter.
    Denn nur wenn wir rigoros durchsetzen dass sich Nutzer beim Serverbetreiber beschweren weil dieser Mist gebaut hat, werden die Serverbetreiber auch sowas sinnvoll verwenden.

    Das Hauptproblem hat aber Snookie schon genannt: auch das beste und genialste System wird verdammt schwer durchzusetzen sein. Einfach weil keiner danach entscheidet was gut oder schlecht ist, sondern alle einfach danach gehen, was alle anderen Sheeple nutzen.

#1230: 05.Apr.2009 01:04 von SirSnookie

Ich mag die freie Marktwirtschaft sie ist so schön abhängig vom Geld.

  • #1231: 05.Apr.2009 02:04 von Dr. Azrael Tod

    Freie Marktwirtschaft wäre ja eins... wenn wir eine hätten, haben wir nur leider nicht, werden wir auch nie haben und sich jetzt schon wieder darüber aufzuregen würde irgendwie den Rahmen bei weitem sprengen.

  • #1232: 05.Apr.2009 02:04 von noqqe

    Also ich find unsere soziale Marktwirtschaft sehr toll. Kartellämter ftw! Sowas muss einfach unterbunden werden. Von Sondersteuern und all solchen Geschichten jetzt mal abgesehen.

  • #1233: 05.Apr.2009 02:04 von Dr. Azrael Tod

    Kartellämter sind natürlich wichtig und gut.. aber ich bezog mich auch eher auf bewusste Marktverzerrungen wie z.B. für den Tagebau oder auf unbewusste wie bei der Bahn, die ihr Schienennetz direkt über den Fahrpreis finanzieren muss, während Autos erstmal billiger erscheinen, da das Straßennetz eh von allen bezahlt wird, egal ob man es selbst nutzt oder nicht.

    Aber wie gesagt: das würde jetzt den Rahmen sprengen

#1234: 06.Apr.2009 01:04 von SirSnookie

Ein netten Ansatz gibt es schon seit 2007:
http://www.linux-magaz...

  • #1235: 06.Apr.2009 08:04 von Dr. Azrael Tod

    Andere versuchen neuerdings sogar eine HTTP-Verbindung permanent offen zu halten um so je nach Bedarf Daten nachladen zu können (siehe z.B. Friendfeeds Realtime-Variante).
    Das funktioniert glaube schon mit Continuations... Die Sache klingt von Grund auf erstmal ja ganz nett, leider hat das halt den Nachteil dass man dann noch immer einen rießigen Rattenschwanz an alten Systemen unterstützen muss und einfach nur beides laufen lassen kann. Sprich: man bekommt die neuen Probleme (z.B. RAM für jede offengehaltene Verbindung benötigt), diese werden durch die nie dafür geschaffene Software sogar noch verstärkt ABER die alten Probleme löst man dadurch nicht.
    Man hat noch immer massive Zugriffe mit dutzenden HTTP-Requests, auch wenn man irgendeine Funktion basierend auf Continuations einbaut.

    Das ist nicht die Lösung für das Problem, das ist einfach der kreativste Weg sich zusätzliche Probleme zu schaffen.

Geschrieben von Dr. Azrael Tod
Later article
Ausweg Amoklauf
Older article
Bring in the Trolls!