New to Pony and want to know more?

Look no further than our swift roundup of the most insightful, easy to digest Pony content from across the internet!

If that’s whetted your appetite, check out Code Mesh LDN 18’s Pony training session with none other than Pony creator Sylvan Clebsch and Pony core team member Sean T. Allen.

 

Why Pony?

Speaker: Sean T. Allen

Pony is a new language designed to make fast, concurrent programming simple. Its actor-based concurrency and advanced type system ensure programs are data race and deadlock free. Not sure about what Pony is and if it's something you might use?

Join Pony core team member Sean T. Allen as he compares Pony to more mature technologies, starting with when you shouldn't use it when you should, and what your alternatives might be. Watch this talk to learn about Pony's design philosophy, how the actors simplify writing safe code and more. You'll leave understanding what Pony is and if it's something you might use.

 

Pony: Making it easy to write efficient, concurrent, data race free programs

Speakers: Sylvan Clebsch, Sebastian Blessing, Sophia Drossopoulou

 

Pony is an object-oriented, imperative, actor-based programming language which makes it easy to write super-fast programs. Its development started as a vision in Sylvan’s mind about eight years ago, followed by a concerted effort 1 year ago, and open sourcing in May 2015.

This talk first answers the question Sylvan, Sebastian, and Sophia are often asked: why is it called Pony? It will then outline the major design and implementation decisions: the type system (which supports data-race-free, copyless message passing of mutable structures), pattern matching, the use of LLVM, the implementation of message queues, the application of the actor paradigm to garbage collection, and benchmarks.

Watch out for the speakers partaking in a bit of hands-on programming to show some interesting features!

 

Pony: 714 Days Later

Speaker: Sylvan Clebsch

In the previous entry, filmed in 2015, Pony had just been open sourced. Between then and 2017, Sylvan had developed a small but thriving community that mostly uses Pony for low-latency, high-throughput, concurrent server-side computing.

In this talk, Sylvan talks about how Pony’s type system and runtime put actors to work to deliver a fast, predictable, GC’d, native-code, actor-model environment, including data-race freedom, optimised binaries, the work-stealing scheduler, fast zero-copy messaging, and efficient no-stop-the-world GC. Sylvan also talks about how industry users and academic researchers have been working together to improve Pony for "real-world" projects.

 

Pony - A Language for Provably Safe Lockless Concurrency

Speaker: Joe McIlvain

 

If you're interested in concurrency, actor-oriented programming, and emerging technologies, then this talk is for you. Joe discusses safe patterns for lockless concurrency and how Pony, an emerging actor language built on LLVM, provides a platform for describing these patterns in Citrusbyte’s code explicitly, verifying their code's safety, and compiling high-performance concurrent applications.

Key takeaways from Joe’s talk:

• You'll learn about common patterns for safe lockless concurrency
• You'll learn about how Pony enforces those patterns via reference capabilities in the type system
• You'll learn about other key concepts in Pony
• You'll get a brief look at where Pony is going

Pony for Safe, Fast, concurrent programs

Speaker: Sophia Drossopoulou

An introduction to the programming language Pony, and how it makes it easy to write safe, fast, concurrent programs. Sophia discusses the actor paradigm, the type system and its guarantee of atomicity at the behaviour level, the use of types for GC, the runtime system, and some benchmarks

Watch this talk if you want to understand the principles guiding the design of the language Pony and to learn how Pony achieves performance.

 

Designing an Actor Model Game Architecture with Pony

Speaker: Nick Pruhs

Pony’s high performance and object-oriented approach already makes it interesting for game development which has been dominated by the C++ programming language for decades. By introducing actors at the language level and a new language concept called capabilities, Pony prevents common multithreading pitfalls and becomes an exciting candidate for game development and real-time application development in general.

With PonyGame, Nick proposes an architecture for building games with Pony.

 

Everyone gets a pony!

Speaker: Kristoffer Grönlund

 

Memory safety in low-level programming languages is a topic that has received a lot of attention in the last few years, with languages like Rust, Julia and Swift that promise high performance and low runtime overhead coupled with a safer memory model than the "you're on your own" model of C and C++.

Pony is a programming language which draws inspiration from a wide variety of existing languages like Erlang, C, and Python while at the same time incorporating some recent academic language research in the form of capability-based security. The resulting language compiles to native code, is compatible with C, highly concurrent and at the same time type safe, memory safe and data-race free. Most importantly, it is a joy to use!

In this talk, Kristoffer will provide an introduction to Pony together with some examples of what it looks like, and also give his own personal reasons for being interested in yet another new programming language.

 

Wide World of Actors

Speaker: Scott Lystig Fritchie

 

For Erlang & Elixir/OTP programmers, the actor model of computation sits comfortably in their minds. Processes that communicate only by message passing makes building concurrent applications easy. It feels natural. They may even take it for granted. The Pony language started with the same foundation as Erlang: the actor model of message passing and independent, concurrent computing units.

But Pony is a very different beast. Pony uses a strong static type system to create crash-free, concurrency-safe access to shareable, garbage-collected memory without running in a virtual machine.

To begin, Scott will review the actor model's definition and history. He will then discuss the design trade-offs that took Erlang/OTP's and Pony's implementations down very different paths. As an example, Erlang/Elixir's "selective receive" feature allows message handling in any order. Pony's message receiving is strictly first-in-first-out (FIFO) order only. What good comes from that difference?

A Principled Design of Capabilities in Pony

Speaker: George Steed

An overview of a formal model of the Pony language which allows us to prove Pony's guarantees about freedom from data-races while having more permissive definitions than the existing implementation. George also briefly discuss bugs found in the language implementation during the development of the model.

Prime Cuts: The Best Pieces Of Pony

Speaker: Andrew Turley

On the surface, Pony may seem like another strongly-typed object-oriented programming language with a touch of functional programming on the side. But the most powerful part of Pony's design is the way that it uses actors and reference capabilities to guarantee that programs are free of data races.

This talk provides a general overview of the Pony programming language, followed by a deeper look at how actors and reference capabilities are used in Pony to give the programmer powerful options for working with data across multiple threads of execution.

 

BONUS - Pony: How I learned to stop worrying and embrace an unproven technology

Speaker: Sean T. Allen

https://www.infoq.com/presentations/pony-wallaroo

Sean T. Allen talks about his experiences using Pony to build Wallaroo, a high-performance, low-latency stream processing engine.