Linux: In Teamviewer neue ID erzeugen lassen

Hallo,

irgendwie gängelt Teamviewer einen laufend, dass man die Version angeblich kommerziell nutzt, ohne jedoch irgendeinen Beweis dafür zu liefern. Mir ging das die letzen Male ziemlich auf den Keks. Diese Gängelung erfolgt i.d.R. dann, wenn man eine bestimmte Anzahl von Sitzungen unter einer Teamviewer-ID gestartet hat.
Also dachte ich mir, wäre es bestimmt sinnvoll, einfach die ID zu wechseln. Unter Windows geht das m.E. leider nicht, unter Linux dafür umso einfacher.

Installiert als erstes das macchanger-Tool mit:

sudo pacman -S macchanger

oder unter Ubuntu mit dem Pendent:

sudo apt-get install macchanger

Nachdem ihr das installiert habt, stoppt erst mal den Teamviewer-Dämon:

sudo teamviewer --daemon stop

Anschließend ermittelt ihr erst einmal mit:

ifconfig

unter welchem Netzadapter ihr euch verbunden habt. In meinem Fall (Manjaro) war das enp3s0. Führt dann mit dem entsprechenden Adapternamen folgenden Befehl aus:

sudo macchanger -r  > /dev/null

Das könnt ihr, solltet ihr regelmäßig verschiedene Adapter benutzen, für die anderen Adapter wiederholen.
Löscht nun die global.conf-Datei im config-Verzeichnis von Teamviewer:

sudo rm -rf /opt/teamviewer/config/global.conf

Last but not least startet ihr den Teamviewer-Dämon neu:

sudo teamviewer --daemon start

Wenn ihr dann den Teamviewer-(Client) startet, kommt wieder eine Lizenzvereinbarung, die ihr absegnen müsst und ihr habt eine neue ID zugeordnet bekommen.
Linux ist schon verdammt cool.

3-Punkt-Kreisbogen in Standardform bringen

Hallo da draußen,

heute mal ein längerer Beitrag, der mal wieder aus einem Projekt entstanden ist. Aktuell entwickle ich einige Dinge am Laserteile-Shop – es wird demnächst einen sehr speziellen Ableger geben, viel mehr darf ich aber nicht verraten. Im Zuge der Umsetzung sind einige geometrische Dinge umzuwandeln. Bisher bin ich da relativ verschont geblieben, wie bereits im letzten Mathematik-Blog-Eintrag hat das in der Vergangenheit mein Kollege und guter Freund übernommen, der inzwischen aber in Rente ist und wohl nicht mehr allzu viel machen wird.
Daher musste ich mich mal etwas mit der Materie befassen.

Schluss der langen Worte, worum geht es genau?

Ich habe einen Kreisbogen gegeben, der durch 3 Punkte definiert ist:

Startpunkt: P_{0}= (x_{0}, y_{0})
beliebiger Punkt auf dem Kreisbogen: P_{1}= (x_{1}, y_{1})
Endpunkt: P_{2}= (x_{2}, y_{2})

Das entsprechende Format, was ich lesen muss, stellt einen Kreisbogen so dar. Damit ich das aber in ein Vektor-Format (speziell DXF) umgewandelt werden kann, wird der Kreisbogen mit folgenden Parametern erwartet:

  • Mittelpunkt
  • Radius
  • Anfangswinkel
  • Endwinkel

So aus der Kalten hatte ich erst mal gar keine Idee, wie ich das umsetzen kann. Glücklicherweise gibt es ja Google, dabei bin ich auf folgende nette Seite gestoßen:

https://arndt-bruenner.de/mathe/scripts/kreis3p.htm

Um aus den drei Punkten den eigentlichen Kreis zu ermitteln, wird ein Gleichungssystem aufgestellt:

A - Bx_{0} - Cy_{0} = -(x_{0}^{2} + y_{0}^{2})
A - Bx_{1} - Cy_{1} = -(x_{1}^{2} + y_{1}^{2})
A - Bx_{2} - Cy_{2} = -(x_{2}^{2} + y_{2}^{2})

Genaueres könnt ihr dem entsprechenden Link entnehmen.
Mit Hilfe des Gleichungssystems können dann Mittelpunkt und Radius ermittelt werden.
Soweit so gut. Nun muss das Gleichungssystem aber gelöst werden. Hierfür nehmen wir das Gauß-Verfahren. Ich weiß, dass ich das mal zu Studienzeiten in Turbo Pascal implementiert hatte, da das nun aber schon über 20 Jahre her ist, musste ich mir das mal selbst wieder herleiten.
Wieder einmal hat mir da Google geholfen:

