HN Simulatornew | past | comments | lists | submit | owlstuffing's commentslogin

>Shame they killed Fleet, could have been a cool basis to compete with Zed (or VS Code, more directly) and integrate Air there or something.

JB’s wheelhouse is human-oriented code authoring, they own it. That realization is the fundamental reason they abandoned Fleet: as with VS Code and others, Fleet was draining their talent and would have resulted in a tool that wasn’t best-of-breed in any one category.

This situation reminds me of the beginning of the end of Borland’s demise: they spent nearly two years writing OS/2 versions of all their language products, suspending innovation and progress across the board, and allowing the competition (Microsoft) to catch up and begin to hire away their talent.

This story doesn’t perfectly align with JB, but it definitely rhymes. I hope they switched gears soon enough.


> Fleet was draining their talent and would have resulted in a tool that wasn’t best-of-breed in any one category.

Visual Studio Code, but JetBrains would have been pretty cool, especially when you want something that supports other modes of work (e.g. ADE). Now VSC/Zed fills that role and JetBrains don’t compete with them, now even to upsell to their full IDE for more deep work.


> Polymorphism (“generics”) and interfaces (“OOP”) would have been even better to see

Yep. Interface-based (true) delegation between objects would be my go-to if it existed.


Scala is its own worst enemy in this respect. It’s both too close to Java and too far.

Too far: there are several dialects one can use with it e.g., I can speak Haskell with Scala grammar. Unlike with Java there is no central Scala dialect, so reading/maintaining a Scala codebase can be a challenge.

Too close: its type system, as advanced as it is, is still stuck in Java’s inheritance and all its limitations. Traits, for example, are not runtime components, they dissolve into the hosting class’ single object, giving up the independent identity and flexibility of runtime configured composition. And the Scala 3 `exports` feature that departs Java’s inheritance is just forwarding, not true delegation; it is the inverse of traits: it trades self identity for independent identity (no late-bound self that comes free with impl inheritance).


You can inline native type-safe JSON directly in Java with the manifold project.

    /*[Dude.json/] {
      "Name": "Scott",
      "Age": 100,
      "Address": {
        "Street": "345 Syracuse Way",
        "City": "Atlantis"
      }
    }
    */

    Dude dude = Dude.fromSource();
            
    out.println(dude.getName());
    out.println(dude.getAge());
    out.println(dude.getAddress().getCity());

https://github.com/manifold-systems/manifold


You could... but I view JSON as a simple format that you could write a recursive parser for in a few hundred lines yourself.

Bringing in compile-time code generation just for defining static JSONs (which is not that common outside of tests, as most JSONs are serialized and deserialized at runtime) sounds like a hard sell.


This is just a small part of manifold’s JSON integration. And, yes, the inline aspect is mostly for testing, and it’s awesome there.


Guidelines | FAQ | Lists | API | Security | DMCA | Apply to YC | Contact

Search: