tivrfoa

https://blog.yoshuawuyts.com/tree-structured-concurrency/

As recently reported by Google, async Rust is one of the most difficult aspects of Rust to learn. It seems likely that the lack of structure in async Rust code today did not help. In async code today neither cancellation nor errors are guaranteed to propagate. This means that if you want to reliably compose code, you need to have knowledge of the inner workings of the code you're using. By adopting a (tree-)structured model of concurrency these properties can instead be guaranteed from the outset, which in turn would make Async Rust easier to reason about and teach. Because "If it compiles it works" should apply to async Rust too.

https://news.ycombinator.com/item?id=36559030

https://sean-parent.stlab.cc/papers-and-presentations/#better-code-concurrency

https://learn.adacore.com/courses/Ada_For_The_CPP_Java_Developer/chapters/11_Concurrency.html

https://www.youtube.com/watch?v=iLHNF7SgVN4

https://www.youtube.com/watch?v=BD9cRbxWQx8

The combiner in Java's Stream.collect() method is an important part of the method's behavior, especially when the stream is processed in parallel. Here's why your combiner might not have been called:

Understanding `Stream.collect()`

The collect method in Java Streams is used to transform elements of the stream into a different form, often a collection (like List, Set, or Map). It takes three arguments:

Supplier: A function that provides a new instance of the result container (e.g., a List or Set).
Accumulator: A function that folds a value into the result container.
Combiner: A function that merges two containers, which is particularly important in parallel processing.

Question

Regarding Java code:

Let's suppose you have a static method that accepts a few interfaces. Different object instances always call it with a concrete combination of the interfaces, but C2 ends up with megamorphic code. How would you improve that?

ChatGPT 3.5

When you have a static method that accepts interfaces and different object instances call it with various combinations of those interfaces, and you observe megamorphic behavior (where the JVM struggles to optimize due to multiple possible types), you can consider a few strategies to improve performance: >

1.) Download a Nerd Font

2.) Unzip and copy to ~/.fonts

3.) Run the command fc-cache -fv to manually rebuild the font cache

	// https://www.youtube.com/watch?v=VmBwn6Nac74

	package main

	import (
	"fmt"
	"sync"
	// "time"
	)

	#include <stdio.h>
	#include <signal.h>
	#include <unistd.h>

	void sigusr1_handler(int sig) {
	printf("------>>> Received SIGUSR1 signal\n");
	}

	int main() {
	signal(SIGUSR1, sigusr1_handler);

	// https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=ae0048c018c77abd71b3c5121e02511a

	trait Animal {
	fn do_sound(&self);
	}

	struct Dog;
	impl Animal for Dog {
	fn do_sound(&self) {
	println!("hoho");

tivrfoa

Understanding Stream.collect()

Question

ChatGPT 3.5

Understanding `Stream.collect()`