Was treiben die Hobby Programmierer denn so ?

[uburoi]

Ich hab auch noch nicht so ganz verstanden, was Dein Ziel ist. Primär zu lernen wie man Lexer und Parser schreibt, oder primär eine eigene Sprache zu implementieren

Eine eigene benutzbare Sprache wäre eher ein Fernziel. Mir geht es vor allem darum zu verstehen, wie die einzelnen Teile funktionieren (Lexer > Parser > Interpreter/Compiler). Als Beispiel habe ich erstmal etwas Einfaches wie das hier genommen:

var a = 2
var b = 3
print (a + b)

Da lauern natürlich schon etliche Fallstricke, das weiß ich (implizite Typkonvertierung etc.). Ich hänge aber jetzt primär an der Frage, wie es weitergeht, sprich: wie komme ich jetzt von meiner Token-Liste zu einem Syntaxbaum. Sicherlich gibt es da vieles, das die Arbeit übernimmt (ich hatte mir schon mal flüchtig ANTLR angesehen), aber das hilft mir nicht, wenn ich nicht verstehe, was da passiert. Und momentan fehlt mir noch ein für mich nachvollziehbares "Packende", von dem aus ich weitermachen kann …

Gruß Jens

 

[michi.o]

Und momentan fehlt mir noch ein für mich nachvollziehbares "Packende", von dem aus ich weitermachen kann

Ich würde versuchen, das von der anderen Seite aus zu betrachten. Historisch war z.B. erst die CPU da, dann Assembler, dann die Hochsprachen.

Von der Hochsprache ausgehen zu wollen und dann zu begreifen wie man von dort weitermacht, halte ich für schwieriger. Mann muss erst mal den Low-Level Part verstehen um die logische Verbindung herzustellen.

Bei C war der Gedankengang z.B. "Hier sind einige Zeilen Assembler, die 2 Zahlen addieren. Wie kann man das einfacher schreiben?". Dann wurde eben so was draus:

void main()
{
  int a = 123;
  int b = 456;
  int c = a + b;
}

Wenn ich das sehe, weiss ich natürlich nicht was das Ziel vom Parser ist. Wenn ich aber von Assembler komme, ist das deutlich klarer.
In Assembler sieht der Code so aus (lässt sich mit "gcc -S main.c" erzeugen):

main:
    pushq    %rbp             // Sichere den Wert vom Stack Frame Register
    movq    %rsp, %rbp        // Kopiere Wert vom Stack Pointer rsp nach rbp
                              // %rbp ist damit die erste freie Adresse im Stack
    movl    $123, -12(%rbp)   // Schreibe die Zahl 123, an die Adresse -12(%rbp)
                              // Also 12 Byte von %rbp entfernt
    movl    $456, -8(%rbp)    // Schreibe die Zahl 456, an die Adresse -8(%rbp)
                              // Also 8 Byte von %rbp entfernt
    movl    -12(%rbp), %edx   // Kopiere Wert von -12(%rbp) ins Register edx
                              // Das ist unsere 123
    movl    -8(%rbp), %eax    // Kopiere Wert von -8(%rbp) ins Register eax
                              // Das ist unsere 456
    addl    %edx, %eax        // Addiere die Register edx und eax
                              // Das Ergebnis steht danach in eax
    movl    %eax, -4(%rbp)    // Kopiere Wert von eax an die Adresse -4(%rbp)
                              // Also 4 Byte von %rbp entfernt
    nop                       // Mache nichts
    popq    %rbp              // Stelle den Stack Frame Register wieder her
    ret

Wenn man weiss, wie Assembler geht, dann fällt es einem einfacher einen C-Parser zu schreiben. In dem Beispiel muss man bereits wissen, was es für Register gibt und wie man auf den Speicher zugreift. Für jemanden, der nichts von CPUs oder Assembler weiss, ist das extrem kompliziert.

Was ich sagen will: Schaue erstmal was der Output von Deinem Parser sein soll, dann überlege erst wie der Input auszusehen hat. Ist einfacher zu verstehen als anders herum.

Im Falle von Programmiersprachen würde ich mir tatsächlich erst anschauen, was eine CPU eigentlich macht, dann einige einfache Assembler Beispiele. Das wäre sogar mein Tipp für alle Programmieranfänger.

 

[andy_m4]

Wenn ich das sehe, weiss ich natürlich nicht was das Ziel vom Parser ist.

Das Ziel des Parsers ist den Quelltext in eine Form zu überführen, wo die Semantik des Programms leicht erfassbar ist. Was Du meinst ist die Kompilierung in eine Zielsprache. Ein Schritt der erst kommt, nachdem der Parser seine Arbeit schon längst abgeschlossen hat.

