Gut, aber falsche VM und schlechte {}-Setzung

[Robert0]

Konzeptuell gefällt mir Kotlin, so wie mir v.a. auch C# gefällt

Mächtige, prägnante Konstrukte gegen Menschliche Fehler.

Das Ding mit den unsichtbaren Typen heißt auf deutsch - und so war ja der Artikel offenbar geschrieben - Typinferenz. Die gibt es in der Informatik schon länger als all die Sprachen.

Problem ist nur: Wie will man all das sinnvolle Zeug machen, ohne Werttypen. Mit einem
new Complex[399949494] gleich alles fertig haben. Eine Operation in O(1). Das sind Dinge, die in der JVM vs. CLR einfach nicht gehen. Zum richtigen Rechnen: fail.

Am Ende muss ich natürlich noch auf diese widersinnige Klammerung eingehen.
Das ist aber irgendwie in der gesammten Javawelt so falsch.
Wie kommt jemand auf die Idee, zusammengehörige optische Konsturkte {
an das Ende der Zeile zu schreiben
}
damit man ja nicht sieht, wo es los geht. So{
wäre konsequent zuendegedacht, aber auch Mist. }

aber
{
so ist viel klarer
}

[eleaiactaest]

Robert0 schrieb:
--------------------------------------------------------------------------------

> {
> so ist viel klarer
> }
Deshalb hat jemand die {
    Einrückung
}
erfunden.

[Dino13]

Robert0 schrieb:
--------------------------------------------------------------------------------
> Konzeptuell gefällt mir Kotlin, so wie mir v.a. auch C# gefällt
>
> Mächtige, prägnante Konstrukte gegen Menschliche Fehler.
>
> Das Ding mit den unsichtbaren Typen heißt auf deutsch - und so war ja der
> Artikel offenbar geschrieben - Typinferenz. Die gibt es in der Informatik
> schon länger als all die Sprachen.
>
> Problem ist nur: Wie will man all das sinnvolle Zeug machen, ohne
> Werttypen. Mit einem
> new Complex[399949494] gleich alles fertig haben. Eine Operation in O(1).
> Das sind Dinge, die in der JVM vs. CLR einfach nicht gehen. Zum richtigen
> Rechnen: fail.
>
> Am Ende muss ich natürlich noch auf diese widersinnige Klammerung
> eingehen.
> Das ist aber irgendwie in der gesammten Javawelt so falsch.
> Wie kommt jemand auf die Idee, zusammengehörige optische Konsturkte {
> an das Ende der Zeile zu schreiben
> }
> damit man ja nicht sieht, wo es los geht. So{
> wäre konsequent zuendegedacht, aber auch Mist. }
>
> aber
> {
> so ist viel klarer
> }

Wie man die Klammer setzt ist doch jedem selbst überlassen. Die kannst du natürlich auch so wie von die gemocht setzten.

[mnementh]

Robert0 schrieb:
--------------------------------------------------------------------------------
> Konzeptuell gefällt mir Kotlin, so wie mir v.a. auch C# gefällt
>
> Mächtige, prägnante Konstrukte gegen Menschliche Fehler.
>
> Das Ding mit den unsichtbaren Typen heißt auf deutsch - und so war ja der
> Artikel offenbar geschrieben - Typinferenz. Die gibt es in der Informatik
> schon länger als all die Sprachen.
>
> Problem ist nur: Wie will man all das sinnvolle Zeug machen, ohne
> Werttypen. Mit einem
> new Complex[399949494] gleich alles fertig haben. Eine Operation in O(1).
> Das sind Dinge, die in der JVM vs. CLR einfach nicht gehen. Zum richtigen
> Rechnen: fail.
>
> Am Ende muss ich natürlich noch auf diese widersinnige Klammerung
> eingehen.
> Das ist aber irgendwie in der gesammten Javawelt so falsch.
> Wie kommt jemand auf die Idee, zusammengehörige optische Konsturkte {
> an das Ende der Zeile zu schreiben
> }
> damit man ja nicht sieht, wo es los geht. So{
> wäre konsequent zuendegedacht, aber auch Mist. }
>
> aber
> {
> so ist viel klarer
> }

Ich setze in Java schon immer die Klammern so wie in Deinem zweiten Beispiel. Komme ja auch ursprünglich von Pascal. Wie Du die Klammern setzt schreibt weder Kotlin noch Java vor. Insofern ist das IMHO irrelevant.

So wie ich das sehe unterstützt Kotlin wohl auch verschiedene Backends. Ich sehe LLVM in der Liste. Keine Ahnung was da gehen würde.

[Pete Sabacker]

Erstaunlich, wie unterschiedlich die Leute sein können. Für mich entscheidet das immer die Sprache selbst, gemessen an der Häufigkeit, wo ich welchen Fall lese. In C# wie in Beispiel 2, sonst wie in 1.

[salvation]

Und in der Linux Enwicklung in C ist {
Das hier mit Einrückung vorgeschrieben
}

// ;)



2 mal bearbeitet, zuletzt am 06.11.20 20:11 durch salvation.

[Robert0]

Ja, irgendwie beides das gleiche verbohrte Klientel.
Bin immer gegen MS, wenn es sinnvoll ist, aber mit deren Konzepten und Klammersetzung komme ich oft besser zurecht.

Geschrieben vom Linuxrechner

[amagol]

Robert0 schrieb:
--------------------------------------------------------------------------------
> aber
> {
> so ist viel klarer
> }

OK, aber warum ist das ein Thema? Genauso wie Tab vs Spaces - Formatter drueber und fertig - was du persoenlich schreibst kanst du halten wie ein Dachdecker - Hauptsache im Repository sieht alles gleich aus.

[dEEkAy]

Robert0 schrieb:
--------------------------------------------------------------------------------
> Konzeptuell gefällt mir Kotlin, so wie mir v.a. auch C# gefällt
>
> Mächtige, prägnante Konstrukte gegen Menschliche Fehler.
>
> Das Ding mit den unsichtbaren Typen heißt auf deutsch - und so war ja der
> Artikel offenbar geschrieben - Typinferenz. Die gibt es in der Informatik
> schon länger als all die Sprachen.
>
> Problem ist nur: Wie will man all das sinnvolle Zeug machen, ohne
> Werttypen. Mit einem
> new Complex[399949494] gleich alles fertig haben. Eine Operation in O(1).
> Das sind Dinge, die in der JVM vs. CLR einfach nicht gehen. Zum richtigen
> Rechnen: fail.
>
> Am Ende muss ich natürlich noch auf diese widersinnige Klammerung
> eingehen.
> Das ist aber irgendwie in der gesammten Javawelt so falsch.
> Wie kommt jemand auf die Idee, zusammengehörige optische Konsturkte {
> an das Ende der Zeile zu schreiben
> }
> damit man ja nicht sieht, wo es los geht. So{
> wäre konsequent zuendegedacht, aber auch Mist. }
>
> aber
> {
> so ist viel klarer
> }

Das schöne an Java ist, du darfst hier Klammern wie du möchtest.



2 mal bearbeitet, zuletzt am 08.11.20 20:17 durch dEEkAy.

[BLi8819]

> Am Ende muss ich natürlich noch auf diese widersinnige Klammerung eingehen.
Das hat ja nichts mit der Sprache zu tun.