Ich möchte professioneller an meine Projekte rangehen

[hmm]

Hi Leute,

ich bin bei neuen Projekten bisher immer relativ schnell mit der erst besten Technologie losgelaufen und habe irgendetwas Implementiert und dass dann solange Refactoriert bis es passt.

Jetzt möchte ich diese Herangehensweise verbessern, dafür habe ich mir folgendes Projekt überlegt:

Ich möchte eine Application schreiben welche:

1. ...ich einfach auf einem beliebigen freien Port eines meiner Linux Server starten kann

2. Die gestartete Anwendung soll folgendes umfassen:

a) Landigpage auf der man seine EMail Addresse eintragen kann, außerdem kann man dort den Datenschutzbestimmungen zustimmen und die EMail per Button absenden.

b) Die Application soll die EMail verifizieren und dem Benutzer eine Willkommensemail zuschicken

c) Impressum+Kontaktseite mit der Möglichkeit EMails an meine EMailaddressen per Kontaktformular zu schicken

d) Die EMails werden in einer engebetteten Datenbank gespeichert

e) Ich möchte die Möglichkeit haben eine EMail an alle EMail Addressen aus der Datenbank zu senden

Ich weiß es gibt bereits Software die das oben beschriebene tut, ich interessiere mich daber dafür das selber zu bauen. Sollte mir das gelingen würde ich das Resultat später für weitere Projekte selbst verwenden, daher versuche ich die Anwendung idealerweise so zu schreiben, dass ich sie leicht irgendwo einbauen und erweitern kann.

Meine Technologie Idee bisher:

1. Eclipse als IDE, weil mir die sehr gefällt

2. Java 9, spring Application, eingebettete H2 Datenbank

3. Ich werde versuche das ganze testgetrieben zu entwickeln

4. Es gibt eine Spring-EMail Funktion die ich nutzen würde, das ganze Teste ich mit dem EMail Client eines meiner Webpakete

5. Das frontend würde ich erstmal mit .html Dateien und später css bauen

Eventuelle Probleme die auftreten könnten/werden:

1. Ich arbeite ungerne mit HTML und CSS, kann ich das irgendwie umgehen? Ich würde die Seiten viel lieber per Zusammenklicken oder java Code erstellen, aber ich glaube das geht nicht…

2. Ich muss gucken wie ich die HTMl Dinger UnitTeste

Fragen:

1. Wie würdet ihr an so ein Projekt herangehen? Angenommen ich wäre Hobbygärtner, dann könnte man sagen, dass ich mir gerne einen englischen teppichrasen heranzüchten würde, qualität ist mir entsprechend wichtiger als zeit und mühe.

2. Was haltet ihr von der Wahl der technologien? Gibts da besseres?

3. UML Diagramme haben mir in der Vergangenheit nicht soviel gebracht wie ich mir gewünscht hätte, würdet ihr an meiner stelle einen Softwareplan erstellen bevor ihr anfangt zu coden? Falls ja, wie würdet ihr diesen bauen? Und mit welchen Technologien?

4. Wie Definiere ich welche Module sinnvoll wären? Und Kapsle ich den Code per Api-Server-Client Architektur oder macht das wenig Sinn, weil ich die ganze Anwendung besser als ein Module definieren sollte? Je mehr Module ich hab desto beschissener wird es den Code zu implementieren, weil ich dann Kreuz und Quer durch die Module klicken muss... andererseits wäre es besser die richtigen Module sofoert anzulegen als später per Refactoring zu modularisieren... könnt ihr mir hierzu ein paar Tipps geben?

[Regina Schaukrug]

...ich einfach auf einem beliebigen freien Port eines meiner Linux Server starten kann

Einfach, beliebiger Port... xinetd kann Dir in vielen Punkten schon mal helfen.

Wie würdet ihr an so ein Projekt herangehen?

Grobplanung -> Feinplanung -> Pflichtenheft mit Mocks -> Speicher, Programmablauf, Module planen -> programmieren 
                                           zeitgleich -> Handbuch schreiben

Vor dem Programmieren alle Funktionen verbindlich vereinbaren.

[hmm]

Grobplanung -> Feinplanung -> Pflichtenheft mit Mocks -> Speicher, Programmablauf, Module planen -> programmieren, zeitgleich -> Handbuch schreiben

ich möchte das projekt alleine und als hobby realisieren

wie baue ich die planung, welche software nehme ich dafür? als worddocument? wie mache ich das möglichst effizient?

[klawischnigg]

Hi there,

ohne Dir nahetreten zu wollen, aber auch nachdem ich mich durch Deine "Rechtschreibe" gequält habe erschliesst sich mir in keiner Weise, warum Du das alles tun willst oder was Du damit bezweckst. Zumindest ganz zart hängt die Auswahl der verwendeten Werkzeuge schon von dem ab, was man damit bauen möchte…

[pl]

Hi,

Ich möchte eine Application schreiben welche:

1. ...ich einfach auf einem beliebigen freien Port eines meiner Linux Server starten kann

Da würde ich mich eher (zunächst) für einen Webserver entscheiden den ich nur noch konfigurieren muss anstatt ihn selbst zu programmieren

2. Die gestartete Anwendung soll folgendes umfassen:

[..] Also Webanwendung.

1. Ich arbeite ungerne mit HTML und CSS, kann ich das irgendwie umgehen? Ich würde die Seiten viel lieber per Zusammenklicken oder java Code erstellen, aber ich glaube das geht nicht…

Klar, Deinen Browser kannst Du Dir auch selber schreiben... aber ich wür'd da eher einen fertigen Browser nehmen. Mit den serverseitigen Anwendungen hast Du doch genug zu tun und wenns später langweilig wird, kannst Du immer noch einen eigenen Server + Client programmieren. Letzeres ist auch nur ein Fensterchen aufm Desktop was per HTTP kommuniziert.

2. Was haltet ihr von der Wahl der technologien? Gibts da besseres?

Nimm doch das was Du kennst und was Du kannst und machs ersteinmal damit.

4. Wie Definiere ich welche Module sinnvoll wären? Und Kapsle ich den Code per Api-Server-Client Architektur oder macht das wenig Sinn, weil ich die ganze Anwendung besser als ein Module definieren sollte? Je mehr Module ich hab desto beschissener wird es den Code zu implementieren, weil ich dann Kreuz und Quer durch die Module klicken muss... andererseits wäre es besser die richtigen Module sofoert anzulegen als später per Refactoring zu modularisieren... könnt ihr mir hierzu ein paar Tipps geben?

Mach Dich erst einmal mit dem Prinzip Client/Server vertraut. Webserver installieren, Browser installieren. Und gucken wie die miteinander reden. Ein Eingabeformular mit Button, das ist doch alles schon fix und fertig vorhanden in Form von native HTML. Wenn Dir das zu langweilig ist, baue Applets oder gleich ne App in JAVA / Perl Tk oder was Du halt schon kennst... Oder vielleicht doch eher so:

Nimm den Browser und lege einen URL fest über den die Komunikation abläuft. Z.B. http://localhost:81/mail.html

Zu diesem URL definiere ein Modul was einerseits das Formular zum Browser schickt und andererseits die Daten empfängt und verarbeitet. Das ist das Frontend.

Ein anderes Modul ist für das Backend zuständig. Das wird vom Manager aufgerufen, braucht also ein Passwort und listet alle Mails die in der DB eingetragen sind womit der Manager das Versenden veranlassen kann.

Nun hast Du schon 2 Module. Haben die was gemeinsam? Mit Sicherheit, finde es heraus. Die Gemeinsamkeit ist eine Basisklasse von der jedes Modul erbt und schon hast Du Deine erste kleine Klassenhierarchie.

MfG

[hmm]

Nun hast Du schon 2 Module. Haben die was gemeinsam? Mit Sicherheit, finde es heraus. Die Gemeinsamkeit ist eine Basisklasse von der jedes Modul erbt und schon hast Du Deine erste kleine Klassenhierarchie.

das verstehe ich, danke.

das sind dann drei module: frontend, backend-manager, common (parent module der beiden module)

d.h. ich hätte keine API für die module.

das frontend kennt sowohl den backend-manager als auch die common (sonst würde das frontend über rest schnittstellen oder über die DB mit dem backendreden, wenn beide auf einem server liegen wäre das aber bisschen bekloppt oder?)

der backend-manager kennt nur die common

richtig?

ich bin ganz gut in java und maven zeugs, wie mache ich meinen webauftritt? nehme ich wordpress plus ein template oder schreibe ich html dateien oder krieg ich das anders besser hin? ich mag es wie bereits erwähnt nicht html code zu schreiben und css schon garnicht. am liebsten bleibe ich in stark typisiertem objektorientierten code.

wenn ich wordpress nehme kann ich wahrscheinlich das ganze frontend module vergessen, weil das dann alles über wordpress läuft oder?

[hmm]

angenommen ich klickere mir eine webseite per wordpress zusammen.

wie müsste ich dann meine spring boot application konstruieren, damit die dazu passt?

damit meine ich:

auf der worpress seite könnte ich wunderbar sachen wie impressum, datenschutzbestimmungen und einen text hinterlegen. aber die oben aufgeführte anwendung:

• besucher gibt seine email ein und klickt auf einen button um sie abzuschicken

• und: manager schaut sich alle emails an und schickt nachrichten an alle gespeicherten emails

würde dann sinnvollerweise über die spring application laufen richtig? wie mache ich das im groben? von wem kommt das formular "email eingeben"? kommt das aus wordpress und komuniziert das einfach mit einem rest service der spring app?

[dedlfix]

Tach!

angenommen ich klickere mir eine webseite per wordpress zusammen.

wie müsste ich dann meine spring boot application konstruieren, damit die dazu passt?

Entweder direkt in das Wordpress-Ökosystem, dann wohl eher in Form eines Plugins, oder du legst das irgendwo anders hin und verlinkst das nur.

von wem kommt das formular "email eingeben"? kommt das aus wordpress und komuniziert das einfach mit einem rest service der spring app?

Wordpress ist ein System zum schreiben von Artikeln. Viel mehr hat es nicht direkt drin. Formularverarbeitung, auch Kontaktformulare, bindet man da in Form von Plugins ein.

dedlfix.

[hmm]

alternativ könnte ich von wordpress aus direkt mit den rest schnittstellen meiner spring app kommunizieren, oder entstehen dabei Probleme?

[dedlfix]

Tach!

alternativ könnte ich von wordpress aus direkt mit den rest schnittstellen meiner spring app kommunizieren, oder entstehen dabei Probleme?

Wordpress kann sowas nicht von Haus aus. Das musst du erst per selbst erstelltem Plugin einbinden.

dedlfix.

[pl]

Nun hast Du schon 2 Module. Haben die was gemeinsam? Mit Sicherheit, finde es heraus. Die Gemeinsamkeit ist eine Basisklasse von der jedes Modul erbt und schon hast Du Deine erste kleine Klassenhierarchie.

das verstehe ich, danke.

Evntl. noch ein paar Anmerkungen: Die Basisklasse hat Methoden die in den Subklassen verwendet werden. Das vermeidet redundanten Code. Eine Subklasse kann jedoch auch Methoden überscheiben nämlich dann wenn sie für die Subklasse spezialisiert werden muss.

das frontend kennt sowohl den backend-manager als auch die common (sonst würde das frontend über rest schnittstellen oder über die DB mit dem backendreden, wenn beide auf einem server liegen wäre das aber bisschen bekloppt oder?)

Data Access Layer sind transparent. D.h., für eine Anwendung wird entweder ein Dateiname oder ein Name der Datenbank konfiguriert. Oder ein URL. Die Anwendung bestimmt nur die Datenstruktur, ob die über HTTP, FTP oder USB und in welchem Format auch immer transportiert wird, interessiert die Anwendung nicht.

Nehmen wir mal an, die Klassen heißen User::Mail und Manager::Mail. Für jede Klasse wird ein URL konfiguriert, z.B. /user/mail.html und /manager/mail.html. Die jeweilige Anwendung im Browser (Frontend bzw. Backend) kennt den URL. Der dazugehörige Code aufm Server kennt den Namen der Datenbank, Host und Port. Der Browser kommuniziert mit dem URL der Server hingegen mit der DB, beide arbeiten jedoch mit denselben Daten in derselben Struktur.

ich bin ganz gut in java und maven zeugs, wie mache ich meinen webauftritt? nehme ich wordpress plus ein template oder schreibe ich html dateien oder krieg ich das anders besser hin?

Lese ich da Wordpress? Das ist wie Fotografieren aus einem fahrenden Auto. Wer sowas macht sollte sich besser dem Kartenspielen widmen 😉