wie komme ich jetzt von meiner Token-Liste zu einem Syntaxbaum.

Ich finde ja immer noch, dass es am einfachsten ist, wenn man sich der Thematik via der Sprache Lisp nähert. Schon allein deshalb weil die auf natürliche Art und Weise mit der Problemstellung harmoniert.
Aber um da jetzt auch noch Alternativwege zu zeigen, verweise ich mal auf 2 Einführungen die vielleicht einigermaßen verständlich sind. Das Thema ist leider nicht ganz so einfach, dass man das mal eben in einem Posting abhandeln kann. Spezielle Nachfragen sind natürlich möglich.

Let's Build a Compiler:
https://compilers.iecc.com/crenshaw/

LR(k)-Analyse für Pragmatiker:
http://amor.cms.hu-berlin.de/~kunert/papers/lr-analyse/

 

[uburoi]

Mit Assembler hatte ich bislang kaum Berührungspunkte. Aber das sieht interessant aus und ich werde mir das mal genauer ansehen.

Gruß Jens

 

[umask007]

Da du in Java unterwegs zu schein seinst, schau dir mal XText an.
https://de.wikipedia.org/wiki/Xtext
Das hab ich während meines Studiums benutzt, um ne DSL zu implementieren.
Im Prinzip gibt man die Grammatik der Sprache an
und bekommt einen Editor mit Syntaxüberprüfung und Codevervollständigung.
Der AST wird automatisch erstellt und kann mittels Plugin dazu verwendet werden,
um beispielsweise Code zu generieren.

 

[uburoi]

Mit Java habe ich zwar angefangen, aber ich nutze es nicht für größere Projekte. Ich mache das meiste in Xojo/Realbasic; da beherrsche ich die Möglichkeiten der Sprache besser und muss dann nicht noch ständig überlegen bzw. recherchieren, wie ich das, was ich schreiben möchte, auch umsetzen kann. Für einen Zweifrontenkampf mit Problem UND Sprache fehlt mir die Zeit.
Zudem suche ich ja keine Software, die mir das Problem abnimmt, sondern ich will verstehen, wie es funktioniert.

Gruß Jens

 

[7LZ]

Ich programmiere kleine -oft experimentelle- Spiele mit Gamemaker. Im programmieren bin ich noch ein Anfänger, gelegentlich verwende ich "brute force". Trotzdem macht es Spaß wenn es funktioniert. Bei Google Play habe ich jetzt drei meiner Spiele hochgeladen, aber hauptsächlich entwickele ich meine Games für Windows PCs.

 

[BAGZZlash]

Alle drei Android-Spiele ausprobiert, alle geil. Waterfall Mountain ist hammer!

 

[PEASANT KING]

Zur Zeit programmiere ich an einer Webanwendung für Plane Spotter. Entstanden aus der Idee meiner Freundin das Archivieren Ihrer Spotting Ergebnisse zu erleichtern. Bin auch ziemlich weit und meine Freundin nutzt das Ganze schon produktiv. Aber man kennt das ja gibt immer hier und da neue Baustellen neue Features.

Das Ganze basiert auf PHP im Laravel Framework. Unteranderem nutzt meine Anwendung noch DataTables, JavaScript.

Leider habe ich zur Zeit keine Lust und keine Zeit den Code zu optimieren und zu erweitern ^^.

 

[Finalspace]

Ich schreibe seit einer Weile einen Text-Editor mit Syntax-Highlighting + Validierung von Doxygen Dokumentationscode.

Was ist Doxygen?

Doxygen ist ein Dokumentationsgenerator für C/C++ Code, ähnlich wie JavaDoc oder die XML-Docs in C#.
Man kann damit C/C++ Code vollständig dokumentieren und darüber hinaus noch spezielle Seiten mit Sektionen anlegen, darin verlinken, Code-Beispiele einbauen, etc.

Als Beispiel hier die Dokumentation einer Library von mir:
https://www.libfpl.org/docs/index.html

Und so sieht der Doxygen-Source dazu aus:
https://raw.githubusercontent.com/f1nalspace/final_game_tech/master/final_platform_layer.docs

Warum das Rad neu erfinden?

Tja es gibt hier praktisch kein Rad, was es allerdings gibt ist halbgares Syntax-Highlighting für Doxygen - aber das wars dann auch. Validierung macht aber kein Editor, z.b. ob ein "ref" auf eine tatsächlich existierende Referenz zeigt oder eine "subpage" auf eine nicht existierende Seite zeigt usw.

