Pony Programming Language: Concurrency and Performance

Programming languages ​​are dynamic fields that always welcome new ideas and insights. Pony programming language is one of the popular languages ​​these days. Pony offers innovative solutions to some common problems in software development with an emphasis on concurrency, performance, and security. In this blog post, we’ll explore the definition of Pony, its main characteristics, and the potential benefits of adding it to your toolkit.

What is Pony programming language?

Pony is an object-oriented, statically-typed, compiled programming language with the goal of offering high performance, memory safety, and concurrent programming features. 

2015 saw its initial release, and Sylvan Clebsch produced it.

Notable Features:

Pony language features

Concurrency Model:

Pony is known for its innovative and concurrent approach. Instead of relying on locks or traditional threading models, Pony adopts an actor-based concurrency model. Actors are independent companies that communicate with each other via messages, providing highly concurrent and scalable solutions.

  class MyActor
  	fun apply(msg: String) => "Received message: " + msg

In the example above, we define a simple actor class MyActor with a single method apply. The apply method takes a string message as an argument and returns a concatenated response. This actor can then be instantiated and used in a concurrent setting.

So lets dive in for hands-on to learn more about Pony programming langauge:

Writing your First program:

How to install:

All the prebuilt releases are available at https://github.com/ponylang/ponyc/blob/main/INSTALL.md

Note: All prebuilt releases are currently AMD64 only. If you want to install on different CPU architecture, you'll need to build from source.

  actor Main
  new create(env: Env) =>
    env.out.print("Hello, world!")

Type System:

Similar to other strongly typed languages like java, C#, Pony is statically typed langauge.  Because of the strong type system, Pony language have provide excellent support in debugging and making sure your system run smoothly. Some of the notable features are as below:

• If your program compiles, it won’t crash.
• There will never be an unhandled exception.
• There’s no such thing as null, so your program will never try to dereference null.
• There will never be a data race.
• Your program will never deadlock.

Classes:

The Core structure in Object Oriented Programming in Classes and similar to other OOP languages, Pony also has Classes.

The Pony Class is composed of three parts:

    Fields: 

    The fields can be of three types var, let and Embed.

• var: This type of fields can be assigned over and over similar to javascript.
• let:  This can only be assigned in constructor and never again.
• embed: embed fields works like composition in other Object Oriented programming language. By this way you can use the fields in another class without inheriting the class.    

Constructors:

The Constructors in Pony programming language are similar to any other languages, except you can have custom name for the constructor.

 class Employee
  let name: String
  var _salary: U64

  new create(name': String) =>
    name = name'
    _salary = 0

  new manager(name': String, salary: U64 = 10000) =>
    name = name'
    _salary = salary

Functions:

    Functions are nothing but methods where you can write your custom behaviour.So for e.g if
you want to return the name of the employee with salary in Pony the sample construct of the function will look like below:

fun getManagerInfo(): String =>
    "Manager Name: " + name + ", Salary: " + _salary.string()

Built in primitives in Pony:

There are four types of primitives in Pony programming langauge:

• Booleans: defined as Bool and value can be either true or false
• Signed Integers: ISize, ILong, I8, I16, I32, I64, I128 . Signed integers of different length.
• Unsigned Integers: USize, ULong, U8, U16, U32, U64, U128
• Floating Point Numbers:F32, F64

Actors:

Actors are similar to classes with function with one difference. The functions in Actors in Pony are async. To define a actor we use actor keyword.

actor Main
  new create(env: Env) =>
    call_me_later(env)
    env.out.print("This is printed first")

  be call_me_later(env: Env) =>
    env.out.print("This is printed last")
 

with actors in Pony programming, you dont have to use threads, hefty context switching and difficult locks. It justs works so nicely, you dont have to worry on performance and thread safety here.

Traits and Interfaces:

Pony language provides subtyping using Traits and Interfaces. Traits are more powerful than interfaces. If you are unsure about what to use, use interface.

Conclusion:

Pony programming language stands out in the programming landscape with its unique features, including the actor-based concurrency model, reference capabilities for error handling, a powerful type system, and a focus on performance.