MfG

[beatovich]

hallo

Lese ich da Wordpress? Das ist wie Fotografieren aus einem fahrenden Auto. Wer sowas macht sollte sich besser dem Kartenspielen widmen 😉

Google Streetview kann beides.

[hmm]

Lese ich da Wordpress? Das ist wie Fotografieren aus einem fahrenden Auto. Wer sowas macht sollte sich besser dem Kartenspielen widmen

wenn ich testen möchte ob sich menschen mehr für ein kaffee-spiel oder doch mehr für ein tee-spiel interessieren würde ich so vorgehen:

1. ich baue zwei kleine startspiele dazu

2. ich baue zu beiden spielen eine kleine Webseite die ich zb sehr schnell mit wordpress zusammenklickern könnte

3. jeder interessent könnte seine email für das hauptspiel eintragen

das sammeln der emails läuft dann über eine restschnittstelle die von beiden wordpressseiten angesprochen wird. oder geht das besser? welche Technologie würdest du anstelle von wordpress nehmen? ich bin leider kein designkundiger, darum brauch ich Werkzeuge die mir das weitestgehend abnehmen

[dedlfix]

Tach!

1. Ich arbeite ungerne mit HTML und CSS, kann ich das irgendwie umgehen?

Nicht, wenn du Webseiten erstellen möchtest. Es sei denn, du nimmst ein Framework, das komponentenbasiert arbeitet. ASP.NET hatte diesen Ansatz vor langer Zeit gewählt, um den Desktop-Programmierern den Einstieg in Web-Anwendungen zu erleichern. Das fühlte sich tatsächlich so ähnlich an, wie das Erstellen von Desktop-Programmen, bei denen man die Komponenten mit der Maus auswählt und anordnet. Vermutlich hat das Java-Ökosystem was ähnliches zu bieten. Aber auch damals schon kam man nicht sehr weit, ohne HTML anzufassen, und sei es nur für den Seitenrahmen. Man kann heute zwar immer noch solche Anwendungen erstellen, aber die meisten sind wohl von diesem Ansatz wieder weggekommen und haben sich ASP.NET MVC zugewendet, bei dem das HTML wieder mehr im Vordergrund steht, damit man die gestiegenen Ansprüche an modernes Web besser befriedigen kann.

Ich würde die Seiten viel lieber per Zusammenklicken oder java Code erstellen, aber ich glaube das geht nicht…

Es gibt auch heutzutage noch Hersteller von Komponenten (kommerziell und frei), die dir eine Menge Arbeit abnehmen, beispielsweise Datagrids mit eingebauten Bedienelementen und Funktionalität für Sortieren, Filtern und Gruppieren, oder Tree-Darstellungen oder Diagramme und anderes Zeug. Wenn es dir aber darum geht, HTML-Elemente mit (Java-)Code zu erzeugen, dann sparst du dir aber auch nicht das Wissen um HTML-Elemente und wie sie am besten verwendet werden, um dein Ziel zu erreichen. Das was du sonst als HTML ins Template schreibst, musst du nun in Form eines DOM in deinem Code erzeugen, damit der dann für dich daraus das HTML für den Browser generiert. Da gibt es bestimmt was in Java für diese Vorgehensweise. Das nimmt dir aber nicht die Arbeit ab, sondern gibt ihr nur eine andere Form. Andererseits gibt es quasi-typsichere Autovervollständigung auch im HTML-Editor von Eclipse.

Ich muss gucken wie ich die HTMl Dinger UnitTeste

Wenn mit "HTML-Dingern" Komponenten gemeint sind, die HTML erzeugen, dann unit-testest du das wie jede andere Funktion, die einen String erzeugt.

Wie Definiere ich welche Module sinnvoll wären? Und Kapsle ich den Code per Api-Server-Client Architektur oder macht das wenig Sinn, weil ich die ganze Anwendung besser als ein Module definieren sollte?

Du bist nicht der erste, der solche Projekte realisiert. Und je größer die werden, desto mehr Organisation braucht man, um sie übersichtlich zu halten. Sprich, die einzelnen Aufgaben sollten in überschaubare Einheiten heruntergebrochen werden. Jedenfalls haben schon viele vor dir diese Probleme gehabt und Lösungswege zu finden versucht, indem sie sich grundlegende Architektur überlegt haben. Beispielsweise eine NLayer Architecture.

Je mehr Module ich hab desto beschissener wird es den Code zu implementieren, weil ich dann Kreuz und Quer durch die Module klicken muss...

Ja, oftmals bleibt man nicht dabei, dass man lediglich an einem Modul schraubt, bis es fertig ist, sondern man möchte ja was sehen, also hat man trotz der Arbeitsteilung die Dateien von mehreren Ebenen gleichzeitig offen. Vielleicht kann man das umgehen, indem man erstmal sehr detailliert plant und dann nur noch runterprogrammiert. Ich weiß nicht, ob ich daran Gefallen finden würde.

andererseits wäre es besser die richtigen Module sofoert anzulegen als später per Refactoring zu modularisieren... könnt ihr mir hierzu ein paar Tipps geben?

Erfahrungen sammeln (inlusive negativer) und bei anderen schauen, wie die ihre Projekte organisieren.

dedlfix.

[hmm]

ich komme gut mit Java klar und mir gefällt spring. aus diesem grund würde ich gerne backendseitig damit arbeiten. jetzt muss ich mir noch überlegen was ich für das frontend nehme.

wie würdet ihr das frontend erstellen?

meine Gedanken dazu sind:

-> ein cms suchen das spring unterstützt, Problem: schwer zu bedienen oder unbekannt

-> angenommen ich nehme kein cms, wie krieg ich dann ein gutes frontend realisiert?

-> was würde eine große Firma nehmen?

-> was würde eine kleine Firma mit schlauen Entwicklern nehmen?

-> wenn ich meine spring app starte belegt diese bereits einen port, ist es nicht unschön, dass mein frontend einen weiteren port belegen würde? das wäre zb so wenn ich wordpress nehmen würde

[dedlfix]

Tach!

wie würdet ihr das frontend erstellen?

Kommt drauf an. Wenn es lediglich statische Seite sind, kann man die am Server erstellen und ausliefern. Aber je interaktiver desto Angular.

-> angenommen ich nehme kein cms, wie krieg ich dann ein gutes frontend realisiert?

Du bekommst auch mit CMS kein gutes Frontend hin, wenn du deine Teile nicht anständig zu gestalten und einzubinden in der Lage bist.

-> was würde eine große Firma nehmen?

Irgendeine teure eierlegende Wollmichsau.

-> was würde eine kleine Firma mit schlauen Entwicklern nehmen?

Was kostenloses oder kostengünstiges.

-> wenn ich meine spring app starte belegt diese bereits einen port, ist es nicht unschön, dass mein frontend einen weiteren port belegen würde? das wäre zb so wenn ich wordpress nehmen würde

Es gibt 65535 Ports, von denen du zwar einige nicht verwenden kannst, aber niemals alle belegen können wirst.

dedlfix.

[hmm]

Es gibt 65535 Ports, von denen du zwar einige nicht verwenden kannst, aber niemals alle belegen können wirst.

mir geht es darum eine solide lösung zu basteln, wenn ich ein projekt starte hinterfrage ich nacht für nacht ob meine gewählten Technologien zusammen passen und ob mein Konzept sinn ergibt. und jetzt frage ich mich: macht es sinn dass das backend auf einen port läuft und das frontend unabhängig davon auf einen anderen oder lacht mich dafür jeder zweite Entwickler aus

Kommt drauf an. Wenn es lediglich statische Seite sind, kann man die am Server erstellen und ausliefern. Aber je interaktiver desto Angular.

ich hab mal von einem Entwickler den satz "kein Problem ist zuklein für 10 verschiedene programmiersprachen" gehört, er meinte das aber ironisch. jetzt habe ich das Problem dass ich pausenlos hinterfrage welche Technologien zusammen passen.

wie müsste ich den ein spring-Java-application + angular (1 oder 2?) projekt angehen damit ein zusammenspiel dieser Technologien sinn ergibt? stellt dann die spring app einfach nur die restschnittstellen und das backend und wird von angular angesprochen oder morkse ich Java zeugs in das angular hinein?

[dedlfix]

Tach!

und jetzt frage ich mich: macht es sinn dass das backend auf einen port läuft und das frontend unabhängig davon auf einen anderen

Du kannst VHosts auch dem DNS-Namen nach unterscheiden. Die Frage ist nicht sinnvoll nach der Anzahl der Ports, sondern ob du mehrere VHosts brauchst oder nur einen. Das kann ich dir nicht beantworten. Das musst du selbst entscheiden, ob es für dein Projekt sinnvoll ist, die API zum Backend getrennt von den Dingen des Frontends laufen zu lassen. Es gibt beispielsweise Projekte, die sind klein genug für All-in-One, es gibt technische Herausforderungen, bei denen es einfacher ist, beides zu trennen, obwohl es sonst eigentlich keine Gründe gibt. Und es gibt Projekte, da sind es nicht nur VHosts sondern eigene Maschinen.

ich hab mal von einem Entwickler den satz "kein Problem ist zuklein für 10 verschiedene programmiersprachen" gehört, er meinte das aber ironisch. jetzt habe ich das Problem dass ich pausenlos hinterfrage welche Technologien zusammen passen.

Bei 0815-Web-Projekten hast du derzeit bereits 4 bis 5 (Nicht-nur-Programmier-)Sprachen im Projekt. PHP/Java/irgendeine_serverseitige, SQL, HTML, CSS und Javascript (als fünfte optionale). Die Sprachen sind aber auch nicht allein da, dazu kommt noch das eine oder andere Framework mit seiner eigenen Sprache (DSL) beziehungsweise Funktionsumfang und Lösungsphilosophie.

wie müsste ich den ein spring-Java-application + angular (1 oder 2?) projekt angehen damit ein zusammenspiel dieser Technologien sinn ergibt?

Angular 1 ergibt gar keinen Sinn mehr. Das ist nicht nur abgekündigt sondern auch kein Vergleich zu Version 2 und darüber. Aktuell ist 5.irgendwas. Angular 1 war hauptsächlich zum Sammeln von Erfahrungen da, was man alles besser machen muss und Version 2 war (und ihre Nachfolger sind) dann etwas, mit dem es sich angenehm und konsistent arbeiten lässt.

stellt dann die spring app einfach nur die restschnittstellen und das backend und wird von angular angesprochen oder morkse ich Java zeugs in das angular hinein?

Wenn du einen Sinn darin siehst, eine Angular-Anwendung aufzusetzen, dann beschränkt sich in aller Regel der Server-Teil auf das Ausliefern der für das Frontend benötigten Dateien und die REST-Schnittstelle. Es spricht aber auch nichts grundsätzliches dagegen, neben der Frontend-Application weitere Webseiten statisch oder dynamisch bereitzustellen.

Üblicherweise wird für die Angular-Anwendung ein Packmechanismus verwendet (z.B. Angular CLI mit WebPack), um die Zahl der auszuliefernden Ressourcen gering zu halten. Es wäre jedenfalls nicht sehr sinnvoll, da irgendwie mit Java/whatever was "hineinzumurksen", und mir fällt da auch grad nicht ein, wozu man das sinnvoll verwenden könnte und für das es keine Alternative gibt. Wohl aber kannst du mit Java/... Aufgaben des Scaffolding erledigen.

dedlfix.

[Mitleser]

Du kannst VHosts auch dem DNS-Namen nach unterscheiden.

Oder mittels eines Proxy bei nur einem Hostnamen anhand bestimmter URL-Fragmente verschiedene Backends auf verschiedenen Servern und Ports ansprechen. Oder... oder...

[beatovich]

-> was würde eine kleine Firma mit schlauen Entwicklern nehmen?

Was kostenloses oder kostengünstiges.

Sehr wahrscheinlich Apache plus PHP, oder etwas ähnliches. Ich wundere mich nur, da der Poster sagte, er verfüge über ein Webpacket. Und da ist ja genau dies sehr wahrscheinlich bereits vorhanden und direkt zu gebrauchen.

[hmm]

Sehr wahrscheinlich Apache plus PHP, oder etwas ähnliches. Ich wundere mich nur, da der Poster sagte, er verfüge über ein Webpacket. Und da ist ja genau dies sehr wahrscheinlich bereits vorhanden und direkt zu gebrauchen.

mein webpaket besteht aus einer cloud ubuntu 16 vm und einer domain

[Matti Mäkitalo]

Hallo,

