1. Foren
  2. Kommentare
  3. Software-Entwicklung
  4. Alle Kommentare zum Artikel
  5. › Kotlin: Das bessere Java

Kotlin, der Flopp des Jahrzehnts

Für Konsolen-Talk gibt es natürlich auch einen Raum ohne nerviges Gedöns oder Flamewar im Freiraum!
  1. Thema
  1. 1
  2. 2

Neues Thema Ansicht wechseln


  1. Kotlin, der Flopp des Jahrzehnts

    Autor: twothe 06.11.20 - 13:00

    Es ist mal wieder Dienstag, irgendwer hat eine neuen Java-Dialekt erfunden. Nur irgendwie ist es dieser Person diesmal gelungen Google und Jetbrains mit an Boot zu holen. Wer sich in die Sprache einliest sieht schnell: ein vermutlich besserer Verkäufer als er Programmierer ist.

    Die gefühlt 3 Features die Kotlin hat sind nett, aber lösen entweder nur Probleme auf Kindergartenniveau, oder schaffen dabei neue. "Listen können nicht mehr versehentlich verändert werden" wuhu! Ein Problem das ich glaube ich das letzte mal vor 10 Jahren oder so hatte. Und selbst wenn man meint das könnte zu Problemen führen, hat Java seit Jahren schon die Immutable-List. Nicht das sie einer je wirklich gebraucht hätte. Die Idee Setter und Getter zu verstecken ist schon bei .NET ein Problem, weil ich als Aufrufer nie weiß was ich da jetzt anstoße. Hoffentlich nur einen Einzeiler, aber vielleicht wird im Hintergrund auch ein Webserver getriggert und 20GB Daten verarbeitet. Und das alles nur damit ein Programmierer sich 3 Buchstaben spart. Und wenn ich jetzt in der Klasse selbst den Wert setze, mache ich dann einen setter-call loop? Man weiß es nicht...
    Und case gibts gar nicht mehr damit man den Break nicht vergisst... Sagt einem in Java zwar jede IDE, und man kann einfach die Brackets stattdessen benutzen, aber das war vermutlich für den Kotlin Erfinder so eine Herausforderung, das er gleich das ganze Switch gekillt hat, mit all den Nachteilen die das mit sich bringt.

    Kotlin wird wie jeder andere unnötige JVM-Dialekt die nächsten Jahre wieder in der Versenkung verschwinden, und sich vermutlich irgendwo neben Scala ins Grab legen.

  2. Re: Kotlin, der Flopp des Jahrzehnts

    Autor: foobarJim 06.11.20 - 13:20

    twothe schrieb:
    --------------------------------------------------------------------------------
    > Es ist mal wieder Dienstag, irgendwer hat eine neuen Java-Dialekt erfunden.
    > "Listen können
    > nicht mehr versehentlich verändert werden" wuhu! Ein Problem das ich glaube
    > ich das letzte mal vor 10 Jahren oder so hatte. Und selbst wenn man meint
    > das könnte zu Problemen führen, hat Java seit Jahren schon die
    > Immutable-List. Nicht das sie einer je wirklich gebraucht hätte.

    Immutability ist gerade bei Parallelverarbeitung sehr sinnvoll. Man kann in Java zwar Variablen mit "const" definieren, aber genau wie beim "val" in Kotlin heißt das nur, dass die Referenz auf das Objekt nicht verändert werden kann. Mit Immutable-Lists ist auch sichergestellt, dass das Objekt, in dem Fall die List, auch immutable ist.

    > Die Idee
    > Setter und Getter zu verstecken ist schon bei .NET ein Problem, weil ich
    > als Aufrufer nie weiß was ich da jetzt anstoße. Hoffentlich nur einen
    > Einzeiler, aber vielleicht wird im Hintergrund auch ein Webserver
    > getriggert und 20GB Daten verarbeitet. Und das alles nur damit ein
    > Programmierer sich 3 Buchstaben spart. Und wenn ich jetzt in der Klasse
    > selbst den Wert setze, mache ich dann einen setter-call loop? Man weiß es
    > nicht...

    Das betrifft doch nur data classes. Und wer packt schon so viel Funktionaliät in eine data class. Aber mit records bekommt Java ja das selbe. Aus dem einfachen Grund weil es praktischer und übersichtlicher ist wegen eine Klasse, die nur Daten beinhaltet , eine Zeile Code statt 50 zu schreiben.

    > Und case gibts gar nicht mehr damit man den Break nicht vergisst... Sagt
    > einem in Java zwar jede IDE, und man kann einfach die Brackets stattdessen
    > benutzen, aber das war vermutlich für den Kotlin Erfinder so eine
    > Herausforderung, das er gleich das ganze Switch gekillt hat, mit all den
    > Nachteilen die das mit sich bringt.

    "when" kann mehr als "switch", z.B. Typen unterscheiden und noch so einiges. Aber manchmal vermisse trotzdem noch die Mächtigkeit von "match" in Scala, z.B. im Zusammenspiel mit Destruktoren.

    > Kotlin wird wie jeder andere unnötige JVM-Dialekt die nächsten Jahre wieder
    > in der Versenkung verschwinden, und sich vermutlich irgendwo neben Scala
    > ins Grab legen.

    Das ist gut möglich. Aber nicht aus dem Grund, weil die Kotlin-Features so schlecht wären sondern weil Java entsprechend nachgezogen hat.

  3. Re: Kotlin, der Flopp des Jahrzehnts

    Autor: MrTridac 06.11.20 - 13:28

    Fast volle Zustimmung.
    Insbesondere für den "Kindergarten" Kommentar.
    Die Fehler die Kotlin verhindern soll, fallen bei jedem vernünftigen Test sowieso gleich ganz am Anfang auf.
    Damit erreicht man nur, dass keiner mehr sorgfältig arbeitet oder testet, weil ja "die Sprache" so toll und sicher ist.
    Wir können uns schon mal auf tausende super-buggy Apps vorbereiten die von lern- und testfaulen Entwicklern in Zukunft geschrieben werden.

    Nicht zustimmen kann ich der Aussage, dass Kotlin wieder verschwinden wird.
    Leider sind zu viele Hippie-Coder auf den Hype-Zug aufgesprungen.
    Weil cool ist was neu ist. C/C++ ist "schlecht" weil's alt ist. Das ist der Hauptgrund für den Hype neuer Programmiersprachen. Die "Argumente" gegen C sind aus den Fingern gesogen und stellen eigentlich ein Armutszeugnis aus.
    "... aus versehen verändert ...", "... break; vergessen ..." ???
    Das ist für mich ein Grund Fähigkeiten in Frage zu stellen.
    Wenn ein Brückenbauingenieur "vergisst" die Traglasten richtig zu berechnen, stellt man seine Fähigkeiten auch in Frage.

  4. Re: Kotlin, der Flopp des Jahrzehnts

    Autor: mnementh 06.11.20 - 13:28

    foobarJim schrieb:
    --------------------------------------------------------------------------------
    > Das ist gut möglich. Aber nicht aus dem Grund, weil die Kotlin-Features so
    > schlecht wären sondern weil Java entsprechend nachgezogen hat.
    Korrekt. Und das Java immer wieder nachzieht liegt auch daran, dass die Vorteile bestimmter Features von Sprachen wie Scala, Ceylon oder eben Kotlin vorgeführt werden. Und eine reale Implementierungslösung gezeigt wird. Daher halte ich diese Nischensprachen keineswegs für sinnlos, selbst wenn sie nie den Mainstream erobern. Ist so ähnlich wie Plan9 - einige der coolen Features sind im Endeffekt in Linux gelandet.

  5. Re: Kotlin, der Flopp des Jahrzehnts

    Autor: fifafunky 06.11.20 - 14:21

    Kotlin wird nicht so schnell verschwinden. Die Community darum ist bereits jetzt großartig und es gibt viele Gründe die absolut für Kotlin sprechen:

    • Es ist wahnsinnig ähnlich wie Swift. Das macht es für native App Projekte aktuell eigentlich zur einzig sinnvollen Wahl. Es ist damit um ein vielfaches realistischer geworden zwei native Apps zu Entwickeln anstatt auf eine hybrid Lösung zu setzen (gerade das erste mal in einem Projekt so umgesetzt und es war ein Traum)
    • Kotlin Multi Platform ist ein extrem spannendes Projekt. Es steckt noch in den Kinderschuhen aber könnte Cross Platform Entwicklung nachhaltig beeinflussen
    • Das gleiche gilt für Jetpack Compose (Da wurde gerade die erste Version von Jetpack Compose for Desktop veröffentlicht.)

    Ob die Sprache jetzt besonders toll ist oder nicht ist schon fast irrelevant solange sie mir als Entwickler mit dem "Drumherum" vieles einfacher macht. Kotlin ist jedenfalls super schnell zu lernen und funktioniert einfach gut.



    1 mal bearbeitet, zuletzt am 06.11.20 14:24 durch fifafunky.

  6. Re: Kotlin, der Flopp des Jahrzehnts

    Autor: kaesekuchen 06.11.20 - 14:38

    twothe schrieb:
    --------------------------------------------------------------------------------
    > Es ist mal wieder Dienstag, irgendwer hat eine neuen Java-Dialekt erfunden.
    > Nur irgendwie ist es dieser Person diesmal gelungen Google und Jetbrains
    > mit an Boot zu holen. Wer sich in die Sprache einliest sieht schnell: ein
    > vermutlich besserer Verkäufer als er Programmierer ist.
    > ...

    Überhaupt keine Zustimmung, aber sowas von nicht. Was soll die Negativität? Klar ist Kotlin "unnötig" im gleichen Sinne, wie jegliche Verbesserung von irgend etwas "unnötig" ist. Wir könnten auch weiter in Assembler programmieren oder uns mit Knochenknüppeln die Köpfe einhauen.

    Ich sollte dazusagen, dass ich weder in Java noch in Kotlin ein Super-Duper-Experte bin, der jedes Sprachfeature in- und auswendig kennt. Ich halte mich allerdings mit meinen knapp 25 Jahren Programmiererfahrung in einer ganzen Reihe von Sprachen und Anwendungskategorien für kompetent genug, die beiden einigermaßen einschätzen zu können. Mir gefällt Kotlin *deutlich* besser. Ich bin schon vor 3 Jahren für alles, was ich sonst in Java geschrieben hätte, auf Kotlin umgestiegen.

    Allein folgende Features finde ich überaus nützlich:

    - Eigenständige Funktionen ohne den Zwang, um alles eine Klasse herum stülpen zu müssen.
    - Closures!
    - Lambdas / "First Class"-Functions! Alles was irgendwie mit dynamisch zugewiesenen Callback-Funktionen zu tun (z.B. Event-Busse) lässt sich in Kotlin sooo viel eleganter schreiben als mit dem Java, das ich kenne (das zugegebenermaßen nicht der neueste Stand ist). Vor allem die Kombination Closures/Lambdas ist super praktisch.

    Auch Coroutinen sind, glaube ich, potenziell ein sehr mächtiges Feature, dessen Wesen ich allerdings noch nicht vollständig begriffen und das ich deshalb bisher noch nicht eingesetzt habe.

    Ich weiß vage, dass Java da in einigen Bereichen (v.a. Lambdas/Closures) inzwischen nachgezogen hat (einen genauen Überblick hab ich nicht, ich kenne Kotlin längst besser als Java). Aber das heißt ja nur, dass offenbar auch die Köpfe hinter Java finden, dass diese Dinge sinnvoll sind.

  7. Re: Kotlin, der Flopp des Jahrzehnts

    Autor: twothe 06.11.20 - 15:20

    kaesekuchen schrieb:
    --------------------------------------------------------------------------------
    > Ich weiß vage, dass Java da in einigen Bereichen (v.a. Lambdas/Closures) inzwischen nachgezogen hat

    Ja, und zwar mehrere Jahre bevor Kotlin erfunden wurde. Was den Rest deiner Argumentation etwas obsolet macht.

  8. Re: Kotlin, der Flopp des Jahrzehnts

    Autor: kaesekuchen 06.11.20 - 15:50

    twothe schrieb:
    --------------------------------------------------------------------------------
    > kaesekuchen schrieb:
    > ---------------------------------------------------------------------------
    > -----
    > > Ich weiß vage, dass Java da in einigen Bereichen (v.a. Lambdas/Closures)
    > inzwischen nachgezogen hat
    >
    > Ja, und zwar mehrere Jahre bevor Kotlin erfunden wurde. Was den Rest deiner
    > Argumentation etwas obsolet macht.

    Das stimmt nicht.

    Die erste Version von Kotlin wurde 2011 veröffentlicht. Und soweit ich das gerade mal schnell zusammengooglen konnte, kann Java Closures seit Version 8, die 2014 erschien, also 3 Jahre später. Und auch die Art und Weise, wie Closures in Java umsetzbar sind, scheint nach wie vor recht umständlich und mit Einschränkungen verbunden zu sein. Das, was man dazu findet, sind eigentlich alles eher Hacks und Workarounds als echte Unterstützung. Kotlin ist da offenbar deutlich weiter, und das schon von Anfang an.

  9. Re: Kotlin, der Flopp des Jahrzehnts

    Autor: pioneer 06.11.20 - 15:52

    twothe schrieb:
    --------------------------------------------------------------------------------
    > ... Geschwurbel

    Ego 1, Ahnung 0

  10. Re: Kotlin, der Flopp des Jahrzehnts

    Autor: foobarJim 06.11.20 - 15:55

    twothe schrieb:
    --------------------------------------------------------------------------------
    > kaesekuchen schrieb:
    > ---------------------------------------------------------------------------
    > -----
    > > Ich weiß vage, dass Java da in einigen Bereichen (v.a. Lambdas/Closures)
    > inzwischen nachgezogen hat
    >
    > Ja, und zwar mehrere Jahre bevor Kotlin erfunden wurde. Was den Rest deiner
    > Argumentation etwas obsolet macht.

    Ich bin in Java gerade nicht soweit drin. Deswegen korrigiere mich bitte wenn ich da falsch liege. Aber IMHO sind Lambdas bei Java nichts anders als nur SAMs, also Interfaces mit einer Methode. Das führt letztlich dazu dass man hintenrum eine Unmenge an SAMs rumfliegen hat anstatt einfach Funktionstypen zu verwenden.

    Allerdings ist das halt der Abwärtskompatibilität geschuldet, dass man nicht einfach etwas komplett Neues einführen kann ohne mit dem Alten zu brechen. Ist ja auch was wert.

  11. Re: Kotlin, der Flopp des Jahrzehnts

    Autor: spyro2000 06.11.20 - 15:57

    twothe schrieb:
    --------------------------------------------------------------------------------
    > Es ist mal wieder Dienstag, irgendwer hat eine neuen Java-Dialekt erfunden.
    > Nur irgendwie ist es dieser Person diesmal gelungen Google und Jetbrains
    > mit an Boot zu holen. Wer sich in die Sprache einliest sieht schnell: ein
    > vermutlich besserer Verkäufer als er Programmierer ist.

    Stimmt, bei Google, Jetbrains und im Sprint-Team arbeiten natürlich keine so fähigen Programmierer, wie du einer bist. Die können den Wert einer Sprache natürlich nicht so kompetenz beurteilen wie du.

    > Die gefühlt 3 Features die Kotlin hat sind nett, aber lösen entweder nur
    > Probleme auf Kindergartenniveau

    Lol, soviel dazu :D

    https://www.educba.com/java-vs-kotlin/

    > Kotlin wird wie jeder andere unnötige JVM-Dialekt die nächsten Jahre wieder
    > in der Versenkung verschwinden, und sich vermutlich irgendwo neben Scala
    > ins Grab legen.

    Klar. Ganz bestimmt.



    1 mal bearbeitet, zuletzt am 06.11.20 15:57 durch spyro2000.

  12. Re: Kotlin, der Flopp des Jahrzehnts

    Autor: wasdeeh 06.11.20 - 16:00

    MrTridac schrieb:
    --------------------------------------------------------------------------------
    > Fast volle Zustimmung.
    > Insbesondere für den "Kindergarten" Kommentar.
    > Die Fehler die Kotlin verhindern soll, fallen bei jedem vernünftigen Test
    > sowieso gleich ganz am Anfang auf.
    > Damit erreicht man nur, dass keiner mehr sorgfältig arbeitet oder testet,
    > weil ja "die Sprache" so toll und sicher ist.
    > Wir können uns schon mal auf tausende super-buggy Apps vorbereiten die von
    > lern- und testfaulen Entwicklern in Zukunft geschrieben werden.
    >
    > Nicht zustimmen kann ich der Aussage, dass Kotlin wieder verschwinden
    > wird.
    > Leider sind zu viele Hippie-Coder auf den Hype-Zug aufgesprungen.
    > Weil cool ist was neu ist. C/C++ ist "schlecht" weil's alt ist. Das ist der
    > Hauptgrund für den Hype neuer Programmiersprachen. Die "Argumente" gegen C
    > sind aus den Fingern gesogen und stellen eigentlich ein Armutszeugnis aus.
    > "... aus versehen verändert ...", "... break; vergessen ..." ???
    > Das ist für mich ein Grund Fähigkeiten in Frage zu stellen.
    > Wenn ein Brückenbauingenieur "vergisst" die Traglasten richtig zu
    > berechnen, stellt man seine Fähigkeiten auch in Frage.

    LOL. Und dann noch die Chuzpe, einen Bauingineursvergleich zu bringen. Mit so einer Einstellung gegenüber der verwendeten Methoden und Werkzeuge würdest du in jeder anderen Ingenieursdisziplin bestenfalls ausgelacht werden, im worst case würdest du kaum mehr einen Job finden.

    Dazu fällt mir nur mehr dieser xkcd ein:

    https://xkcd.com/2030/

  13. Re: Kotlin, der Flopp des Jahrzehnts

    Autor: hyperlord 06.11.20 - 16:22

    Komm, es ist Freitag - geh doch einfach besser hüpfen und lass die Erwachsenen in Ruhe.

  14. Re: Kotlin, der Flopp des Jahrzehnts

    Autor: apoth90 06.11.20 - 16:25

    Jaja, C++ ist eine total sichere und produktive Sprache... wenn man erstmal 20 Jahre Erfahrung damit hat.

  15. Re: Kotlin, der Flopp des Jahrzehnts

    Autor: twothe 06.11.20 - 16:39

    foobarJim schrieb:
    --------------------------------------------------------------------------------
    > Ich bin in Java gerade nicht soweit drin. Deswegen korrigiere mich bitte
    > wenn ich da falsch liege. Aber IMHO sind Lambdas bei Java nichts anders als
    > nur SAMs, also Interfaces mit einer Methode. Das führt letztlich dazu dass
    > man hintenrum eine Unmenge an SAMs rumfliegen hat anstatt einfach
    > Funktionstypen zu verwenden.

    Da Kotlin und Java auf der gleichen JVM laufen wird am Ende ca. der selbe Bytecode raus kommen. Kotlin kann keine "Magic" auf der JVM machen die Java nicht auch könnte.

    Man darf nicht verwechseln was der Programmierer sieht und was die JVM daraus für Bytecode generiert. Die SAMs wie du sie nennst sind nur eine abwärtskompatible Visualisierung.

    > https://www.educba.com/java-vs-kotlin/

    - NullPointerExcptions sind keine "Frustration für alle Programmierer" sondern nur für Einsteiger. Jeder bessere IDE zeigt zudem potentielle NullPointer an, wenn man überhaupt noch so programmiert das sie auftreten können.

    - Extend Functions sind Klassen die um eine Funktion erweitert wurden. Also exakt das was auch ein extends in Java macht. Man kann über die nötige Formalie streiten, das Klassen aber spontan neue Funktionen haben können hat schon in JavaScript immer für viel Probleme gesorgt.

    - Coroutinen: wer irgendwie denkt Coroutinen wäre besser als nebenläufige Threads hat das ein oder andere Konzept nicht verstanden. Support für Coroutinen gibt es in Java schon seit 1.0, dass das niemand benutzt hat gute Gründe: es gibt wesentlich bessere Optionen. Das Argument das Android single-threaded sei und das Coroutinen Vorteile hätten ist einfach nur in jeder Hinsicht falsch.

    - Checked Exceptions: bei Kotlin darf ich also zu erwartende Programmfehler einfach ignorieren. Großartig! Dann crashen wir wieder auf den Desktop wie damals 1998.

    - Data Classes: gibt es in Java schon seit einer Ewigkeit und heißt dort Bean. Data-Klassen in Kotlin sind nichts anderes als Beans, die schlicht und ergreifen ihre Setter und Getter verstecken. Man darf darüber streiten was besser ist, ich persönlich mag keine Code Magic.

    - Smart Casts: ganz nett das man sich hier ein paar Buchstaben spart, aber wie oben schon erwähnt: ich bin kein Freund von Code Magic.

    - Type Inteference: Das wird immer so gehyped das man keinen Typ angeben muss. In JavaScript, einer Sprache wo das schon seit Anbeginn geht, tut man gerade alles um das zu unterbinden, weil es in größeren Projekten eine Katastrophe und häufige Fehlerquelle ist. Das ist also bei Kotlin kein Vorteil sondern ein Nachteil.

    - Functional Programming: in Java seit Java 8 voll supported, also seit 6 Jahren. Wenn man das offizielle Release-Date von Kotlin nimmt, dann kann Java schon 2 Jahre länger Functional.

    Kotlins Vorteile schrumpfen also im Fazit auf ein paar Tipp-Unterstützungen zusammen.

  16. Re: Kotlin, der Flopp des Jahrzehnts

    Autor: apoth90 06.11.20 - 16:59

    twothe schrieb:
    --------------------------------------------------------------------------------
    > - Type Inteference: Das wird immer so gehyped das man keinen Typ angeben
    > muss. In JavaScript, einer Sprache wo das schon seit Anbeginn geht, tut man
    > gerade alles um das zu unterbinden, weil es in größeren Projekten eine
    > Katastrophe und häufige Fehlerquelle ist. Das ist also bei Kotlin kein
    > Vorteil sondern ein Nachteil.

    Beantworte mal bitte Folgendes: Was passiert wenn ich folgendes Stückchen Code sowohl in Kotlin als auch in JavaScript ausführe:
    var x = 5;
    x = "foobar"

  17. Re: Kotlin, der Flopp des Jahrzehnts

    Autor: pioneer 06.11.20 - 17:02

    apoth90 schrieb:
    --------------------------------------------------------------------------------

    > Beantworte mal bitte Folgendes: Was passiert wenn ich folgendes Stückchen
    > Code sowohl in Kotlin als auch in JavaScript ausführe:
    > var x = 5;
    > x = "foobar"

    :-D Dazu werden seine Skills nicht reichen ;-)

  18. Re: Kotlin, der Flopp des Jahrzehnts

    Autor: d4rky1989 06.11.20 - 17:12

    twothe schrieb:
    > - Type Inteference: Das wird immer so gehyped das man keinen Typ angeben
    > muss. In JavaScript, einer Sprache wo das schon seit Anbeginn geht, tut man
    > gerade alles um das zu unterbinden, weil es in größeren Projekten eine
    > Katastrophe und häufige Fehlerquelle ist. Das ist also bei Kotlin kein
    > Vorteil sondern ein Nachteil.

    Da muss ich Dich korrigieren. Du verwechselst "Type Inference" mit einer "Static Typed Language". Letzteres wird aktuell versucht mit Hilfe von TypeScript zu erreichen. Ersteres ist lediglich ein Hilfsmittel um Boilerplate-Code zu vermeiden (der (statische) Variablentyp wird vom Compiler aus dem Kontext automatisch ermittelt). Ohne Type Inference währen mMn. z.B. Lambas überhaupt nicht zu gebrauchen.



    1 mal bearbeitet, zuletzt am 06.11.20 17:15 durch d4rky1989.

  19. Re: Kotlin, der Flopp des Jahrzehnts

    Autor: Pete Sabacker 06.11.20 - 17:12

    twothe schrieb:
    --------------------------------------------------------------------------------
    > - NullPointerExcptions sind keine "Frustration für alle Programmierer"
    > sondern nur für Einsteiger. Jeder bessere IDE zeigt zudem potentielle
    > NullPointer an, wenn man überhaupt noch so programmiert das sie auftreten
    > können.

    In der Realität hast Du halt Leute, die nicht aufpassen. Seit ich Kotlin und Swift mit anderen Leuten in Projekten nutze, fällt die Zahl dieser Exceptions auf fast Null, weil eben Programme ohne Rücksicht darauf nicht kompilieren.

    > - Coroutinen: wer irgendwie denkt Coroutinen wäre besser als nebenläufige
    > Threads hat das ein oder andere Konzept nicht verstanden. Support für
    > Coroutinen gibt es in Java schon seit 1.0, dass das niemand benutzt hat
    > gute Gründe: es gibt wesentlich bessere Optionen. Das Argument das Android
    > single-threaded sei und das Coroutinen Vorteile hätten ist einfach nur in
    > jeder Hinsicht falsch.

    Ja, deswegen fahren alle so auf Koroutinen ab, weil Threads einfach immer besser sind.

    > - Checked Exceptions: bei Kotlin darf ich also zu erwartende Programmfehler
    > einfach ignorieren. Großartig! Dann crashen wir wieder auf den Desktop wie
    > damals 1998.

    Also Nullability darf man ignorieren, wenn der Compiler sich beschwert, Exceptions jedoch nicht? Die man ganz abgesehen davon in Java ohnehin viel zu sehr missbrauchte?

    > - Data Classes: gibt es in Java schon seit einer Ewigkeit und heißt dort
    > Bean. Data-Klassen in Kotlin sind nichts anderes als Beans, die schlicht
    > und ergreifen ihre Setter und Getter verstecken. Man darf darüber streiten
    > was besser ist, ich persönlich mag keine Code Magic.

    Das ist absoluter Schwachsinn oder nur ein veschwindend geringer Teil dessen, was data classes ausmacht:

    https://kotlinlang.org/docs/reference/data-classes.html

    > - Smart Casts: ganz nett das man sich hier ein paar Buchstaben spart, aber
    > wie oben schon erwähnt: ich bin kein Freund von Code Magic.

    Ja, cluttern wir den Code einfach mit allem Rotz zu, weil das Typsystem von Java so toll ist.

    > - Type Inteference: Das wird immer so gehyped das man keinen Typ angeben
    > muss. In JavaScript, einer Sprache wo das schon seit Anbeginn geht, tut man
    > gerade alles um das zu unterbinden, weil es in größeren Projekten eine
    > Katastrophe und häufige Fehlerquelle ist. Das ist also bei Kotlin kein
    > Vorteil sondern ein Nachteil.

    Uff.

    > - Functional Programming: in Java seit Java 8 voll supported, also seit 6
    > Jahren. Wenn man das offizielle Release-Date von Kotlin nimmt, dann kann
    > Java schon 2 Jahre länger Functional.
    >
    > Kotlins Vorteile schrumpfen also im Fazit auf ein paar Tipp-Unterstützungen
    > zusammen.

    Doppel-Uff.

  20. Re: Kotlin, der Flopp des Jahrzehnts

    Autor: andy848484 06.11.20 - 17:13

    Den Kritikpunkt hab ich auch nicht verstanden.
    Trotz der Typableitung bleibt kotlin eine statische stark typisierte Sprache.
    Gerade bei irgendwelchen generischen Listentypen, bei denen man sich in Java die Finger bricht beim Tippen ein sehr angenehmer Vorteil (Typableitung)

  1. Thema
  1. 1
  2. 2

Neues Thema Ansicht wechseln


Um zu kommentieren, loggen Sie sich bitte ein oder registrieren Sie sich. Sie müssen ausserdem in Ihrem Account-Profil unter Forum einen Nutzernamen vergeben haben. Zum Login

Stellenmarkt
  1. Melitta Business Service Center GmbH & Co. KG, Minden
  2. Information und Technik Nordrhein-Westfalen (IT.NRW), Düsseldorf, Hagen
  3. InnoGames GmbH, Hamburg
  4. Der Polizeipräsident in Berlin, Berlin

Golem pur
  • Golem.de ohne Werbung nutzen

Anzeige
Spiele-Angebote
  1. 15,99€
  2. 14,99€
  3. 7,99€


Haben wir etwas übersehen?

E-Mail an news@golem.de


Programm für IT-Jobeinstieg: Hoffen auf den Klebeeffekt
Programm für IT-Jobeinstieg
Hoffen auf den Klebeeffekt

Aktuell ist der Jobeinstieg für junge Ingenieure und Informatiker schwer. Um ihnen zu helfen, hat das Land Baden-Württemberg eine interessante Idee: Es macht sich selbst zur Zeitarbeitsfirma.
Ein Bericht von Peter Ilg

  1. Arbeitszeit Das Sechs-Stunden-Experiment bei Sipgate
  2. Neuorientierung im IT-Job Endlich mal machen!
  3. IT-Unternehmen Die richtige Software für ein Projekt finden

Weclapp-CTO Ertan Özdil: Wir dürfen nicht in Schönheit und Perfektion untergehen!
Weclapp-CTO Ertan Özdil
"Wir dürfen nicht in Schönheit und Perfektion untergehen!"

Der CTO von Weclapp träumt von smarter Software, die menschliches Eingreifen in der nächsten ERP-Generation reduziert. Deutschen Perfektionismus hält Ertan Özdil aber für gefährlich.
Ein Interview von Maja Hoock


    Fiat 500 als E-Auto im Test: Kleinstwagen mit großem Potenzial
    Fiat 500 als E-Auto im Test
    Kleinstwagen mit großem Potenzial

    Fiat hat einen neuen 500er entwickelt. Der Kleine fährt elektrisch - und zwar richtig gut.
    Ein Test von Peter Ilg

    1. Vierradlenkung Elektrischer GMC Hummer SUV fährt im Krabbengang seitwärts
    2. MG Cyberster MG B Roadster mit Lasergürtel und Union Jack
    3. Elektroauto E-Auto-Prämie übersteigt in 2021 schon Vorjahressumme