Warum haben Code-Basen in der n-Tier-Entwicklung jetzt die gleiche Menge, wenn nicht sogar mehr JavaScript-Code?

Ich mache schon lange Webprogrammierung und irgendwo habe ich den Überblick verloren, warum wir das tun, was wir heute tun (oder wie wir dazu gekommen sind, Dinge auf diese Weise zu tun)?

Ich habe mit der grundlegenden ASP-Webentwicklung begonnen, und schon sehr früh waren Anzeige und Geschäftslogik auf der Seite gemischt. Die clientseitige Entwicklung war sehr unterschiedlich (VBScript, verschiedene JavaScript-Varianten), und wir hatten viele Warnungen vor serverseitigen Überprüfungen (und deshalb habe ich mich von der clientseitigen Logik ferngehalten).

Ich bin dann für eine Weile zu ColdFusion gewechselt. ColdFusion war wahrscheinlich das erste Webentwicklungsframework, das Anzeige und Geschäftslogik mithilfe ihrer Tags trennte. Es schien mir sehr klar, aber sehr ausführlich zu sein, und ColdFusion war auf dem Markt nicht sehr gefragt, und so ging ich weiter.

Ich bin dann auf den ASP.NET-Bandwagen gesprungen und habe angefangen, ihren MVC-Ansatz zu verwenden. Ich erkannte auch, dass Java eine Elfenbeinturmsprache für Unternehmenssysteme zu sein schien, und versuchte auch deren MVC-Ansatz. Später entwickelte ASP.NET dieses MVVM-Entwurfsmuster, und auch Java (genauer gesagt J2EE oder JEE) kämpfte mit seinen MVC2-Ansätzen.

Heute habe ich jedoch festgestellt, dass die Aufregung und der Fortschritt beim Backend-Programmieren nicht mehr bestehen. Außerdem scheinen serverseitige MVC-Praktiken veraltet zu sein (verwenden die Leute JSTL wirklich mehr?). In den meisten Projekten, an denen ich arbeite, habe ich heute festgestellt, dass in JavaScript-Frameworks und clientseitigen Entwicklungen all die aufregenden und innovativen Fortschritte erzielt werden.

Warum wurde diese Verlagerung von der Server- zur clientseitigen Entwicklung durchgeführt? Ich habe eine einfache Zeilenzählung für eines meiner JEE-Projekte durchgeführt, und in JavaScript sind mehr Codezeilen als in Java (ausgenommen Bibliotheken von Drittanbietern). Ich finde, dass die meisten Back-End-Entwicklungen mit Programmiersprachen wie Java oder C # lediglich eine REST-ähnliche Oberfläche erzeugen und dass alle Anstrengungen in Bezug auf Anzeige, Visualisierung, Dateneingabe / -ausgabe, Benutzerinteraktionen usw. angegangen werden über clientseitiges Framework wie Angular, Backbone, Ember, Knockout, etc ...

In der Zeit vor jQuery habe ich viele Diagramme gesehen, in denen in MVC in der n-Tier-Entwicklung eine klare, konzeptionelle Grenze zwischen M, V und C bestand. Nach jQuery, wo werden diese Linien gezeichnet? Es sieht so aus, als ob MVC und MVVM im JavaScript-Code auf der Clientseite genau richtig sind.

Was ich wissen möchte, ist, warum wir einen solchen Übergang gemacht haben (von der Betonung der serverseitigen Programmierung zur clientseitigen, von der Bevorzugung kompilierter Sprachen zu Skriptsprachen, von der zwingenden zur funktionalen Programmierung, all dies scheint gleichzeitig stattgefunden zu haben ) und welche Probleme hat diese Umstellung / Verschiebung gelöst?

Das Verschieben der Rechenlast zwischen dem Server und dem Client ist ein zyklisches Phänomen, und das schon seit geraumer Zeit.

Als ich auf dem Community College war, bekam der Personal Computer gerade erst Schwung. Ethernet war jedoch noch nicht weit verbreitet, und niemand verfügte über ein lokales Netzwerk. Das College verfügte damals über einen Großrechner, der die Aufzeichnungen der Schüler handhabte und als Plattform für Programmierkurse diente. Die Verwaltung verfügte über Terminals, die auf Time-Sharing-Basis mit dem Mainframe verbunden waren, aber die Studenten mussten Karten lochen, um ihre Programmieraufgaben zu erledigen, was ein mühsamer Prozess war. Schließlich haben sie ein Labor eingerichtet, in dem sich die Schüler für ein Terminal anmelden konnten, aber es dauerte noch etwa eine halbe Stunde, bis Sie einen 15 Zentimeter dicken Ausdruck der Fehler erhielten. Die gesamte Verarbeitungsarbeit wurde auf dem Mainframe (dem Server) ausgeführt.