1. Ich arbeite ungerne mit HTML und CSS, kann ich das irgendwie umgehen? Ich würde die Seiten viel lieber per Zusammenklicken oder java Code erstellen, aber ich glaube das geht nicht…

Da fiele mir zum Beispiel GWT ein, dass das mW erlauben soll. Da ich aber persönlich lieber näher an HTML arbeite halte ich von solchen Frameworks eher Abstand. Der Standard-Spring-Weg über Thymeleaf wäre daher meine Wahl.

2. Ich muss gucken wie ich die HTMl Dinger UnitTeste

Wenn du HTML selber schreibst (auch, wenn du Komponentenbibliotheken wie JSF u.ä. verwendest) willst du keinen Unit-Test dafür schreiben. Ich würde dir empfehlen, einen GUI-Test (mit Mock-Backend oder als Integrationstest mit echten Backends) zu schreiben. Ansatzpunkte bzw. Stichworte: Selenium (wenn du mehrere Browser nutzen willst) oder du nimmst deinen bevorzugten Browser in der "headless"-Variante (z.B. bei firefox, chrome verfügbar). Dann programmierst du die Interaktionen des Benutzers mit der Seite und testest, ob nach den Interaktionen entsprechende Informationen in der GUI zu sehen sind.

Ich rate dir hier aber, dass du nicht zu viel auf einmal lernst. Schau erstmal, dass du ordentliche Unit-Tests schreibst. GUI-Tests sind dann nochmal ein ganz neues Thema.

1. Wie würdet ihr an so ein Projekt herangehen? Angenommen ich wäre Hobbygärtner, dann könnte man sagen, dass ich mir gerne einen englischen teppichrasen heranzüchten würde, qualität ist mir entsprechend wichtiger als zeit und mühe.

Es kommt sicher darauf an, in welchem Umfeld du es verwenden willst. Beruflich verwenden wir in meiner Firma viel Liferay, eine professionelle Portal-Lösung - davon gibt es auch eine Open-Source-Variante. Die nimmt dir das ganze Benutzerhandling, E-Mail-Validierung usw natürlich sofort ab und du kannst dich in die Portlet-Programmierung stürzen. Ist aber auch etwas gewöhnungsbedürftig. Ansonsten ist dein Ansatz über Spring schon nichtmal schlecht.

Bis auf deine Auswahl von eclipse. Ich lese im anderen Thread, dass du Student bist - hole dir ASAP eine Studentenlizenz von IDEA IntelliJ und steig um. Das wird dir schon mittelfristig dutzende Stunden Konfiguration von eclipse (oder, wie ich es nenne, Schrottlipse) sparen.

2. Was haltet ihr von der Wahl der technologien? Gibts da besseres?

Wenn du im Java-Umfeld bleiben willst, sehe ich nur drei relevante Optionen, insb. wenn du das auch als Vorbereitung für dein Berufsleben nutzen willst: Spring und JEE als die großen Enterprise-Java-Webframeworks und Liferay als "fertige" Portal-Lösung.

3. UML Diagramme haben mir in der Vergangenheit nicht soviel gebracht wie ich mir gewünscht hätte, würdet ihr an meiner stelle einen Softwareplan erstellen bevor ihr anfangt zu coden? Falls ja, wie würdet ihr diesen bauen? Und mit welchen Technologien?

Ich bin kein UML-Fan. Ein paar grobe Skizzen für die Architektur sind aber hilfreich. Wichtig sind:

• welche Komponenten will/kann/muss ich verwenden, wie sind diese verbunden? Datenbank, User-Store, Application Server, …
• Welche User-Gruppen/-Rollen gibt es, welche Use-Cases nutzen sie (ein klassisches Use-Case-Diagramm).
• ER-Diagramm ist hilfreich. Wenn es komplizierter wird aber nicht ein Diagramm für die ganze DB, sondern domainenbezogene kleinere.

4. Wie Definiere ich welche Module sinnvoll wären? Und Kapsle ich den Code per Api-Server-Client Architektur oder macht das wenig Sinn, weil ich die ganze Anwendung besser als ein Module definieren sollte? Je mehr Module ich hab desto beschissener wird es den Code zu implementieren, weil ich dann Kreuz und Quer durch die Module klicken muss... andererseits wäre es besser die richtigen Module sofoert anzulegen als später per Refactoring zu modularisieren... könnt ihr mir hierzu ein paar Tipps geben?

Ich würde mal mit zwei Modulen starten:

• Frontend
• Business-Logik

Deine Business-Logik teilt sich dann in folgende Teile:

• eine Boundary. Hier machst du pro use-case eine Methode rein. Das Frontend darf nur Methoden aus der Boundary aufrufen. Die Boundary darf nur Methoden aus dem BL-Logik aufrufen (nicht aus der Boundary). Aufgabe der Boundary ist insb. der Transaktionsabschluss.
• Business-Logik. Hier gibt es zwei Varianten: Anemic Design und DDD. Im Anemic-Design machst du kleine Entity-Klassen ohne eigene Logik (deine Entities sind also nur Getter/Setter). Die Logik kommt dann in *Service-Klassen, welche die Entities dann passend bearbeiten. Das ist vielerorts gängige Praxis, hat aber den Ruf einer bad practice. Die Alternative DDD bedeutet, dass deine Entities Logik beinhalten. Service-Klassen schreibst du nur noch für Infrastruktur-Aufgaben.
• Entities (im Falle von Anemic Design) und Repositories sind etwas näher an der DB dran.

Generell empfehle ich dir, deinen Code nach inhaltlichen und nicht nach strukturellen Erwägungen zu sortieren. D.h. deine packages sind nicht "controller", "entities", ... sondern zum Beispiel "userregistration", "userconfirmation", … In vielen Tutorials sieht man es leider anders, aber das halte ich für Murks.

Der Vorteil des separaten BL-Moduls ist, dass du hier später noch ein API-Modul draufsetzen kannst, wenn du z.B. eine Single-Page-App bauen willt und ein ReST-Frontend brauchst.

Viele Grüße Matti

[1unitedpower]

Hallo hmm,

