seer-zig

How do you suggest getting rid of DAO/DTO? This has nothing to do with Java, but with the domain at hand.

I worked on several golang projects where protobuf was used, and the same dichotomy showed up in the code. There were three types even, protobuf types, internal types, and DB types, with manual mappers and validators having to be written between them. Quite a bad, verbose, and error prone experience, especially that golang itself is quite verbose.

I don't get the "don't need to use an IDE" excuse. Almost any present day project is big enough that you need an IDE, regardless of how simple a language is. This is even more so for dynamic languages. Who doesn't want immediate type checking, safe and effective refactoring, call stack lookup, and the many other features an IDE provides? Do people making that claim write code in notepad or something?

Modern Java isn't really any more verbose than other languages it gets compared against. It is very nicely balanced between expressiveness and readability.

The GCs on the JVM are superior to what golang offers. You have several to choose from based on the use case you have (batch processing, web backend, latency sensitive ,etc.).

Modern Java is much more terse than golang. No comparison really.

Can't you setup your project to be `@NotNull` by default, and explicitly mark @Nullable fields? Those should be more rare anyway.

Kotlin is getting some of its own baggage, at least by virtue of having to deal with multiple compilation destinations (JVM, native, Android, JS). This is why you end up with things like @JvmStatic or @JvmInline.

Java is coming along quite nicely. Its pattern matching looks to be better implemented than Kotlin's (e.g. destructuring implementation). Same with string interpolation (https://openjdk.org/jeps/8273943). And now with Loom, no need to maintain two separate API surfaces for sync vs async. It has the last mover advantage.

> but there are facets of coroutines that are just really straight forward that simply green threads can't easily resolve

Could you elaborate on some of those?

Won't work for the people who don't drink.

What was the use case for the app? Was it also HFT?

UBI is not sustainable. For something that is sustainable (and proven), look into Islam's Zakat.

> homosexuality isn't harmful or morally wrong.

Who gets to decide that? For many religious people, it is both (and actually criminal when proven). We take our religion seriously.

How do you think it stands up to Carbon?

Yet, it has a huge influence on spreading certain ideologies. The effect does not have to be direct.

It's definitely a challenge. A good start is to instill a sense of accountability in people, that there is a Day of Judgement where they will face God for their actions. Improve infrastructure and education. Crack down hard on crimes.

> Crimes like this take place everywhere

Everywhere in the US maybe. I couldn't imagine normalizing this sort of behavior. Peace is definitely a huge blessing that many people take for granted.

The phrase "3rd world" was invented to continue the status quo of Western colonization of said "3rd world" countries.

The primary complaint about the 2008 (and the entire move to fiat) is (1) the government gets to print money at its own whim, deflating everyone's hard work. (2) fiat is inherently based on usury, which billions of people find appalling and abhorrent. What happened in 2008 was the natural outcome of such a system, and it will continue to happen if things are not fixed.

When do you expect interest rates to lower?

> model of superlight "threads" exchanging messages

That's exactly what Loom is.

Nothing is stopping the developer from starting a single thread executor and using that to launch many virtual threads. Is that what you meant?

This will make it trivial in Java: https://openjdk.org/jeps/428

It's still error prone in golang. Java's structured concurrency approach is much better.

Not quite: https://www.uber.com/blog/data-race-patterns-in-go/

Rust and golang are not really in the same space. Rust is more of a C++ competitor, while golang is somewhere between python/ruby and Java/C#. Furthermore, there really isn't anything that golang does that Java or C# don't, but the latter do it in a much more saner way, especially Java now with Loom on the way. Unless you really need to compile to binaries, but both ecosystems are getting solutions in the works (GraalVM and Native AOT).

Java's type system supports code gen. See projects like the Checker framework or NullAway

golang is not semicolon insensitive, otherwise you'd be able to write

    if
    {
        // ...
    }
    else
    {
        // ...
    }

but the compiler doesn't let you.

Yes, but you can also read about how when the prohibition was revealed, people obeyed without delay. It has been documented that people immediately broke their wine containers and poured them in the streets of Madinah, such that it flowed through them.

The way the US went about it is just one data point. In Islam, we have successfully minimized drinking to an extremely large extent.

What do they do when the society around them doesn't care and is reckless? For example, because drinking is so ingrained in many societies today, you have to do what you can to protect yourself from drunk drives.

What about the last mile issue? Like getting products to grocery stores and outlets?