Mahlzeit!
Ich bin zufällig auf dieses Forum gestoßen und finde, es ist eine gute Idee hier mal von meiner Idee zu schreiben.
Also kurz zur Person, ich bin ein 18 Jähriger Schüler aus NRW und habe eine Leidenschaft für das Programmieren vor vielen jahren entdeckt. Naja es ist nicht wirklich eine Leidenschaft, da ich aktiv nicht viel Programmiere, mehr ein sehr großes Interesse.
Die ersten Versuche waren alles mehr oder weniger Spielereien, aber einiger zeit (vor 2 Jahren) wollte ich mich etwas größerem widmen, einem CMS-System für Websites, welches zwar einfach und intuitiv zu bedienen ist, aber auch eine möglichst gute funktionalität besitzt und sauber programmiert ist. Nachdem ich angefangen hatte (übrigens in PHP geschrieben) merkte ich das ich mit der Programmiersprache ansich nicht wirklich zufireden war. Also habe ich andere Programmiersprachen ausprobiert, zb Java, aber auch Java hat mich in speziellen Gesichtspunktne nicht wirklich zufiredengestellt. Andere Programmiersprachen fielen für die Webentwicklung eigentlich flach, das sie recht wenig verbreitung besaßen.
Mein Hauptproblem liegt in der geringen Portabilität des geschriebenen Codes. Einmal geschrieben kann man nur schwer einzelne Komponenten austauschen, bzw nur durch Tricks. Kaum eine Programmiersprache ist auch auf jeder Platform ohne Probleme zu kompilieren(jaja Java, aber Java ist einfach uneffizient, das schlägt jedes Argument ^^),(C/C++, okay, aber ich rede von einer einfachen Sprache , zudem ist ein C Programm nicht einfach zu übersetzen, vorallem nicht für Laien).

Also kam mir die Idee eine eigene Programiersprache zu schreiben, die entsprechende Merkmale aufweißt. Erstmal sollte es nur ein Art Wrapper für PHP werden, quasi ein PHP Hypertext Preprozessor Preprozessor .
Ich habe mich sehr intensiv mit dem Thema befasst und bekam größere Ideen. Warum kann man diesen Preprozessor nicht auf alle Programmiersprachen ausweiten. Dazu noch Platformunabhängig, einfach und sauber zu benutzen.
Naja, die Zeit ist ins Land gezogen, weil ich nicht wirklich einen Anfangspunkt fand um meine Ideen zu verwirklichen.

Dann fand ich LLVM (Low Level Virtual Mashine), ein super Framework, es entsprach genau meinen Vorstellungen. Kurzum, es ist ein Compile-System welches durch eine sehr prozessornahen virtuellen Bytecode representiert wird. Darum werden Backends und Frontends erstellt. backends für jede erdenkliche Prozessorarchitektur und Frontends für jede erdenkliche Programmiersprache. Somit kann man "relativ" einfach einen Compiler für eine programmiersprache erstellen, die auf beliebig viele Prozessorarchitekturen sehr effizeint und ausgezeichnet optimiert compiliert werden kann. Es wird der schwierigste Schritt am Compilerbau abgenommen und es wird permanent weiterentwickelt, da es zudem auch noch von Apple unterstüzt wird, die es in ihrem hauseigenen Betriebssystem verwenden. Von Apple stammt auch die komplette Unterstützung für die ARM-Architektur (iPhone, iPod Touch), somit ein zukunftssicheres und freies (University of Illinois/NCSA Open Source License) Projekt.
Mit der Zeit hab ich auch die Vorstellung von einer perfekten Programmier-sprache- aufgegeben, da eine Programmier-sprache- ein sehr schlechter Ansatz ist ein komplexes und gut durchschaubares Programm zu erstellen ist, meiner Meinung nach.
Meine jetizge Idee ist es eine graphische IDE zu erstellen, die im Endeffekt LLVM-Bytecode erzeugt.
Wie ich entdeckt habe, sind mir schon andere leute mit dieser Idee zuvor gekommen (also eine graphische IDE), aber die einzigen Lösungen die aktiv entwicklet werden beschränken sich auf wissentschaftliche Bereiche oder sind einfach proprietär. Alles keine wirklichen Alternativen zu einer professionellen, universellen, freien, einfach zu erlernden und sauberen graphischen Programmierumgebung.
Ich habe schon einige Ideen gesammelt und könnte sie heir genauer erläutern, wenn denn Interesse besteht. es ist auch ein sehr umfangreiches Vorhaben von dem ich weiß, dass ich es wohl kaum alleine bewältigen kann. Aber ich habe nun mal diese Vision und sie lässt mich nicht los
Also ich bitte um Kritik, Fragen und Antwort auf die Frage ob es hier jemanden interessiert oder ob noch jemand gleich denkt.
Danke fürs lesen und noch ein schönes Wochenende!