rückblickend wüsste ich bei all meinen Projekten was ich besser machen könnte, und das wird hoffentlich auch immer so bleiben. Will sagen, "professionell" ist kein Zustand, den man irgendwann meistert und an dessen Ende das vollkommene Stück Software schlummert, sondern ein ständig andauernder Lernprozess. Dass du gerade deinen Entwicklungsprozess vor dem Beginn eines neues Projekts evaluierst und zu optimieren versuchst, ist bereits ein professioneller Schritt. Das mache ich zu Beginn meiner Projekte auch verstärkt, mir nützt es aber auch schon während der Entwicklung Entscheidungen neu zu bewerten. Manchmal komm ich zu dem Schluss, dass ich ein Framework oder eine Library besser nicht eingesetzt hätte, und obwohl es für das laufende Projekt zu spät ist, daran etwas zu ändern, habe ich für das nächste Projekt etwas gelernt. Ich denke, das ist ein ganz natüricher Lernprozess, den man unterbewusst sowieso die ganze Zeit durchlebt, und den man noch intensivieren kann, indem man sich regelmäßig (und nicht nur am Anfang eines Projekts) bewusst damit beschäftigt.

Wenn ich dein Posting richtig verstehe, fragst du nun danach was du in deinem Entwicklungsprozess als nächstes verbessern könntest. Das ist keine Frage, die ausschließlich andere für dich beantworten können. Zum Beispiel sagst du, dass du mit Java gut zurecht kommst, dann solltest du daran für den Moment auch nichts ändern (außer aus Neugier und der Freude am Erlernen neuer Sprachen). Mich persönlich behindert Java eher bei der Arbeit, das heißt nicht das Java unprofessionell ist, es wäre nur unprofessionell von mir mit Java zu arbeiten trotz des Wissens, dass ich mit anderen Sprachen produktiver wäre. Genauso sagst du, dass du Eclipse gut findest, also warum was daran ändern? Von UML sagst du, es hat dir in der Vergangenheit nicht besonders geholfen, ein Werkzeug, dass dich nicht unterstützt, das wäre ein Punkt an dem du ansetzen könntest. Ich mag UML auch nicht besonders, hab aber auch gemerkt, dass ich ganz ohne grafische Beschreibung meiner Programme nicht besser dran bin. Für mich habe ich einen Mittelweg gefunden, indem ich formlose Skizzen anlege, die ich nach Bedarf erstelle. Außerdem scheinst du Schwierigkeiten bei der Architektur deiner Software zu haben, bisher hast du einen ad-hoc Ansatz verfolt: schnell loslegen, dann aufräumen, und das Spiel wieder von vorn. Beim deinem nächsten Projekt könntest du mal eine existierende Software-Architektur anwenden, in Java ist Clean Architecture sehr beliebt. Das wäre eine sehr unmittelbare Maßnahme. Eine eher mittelbare Maßnahme wäre es, den prototypischen Entwicklungsprozess beizubehalten, aber etwas an deiner Programmier-Disziplin zu ändern: Eine Programmier-Disziplin hast du ja schon genannt: Test Driven Development (TDD), für viele Programmierer ist das der heilige Gral. Ich hab damit leider auch so meine Schwierigkeiten, ich schreibe zwar Tests, aber meistens im Nachhinhein, ich kann mich von den Tests nicht wirklich bei der Entwicklung "treiben" lassen. Aktuell bin ich bei einer Kombination aus "Documentation Driven Development" und "Type Driven Development" angelangt: Beim ersten Ansatz schreibt man zunächst die Dokumentation für ein Software-Modul in natürlicher Sprache auf, beim zweiten Ansatz in einer formalen Sprache (häufig benutzt man dafür die Typsignaturen der verwendeten Programmiersprache, daher der Name).

Auf den Punkt gebracht: Finde heraus was für dich funktioniert. Dabei kann es hilfreich sein, sich an dem zu orientieren, was anderen hilft, aber wenn eine Technik oder ein Werkzeug, dir keinen Nutzen bringt, dann zieh weiter, probier was anderes aus. Manchmal hilft es auch eine Technik, nach mehreren Jahren mit einem breiteren Erfahrungsschatz neu zu bewerten: Wenn TDD heute nicht für dich funtkioniert, ist es vielleicht einfach zu früh, vielleicht hilft es dir aber in zwei oder drei Jahren.

[hmm]

danke für die ausführlichen postings! gestern hatte ich eine prüfung (bestanden aber "nur" mit 2,7), darum erst jetzt die antworten.

ich könnte folgendes tun:

a) mir eine webseite per wordpress zusammenklickern die vieles was ich mir wünsche kann (email verwaltung würde bereits gehen, shopsystem könnte ich mir reinklickern wenn ich eins zum vertrieb von software brauche etc.)

b) auf dieser wordpress seite könnte ich d3 js scripte hinterlegen die daten visualisieren

c) ich könnte das backend meiner anwendung als springapp mit java realisieren, das backend wäre dann über json rest schnittstellen erreichbar. dieses backend kann ich mit tests abdecken.

d) die kommunikation zwischen frontend und backend könnte zb dadurch gehen, dass frontendseitig javascript requests zu meiner json schnittstelle schickt, alternativ könnte frontend und backend über eine tabelle komunizieren oder aber wie bereits oben geschrieben könnte ich versuchen einen spring client in wordpress reinzumorksen

was könnt ihr mir zu dieser idee sagen? was haltet ihr davon? begehbarer weg? insbesondere würde mich interessieren wie ihr die drei möglichkeiten von d) einschätzt, da mache ich mir am meisten sorgen bezüglich performance und sicherheit

[pl]

was könnt ihr mir zu dieser idee sagen? was haltet ihr davon? begehbarer weg? insbesondere würde mich interessieren wie ihr die drei möglichkeiten von d) einschätzt, da mache ich mir am meisten sorgen bezüglich performance und sicherheit

Na wenn Du das mit Wordpress erledigen willst, sollte die Frage der Sicherheit doch geklärt sein 😉

Ansonsten guck mal was WP unter XMLRPC versteht und dafür vorhält: Nämlich alldas was Dein Herz begehrt in Sachen Rest Schnittstelle. Somit kannst Du Dich voll und ganz auf die Entwicklung Deines Backends konzentrieren und soll ich Dir noch was sagen: Das ist eine saugute Idee!!!!

MfG

[markk]

Moin,

neben den bereits anderen guten Antworten möchte ich ein paar technische und me­tho­do­lo­gisch Anreize und Tools in den Raum werfen )ohne dabei zu sehr auf deine erwaehnte Probleme einzugehen) - ausgehend von deinem Java-Background und der Aussage, dass du dich gerne weiter entwickeln moechtest.

