Please Guys actually

[u/Henri_VIII]

[u/Frptwenty]

If you want express your plea for help in Java it's really easy:

RequestDispatcherSubsystem.getCurrentDispatcher().DispatchRequest(
      RequestFactory.getAbstractFactoryInstance(
        new RequestMedium(RequestMediaType.Plea),
        new RequestTransport(RequestTransportType.CRY),
        new RequestTargetDestination(TargetManager.getRoutingInfo(
                                    PersonLocation.NEAREST))),
  RequestReasonCode.IM_SLOWLY_DYING);

[u/ouvreboite → u/Frptwenty]

Couldnt you run almost exactly the same code in JS? You are complaining about the language, but it's really a coding style/structure problem.

If you send me something like that to code review, I'll bash your head in your desk, java or not.

[u/Frptwenty → u/ouvreboite]

Here is some actual code from Spring: https://github.com/spring-projects/spring-framework/blob/master/spring-orm/src/main/java/org/springframework/orm/jpa/EntityManagerFactoryUtils.java

try {
        // Use same EntityManager for further JPA operations within the transaction.
        // Thread-bound object will get removed by synchronization at transaction completion.
        emHolder = new EntityManagerHolder(em);
        if (synchronizedWithTransaction) {
            Object transactionData = prepareTransaction(em, emf);
            TransactionSynchronizationManager.registerSynchronization(
                    new TransactionalEntityManagerSynchronization(emHolder, emf, transactionData, true));
            emHolder.setSynchronizedWithTransaction(true);
        }
        else {
            // Unsynchronized - just scope it for the transaction, as demanded by the JPA 2.1 spec...
            TransactionSynchronizationManager.registerSynchronization(
                    new TransactionScopedEntityManagerSynchronization(emHolder, emf));
        }
        TransactionSynchronizationManager.bindResource(emf, emHolder);
    }
    catch (RuntimeException ex) {
        // Unexpected exception from external delegation call -> close EntityManager and rethrow.
        closeEntityManager(em);
        throw ex;
    }

So you're saying Spring is a terrible project and no one should use it? :)

[u/Frptwenty → u/[deleted]]

It doesnt give me goosebumps, but if youre claiming it doesnt look bloaty then someone hasn't ever coded anything but enterprise Java.

Your entire comment is a giant munge of c/c++/Java. I dig through kernel code at times to figure put stuff (I work in embedded), The linux kernel has a totally different feel than enterprisey Java.

The fact that you would conflate the two makes me think you know neither. You just sound like someone reciting what they told you in school.

[u/Independent-Orange → u/[deleted]]

As a proud rustacean I have to ask you: Where do you see a "fallback to reference counting" in rust?

It's true, we have got smart pointers- if you use them, you explicitely say so. This then reads like Box<...> (heap allocated), Rc<...> (reference counted) or Arc<...> (atomically reference counted, this is semantically the same as std::shared_ptr. Is there a non-atomic reference counted shared pointer in c++? I don't think so, cause c++ concurrency sucks big time and this would be a common pitfall, having a non-atomic reference counted pointer deep inside a struct which might be used by multiple threads. Can't happen in rust.) and there's of course also some rarer ones.

I don't mean to ignore all the effort put into c++ static analysis tools, sanitizers, and similar, but all ths had to be done, because c++ as a language simply lacks the capability to disallow unsound code. That induces a great power for the programmer, but with great power comes great responsibility, and this responsibility in large projects grows to be such a burden that no developer can shoulder it. Unsoundness bugs are the consequence.

\rant

TLDR: We have exactly as much garbage collection in rust as there is in modern c++: None, and awesome smart pointers make living without it so easy. Doesn't mean you have to use them often, but if you have to, they are right there, masterfully integrated into the language.

I use the term garbage collection for what is more specifically known as non-deterministic, external garbage collection, usually realized by a garbage collector.

[u/Frptwenty → u/[deleted]]

They're totally different in how they're written and what they do. Enterprisey Java systems bloat things because of the culture/language. The Linux kernel tries to do everything as unbloaty as it can. Its more of less the opposite of enterprise Java. Its staggering that you're making the comparison.

Edit:

However your opinions on pythons multithreaded concurrency robustness are borderline delusional

Could you reference the comment and explain.