Nein tatsache
Also ich meine damit nur das es im Verhältnis zu nativen Sprachen ineffizient ist. Also wenn Code interpretiert wird, dann muss mehr Leistung hineingesteckt werden und ist er ineffizienter als nativer. Java ist nicht schlecht, das wollte ich nich sagen, nur ich finde native Sprachen besser, weil sie energie- und leisuntgseffizienter sind. Okay, die Ausnahme ist Just-In-Time Compilierung, die erreicht ja auch eine beachtliche Geschwindigkeit.
Hast du überhaupt alles gelesen?
Übrigens ist LLVM Java ziemlich ähnlich, nur besitzt es eine bessere Optimierung.

Okay Okay,
ich will hier gar nicht über Java disktuieren, und mir geht es grade darum portable nud robuste Programme zu schreiben. Genau das ist mein Ziel! Nur das ich im Unterschied zu Java eben eher eine andere Programmierweise vorschlage, die eine einfacher und übersichtlicher ist!
naja mal sehen, vielleicht kommt ja hier noch etwas konstruktives.

Okay, also zu Punkt 1:
LLVM ist einfach nur eine Art Zwischenlayer, welches Programmiersprache und Kompilat verbindet, sodass es unerheblich ist. in welcher Sprache man das Programm geschrieben hat und in welche man es übersetzen will. Theoretisch kann man auch in Java-bytecode übersetzen lassen, aus dem LLVM-Code heraus. Nur dafür gibt es soweit ich weiß bisher kein Backend.
Zu Optimierung: Die wird in mehreren Schritten durchgefüht. Zuert eine AOT-Optimierung inder gängige Sachen durchgeführt werden, wie tote Äste entfernen und idverser Kram der in fast allen Compilern durchgeführt wird. Danach gibt es "Interfunktionsoptimierung", da die einzeelnen Funktionen im LLVM Bytecode noch enthalten sind, kann das Programm wenn es gegen andere Bibliotheken oder sonst was gelinkt wird auch nochmal optimiert werden. Es können hier auch automatisch Funktionen geinlined werden. Und der letzte Schritt ist eine Optiierung die zwischen den einzelnen Ausführungen selber durchgeführt wird, in dem kritische Abschnitte besonders effizient kompiliert werden. Wie das genau abläuft kann ich mir auch noch nicht so gut vorstellen, aber das tut erstmal nichts zur Sache.

zur graphischen Programmierung. Ich finde das ist ein guter Ansatz weil er die Fehleranfälligkeit des Programmes stark einschränkt. Es können zb bestimmte Konstrukte nur dahin gesetzt werden, wo sie auch hinkönnen und Sinn machen. der ganze Programmierprozess wird von der IDE zu jeder zeit überwacht und sie kann auf zahlreiche Fehler hinweisen.
Desweiteren finde ich es übersichtlicher, da man anhand von Pfeilen besser sehen kann, welche Richtungen ein programm einschlägt und man kann die einzlenen Pfade besser voneinander trennen.
Es geht schon in Richtung UML-Diagramm, aber es sollte doch einne etwas pragmatischeren Ansatz verfolgen. Ganz auf die Texteingabe zu verzichten ist nicht wirklich sinnvoll, da man vieles besser mit ein paar kurzen Stichworten ereichen kann, also mit zahlreichen Klicks.
Man müsste ein Gleichgewicht finden, wieviel graphische Konstrukte man dem Programmierer zumuten kann, damit er nicht überfordert ist.
Eine Möglichkeit wäre es, wenn man zb an einer bestimmten Stelle eine bedingte Ausführung setzen will bspw. eine Tastenkombination drückt (zb. strg+i) und daraufhin erstellt die IDE einen neuen Knoten im Ablaufdiagramm der dieses Konstrukt darstellt und es befinden sich in dem Konstrukt Platzhalter für Variablen und bedingungen die man dann einfach durchgeht, zb. mit Tab und dorthin seine zu prüfende Variable und die Bedingungen hineinschreibt. das ganze wird dann mit Autovervollständigung unterstützt, da die IDE immer weiß, was wo rein kann und sinnvoll ist.
Also dieser Teil braucht eine Menge Ausarbeitung, so dass es perfekt und intuitiv zu bedienen ist, aber in die Richtung wird es wohl gehn.