Ich entwickle seit einigen Jahren ausschließlich testgetrieben. Testgetrieben zu entwickeln bedeutet den Code so zu implementieren, dass er einfacher testbar ist. Allein durch diese Vorgehensweise folgt man recht intuitiv bekannten Pattern und Prinzipien und erhoeht Qualitaet und Wartbarkeit.

SOLID

Beispiele:

a) Code under test darf keine neue Instanzen erstellen oder auf static Methoden zugreifen, da diese nicht (lies: nur sehr schlecht) testbar sind. Spring-Boot liefert hierzu beste Voraussetzungen. Dependencies werden injected, können in den Tests als Mock übergeben werden. --> (Teile von) Inversion of control werden erfüllt.

b) Angenommen man hat einen Converter-Service, der durch eine beliebige Liste von Converter iteriert und Daten von x nach y converted:

if(myConverter.class == XMLConverter)
   myConverter.convertToXml()
else if(myConverter.class == PDFConverter)
   myConverter.convertToPDF()

Dies ist recht aufwendig zu testen, und bei jeder Erweiterung muss der Service modifiziert werden. --> Testgetrieben fällt einem bereits vor der Implementierung auf, dass das Open-close-principle nicht eingehalten wird: Open for extension, close for modification. OCP folgend wird der Code in etwa so aussehen, da alle Converter einem Interface folgen.

myConverters.foreach {
    it.convert()
}

c) Da fuer eine Unit sehr haeufig drei/vier oder mehr Tests (plus Negativtest(s)) erstellt werden, merkt man beim Testen bereits, dass eine Klasse eventuell zu viele Aufgaben hat. Spaetestens wenn dann noch n Services gemockt werden muessen, refactored man die unit under test in mehrere Units. --> single-responsibility, seperation of concerns werden eingehalten.

Ich koennte hier noch recht viele Beispiele nennen, aber ich denke du weiszt worauf ich hinaus moechte..

Lesestoff:

• https://zeroturnaround.com/rebellabs/object-oriented-design-principles-and-the-5-ways-of-creating-solid-applications
• https://dzone.com/articles/the-solid-principles-in-real-life
• https://en.wikipedia.org/wiki/SOLID_(object-oriented_design)

Testing Tools

Testgetrieben zu entwickeln bedeutet, dass man den Spring-Container haeufig lediglich dazu starten muss, dass der Test ausgefuehrt werden kann. Da das ein paar Sekunden in Anspruch nimmt und ein Entwickler ungerne wartet, empfiehlt es sich sehr dem Prinzip der Testing-Pyramide zu folgen:

• Viele Unit-Tests
• Einige Integration-Tests
• Wenige Functional-(E2E)-Tests

Spring-Boot bietet allerdings an, fuer Integration-Tests nicht den gesamten Container starten zu muessen. Das heisst du kannst auf die Annotation @RunWith(SpringRunner.class) verzichten, und dennoch wird der ServletContext initialisiert, sprich Routes werden erstellt, Annotations interpretiert, Beans geladen etc.. Beispiel Request innerhalb eines Tests:

MockHttpServletResponse response = this.mockMvc.perform(
    MockMvcRequestBuilders
        .get(url)
        .accept(MediaType.APPLICATION_JSON))
        .andReturn()
        .response

Ich persönlich nutze (wenn ich die Auswahl habe) in fast allen Projekten das Spock-Framework. Dies ist ein Testing-Framework basierend auf Groovy. Beispiel:

def 'getById: convert businessAreaEntity to DTO and return it'() {
    given:
    businessAreaServiceMock.findById(_, _) >> ANY_BUSINESS_AREA_ENTITY_1

    when:
    BusinessAreaDTO result = underTest.getById(AUTH_USER, ANY_BUSINESS_AREA_ID_1)

    then:
    1 * objectConverterMock.createDto(ANY_BUSINESS_AREA_ENTITY_1) >> ANY_BUSINESS_AREA_DTO_1
    result == ANY_BUSINESS_AREA_DTO_1
}

Durch die benannten Methoden und given-when-then-Syntax sind die Tests sehr einfach zu lesen und zu verstehen.

Fuer das Mocking von 3rd-Party-Diensten (oder generell Requests, die nach "drauszen" gehen) kann ich Wiremock empfehlen. Hierueber kann man ausgehende Request abfangen und beliebige Responses emulieren.

Lesestoff:

• https://martinfowler.com/bliki/TestPyramid.html
• https://thepracticaldeveloper.com/2017/07/31/guide-spring-boot-controller-tests/
• http://spockframework.org/
• http://wiremock.org/docs/getting-started/
• https://dzone.com/articles/spring-4-groovy

Module Design

4. Wie Definiere ich welche Module sinnvoll wären? Und Kapsle ich den Code per Api-Server-Client Architektur oder macht das wenig Sinn, weil ich die ganze Anwendung besser als ein Module definieren sollte? Je mehr Module ich hab desto beschissener wird es den Code zu implementieren, weil ich dann Kreuz und Quer durch die Module klicken muss... andererseits wäre es besser die richtigen Module sofoert anzulegen als später per Refactoring zu modularisieren... könnt ihr mir hierzu ein paar Tipps geben?

Stateless RESTful-JSON-APIs auf Microservice-Basis sind so ziemlich Standard in der heutigen Web-Welt. Das Trennen von Frontend-Logik und Backend auch. Wegen der von dir erwaehnten Gefahr bezgl. einer kreuz-und-queren-Kommunikation gibt es wohl definierte software designs. Je nachdem, fuer welche du dich entscheidest, klaeren sich diese Probleme eigentlich recht schnell.

Beispiel (vereinfacht) anhand DDD (domain-driven-design) Es ist klar definiert, wo welche Logik zu implementieren ist. Frontend im UI-Layer, Handling im Application-Layer, Business-Logik im Domain-Layer, Repositories (Persistence) im Infrastructure-Layer. Wird eine Domain zu grosz, wird sie in einzelne Module unterteilt und es greift das Aggregation pattern: Mehrere Module werden von einem root-Modul orchestriert.

Beispiel (vereinfacht) anhand SOA (service-oriented-architecture) Jedes Modul ist self-contained, also in sich selbst gekapselt, ist eine Blackbox nach auszen, und spiegelt eine eindeutige Business-Activity mit wohl-definiertem Output wieder. Die Kommunikation zwischen Modulen findet ueber Contracts statt. D.h. auch hier findet eine explizite Definition von Modulen statt.

