Es gibt natürlich eine Reihe von Kriterien. Sicherlich wird der eine oder andere die Codegeschwindigkeit und Größe hervorheben – bald kommt man dann aber auf hersteller- bzw. Plattformspezifische Implementierungen. Man muss dazu nur mal ein einfaches „Hello World“ mit einem C-Compiler erzeugen und hat ein Programm das um ein vielfaches größer ist als dasselbe vor 20 Jahren unter DOS.<\/p>\n
Natürlich gibt es noch die Eignung der Sprache – es gibt Scriptsprachen für die Kommandoshell, Sprachen die im Browser ablaufen und Sprachen mit denen man EXE Dateien oder andere Binarys erzeugt. Aber gehen wir mal von der technischen Seite weg, auf die Sprachdefinition. Für mich ist an einer Sprache folgendes wichtig:<\/p>\n
Eine gute Sprache ist logisch durchdacht. Nun sind das wird der eine oder andere sagen alle Sprachen nach der BNF oder für die es eine exakte Grammatik gibt. Das muss aber nicht logisch durchdacht sein. logisch durchdacht ist z.B. das Schlüsselworte oder verwendete Zeichen eine gleiche (oder wenn mehrfach verwendet) ähnliche Bedeutung haben.<\/p>\n
Meine Negativbeispiele kann ich hier leicht aus der Sprache „C“ ziehen. Da ist mal das Komma ein Separator von Werten und mal ein Operator, was wirklich tolle Ergebnisse und viele Stunden mit einer spannenden Fehlersuche verursachte. z.B. ist:<\/p>\n
<\/span><\/p>\n a <\/span>=<\/span> feld <\/span>[<\/span>i<\/span>,<\/span>j<\/span>];<\/span><\/p>\n <\/span><\/p>\n <\/span> <\/span><\/p>\n a <\/span>=<\/span> feld <\/span>[<\/span>i<\/span>][<\/span>j<\/span>];<\/span><\/p>\n <\/span><\/p>\n <\/span><\/p>\n nicht das gleiche…. dasselbe kann man über das Multiplikationszeichen sagen, das mal eine Multiplikation durchführt und mal eine Referentierung.<\/p>\n Auf der anderen Seite wird je nachdem ob man es mit einem Zeiger oder einer Variablen zu tun hat auf die Elemente eines Records mal mit „.“ und mal mit „->“ zugegriffen. Ist echt logisch.<\/p>\n In diesem Zusammenhang halte ich überhaupt nichts von Sprachen ohne Typisierung, weil Typen ja nicht nur Konstrukt einer Sprache sind sondern sich auch im täglichen Leben wiederfinden. Wir nennen sie dort Kategorien. Da gibt es Zahlen oder Texte, Autos oder Häuser. Zahlen kann man addieren, Texte verknüpfen. Autos haben die Eigenschaft PS, Fabrikat, Häuser die Eigenschaften Quadratmeter, Bewohner u.a.<\/p>\n Eine Sprache die keine Typisierung kennt, lässt es zu einer Stringvariablen eine Zahl zuzuweisen und umgekehrt. Besonders tolle Sprachen lassen so was zu:<\/p>\n a=“ab“<\/p>\n a= a+1<\/p>\n Ratet mal was raus kommt….<\/p>\n Kriterium 2: Eine Sprache soll so umfangreich sein, dass man alles damit erledigen kann, aber so klein, dass man sie möglichst schnell verstehen kann.<\/p>\n Was ich damit meine ist, das ein Sprache zum einen so mächtig sein soll, dass alle Sprachelemente zur Verfügung stehen die man braucht, zum anderen aber auch sie nicht unnötig kompliziert ist. Der Mittelweg zu finden ist schwierig und was nötig ist, ändert sich auch im Laufe der Zeit. So haben ältere prozedurale Sprachen noch nicht als Datentyp die Map, oder das assoziative Array. Das ist in vielen Dingen wo man auf Daten nicht mit Indexen zugreifen kann sehr nützlich. Dagegen finde ich die auch in diesen Sprachen nicht vorhandene for-each Schleife nicht so nützlich, dass sie unbedingt dazu gehören müsste.<\/p>\n Pascal (im Wirth Standard) mangelt es sicher an einigen nützlichen Dingen wie vernünftigen Strings. Auf der der anderen Seite hat C so viele Features die Abkürzungen sind aber nicht unbedingt notwendig für eine Sprache wie die Möglichkeit der Zuweisung in der If Anweisung, die Inkrement und Dekrement Operatoren oder die Kombination Operator mit Zuweisung. Alle diese sind durch etwas mehr Schreibarbeit ersetzbar.<\/p>\n Ein sehr interessanter psychologischer Aspekt ist ja das viele Programmierer glauben, dass kurzer Code, am besten noch etwas kryptisch geschrieben, schneller wäre. Siehe Alexanders Beispiel. Wie das Programm von mir beweist, das deutlich länger ist muss das nicht der Fall sein. Vieles hängt davon ab wie ein Compiler den Quelltext übersetzt, aber auch wie effizient eine Programmiersprache implementiert werden kann. Im C-Beispiel ist es per Definition so, dass das Stringende? gesucht werden muss da es durch die binäre Null markiert ist. Egal wie man nun im beispiel daran einen neuen String anhängt – die Suche dauert immer länger je länger der String ist.<\/p>\n Ich habe schon während des Studiums und dann während der Diplomarbeit Sprachen verglichen. Bei der Diplomarbeit C#, Java und Delphi. Es zeigte sich dass bei dem elementaren Operationen ohne Ausgabe es praktisch keine Unterschiede in den Laufzeiten gab. Diese kamen erst auf als es auf die grafische Ausgabe ging, wobei die beiden interpretierten Sprachen deutlich langsamer waren, und das trotz C# Mogeltrick mit der Garbage-Collection.<\/p>\n Kriterium 3: Eine Sprache ist syntaktisch so aufgebaut dass man sie ohne viel Nachdenken lesen kann.<\/p>\n Ich muss sagen das Kriterium 3 mich bis heute abgehalten hat viele Sprachen zu lernen. Ich denke es ist möglich eine Programmiersprache so grammatikalisch auszulegen, dass der Quelltext auch für nicht Programmierer verständlich ist. Ich denke das ist bei Pascal oder Modula, aber auch andere Sprachen gegeben. Das kann geschehen durch geschickte Wahl der Schlüsselwörter und vermeiden von zu vielen Operatoren? die man erklären muss. Auf der anderen Seite gibt es das Gegenbeispiel einer Sprache die zu schwafelig ist. Ich rede von COBOL: Wenn man selbst +, *, – und \/ durch Worte ersetzt verzichtet man auf die Grundkrenntnisse der Mathematik die jeder hat und macht den Quelltext schwer lesbar.<\/p>\n Doch das ist die Ausnahme. Der Trend geht heute eher dazu dass Sprachen eher wenige Schlüsselwörter haben und vieles mit Operatoren definiert wird. Perl ist so ein Beispiel. Aber auch Smalltalk hat nicht sehr viele Schlüsselwörter. Dann gehört viel Wissen dazu um einen Quelltext zu verstehen. Man kann aber auch für Profis das Lesen erschweren, z.B. so:<\/p>\n <\/span> <\/span><\/p>\n #include <stdio.h><\/span><\/p>\n <\/span><\/p>\n <\/span> <\/span><\/p>\n main<\/span>(<\/span>t<\/span>,<\/span>_<\/span>,<\/span>a<\/span>)<\/span><\/p>\n <\/span><\/p>\n <\/span> <\/strong><\/span><\/p>\n char<\/strong><\/span> <\/span>*<\/span>a<\/span>;<\/span><\/p>\n <\/span><\/p>\n {<\/span>return<\/strong><\/span>!<\/span>0<\/span><<\/span>t<\/span>?<\/span>t<\/span><<\/span>3<\/span>?<\/span>main<\/span>(-<\/span>79<\/span>,-<\/span>13<\/span>,<\/span>a<\/span>+<\/span>main<\/span>(-<\/span>87<\/span>,<\/span>1<\/span>–<\/span>_<\/span>,<\/span><\/p>\n <\/span><\/p>\n <\/span> <\/span><\/p>\n main<\/span>(-<\/span>86<\/span>,<\/span> <\/span>0<\/span>,<\/span> a<\/span>+<\/span>1<\/span> <\/span>)+<\/span>a<\/span>)):<\/span>1<\/span>,<\/span>t<\/span><<\/span>_<\/span>?<\/span>main<\/span>(<\/span>t<\/span>+<\/span>1<\/span>,<\/span> _<\/span>,<\/span> a <\/span> ):<\/span>3<\/span>,<\/span>main <\/span>(<\/span> <\/span>–<\/span>94<\/span>,<\/span> <\/span>–<\/span>27<\/span>+<\/span>t<\/span>,<\/span> a<\/span><\/p>\n <\/span><\/p>\n <\/span> <\/span><\/p>\n )&&<\/span>t <\/span>==<\/span> <\/span> 2<\/span> <\/span>?<\/span>_<\/span><<\/span>13<\/span> <\/span>?<\/span>main <\/span>(<\/span> <\/span>2<\/span>,<\/span> _<\/span>+<\/span>1<\/span>,<\/span> <\/span>„%s %d %d\\n“<\/span> <\/span> ):<\/span>9<\/span>:<\/span>16<\/span>:<\/span>t<\/span><<\/span>0<\/span>?<\/span>t<\/span><-<\/span>72<\/span>?<\/span>main<\/span>(<\/span>_<\/span>,<\/span><\/p>\n <\/span><\/p>\n <\/span> <\/span><\/p>\n t<\/span>,<\/span>„@n’+,#’\/*{}w+\/w#cdnr\/+,{}r\/*de}+,\/*{*+,\/w{%+,\/w#q#n+,\/#{l,+,\/n{n+\\<\/span><\/p>\n <\/span><\/p>\n ,\/+#n+,\/#;#q#n+,\/+k#;*+,\/’r :’d*’3,}{w+K w’K:’+}e#‘;dq#’l q#’+d’K#!\/\\<\/p>\n +k#;q#’r}eKK#}w’r}eKK{nl]’\/#;#q#n‘){)#}w‘){){nl]’\/+#n‘;d}rw‘ i;# ){n\\<\/p>\n l]!\/n{n#‘; r{#w’r nc{nl]’\/#{l,+’K {rw‘ iK{;[{nl]’\/w#q#\\<\/p>\n n’wk nw‘ iwk{KK{nl]!\/w{%’l##w#‘ i; :{nl]’\/*{q#’ld;r‘}{nlwb!\/*de}’c \\<\/p>\n ;;{nl‘-{}rw]’\/+,}##’*}#nc,‘,#nw]’\/+kd’+e}+;\\<\/p>\n #’rdq#w! nr’\/ ‚) }+}{rl#'{n‘ ‚)# }’+}##(!!\/“<\/span>)<\/span><\/p>\n <\/span><\/p>\n :<\/span>t<\/span><-<\/span>50<\/span>?<\/span>_<\/span>==*<\/span>a <\/span>?<\/span>putchar<\/span>(<\/span>a<\/span>[<\/span>31<\/span>]):<\/span>main<\/span>(-<\/span>65<\/span>,<\/span>_<\/span>,<\/span>a<\/span>+<\/span>1<\/span>):<\/span>main<\/span>((*<\/span>a <\/span>==<\/span> <\/span>‚\/‘<\/span>)+<\/span>t<\/span>,<\/span>_<\/span>,<\/span>a\\<\/span><\/p>\n <\/span><\/p>\n <\/span> <\/span><\/p>\n +<\/span>1<\/span> <\/span>):<\/span>