https://www.matopt.de/grundlagen/gauss-algorithmus.html

Blöderweise ist dem Autor im Beispiel ein ziemlich schlimmer Fehler unterlaufen, das Tableau 1 ist definitiv falsch, weil er wohl nicht das 3fache der ersten Zeile genutzt hat, sondern das -3 fache der ersten Zeile, was definitiv falsch ist. Aber zumindest die Erklärung ist so nicht schlecht.

Hier wird genauer das Gauß-Verfahren erklärt, allerdings ist da noch keine Computer-Implementierung hinterlegt. Daher werde ich das mal hier in diesem Blog in java tun. Die entsprechenden Dinge erkläre ich dann als Kommentar. Ich habe mir die ganzen Sachen mal hergeleitet, man kann die Klasse mal als Ansatz nutzen, ggf. müsste man noch etwas mehr Fehlerbehandlung durchführen, wenn das System eben nicht lösbar ist.

package com.cutworks.btleasy.helper;
 
import java.util.Vector;
/**
 * Diese Klasse löst ein Gleichungssystem über das Gauss-Verfahren
 * Bei einem Gleichungssystem mit n Variablen werden dabei n Vektoren (Zeilen) der Größe n+1 erwartet,
 * wobei der n+1-te Wert des Vektors das Resultat (ohne unbekannte entspricht)
 * 
 * Beispiel: Für die Gleichung:
 *  2*x + 3*y + 1*z = 5 wird der Vektor: {2, 3, 1, 5} übergeben, für die nächste Zeile dann der nächste Vector, usw.
 *  
 *  
 * @author carsten
 *
 */
public class GaussSolver {
 
 
	@SuppressWarnings("unchecked")
	public static Vector solve(Vector... input) throws Exception {
		if (input.length == 0 || input.length < input[0].size()-1 || input.length >= input[0].size()) {
			throw new IllegalArgumentException("Zur Lösung eines Gleichungssystems mit n unbekannten müssen auch n Vektoren übergeben werden!");
		}
		int size = input.length;
		//der erste Vektor bleibt erst einmal stehen
		//start-Wert der Normalisierung
		//wir fangen mit 1 an und zählen dann später weiter hoch!!
		for (int i= 0; i< size; i++) {
			Vector previousLine = input[i]; //Vektor des entsprechenden Schritts holen = 0. Schritt =&gt; 0. Vektor
			Double prevLineEl = previousLine.get(i); //entsprechenden Spaltenwert holen = 0. Spalte bei 0. Schritt
 
			//nun werden alle restlichen Vektoren durchgegangen
			for (int j = i+1; j<size; j++) {
				Vector line = input[j]; //entsprechenden Vektor holen
				Double elLine = line.elementAt(i); //Wert der Spalte im Vektor des zugehörigen Schrittes holen
				//Ermittlung des Faktors, mit dem die erste Zeile multipliziert wird 
				//um dann die entsprechende Zeile in der i. Spalte durch Addition nullen zu können
				double faktor = (-elLine.doubleValue()/prevLineEl.doubleValue()); 
 
 
				for (int k = i; k < line.size(); k++) {
					double element = line.get(k); //nun alle Elemente des entsprechenden Vektors durchgehen
					double result = faktor*previousLine.get(k)+element; //Faktor*Wert der i.Zeile + Wert der aktuellen Zeile
					line.set(k, result); //und im Vektor aktualisieren!!
				}
			}
		}
		//nun sollte die "Matrix" normalisiert sein 
		//jetzt gilt es noch die entsprechende Werte zu berechnen
		//dieser Vector wird dann später zurückgegeben
		Vector resultVector = new Vector<>();
		//erst mal initialisieren wir ihn mit 0-Werten in der Größe der vorhandenen Variablen
		for (int i=0; i< size; i++) { 
                        resultVector.add(0, 0.0); 
                } 
                //nun gehen wir die Matrix von hinten durch 
                for (int i=size-1; i>=0; i--) {
			Vector vect = input[i];//ermitteln des zugehörigen Vektors
			double summe = 0.0; //Zwischenelement summe initialisieren
			//nun iterieren wir über bereits alle schon ermittelten Resultate und multiplizieren diese 
			//mit den zugehörigen Werten in der Matrix
			//beim ersten Durchlauf wird hier nix iteriert, da wir ja noch kein richtiges Ergebnis haben
			for (int j=i+1; j<size;j++) {
				summe += vect.get(j)*resultVector.get(j);
			}
			//Zur Ermittlung des Wertes wird die letzte Spalte (absolutwert ohne Variable) um die Summe der
			//bereits ermittelten reduziert und durch den entsprechenden Faktor in der Matrix dividiert
			if (vect.get(i) == 0) {
				throw new Exception("Das Gleichungssystem ist nicht lösbar!!");
			}
 
			resultVector.set(i, (vect.get(size)-summe)/vect.get(i));
		}
		return resultVector;
	}
}