Natuerlich gibt es noch einige andere Loesungsansaetze in der Software-Architektur.

Lesestoff:

• https://www.nginx.com/blog/refactoring-a-monolith-into-microservices/
• https://technologyconversations.com/2014/08/12/rest-api-with-json/
• https://www.infoq.com/minibooks/domain-driven-design-quickly
• https://en.wikipedia.org/wiki/Service-oriented_architecture

Monitoring

Wie auch immer man sich entscheidet, durch distributed services kommen ein paar Komplikation auf einen zu, vor allem wenn man mitbekommen moechte, was genau wo und wann geschieht.

Hier hat sich der ELK-Stack (Elasticsearch, Logstash, Kibana) sehr etabliert. (Neuerdings ist da noch Beat hinzugekommen).

Der Ablauf des ELK-Stacks kurz skizziert:

• Jeder Microservice loggt in sein eigenes Logfile.
• Filebeat pushed changes nach Logstash
• Logstash parsed anhand definierter Grok-Patterns die unterschiedlichen Logfiles und sendet sie an Elasticsearch
• Kibana liest die Daten aus Elasticsearc aus und visualisiert sie entsrepchend.

Lesestoff:

• https://logz.io/learn/complete-guide-elk-stack/
• https://www.elastic.co/guide/index.html
• https://www.elastic.co/guide/en/logstash/current/plugins-filters-grok.html
• https://www.elastic.co/products/kibana
• https://www.elastic.co/products/beats/filebeat

Continuous deployment, Containers

Auch zum mittlerweiligen Standard gehoert das kontinuierliche Deployment der Anwendungen. Hier gibt es diverse Anbieter - von kostenfrei bis zu Enterprise, name-dropping: Teamcity, Jenkins, Gitlab CI.

Lesestoff:

• https://www.jetbrains.com/teamcity/features/
• https://docs.gitlab.com/ce/ci/environments.html
• https://dzone.com/articles/jenkins-pipeline-for-continuous-delivery-and-deplo

Diverses

Da du ja sehr interessiert bist, neue Dinge zu lernen, moechte ich an dieser Stelle (kontextlos) noch Histrix, Docker und Kubernetes, so wie AWS serverless erwaehnen.

Cheers, markk

[hmm]

danke, das werde ich mir genauer anschauen.

Ich sag dir dann bescheid, bzw. werde weitere Fragen dazu stellen. Übrigens gab es in der aktuellen Ausgabe von "Java Aktuell" einen bericht über die Testgetriebene Entwicklung, dass Fazit war: Entwickler die das benutzen möchten sollten das auch dürfen, aber man sollte keine Entwickler dazu zwingen. Außerdem war der Autor der Meinung, dass er jetzt stärker auf testbaren Code achtet (was glaube ich zu deiner Anmerkung über testbaren Code passt). Der Artikel sagt aber auch, dass es extrem schwer sein soll die Testgetriebene Entwicklung zu lernen und sie anzuwenden. Nimmst du sowas wie Sona Qube um die Testabdeckung zu prüfen?

U.a. mit Docker soll ich mich jetzt ab dem 01.06 als frisch beginender Applikationsentwickler auseinander setzen. Ich bin gespannt.

[markk]

Moin,

Entwickler die das benutzen möchten sollten das auch dürfen, aber man sollte keine Entwickler dazu zwingen.

Da stimme ich mit dir ueberein. Wozu man Entwickler meiner Meinung nach jedoch (berechtigter Weise) zwingen darf (und das tue ich auch), sind Tests im Allgemeinen.

Der Artikel sagt aber auch, dass es extrem schwer sein soll die Testgetriebene Entwicklung zu lernen und sie anzuwenden.

Es braucht schon seine Zeit, da liegst du mit deiner Aussage richtig. In vielen unterschiedlichen Projekten habe ich jedoch haeufig festgestellt, dass Entwickler, die bis dato nicht mit TDD entwickelt haben, nach ein paar Monaten sich eine nicht-test-getriebene Entwicklung nur noch schwer vorstellen koennen.

Irgendwann gelangt man an den Punkt, an dem man der Meinung ist, nur Code, der entsprechend getestet ist, sei valider Code - und Code, der nicht getestet ist, ist nicht relevant und darf entfernt werden. Natuerlich ist das uebertrieben, aber solange die Qualitaet dadurch steigt, ist es eine willkommene Einstellung.

Es ist von groszen Vorteil, wenn man TDD in einem Team mit erfahrenen Entwicklern lernen kann. Denn haeufig reicht die Theorie nicht aus, und mit ein zwei real-world examples erklaeren sich die Dinge dann recht schnell.

Außerdem war der Autor der Meinung, dass er jetzt stärker auf testbaren Code achtet (was glaube ich zu deiner Anmerkung über testbaren Code passt).

Ja, genau, das war das, was ich mit den design principles zu erklaeren versucht habe.

Nimmst du sowas wie Sona Qube um die Testabdeckung zu prüfen?

Sonaqube hat durchaus seine Vorteile, gerade was Code Smells angeht. Ich kann zu der Benutzung raten. Wenn es dir jedoch ausschlieszlich um Code-Coverage geht, dann wuerde ich mir mal JaCoCo o.ae. naeher anschauen. IntelliJ (zum. in Verbindung mit Gradle) bietet Code-Coverage z.B. bereits von Hause aus an (run with coverage).

Es sei noch gesagt, dass Testabdeckung nicht nur schwarz-weisz betrachtet werden sollte. Am Anfang ist das Ziel einer 100%igen Abdeckung ehrenhaft - da man dabei dann auch sehr viel lernt. In echten Projekten koennen aber auch 85% oder 90% zufriedenstellend sein - vorausgesetzt, dass es e2e-Tests gibt, die zumindest einmal jeden moeglichen Workflow durchlaufen, so dass es dennoch "knallt", sollten Contracts gebrochen werden.

Aber bedenke, bei Reduzierung von Testabdeckung schwindet prozentual die Vergewissheit, dass der Code das tut, was er tun soll.

U.a. mit Docker soll ich mich jetzt ab dem 01.06 als frisch beginender Applikationsentwickler auseinander setzen. Ich bin gespannt.

Na, das ist doch toll! Bist du Teil eines Teams?

Cheers, markk