Da Mainframes jedoch teuer waren, begannen die Unternehmen, lokale Netzwerke einzurichten, und die Verarbeitungslast wurde vom Server auf die einzelnen Clientcomputer verlagert, die leistungsfähig genug waren, um einzelne Textverarbeitungs-, Tabellenkalkulations- und Branchenanwendungen auszuführen, jedoch nicht leistungsfähig genug Teilen Sie ihre Rechenleistung mit anderen. Der Server war ein ähnlicher Computer mit ähnlichen Funktionen (möglicherweise mehr Speicher und Festplattenspeicher), wurde jedoch hauptsächlich zum Freigeben von Dateien verwendet. Dies wurde als Client / Server bezeichnet. Der größte Teil der Verarbeitung wurde auf die Client-Computer verlagert.

Einer der Nachteile der gesamten Verarbeitung auf den Client-Computern bestand darin, dass Sie in diesen fortwährenden Zyklus der Softwareinstallation und -Upgrades und die damit verbundenen Kopfschmerzen verstrickt waren. Das Programmiermodell dieser Maschinen (ereignisbasierte, Code-behind-Benutzeroberflächen) förderte die Erstellung von chaotischen, schwer zu wartenden Programmen (große Schlammballen). Die meisten Endbenutzer verfügten nicht über die erforderlichen Fähigkeiten, um ihre Hardware und Software ordnungsgemäß zu warten, was Armeen von IT-Wartungspersonal erforderlich machte.

Mit zunehmender Leistungsfähigkeit der Computer wurde eine Arbeitsteilung möglich. Jetzt können Sie Dateiserver, Datenbankserver, Webserver, Druckserver usw. einrichten. Jede Maschine könnte für die gestellten Aufgaben etwas optimiert und von jemandem mit dem erforderlichen Fachwissen gewartet werden. Es konnten Programme geschrieben werden, die im Webbrowser ausgeführt wurden, sodass keine Client-Installationen mehr erforderlich waren. Dies wurde Multi-Tier oder n-Tier genannt. Browser wurden im Wesentlichen wie in den Mainframe-Zeiten als dumme Terminals verwendet, obwohl die Kommunikationsmethode mit dem Server ausgefeilter und weniger proprietär war und auf Interrupt-Mechanismen statt auf Timesharing und Polling basierte. Die Verarbeitung wurde zurück auf den / die Server verschoben.

Die Webentwicklung brachte jedoch ganz neue Kopfschmerzen mit sich. Die meisten Geschäftsanwendungen, die für den Browser geschrieben wurden, waren statische Formulare und Berichte. In der Benutzeroberfläche war sehr wenig Interaktivität verfügbar. Javascript hatte seinen zweiten Wind noch nicht gefunden, und es gab große Probleme mit Browser-Inkompatibilitäten, die seine breite Akzeptanz verhinderten. Es ist jedoch viel besser geworden. HTML5 und CSS3 bieten wesentliche neue Funktionen für das Browser-Programmiermodell. Mit jQuery entdeckte eine ganze Generation von Programmierern, wie nützlich Javascript sein kann. Neue Front-End-UI-Frameworks entstanden. Es wurde möglich, interaktive Benutzeroberflächen in den Browser zu schreiben, sogar komplette Spiele. Die Verarbeitung wurde wieder auf den Client verlagert.

Heute können Sie in der Cloud so viel oder so wenig Rechenleistung kaufen, wie Sie möchten, und Programme auf dem Server ausführen. Ich würde sagen, wir sind jetzt an einem Ort, an dem Sie als Softwareentwickler viele Möglichkeiten haben, wie Sie Ihre Verarbeitungsleistung sowohl auf dem Client als auch auf dem Server ausführen können.

Sie scheinen zwei sehr unterschiedliche Konzepte zu vermischen:

1. Trennung von Präsentation und Geschäftslogik (MVC) => Verbesserung der Wartbarkeit
2. Ausführung einem Knoten zuordnen => Effizienz steigern