Daher schreibe ich das ganze selbst, mit folgendem Feature-Set - auch mich und meine C/C++ Projekte abgestimmt:

• Standard-Editor mit mehreren Tabs (Laden/Speichern, Kopieren/Einfügen, Suchen & Ersetzen, etc.)
• Syntax-Highlighting für C/C++
• Syntax-Highlighting für alle Doxygen Commands & HTML Tags
• Validierung von Doxygen Commands (ref, subpage, code, etc.)
• Unterstützung für Gruppen/Sektionen/Seiten inkl. Verschachtelung
• C/C++ SyntaxAnalyse von "code"-Blöcken
• C/C++ Dokumentationsblockanalyse (Doxygen oder Javadoc style)
• Symbolsuche für C/C++ sowie für Doxygen
• Spezielle Analyse für C/C++ Doxygen für meine Projekte
• Integration des Doxygen-Compilers (doxygen.exe)

Womit wirds gemacht?

Visual Studio und C# und als Editorgrundelement nutze ich Scintilla.net, allerdings kann ich leider die integrierten Lexer nicht nutzen - weil diese kein Mixing unterstützen :-(
Daher muss ich das C/C++/Doxygen/HTML Lexing vollkommen selber machen. Dazu kommt dann noch nen Syntax-Parser für C/C++, damit ich Definitionen rausziehen und später dann auch Code validieren kann.

Wie funktioniert das Ganze:

Zu aller erst mal, wird der gesamte C/C++ Code in Tokens umgewandelt (Lexikalische Analyse). Danach werden alle Kommentarblöcke für Doxygen /** /*! oder //! In Doxygen Tokens umgewandelt. Normaler Text wird mit nem HTML Lexer verarbeitet, damit es auch für Tags Syntax-Highlighting gibt. Als letzten Schritt, werden alle "code"-Blöcke von Doxygen mit dem C/C++ Lexer verarbeitet, damit auch diese Highlighting bekommen.
Damit kann man dann alle diese Tokens farblich hervorheben. Danach beginnt dann das eigentliche (Parsing) von Doxygen und C/C++.

Was es nicht ist:

Es soll kein C/C++ Editor werden, daher liegt der Fokus komplett auf Doxygen.

Wo finde ich das ganze:

https://github.com/f1nalspace/doxygeneditor/tree/develop

 

[7LZ]

Alle drei Android-Spiele ausprobiert, alle geil. Waterfall Mountain ist hammer!

Danke #'_'# Es freut mich immer wenn ich ein Download/Install sehe, aber solche positiven Kommentare machen mich super glücklich.

Planespotting?!
Ich habe erst neulich erfahren das Trainspotting nicht nur ein Film ist. Interessant, auch wie es entstanden ist.

 

[Hancock]

Ihr macht ja echt coole Sachen.

Meine Hobbyprogramme:

• Ein VPN-Tool: Layer 2 Routing, daher funktionieren alle Spiele drüber, oder was für mich praktisch war: Steam In-Home-Streaming (10 Mb/s Upload), gut geeignet für z.B. Videobearbeitung daheim zu machen und zu rendern (und dann via SMB auf den Zielrechner laden). Die erste Variante tunnelte dabei über SSH, die aktuelle Variante nutzt für besseren Ping zusätzlich einen UDP-Port (hat aber dadurch ne Race-Condition).
• VC4-Treiber: (Raspberry-Pi GPU) Da habe ich ein paar kleine Teile mit programmiert (und einmal Mesa-Master für alle Architekturen bei Aktivierung von Optimierungen zum Absturz gebracht (SIGBUS)).
• VC4-Leistungsmonitor: vc4top https://github.com/jonasarrow/vc4top
• Ein Programm für meinen Verein, das die Zeitnahme bei Wettkämpfen verbessert und vereinfacht und zeitgleich einen Liveticker auf der Vereinshomepage anbietet. Die Prüfung auf Korrektheit der Ergebnisse ist so statt O(n²) nur noch O(n), (n=Sportleranzahl, n ca. 120).
• KillProcess: Tötet den aktiven Prozess (fokussiertes Fenster) mit Hotkey (Strg+Shift+K)
• Einen Mensaplan als UWP-App für meine Uni: Hauptsächlich, um mal zu schauen, wie UWP so tickt. Die App hat ganze 30 Nutzer (und so ca. 10 aktive pro Monat) .
• Raytracer auf der GPU: War mit einer Radeon 3870 gar nicht so einfach, da war ich aber noch in der Schule und hatte noch keine Vektorrechung...
• WikipediaSpiel: Es gibt ja die Behauptung, dass man via Wikipediaverknüpfungen innerhalb 6 Klicks von jedem Artikel auf Hitler kommen kann. Das wollte ich prüfen und habe ein Programm geschrieben, das mir die Klickdistanz zwischen zwei Artikeln berechnet hat. Performance: ca. 4 s für zwei weit entfernte Artikel den kürzesten Weg. Problem war damals hauptsächlich der RAM, ich hatte 4 GB und die deutsche Wikipedia hatte glaub so ca. 500 Mio. Links (2 GB). Heute mit 32 GB wäre die gesamte Wikipedia spannend (mit den Sprachverknüpfungen). Ach ja: Es gibt zigtausend Artikel, die mehr als 6 Klickdistanz haben. Es gibt auch viele Artikel, die Inseln bilden.

Leider habe ich in letzter Zeit deutlich weniger Zeit, sodass die Hobbyprogrammierung etwas unter den Tisch fällt.

 

[new Account()]

Einen Mensaplan als UWP-App für meine Uni: Hauptsächlich, um mal zu schauen, wie UWP so tickt. Die App hat ganze 30 Nutzer (und so ca. 10 aktive pro Monat) .

Was ist dein Fazit/deine Erfahrung diesbezüglich?

 

[Hancock]

Sehr steile Lernkurve, und in nicht C# (z.B. C++) eine echte Qual.
XAML und MVVM sind vom Konzept her echt nett (und mächtig), aber manchmal sehr unintuitiv und unübersichtlich. Visual Studio ist quasi unverzichtbar, da ohne die Autovervollständigung man wie ein Ochs vor dem Berge steht.

Also UI zum Programmieren ist es ein bisschen wie HTML + CSS. Kann Spaß machen, ist aber nicht für alle UI-Formen perfekt geeignet.

Was mich persönlich stört: Da hat man eine Mensaplan-App, keine großen Abhängigkeiten, keine großen Bilder, trotzdem kommt da ein 20 MB Koloss bei raus, warum?

Der Store ist an sich OK, es dauert bloß alles relativ lange, z.B. wenn deine App veröffentlicht ist, dauert es gut mal ein Tag, bevor man sie auch finden kann.

Für mich fühlte es sich an, wie Android-Apps zu programmieren, also vom Workflow ganz Ok. Die App hatte ich glaub nach 3 oder 4 Tagen funktionsfähig.

 

[new Account()]

und in nicht C# (z.B. C++) eine echte Qual.

Hast du dabei auf C++/WinRT gesetzt?
Wenn ja, würde mich das schon negativ überraschen.

Ansonsten danke für den Einblick!

 

[Hancock]

Ich hab mich mal durchgehangelt (wollte ein kleines 3D (eher 2D) DirectX spiel schreiben). Da ich es schnell haben wollte (Premature Optimization ) habe ich es in C++ geschrieben (inkl. dem WinRT Zeug mit Obj^), war trotzdem ein Gefrickel.

Ja, es hat funktioniert, aber es war echt umständlich (im Vergleich z.B. zu Gtk+, das sogar in C überraschend angenehm zu programmieren ist).

Das Problem ist die ganze Magie von C# (async, Events, properties), die es in C++ nicht umsonst gibt (also es geht schon, aber ist Codingarbeit). Es kann gut sein, dass ich es damals nicht richtig gemacht habe (wenn ich heut meine alten Projekte so anschaue schauder).

 

[new Account()]

WinRT Zeug mit Obj^

Obj^?

 

[Hancock]

Die WinRT-Projektion in C++ heißt C++/CX (hab ich gerade gegoogled), und die referenzgezählten Platform-Typen haben dabei wie bei C++/CLI ein ^ statt ein * (siehe https://blogs.msdn.microsoft.com/vcblog/2012/09/17/ccx-part-2-of-n-types-that-wear-hats/).

 

[new Account()]

Die WinRT-Projektion in C++ heißt C++/CX (hab ich gerade gegoogled)

C++/WinRT is Microsoft's recommended replacement for the C++/CX language projection

https://docs.microsoft.com/de-de/windows/uwp/cpp-and-winrt-apis/intro-to-using-cpp-with-winrt


C++/WinRT ist ganz normales C++ mit Header Only C++ libraries für die UWP API.

 

[Hancock]

Das scheint es damals noch nicht gegeben zu haben. Das erklärt es, warum es so umständlich war (ist jetzt schon ne Weile her (2016)). Das scheint tatsächlich etwas eleganter zu sein. Also ist meine C++ + UWP eine C++/CX Erfahrung und heute überholt. Muss ich mir definitiv mal anschauen, wenn ich Zeit dafür finde.