Okay ich werd mal eine grobe Skizze von dem Programm auf der Seite erstellen und sie hierreinsetzen im Laufe des Tages!

Gruz Kevin

Okay, erstmal danke für das Interesse!
Ich habe im Anhang eine Skizze der Komponene angefertigt die 99BottlesOfBeer als Songtext erstellt.

@d0nut: Um die IDE kom ich nicht herum, da mein System nicht auf Texten (bzw. nur sehr wenig) sondern auf Ablaufdiagrammen basiert und das meiste wird auf graphische Weise darstellt. Zudem haben Schlüsselwörter eine Schwäche. Sie funktionieren nur eindimensional. Also in der Richtung von oben nach unten. Bei mir wären sie 2-dimensional, wie auf einer Blaupause. Wenn man einen Exceptionabschnitt erstellt, dann erstellt man einfach ein 2D-Feld in das man alles was von dem Exception-Handler berücksichtigt werden soll reinpackt, das zeigt sofort wo der kritische Bereich ist und man kann ihn nach belieben vergrößern und verkleinern. Das selbe gilt für alle Konstrukte.
Desweieren möcht eich auch das man sich eigene Konstrukte erstellen kann. Ein Beispiel ist mir eingefallen:
Bei der Programmierung von OpenGL erstellt man die Dreieicke immer mit glBegin() ein paar Befehle glEnd(), oder in der Art, ist mir jetzt grade nicht mehr genau präsent. In dem Fall kann die OpenGL oder Wrapper-Bibliothek einfach ein neues Konstrukt definieren, welches man wie in Java mit import Anweisungen der IDE bekannt macht und dann verwenden kann. Das steigert die Übersichtlichkeit und verringert die Fehleranfälligkeit.



Also einmal zur Erläuterung meiner Skizze:
Das ganze Projekt ist hierarchisch aufgeteilt, ganz oben steht jetzt in dem Beispiel die Komponente LyricGenerator (das ist eine Idee von mir um statische klassen und Objekte aufzuteilen, eine Komponente ist quasi eine statische Klasse und soll auch für die Objekterstellung zuständig sein, aber das hab ich erst kürzlich mir ausgedacht undist in dem Fal auch nicht wichtig, lyricGenerator könnte in dem Fall auch ein ganz normales Objekt sein, welches hier mit Standardwerten gefüllt wird, das sind übrigens keine Anweisungen, sondern eine Tabelle, so sollne die Objekte auch erstellt werden in der IDE, mithilfe einer Tabelle in der man die gazen Eigenschaften schreibt).
Das Ganze kann dann von irgendwo her, nach importieren der Komponente, mit LyricGenerator.generateLyric() angestoßen werden, in eine Variable gespeichert werden und dann mit der System Funktion zur Ausgabe in einer TextConsole oder in einem Fenster als Label ausgegeben werden.
Die Standartwerte könnne vor ausführen der Funktion auch noch beliebig geändert werden, sodass der Liedtext über Vodka, Kakao oder Mineralwassser handelt.

String ist in dem Fall ein besonderes String Objekt, dessen Inhalt man problemlos ändern kann, in QT gibt es sowas. Auf die Deklaration der temp. Variablen hab ich in diesem Beispiel verzichtet. ich denke die bedingten Pfade werdenhier ganz gut deutlich, die Schleife ergibt sich einfach aus dem Ablaufdiagramm und brauch kein extra Konstrukt.
Das alles ist auch nur eine sehr grobe Skizze die zum Teil auch noch nicht so ganz stimmt, wie ich es mir vorstelle, aber sie sollte gnaz gut zeuien wie die graphische Programmierung funktionieren kann.

Solong von mir, viel Spaß beim lesen und verstehen!

