HN Theater @HNTheaterMonth

Here's a great talk (from Strange Loop conf 2017) by David Sullins about Rust concurrency:

https://youtu.be/oIikwmeGVYY

* To Serve The People: Public Interest Technologists. Matt Mitchell is a hacker, security researcher, operational security trainer, and data journalist who founded & leads CryptoHarlem, impromptu workshops teaching basic cryptography tools to the predominately African American community in upper Manhattan.

https://www.youtube.com/watch?v=2Cm3N4Yi3b0

* Stop Rate Limiting! Capacity Management Done Right. Jon Moore is the Chief Software Architect at Comcast Cable, where he focuses on delivering a core set of scalable, performant, robust software components for the company's varied software product development groups.

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

* Keeping Time in Real Systems. This talk will tour the fascinating timekeeping mechanisms used in real systems. We will explore atomic clocks, NTP and GPS through systems that use them, and logical clocks in the context of systems built on logical time.

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

* Level Up Your Concurrency Skills With Rust. This talk will show you how Rust will catch many concurrency errors at compile time.

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

* Diablo: A Classic Game Postmortem. Diablo developer David Brevik returns to the GDC stage to give a classic post-mortem on Blizzard's action RPG hit Diablo in this 2016 talk.

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

* The Flash Games Postmortem. In this 2017 GDC talk, Kongregate's John Cooney attempts to encapsulate the immense history of Flash games and how it has shaped the current game industry by giving game developers their first chance to build and publish their games quickly to the web.

https://www.youtube.com/watch?v=65crLKNQR0E

* Siege Battle AI in Total War: Warhammer. In this 2017 GDC session, Creative Assembly's Andre Arsenault shows the approach used in Total War: Warhammer to create the very specialized high-level AI to guide these massive armies in a way that provides a convincing, epic-scale battle.

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

⬐ KwanEsq

The music does end after the first minute, fortunately.

⬐ senorsmile

why oh why is this music in the background?!?!?

⬐ equalunique

I wish I had the name of the song. It's great.

⬐ tiuPapa

Sorry for straying offtopic, but what are some good resources to understand concurrency in general?

⬐ Jtsummers

Is there a specific aspect of it you want to understand?

My recommendation to younger colleagues has been: Learn Go and Erlang. Go implements (basically) communicating sequential processes. If you want to know more from a theory side, you can read C.A.R. Hoare's book on the topic [0]. Erlang uses the actor model and message passing. There are many similarities but enough differences that you can learn a lot by learning both. Other languages offer these same approaches, but these two are the closest mainstream languages I'm aware of that take CSP or actor model as almost their basic design philosophy. This reduces the semantic distance between the language and the theory and makes it easy to learn, IMHO.

Lots of good resources for both, you can google around for.

After getting the hang of things here, I'd continue with studying the concurrency primitives or libraries of your language of choice. You'll hopefully find that you can apply the knowledge you've found from the first two to designing good concurrent software in most other languages.

[0] http://www.usingcsp.com/

⬐ tiuPapa

Yeah learning Go and Erlang has been on my mind. Basically I am interested in learning about the different prevalent models like CSP, STM, actors and how they differ or relate to each other, or how things like event loops or sync and async fit in here. I have a basic idea of the terms but I don't have a clear picture in mind.

⬐ dmlorenzetti

You might try "Seven Concurrency Models in Seven Weeks" for a high-level overview of different approaches.

https://pragprog.com/book/pb7con/seven-concurrency-models-in...

⬐ tiuPapa

Whoa nice, seems like exactly what I wanted

⬐ bulldoa

does anyone know what is the trade off between csp and actor?

⬐ rubiquity

It varies by implementation but with Actors the processor is addressable (process ID) and with CSP the transport, typically channels, are what is addressable.

To make it more concrete, with CSP you send the message to a channel and you don’t know who is reading from that channel. With Actors you send a message to a specific Actor.

Time for opinions: It’s pretty trivial to get channel semantics with Actors by having an Actor that acts as a reverse proxy. It’s harder, or maybe less conventional, to have Actor semantics with CSP. You would have to assign a channel to each processor (goroutine in Go) and maintain a reference to that.

At the end of the day, they are just abstractions and we are always working with references to memory, IO, and CPU, so the differences are mostly philosophical. Actors resonate better with the model of computation and program structure I have built up in my head over time.

⬐ midknightowl

You may want to start with "The little book of semaphores" before delving into the concurrency models of a language. I have not found a more approachable text for understanding/solving synchronization problems.

http://greenteapress.com/semaphores/LittleBookOfSemaphores.p...