Sicher könnte man die Eingabe-Parameter auch als double-Array / zweidimensionales double-Array machen, aber mir erscheint die Lösung mit den Vektoren einfacher, speziell die Befüllung eines / mehrerer Vektoren ist bei weitem einfacher, als programmiertechnisch ein zweidimensionales Array zu erzeugen.

Mit Hilfe des Gauß-Algorithmus haben wir schon die halbe Miete. Wenn man folgende Vektoren übergibt:

\{1, -x_{0}, -y_{0}, -(x_{0}^{2}+y_{0}^{2})\} \{1, -x_{1}, -y_{1}, -(x_{1}^{2}+y_{1}^{2})\} \{1, -x_{2}, -y_{2}, -(x_{2}^{2}+y_{2}^{2})\}

erhält man dann die Werte A, B und C.
Folgt man dann dem Schema auf der Seite von Arndt Brünner kann man dann x_{m} und y_{m} mit folgenden Formeln ermitteln:

 x_{m} = \frac{B}{2}
y_{m} = \frac{C}{2}

und last but not least auch den Radius:
 r = \sqrt{x_{m}^{2} + y_{m}^{2} - A}

Nun haben wir ja fast alles. Bis auf die Winkel….

Gut, dass ich mich für den letzten Mathematik-Beitrag mal wieder etwas mit den Winkelfunktionen beschäftigt hatte. Mit Hilfe dieser kann man dann die Winkel relativ einfach ausrechnen.

Für den Anfangswinkel nutzen wir einfach den Sinus-Satz. Wir erinnern uns:

\sin \alpha = \frac{Gegenkathete}{Hypothenuse}

Die Hypothenuse ist in unserem Fall dann der Radius, die Gegenkathete der Abstand zwischen x_{0} und x_{m}.
Hier ergibt sich dann also:

\sin \alpha = \frac{x_{0}-x_{m}}{r}

Um auf den Anfangs-Winkel zu kommen nutzt man die Umkehrfunktion des Sinus, also den arcussin (asin)

\alpha_{a} = \arcsin(\frac{x_{0}-x_{m}}{r})

Der Endwinkel kann man dann analog ermitteln:

\alpha_{e} = \arcsin(\frac{x_{2}-x_{m}}{r})

Hier ist darauf zu achten, wenn man die Winkel wirklich für eine DXF-Generierung einsetzen möchte, dass an dieser Stelle komischerweise Anfangs- und Endwinkel vertauscht sind.  Erzeugt man die, so wie man sich das eigentlich vorstellen würde, wird der Bogen lustigerweise umgedreht. Wenn man das weiß, ist das aber kein Problem.

Mit Hilfe dieser Sachen konnte ich dann in meinem Projekt aus einem XML-Dokument Polygonzüge auslesen, mit Hilfe der Formeln umwandeln und mit ein paar Freemarker-Templates für ein DXF-Dokument und die entsprechenden DXF-Entities ein im CAD und im Shop lesbares DXF erzeugen.

Ich hätte nie gedacht, mal irgendwann was mathematisches aus meiner Studienzeit wieder auskramen zu müssen. Aber ist schon interessant, wie  das Leben so spielt.

Update 14.05.:

So einfach ist dann das mit den Start- und Endwinkeln wohl doch nicht. Das Problem ist, dass die Vertauschung von Start- und Endwinkeln nur in bestimmten Situationen anwendbar ist, außerdem ist in bestimmten Fällen auch die Subtraktion der Winkel von 360° notwendig.

Durch mehrfaches Trial & Error konnte ich folgende Gesetzmäßigkeiten erkennen:

Vertauscht werden Anfangs- und Endwinkel bei folgenden Situationen:

x_{m} < x_{1}, y_{m} >= y_{1}, x_{2} - x_{0} >= 0, y_{2} - y_{0} >= 0
x_{m} >= x_{1}, y_{m} < y_{1}, x_{2} - x_{0} < 0, y_{2} - y_{0} < 0
x_{m} >= x_{1}, y_{m} >= y_{1}, x_{2} - x_{0} >= 0, y_{2} - y_{0} < 0
x_{m} < x_{1}, y_{m} < y_{1}, x_{2} - x_{0} < 0, y_{2} - y{0} >= 0
x_{m} >= x_{1}, y_{m} < y_{1}, x_{2} - x_{0} < 0, y_{2} - y{0} >= 0
x_{m} < x_{1}, y_{m} >= y_{1}, x_{2} - x_{0} < 0, y_{2} - y{0} >= 0

In diesem Fall werden Anfangs- und Endwinkel getauscht. Zumindest in meinen Beispielen hat das soweit funktioniert.

Abschließend gibt es noch Fälle, in denen der Winkel von 360° subtrahiert wird:

Der Anfangswinkel wird von 360° abgezogen, wenn die Tauschung von Anfangs- und Endwinkel vorgenommen wurde und :
 y_{m} > y_{0}
oder wenn keine Tauschung vorgenommen wurde:
 y_{m} > y_{2}

Der Endwinkel wird von 360° abgezogen, wenn die Tauschung vorgenommen wurde und:
 y_{m} > y_{2}
oder wenn keine Tauschung vorgenommen wurde:
 y_{m} > y_{0}

Nach Einbau dieser Sonderlocken konnte ich dann aus vorgegebenen Konturen auch eine passende DXF erzeugen.

Von Virtualbox auf KVM

Hallo mal wieder,

wie bereits vor einiger Zeit geschrieben, habe ich meinen Desktop-Rechner nun inzwischen komplett auf Manjaro Linux umgestellt, da es Zeit war, sich von Windows 7 zu verabschieden, Windows 7-Updates sowieso nicht möglich waren und die Partitionierung meiner Festplatte sowieso extrem ungünstig war, so dass eine Erweiterung meiner Windows-Daten-Platte nicht möglich war.

Nachdem ich dann Windows7 entfernt und nun die gesamte Festplatte für Manjaro Linux nutze, habe ich mich daran gemacht, Windows 10 auf einer virtuellen Maschine zu installieren. Da ich das öfter gemacht habe, habe ich erst einmal Virtualbox genutzt. Die Installation an sich ging eigentlich ziemlich gut, jedoch fühlte sich alles irgendwie viel langsamer an. Etwas Performance-Verlust war ja abzusehen. Leider musste ich jedoch feststellen, dass die 3D-Beschleunigung von Virtualbox nur Probleme bereitet. Sobald das nämlich passiert, gibt es tierisch viele Grafikprobleme, vor allem mit Office-Programmen (da wird nur die Hälfte dargestellt) und auch das Start-Menü bringt echt unschöne Effekte mit sich. Stellt man die 3D-Beschleunigung aus, funktioniert das zwar dann ohne Probleme, allerdings kann dann Firefox z.B. nicht die 3D-Beschleunigung für das Browsen nutzen, und durch die extrem hohe CPU-Last wird der Rechner extrem langsam.

Zwar habe ich probiert, auch mal den anderen Treiber (statt VboxSVGA den VMSVGA) zu nutzen, was aber daran scheitert, dass es unter Windows 10 da keinen Treiber dazu gibt und am Ende die Auflösung bei mickrigen 1024×768 Pixeln bleibt.

Heute habe ich dann endlich den Schritt gewagt und mir mal KVM angeschaut. Bevor die Installation los geht, prüft erst einmal, ob Eure CPU Hardwarevirtualisierung unterstützt und ob diese im BIOS eingeschaltet ist.

Unter Linux / Manjaro könnt ihr das mit folgendem Befehl prüfen:

grep -E --color=auto 'vmx|svm|0xc0f' /proc/cpuinfo

Außerdem solltet ihr sicher stellen, dass KVM im Kernel aktiviert ist, dass für Eure CPU das entsprechende Modul aktiv und im nested-Modus ist.
Da ich das jetzt nicht komplett erklären will, hier mal die Seite, um alle Bedingungen zu prüfen:

https://wiki.archlinux.org/index.php/KVM

Anschließend könnt ihr die entsprechenden Tools installieren, die die Nutzung von KVM bedeutend erleichtern und eine GUI zur Konfiguration / Installation zur Verfügung stellt.

