Would be nice to add Concurrency to the concept tree in the Go track

Concurrency is explicitly highlighted in the Go introduction video. Yet currently the entire tree of Go concepts has no link to concurrency. Would be something really nice to add.

Not complaining, just pointing out the obvious for future improvement.

Great work overall!

(BTW. No rush. Quality is probably more important than quantity.)


Counterexample: Bank Account. There might be more.

There is also Parallel Letter Frequency, but that is about parallelism rather than concurrency.

1 Like

@MatthijsBlom Neither of those are Concept Exercises. Unless I’ve missed something @someknowit is correct that Concurrency isn’t a Concept on the Elixir track.

1 Like

@someknowit It’s also one of my personal frustrations that the Go track doesn’t have concurrency on the syllabus yet. It’s one of the reasons people chose Go and we don’t do a very good job of teaching it in Exercism. The Parallel Frequency exercise is great, and it’s really satisfying to do it in Go, but currently, you must learn concurrency somewhere else.

We want to add concurrency to the syllabus. It’s on our minds as a thing to do. The tricky thing is to come up with a really good exercise for it. Concept exercises encourage a test-based approach where you incrementally practice more about the concept gradually in each task. That’s tricky for concurrency, since explaining channels and goroutines go hand-in-hand, and it’s hard to think of a meaningful simple task that teaches just one of the concepts in isolation. For instance, most resources start teaching goroutines first, but the way they ask you to see concurrency happening is by doing prints to the output in each goroutine. Exercism being test-driven, the print approach wouldn’t work too well. This is an example of some of the difficulties we found when thinking about teaching concurrency in Exercism.

We already had some discussions about this, and there are a few ideas we can try to see if they would work. We’ll get there, but it’ll be tricky!

Would like to support that, bringing concurrency to Go’s syllabus.

From my side, I am not so worried about the task being difficult, it is more that most people underestimate the time it takes to create a good concept and exercise. I simply did not have that time so far.

I am currently sorting out some problems with the errors/interfaces exercise and concurrency was my next stop after that (which could be easily a couple of month in the future though).

For people like @sebastian0x62 that want to help with this, please keep in mind that we have not yet worked out a good new volunteering model, see this blog post.

Before more people pile on to say they want to help, please consider that it only really helps us maintainers and brings the track forward if some conditions are fulfilled:

  • if you haven’t created a concept and learning exercise before, you need to be willing to read a lot of documentation before you can start
  • you can commit multiple hours per week for a couple of month
  • you are fluent in Go and English
  • you have some affinity to teaching (e.g. you can explain complex topics in an accesible way)

@sebastian0x62 I will contact you on Discord and we discuss in more detail.

1 Like