Früher wurde Client / Server-Computing oft als erstes bezeichnet, da Clients im Vergleich zu Servern im Allgemeinen nicht über viel Rechenleistung verfügten. Daher schien es naheliegend, die "schwere" Geschäftslogikberechnung (M) auf Server zu verlagern, während die "leichte" Ansichtsverarbeitung (V) für Clients beibehalten wurde. Im Gegenzug mussten Sie eine Art Schiedsrichter (C) implementieren, um zwischen den beiden zu übersetzen.

Da Clients jetzt problemlos über Prozessfähigkeiten verfügen, für die früher einige teure Serverhardware erforderlich war, verschwimmen die Zeilen hinsichtlich der Ausführung der Geschäftslogik - clientseitig oder serverseitig. In Wirklichkeit hängt die Antwort von Ihrem spezifischen Anwendungsfall und Ihrer Wahl der Kompromisse ab, z.

• Client-Latenz im Vergleich zur Komplexität: Die serverseitige Verarbeitung vereinfacht die Systeme, da kein Code auf dem Client bereitgestellt / heruntergeladen werden muss. Dies geht jedoch zu Lasten der clientseitigen Latenz während der Berechnung.

• Komplexität im Vergleich zur Serverauslastung: Client-seitiges Computing kann die Systemkomplexität erhöhen, aber auch dazu beitragen, die Serverauslastung zu verringern.

• Ausfallsicherheit dezentraler Anwendungen im Vergleich zur zentralen Ausführung: In einer Welt mobiler Anwendungen kann es wichtig sein, die Clients trotz einer Netzwerkunterbrechung am Laufen zu halten. Dies geht jedoch zu Lasten der Verwaltung mehrerer implementierter Versionen der Geschäftslogik.

Dies ist eine nicht erschöpfende Liste vieler Kompromisse.

Weil Benutzer immer die gleiche Funktionalität wollten, die sie mit ihren Web-Apps (nicht nur mit Websites) hatten, die sie mit Desktop-Apps hatten. Dies alles in einem Browser (eigentlich in mehreren Browsern) laufen zu lassen, ist nicht wie früher, als Sie ein VB-Formular mit wenig Code mit einer Datenbank verknüpfen konnten. Dies ist einfacher, wenn Sie nicht zum Server zurückkehren müssen.

Die meiste Backend-Entwicklung mit Programmiersprachen wie Java oder C # besteht einfach darin, eine REST-ähnliche Oberfläche zu erstellen, und dass der gesamte Aufwand für Anzeige, Visualisierung, Dateneingabe / -ausgabe, Benutzerinteraktion usw. über Client-Server abgewickelt wird. Seitengerüst wie Angular, Backbone, Ember, Knockout, etc ...

Vielleicht scheint die Back-End-Programmierung / -Dienste das Gleiche zu sein, aber es ist das Herzstück der Anwendung. Die Codierungspraktiken können in diesen Bereichen effizienter sein. Die Tools, Sprachen, Browser und Frameworks sind noch in der Entwicklung, sodass die UI / UX nur schwer zu entwickeln ist. Sie sind die neuen Dinge, die der alte ASP nicht hatte. Wenn wir uns mit Benutzeroberflächen mit einfachen Formularen und HTML-Tabellen abfinden könnten, gäbe es auch in diesen Bereichen kein großes Interesse / Hype, aber Benutzer möchten Drag & Drop, Animationen, Übergänge, Pop-ups usw.

In den meisten Projekten, an denen ich arbeite, habe ich heute festgestellt, dass in JavaScript-Frameworks und clientseitigen Entwicklungen all die aufregenden und innovativen Fortschritte erzielt werden.

Warum wurde diese Verlagerung von der Server- zur clientseitigen Entwicklung durchgeführt?

Hier gibt es eigentlich zwei Fragen:

1. Warum macht die clientseitige Programmierung Fortschritte?
2. Warum werden Anwendungen so geschrieben, dass sie auf dem Client und nicht auf dem Server ausgeführt werden?

Die beiden sind eigentlich verschieden.

Warum macht die clientseitige Programmierung Fortschritte?

Weil die Laufzeit, die Umgebung und das Ökosystem in den letzten drei Jahren erheblich gereift sind und dies neue Nischen eröffnet hat, auf deren Nutzung Innovatoren gewartet haben.