Als erstes installiert erst einmal die Tools mit folgendem Befehl:

  sudo pacman -S qemu libvirt virt-manager spice-vdagent virt-viewer bridge-utils

Nach der Installation müsst ihr den libvirtd-Dämon starten:

sudo systemctl start libvirtd

Ohne den Start dieses Dämons werdet ihr kein System einrichten können.
Nachdem das passiert ist, habe ich die folgende Anleitung genutzt:

https://dennisnotes.com/note/20180614-ubuntu-18.04-qemu-setup/

Das hat wirklich Top funktioniert. Beachtet auch bitte, den letzten Punkt, d.h. den Download der Spice-Guest Tools auf dem Gast. Ohne diese wird euer System quälend langsam laufen und Euch wirklich keinen Spaß machen.
Die ganze Installation ging ziemlich schnell und hat echt prima funktioniert. Während der Installation hatte ich zwar mal ein paar Grafik-Probleme (einige Striche hier und da), die aber nach Installation der spice-Tools wieder weg waren.
Eigentlich hatte ich ja überlegt, die virtuelle Maschine von Virtualbox direkt nach KVM zu migrieren, es gibt auch eine Anleitung, womit das wohl geht, aber irgendwie hatte ich da einen Fehler gemacht und die Virtualbox-Umgebung startete dann leider nicht mehr.
Da die Virtualbox-Installation sowieso erst mal nur eine Spielumgebung war, tat das dann nicht unbedingt wirklich weh, die Umgebung zu verlieren, eine komplette Neuinstallation war daher nicht wirlich schlimm.
Auf alle Fälle funktioniert nun die Umgebung ausgezeichnet, relativ performant und ohne nervige Grafik-Bugs. Ich bin echt froh, auf KVM gewechselt zu sein.

Winkelfunktionen

Obwohl ich zu Schulzeiten eigentlich ganz gut in Mathe war, habe ich vor allem die Winkelfunktionen nie so richtig verstanden. Ich habe zwar später auch (Wirtschafts-)Mathematik studiert, aber irgendwie habe ich da keine Winkelfunktionen benötigt. Auch bei der Entwicklung des Shops wurde zwar viel Computergeometrie und Winkelfunktionen benötigt, aber die Umsetzung hat mein guter Kollege gemacht, der bereits an der Entwicklung einiger CAD-Systeme beteiligt war und daher blieb mir das erspart.

Neulich habe ich eine Email von meinem Kunden und inzwischen guten Freund bekommen, der für die Erweiterung unseres Shops die Biegeverkürzung berechnen muss.

Das Problem ist eigentlich simpel:

Gegeben sind zwei Linien, die in einem Winkel w zueinander stehen und die beide einen Kreis mit dem Radius r als Tangente berühren. Dabei ist der Abstand zwischen dem Schnittpunkt der Linien und der Tangenten-Punkte gleich lang -> Länge X.

Mit bekanntem Winkel W und Radius r soll die Länge der Strecke X ermittelt werden.
Als mir die Aufgabe gestellt wurde, habe ich erst einmal gar nix verstanden, bzw. wusste auf Anhieb erst mal nicht weiter. Mein großer Sohn hat mir da einen  Tipp gegeben. Wenn man eine Linie zwischen dem Linien-Schnittpunkt und dem Mittelpunkt zeichnet, ergeben sich zwei rechtwinklige Dreiecke. Mit der Prämisse, dass die Abstände X auf beiden Seiten gleich sind, ergibt diese Linie die Winkelhalbierende .

Mit Hilfe des Winkels und einer Seitenlänge kann man mit den Winkelfunktionen die Seitenlänge einer anderen Seite ermitteln.

Es stehen prinzipiell 3 Winkelfunktionen zur Verfügung.

Sinussatz

sin \alpha = \frac{Gegenkathete}{Hypotenuse}

in unserem Fall also :

sin \frac{w}{2} = \frac{r}{h}

Cosinussatz

cos \alpha = \frac{Ankathete}{Hypotenuse}

in unserem Fall also:

cos \frac{w}{2} = \frac{x}{h}

Tangenssatz

tan \alpha = \frac{Gegenkathete}{Ankathete}

in unserem Fall also:

tan \frac{w}{2} = \frac{r}{x}

Für unseren Fall können wir den Tangenssatz nutzen und nach x umstellen.

So ergibt sich:

x = \frac{r}{tan \frac{w}{2}}

Anhand eines Sonderfalls können wir prüfen, ob der Tangenssatz passt. Wenn die Linien im 90 Grad-Winkel stehen, entspricht die Länge von x genau dem Radius.

Setzt man die entsprechenden Werte in die Formel ein ergibt sich:

 x = \frac{r}{tan 45}

Da der Tangens von 45 Grad = 1 ist, ergibt sich:

 x = r

Alternative Berechnung und Herleitung von Tangenssatz

Anhand des Sachverhaltes kann man aber auch den Tangenssatz mit Hilfe des Sinus-Satzes und des Cosinus-Satzes herleiten.

Zur Herleitung wird z.B. das oberste Dreieck genutzt und der Sinus-Satz genutzt.

sin \alpha = \frac{Gegenkathete}{Hypotenuse}

wird nach der Hypotenuse umgestellt. Es ergibt sich also:

 Hypothenuse = \frac{Gegenkathete}{sin \alpha}

Nun nimmt man den Cosinus-Satz:

 cos \alpha = \frac{Ankathete}{Hypotenuse}

und setzt den im Sinus-Satz umgestellten Term für die Hypotenuse ein.

 cos \alpha = \frac{Ankathete}{\frac{Gegenkathete}{sin \alpha}}

Nach „Normalisierung“ des Bruchs ergibt sich:

 cos \alpha = \frac{Ankathete \cdot sin \alpha} {Gegenkathete}

So ergibt sich:

 \frac {cos \alpha}{sin \alpha} = \frac{Ankathete}{Gegenkathete}

bzw.

 \frac {sin \alpha}{cos \alpha} = \frac{Gegenkathete}{Ankathete}

Das ist genau der Tangenssatz, d.h. :

\tan \alpha = \frac {\sin \alpha}{\cos \alpha}  = \frac {Gegenkathete}{Ankathete}

Winkel vs. Bogenmaß

Bei der Berechnung von Sinus, Cosinus und Tangens ist entscheidend, ob der Winkel als „absoluter Winkel“ oder im Bogenmaß angegeben wird. Beim Taschenrechner gibt es drei Modi, der i.d.R. durch die DRG-Taste umgestellt wird. Der „normale Winkel“ Modus ist DEG (D) dort wird der Winkel absolut angegeben, zwischen 0 und 360 Grad. Beim zweiten Modus (RAD) wird ein Winkel als vielfaches von Pi angegeben, dabei ist ein Vollkreis durch

 2\cdot \pi

gekennzeichnet.  Die Umrechnung eines Winkels in Bogenmaß ist dabei ziemlich einfach:

1 Grad = \frac{\pi}{180}

Verschiedene Computerprogramme z.B. auch Excel erwarten Winkel im Bogenmass, so dass ihr die „normalen“ Winkel entweder erst einmal manuell umrechnen müsst, oder durch eine Funktion entsprechend transformieren müsst. In Excel geht das z.B. durch die Funktion: BOGENMASS(Winkel). Bitte achtet bei Excel darauf.

Der dritte Modus GRAD am Taschenrechner ist ziemlich exotisch, dort besteht ein Vollkreis aus 200 Grad. Da das sehr speziell ist, betrachte ich das nicht weiter.

Komisch, dass man, wenn man sich mal wieder mit der Materie beschäftigt und dabei ein praktisches Beispiel hat, das Verständnis doch besser ist, als wenn man das nur in der Schule lernt. Auf alle Fälle habe ich das jetzt verstanden, ich hoffe, mit Hilfe meines Beitrags versteht ihr den Sachverhalt auch besser.

Neue Kategorie Javascript

Ich werde in Kürze wieder ein neues Projekt realisieren, das zumindest vom Backend her viel von der Cutworks-Shop-Logik übernehmen wird. Da die Weiterentwicklung von GWT aber inzwischen seitens Google eingestellt wurde, die Entwicklungsgeschwindigkeit aufgrund der zeitaufwändigen, rechenintensiven Übersetzung von Java nach Javascript ziemlich langsam ist und auch das Debuggen von GWT eher kompliziert ist, bin ich auf der Suche nach einer neuen Frontend-Technologie.
Auch wenn ich Apache Wicket immer noch ziemlich cool finde, da man dort komplett in Java entwickelt, führt inzwischen eigentlich kein Weg mehr an einem Javascript-Framework vorbei.

In der neuen Kategorie werde ich ein paar Javascript-Frameworks vorstellen und meine Arbeit mit Javascript dokumentieren. Seid gespannt, in Kürze kommen einige Beiträge dazu.