Achja, nochmal zum Verständis an d0nut:
Ich habe die Idee nicht aufgegeben, sondern die Idee einer Sprache, also einer textform, aufgegeben, weil das einfach zu meinen anderen ideen nicht paseen würde und unübersichtlich werdenwürde. Am besten eigenet sich deshalb eine graphische Darstellung.
Und das eigentliche Probelm ist auch etwas anders, also es geht mir nicht um die portabilität auf andere Sprachen, sondern Systeme im allg. Ein einmal geschriebenes Programm sollte überall lauffähig sein, wie bei Java, nur möchte ich LLVM als Basis benutzen und einige Dinge anders als bei Java machen, nämlich die graphische Komponente.
Das was dann am Ende rauskommen wird, wenn man es dann noch Sprache nenen kann, ist eher ein komplett sprachneutrales und intuitives Entwicklungssystem, wird komplett objetorientiert sein und kann alle möglichen weiteren Paradigmen unterstützen, da man eignee Erweiterungen schreiben kann, die als Bibliothek ausgeliefert, neue "domänenspezifische" Konstrukte einführen, also bei der jeweiligen Aufgabe des Pogrammes behilflich sind.
Und compiliert wird es dann auf alle möglichen Systeme, ausgedacht hab ich mir bisher:
nativ (alles was LLVM unterstüzt: x86,x64,ARM...)
PHP/Ajax: Wenn diese Kombination weiter an Bedeutung im Web gewinnt, lohnt es sich ein einmal geschriebenes Programm welches eigentlich auf dem Desktop läuft, problemlos als Website darzustellen. zB ein CMS, welches sowohl auf einem eigenen Root-Server als natives und schnelles Programm laufen kann, als auch auf einem PHP-Webserver. Durch konsequente Abstraktion in den Schnittstellen wäre das theoretisch möglich.
Und bei Bedarf auf ein weiteres Backend. So bleiben einmal geschriebne Programme und Algorithmen zukunftssicher.

Nya ich bin mit dem was es gibt eigentlich zufrieden.
Was mich mal interessieren würde:
Wie macht man eine eigene Programmiersprache?
Ich kann mir irgendwie nix darunter vorstellen...
Über eine Antwort würde ich mich freuen.

MfG PS

Okay, die Ausführungen von Deadman44 sind ziemlich ausführlich und gut erläutert, es IST ein ziemlich großes Vorhaben, was aber durch den Einsatz von LLVM um ca. 40% vermindet wird, da man sich nur um dne Aufbau der Programmiersprache kümmern muss, und LLVM den Schwierigsten Teil, nämlich das Übersetzen in eine Andere Sprache, sei es C oder auch direkt Maschinencode, ermöglicht.
Naja, und der Grund warum ich das ganze mache, ist eben, dass ich mit dem was es zur Zeit gibt nicht zufrieden bin, ob es die Einfachheit, Wiederverwendbarkeit oder Portabilität angeht.

@ truespin:
1. Richtig, es gibt eben Fälle in denen kommt es noch auf die Zeit an, bzw muss man einfach nicht unnötig Rechenzeit verplempern, das kostet Energie und Zeit. Es geht mir daraum eine Universelle Programmierumgebung zu erfinden, die alles erlaubt.
Zb. kommt es in einem Mathe-Programm auf die Geschwindigkeit an, da hier viele Rechnungen wiederholt ausgeführt werden und sich der Overhead läppert. In Echtzeit-Anwendungen wie in der Fahrzeugelektronik kommt es auch auf jede Millisekunde an, das steht außer Frage.
Ein anderes Gebiet sind abstrakte Anwendungen, wie graphische Benutzeroberflächen. In dem Gebiet kommt es auf Flexibilität des Programmes an, damit es nicht gleich bei einem kleinsten Fehler abstürzt und man einfach komplexe Vorgänge beschreiben kann.
2. Mathlab, bzw Simullink sind zum einen proprietär und zum anderen Anwendungsbeschränkt auf die Mathematik, ich möchte lieber ein universelles System, was auf beliebig viele Anwendungsgebiete zugeschnitten werden kann. Ich bin kein Gegner von proprietärer Software, grade von dort kommen oft Anstöße zur weiterentwicklung, bzw wichtige Meilensteine. Aber eine universelle Programmierumgebung sollte einfach nicht von einem einzigen Hersteller kontroliert werden, zudem würde grade das die Entwciklung hemmen, denn oft entwickeln sich closed-source Projekte an den Anwendern vorbei, das möchte ich nicht.

@ Deadman44:
ich denke das wäre eher eine Revolution, da ich vollständig auf das Konzept des Quellcodes verzichten möchte.

Also das war erstmal eine Beantwortung eurer Fragen, ich werde demnächst wieder hier posten und weitere Ideen sammeln. Jetzt habe ich auch mehr Zeit

PS: Habt ihr die Skizze wirklich verstanden (also lesen können) oder wollt ihr mich einfach nich kränken^^ ich weiß, dass ich ein grauenhafter Zeichner und Maler bin!