Früher war die Frontend-Entwicklung schwierig . Sie mussten für Browser - immer eine feindliche Umgebung - unter Verwendung der eingeschränkten Funktionen von ECMAScript 3 in einem Ökosystem programmieren, das weder über den Stand der Technik noch über Tools zum Erstellen von Thick-Client-Anwendungen verfügte. Es gab keine Modullader. Sie konnten mit Abhängigkeiten nicht richtig umgehen. Es mangelte an Flusenwerkzeugen. Frameworks waren unausgereift und der schlechte Ruf des Frontends distanzierte Innovatoren, die diese Probleme lösen konnten.

Da sich diese Faktoren inkrementell geändert haben, hat sich eine kritische Masse für die schnelle Entwicklung und konsistente Ausführung von Rich-Client-Anwendungen gebildet.

Als Antwort auf Ihre Frage haben die neuen Front-End-Technologien den Fortschritt weniger vorangetrieben, als vielmehr Engpässe beseitigt und es den Kunden ermöglicht, die Erwartungen der Benutzer nachzuholen.

Warum werden Anwendungen so geschrieben, dass sie auf dem Client und nicht auf dem Server ausgeführt werden?

Es gibt viele nahe liegende Ursachen, aber die deutlichste der letzten Jahre ist der Aufstieg von Smartphones.

Smartphones machen mäßig leistungsfähiges Computing billig, allgegenwärtig und nützlich. Sie sind im Besitz von Milliarden von Menschen auf der ganzen Welt und haben im Wesentlichen die Mittelschicht der aufstrebenden Volkswirtschaften mit Computern versorgt. Mobilfunknetze sind jedoch träge, lückenhaft und werden durch geografische, technische und politische Probleme eingeschränkt. In dieser Umgebung ist es für Anwendungen unumgänglich, den Status lokal zu speichern und Daten widerstrebend und bei zustandslosen Vorgängen nach oben zu patchen.

Wie könnte es anders sein? Stellen Sie sich vor, Ihr Smartphone wäre nur ein dummes Terminal. Jede Zustandsmutation müsste asynchron und fehlbar sein. Jedes Laden von Inhalten würde kostbare Cent kosten. Sie müssten in enorme Serverfarmen mit einer Betriebszeit von fünf Minuten investieren. Die Kosten für die Datenverarbeitung würden direkt von Ihnen getragen, sodass ein plötzlicher Anstieg der Popularität Ihr Unternehmen tatsächlich stärken könnte.

Mit clientseitigen Anwendungen können Sie den Status für den einzelnen Benutzer schnell und synchron verarbeiten. Mit ihnen können Sie Ihre Computerkosten an Ihre Benutzer weitergeben. Sie können mit Ausfallzeiten und schlechter Netzwerkverbindung davonkommen. Sie machen den Servercode so dumm, dass er in der Netzwerkinfrastruktur selbst zwischengespeichert werden kann - statische HTML- und JS-Dateien oder vorgefertigte Antworten für mobile Apps.

Um es ganz allgemein auszudrücken: Die clientseitige Entwicklung nutzt die niedrigen Kosten für Personal Computing mit mittlerer Leistung und vermeidet die hohen Kosten für zentralisiertes High-Power-Computing.

Sie haben mehrere Fragen gestellt, von denen einige bereits gute Antworten haben. Einige haben ihre Antworten noch nicht erhalten:

Was ich wissen möchte, ist, warum wir einen solchen Übergang gemacht haben (vom Schwerpunkt der serverseitigen Programmierung zur clientseitigen Programmierung, ... all dies scheint gleichzeitig stattgefunden zu haben) und welche Probleme hat dieser Übergang / diese Verschiebung gelöst?

Robert Harvey gab eine ausgezeichnete Antwort.

... von der Bevorzugung kompilierter Sprachen zu Skriptsprachen,

Skriptsprachen bieten ( auch ) viele Vorteile gegenüber kompilierten Sprachen, zB:

• sind leichter zu erlernen und anzuwenden
• Kompilierzeit eliminieren (schnellere Entwicklung)
• Bieten Sie mehr Funktionen (höhere Anwendungskontrolle)
• Schnelle Änderungen am laufenden Code zulassen
• etc.

... vom Imperativ zur funktionalen Programmierung,

Hier ist ein guter Vergleich, aber ich möchte zusammenfassen, dass das Verwalten von Statusänderungen (Synchronisation über viele Knoten) in verteilter Software (Think Cloud Computing) ein großes Problem sein kann. In der funktionalen Programmierung ist die Notwendigkeit, mit Zustandsänderungen umzugehen, viel geringer.