10:20 We don't have to worry about parallelism when we're doing concurrency. If we get concurrency right, the parallelism is a free variable that we can decide. 12:04 Concurrent Decomposition: Conceptually, this how you think about parallelism. You don't just think about running a problem statement in parallel. Break the problem down into independent components(that you can separate, understand, and get right), and then compose to solve the whole problem together.

brilliant! thank you!

😂

sarcasm?

@@user-ij9vc1lw9r As an ai model you do not get sarcasm!

CompletableFuture, ha? Virtual Threads in Java 19 are implemented even better than goroutines. Short disclaimer: I also love Go, but it's not ideal. Java is still superior in many aspects.

@@jackdanyal4329 nice, but how many companies are using Java 19? almost none. Like 80% of companies still using Java 8 or 11, so you will not be able to use the new features on your work.

@@rj7250a in the company where I'm working right now (one of the biggest in the Netherlands) the lowest version of Java is 17. I don't care about companies who still use 1.8 ver. It's their problem, not mine. By using virtual threads in production is just a matter of a short time. But you will get a much better implementation of concurrency + solid java with all libraries, community, etc. At least we see that Java does smth right and trying to become more modern. But what does Go do? For several years they said "we don't need generics", and what? now they have generics. but still doesn't have a usable collection types, error handling, etc and etc. and as I mentioned CompletableFuture allows you use concurrency w/o locks and sync problems. and tbh it's much easier to understand the completable future rather trying to understand the whole flow of channels in a not trivial project.

​@@jackdanyal4329why specifically do you think that Java virtual threads are implemented better than goroutines?

@@jackdanyal4329 Virtual Threads in Java 19 are implemented even better than goroutines. They're not... even ... remotely ... close. Java and Go have stolen a lot of concepts from one another, but Java has the burden of being a 20 ton gorilla that you need to wrestle, and Go just works. Go is faster, uses less resources, and so on. Java is so inferior, it's not even close.

With an unbuffered channel, each worker will block until someone receives their result over the channel. Since only the first result will be received from the channel , the remaining workers will block forever. Blocked goroutines cannot be garbage collected, so we would end up with leaked goroutines. Using a buffered channel allows all workers to send their work to the channel regardless of there being a receiver or not, and finish execution cleanly.

Actually, there is no need to create a buffered channel at all. You can just wrap a writing to the channel with a select statement and add a default clause to prevents a goroutine leak.

@ernestnguyen1169, in this case, you are right. But in general, would it be a good idea for a server to swallow its result if it cannot be sent immediately?

I think that's a given for any Comp Sci student.

@@metabolic_jam that’s true, but not everyone who wants to learn about concurrency and parallelism is a cs student

@@metabolic_jam except not everyone watching this is/was a comp sci student

Need a deeper stack for that

I just assumed it somehow was related to Commander Pike in the original Star Trek TV series pilot. We are of that age. . .

There is no difference. Not between the two words. They literally mean the same thing. There is of course difference between the concepts he's describing (parallelization and multi-tasking) but he's using the wrong words to describe them, needlessly sowing confusion.

No, it won't automatically do that.

yes

wait what

@@AlbertBalbastreMorte kzfaq.info/get/bejne/nN59ftinlaeaqmg.html

Beta

This talk was from eight years ago, long before AI was invented. If you are now typing a response to this to inform me that AI was not in fact invented in the past few years, you make me sad.

@@Naeddyr AI was not invented in the past few years. This applies both to AI in general and LLMs specifically. LLMs are a thing for at least 15 years.

It's not just about the program. It also depends on the machine architecture and the input data. I'd say some optimizations can be done (and have been, although not with LLMs which are a very bad tool for that job) but I doubt that fully optimal structure can be achieved.

you are wrong, he says about sawzall: "its an incredible parallel language but has absolutely no concurrency"

"concurrency makes parallelism easy"

Those terms are related, but they do not describe disjoint sets of things. The meanings overlap and vary by situation. In the context of programming, concurrency is the ability of your code to be "composed" into bits of logic that could be run at the same time. Parallelism (when combined with concurrency) is taking said code and running it on a 100-core machine.

😂

its not, concurrency involves running multiple virtual/green threads and switching between them so they appear to run at the same time, but parallelism is actually the multiple things are running at the same time in separate cores, you cannot run multiple things on the same core without doing context switches.

@@vxcute0 No. What you are describing is not concurrency. That's called multi-tasking, or time-sharing, or multiplexing (in networks). I.e. dividing a single resource like a processing unit or a communication channel into multiple time-pieces so that during some longer time period it seems as if it was available to multiple users "at once". But this is only emulated concurrency. My point was different. I'm saying that terms "concurrency" and "parallelism" have the exact same meaning. Running multiple tasks at the same time = concurrently = in parallel. (This goes beyond computers. It applies to general planning and scheduling of tasks like in factory lines, or even trivial daily tasks.) What he is describing in the video as "concurrency" should NOT be called concurrency, nor parallelism, but paralleliZATION. An act of designing processes in such a way that their sub-tasks that are independent on each other are not prevented from running in parallel. It doesn't matter in this context whether that parallelism is real (on multiple units) or emulated (on a single unit that pretends to be multiple units).

@@kyjo72682 I know time-sharing, but in my understanding green threads works the same, also do you have any other reputible resource that defines concurrency as running tasks at the same time ? because this is not the definition I see any were the definition I see is like what rob pike said.

At 1:42 he literally said "[...] as it is intended to be used in computer science"

idiot

Yes, yes you are.

It is C++ joke, it would be distasteful if it was real

[insert that bjarne gigachad quote about people loving to hate the most useful programming languages here]

"highly misplaced and disrespectful" burn the snowflakes!! or as he said, the "lesser minds" : D

It is provocative, but clearly not an endorsement of actual book-burning

Disciplines usually have precise definitions of words to encapsulate concepts. Math, computer science, etc, all do this. The formal inter-discipline definitions usually doesn't perfectly match the colloquial definitions, which you are alluding to in the dictionary. The formal definition of concurrency in computer science has been around for decades.

Артем Арте, dude, go home. You are drunk and/or high.

what the fuck are you talking about

Lets say your right, and hes somehow wrong for trying to distinguish between paralellism and concurrency: What phrases do you suppose people like Rob Pike and the plethora of library/language designers who are reasoning about these problems do? Should they invent new phrases? I think you're a better software developer if you're able to think about this talk when you find yourself speaking with someone who is carefully differentiating between "parallelism" and "concurrency". To me this phrasing becomes very important when we thinking about concurrency in UI design where thread-confinement is a factor: we very much want concurrent decomposition, but not for a throughput increase but for a latency reduction. That is, we want concurrency without parallelism as a way to control for responsiveness, and if you don't understand this, well its good that you don't have my job. Further, to your use of Enstein's maxim [I've never heard the "hand gestures only" variant]: I wonder what you think Rob's use of Gofers is supposed to be if not an attempt to explain something to a six year old? He's trying, I think rather successfully, to explain a very fine point using very elementary components.

LMAO! Right, it's Rob Pike that doesn't understand parallelism. Good one, Ya almost had me. Hilarious!