Okay, Butter bei die Fische.
Mein Plan ist es zu allererst mithilfe einer konventionellen Programmiersprache eine Entwicklungsumgebung auf die Beine zu stellen und mir dabei Gedanken um die Representation des Programmablaufes zu machen, denn der muss ja auch irgendwie als Daten auf der Platte abgelegt werden. Warscheinlich wird es XML hinauslaufen. Zur Programmiersprache, ich dachte an Java, denn Java ist ja an sich schon platformunabhängig und da ich meistens unter Windows arbeite (Bequemlichkeit) und ich LLVM bisher unter Linux zum Laufen bekommen habe und nicht glaube das es problemlos auf Windows laufen wird, denke ich, ist das eine gute Lösung.
Die erste Version soll auch gar nicht unbedingt perfekt sein, denn wie das bei einem Compiler ist, sollte man ihn in der kompilierenden Programmiersprache neu verfassen und damit sich selber kompilierbar machen.
Die IDE soll eine ganz allgemeine Umgebung für Softwareprojekte sein und wie Eclipse erweiterbar und dynamisch anpassbar sein (am Ende). Für den Anfang reicht eine rudimentäre Funktionalität, sie soll nur das wichtigste können. D.h. aus den "Diagrammen", deren genauer Aufbau noch sehr gut ausgearbeitet werden muss, LLVM-Code erzeugen können. Die Diagramme werden Top-Down orientiert sein, wobei es einen Hauptcontainer gibt, der das Projekt enthält, der dann weitere Unterbehälter besitzt die jeder für sich noch weiter verzweigen. jeder Container verarbeitet die Objekte die in ihm sind und gibt das Ergebnis an den übergeordneten Container weiter und so weiter bis man oben angekommen ist. Nach meinen Vorstellungne sollte alles objektorientiert sein, was das genau für Auswirkungen hat, ein andermal.
Also die IDE sollte trotz der abstrakten und graphischen Darstellung trotzdem hoch performanten Code erzeugen, bspw sollte es damit auch möglich sein ein Betriebssystem zu programmieren, wie gesagt es geht mir um ein universelles System. Also ales wird standartmäßig mit höchster Effizienz übersetzt. Wenn der Programmierer Komfortfunktionen haben möchte, muss er diese auch explizit benutzen bzw. angeben.

Pointer-Programmierung wie in C wird prinzipiell auch möglich sein, nur eher im Hintergrund, denn ich habe mir da ein gutes Verfahren ausgedacht:
Bei einer Variablenübergabe an eine Funktion geht die IDE automatisch von schreibgeschützten (const) Referenzen (&) auf Objekte aus. Hierzu muss der Funktion nur ein Zeiger auf den Speicherbereich, an dem das Objekt liegt, mitgegeben werden (Aufwand: Kopieren eines Prozessorwortes, i.d.R. 32 Bit auf einem 32Bit Prozessor). Da die Variable schreibgeschützt ist, können auch problemlos Literale und Konstanten übergeben werden, da diese aus Prinzip nicht verändert werden dürfen. Diese Konvention deckt denke ich mal 70-80% aller Parameterübergaben ab. Wenn der Programmierer unbedingt eine Kopie oder eine schreibbare Referenz haben möchte, gibt er dies explizit an. Desweiteren werden Objekte die weniger oder genau so groß sind wie die Wortbreite des Prozessors, wie zB. Ganzzahlen, direkt auf den Stack geschrieben, was auch der üblichen Konvention entspricht, da sie eh nicht als dynamische Objekte behandelt werden, sondern nur zur Übergabe von Einzelwerten benutzt werden.

Die IDE an sich soll sehr modular aufgebaut sein, heißt nur wenige bis gar keine fest eingebauten Konstrukte haben, die Sprache soll von Grund auf aus Erweiterungen bestehen, die man auch selber erstellen kann. Das Allgemeinste was es gibt ist das Objekt. Ein Objekt represetiert einfach nur einen Speicherbereich, der nach einem festgelegten Muster aufgebaut ist, bspw. eine Zahl, eine Funktion, ein String. Auf alle diese Speicherbereiche kann mit bestimmten Funktionen zugegriffen werden, die so oder so als ersten Parameter eine Referenz auf das zu bearbeitende Objekt benötigen, also Methoden. Fertig ist die Objektorientierte Programmierung, die auf alles anwendbar ist, und da auf jeglichen Overhead verzichtet wird, bis er benötigt wird, kann man somit die gleiche Performance erreichen, wie mit einem komplizierten C-Programm, welches nur aus losen Structs und Funktionen besteht.

Alles in allem ist das ganze noch sehr grob in Planung, aber die hier angeschnittenen Punkte stehen mit ziemlicher Sicherheit jetzt fest.
Hauptziele sind weiterhin eine hohe Proffesionalität und Mächtigkeit, trotz hoher Benutzerfreundlichkeit und Einfachheit.

Solong meine Gedanken hierzu, weitere Artikel folgen.