ingrysty October 31, 2015 at 03:17

Pony is the killer ...?

Recovery mode

Everyone knows such progressive beginners in programming as “Go, Rust, Nim, Crystal” and they are all very cool in their specific areas.

For example:

Go was born as a super simple and industrial language for quickly solving tasks with ideas that are well known to everyone, but some of them are nailed to other languages (5mm).
Our second opponent is Rust, the winner in life, but because of his difficult life in development, he became for the community, as a future and fashionable replacement for C ++. For me, his fate is not yet clear, since green flows and IO for them are still tight there, then I put him in a row with C for microcontrollers, drivers and operating systems.
Crystal ... Directly and clearly I say that this is a super productive Ruby clone. Nothing more to say, all of it is saturated with his spirit.
Nim (He is Nimushka or Nimrod) and its similarity to scripting languages create a special atmosphere for him, but inside he is quite a complex organism and for me this essence is like Haxe with the same sensations when programming on it.

And Pony is my favorite and little puff. In appearance and the name of the language, you can famously pass by ... In general, I invite you under the hood of the article.

This is just the beginning.

I’ll tell you a little about myself in order to create a special atmosphere for you to understand the language and its possible applications.

I am Nyarum, known as a simple user of the Go language. I often push the irony with Rast and co-authored the Slack gopher community.
My pet projects are always connected with emulating online games. From reverse to server side playback.
And I really love Anime.

Now you know all my secrets, you can continue our interesting story into the world of beautiful Pony.

Tongue and short educational program

This is the same cheerful breadwinner and it looks more like a rabbit

Pony - an object-oriented programming language, built primarily on the model of actors and transparent competition. In its additional advantages, such concepts as “Open-source, performance, interesting ideas” are rubbed. The main emphasis is on multi-core systems, modern development without thinking about a low level and very productive competitiveness.

Opportunities

Type safety. Confirmed by a mathematical background.
Safe work with memory. Although this is a consequence of type safety, this item should not be missed. In it you will not find dangling pointers, buffer overflows, or in the most common case - you do not have to know what null is.
Safe work with executions. All of them are defined on a semantic level and no runtime surprises.
Say no to racing data! No atomics, mutexes, or timers. A type system with checks at compile time gives a high guarantee on this concept. Write a competitive code and do not worry about the rest.
No deadlocks. The consequence of the absence of any operations with locks.

Brief language specification

Type system:

Class, standard from OOP world. Fields, constructors, and functions are at your disposal.

class Habra
  let _name: String
  new create(name': String) =>
    _name = name'
  fun name(): String => _name

An actor is identical to a class, but has the ability to define asynchronous functions. This refers to transparent competition.

actor Habro
  let name: String
  var _hunger_level: U64 = 0
  new create(name': String) =>
    name = name'
  be eat(amount: U64) =>
    _hunger_level = _hunger_level - amount.min(_hunger_level)

The primitive is also identical to the class with 2 differences. It cannot have fields and in the process of the program only 1 instance is created for the primitive you define. It is used for many things, but more often, as a special kind of generic with the ability in the None type to check the values coming from the FFI world, if it does not equal the void.
```
primitive _Habras
```
Trait and interface (They are subtypes, but are defined in the same way as a class). Many PLs have only 1 of them at a time, but in Pony they are both involved. The difference is that the trait is a conditional membership check, and the interface checks structurally for consistency.
```
// Trait
trait Family
  fun age(): U64 => 5
class Habravi is Family
// Interface
interface Habrovik
  fun name(): String
class Habrovichek
  fun name(): String => "Model #1"
```

Aliases for types. I will not talk here about them a lot, a powerful system and requires independent study.

// Enumeration
primitive Red
primitive Blue
primitive Green
type Colour is (Red | Blue | Green)
// Complex
interface HasName
  fun name(): String
interface HasAge
  fun age(): U32
interface HasAddress
  fun address(): String
type Person is (HasName & HasAge & HasAddress)

A tuple is a sequence of types that can be defined in a single variable.
```
var x: (String, U64)
x = ("hi", 3)
```
The union is very similar to a tuple, only used to generalize the possible types. A special kind of generic.
```
var x: (String | U64)
x = "hello habr"
// or
x = 5
```
An intersection is almost the opposite of a union and can describe the same value for several types at the same time. The example below shows how a card can simultaneously contain a key of two different types.
```
type Map[K: (Hashable box & Comparable[K] box), V] is HashMap[K, V, HashEq[K]]
```

All of the above type expressions can be combined

// Tuple in Union which in Array
var _array: Array[((K, V) | _MapEmpty | _MapDeleted)]

Standard expressions:

These are very familiar to everyone - "Variables, operation signs, checks, loops, methods, actions, etc ..". I leave for independent study.

Opportunities:

Object - Low-level ownership is limited for you, FFI is an exception and may break your code, but it is controlled. No global variables and functions.
Reference - built on several basic concepts and 3 letter keywords are used to control ( Warranty ).
- iso - Full isolation, other variables will not be able to access this data. It can be changed as your soul pleases and transferred to other actors.
- val - Immutable data, respectively, the variable under this protection is readable and can be transferred to other actors.
- ref - Variable data, you can rotate in any direction and have several variables on this data, but transfer to other actors is not possible.
- box - This is a combination of val and ref, as the case may be. If the data is read-only, then the variable on them behaves like val and can be passed to other actors. However, if you try to write new data to it, you get ref and not the ability to use between several actors.
- trn - Data that can be written to constantly, but given to other variables, like box. Later you can change the limiter to val and pass it to other actors.
- tag - Identification of data, you cannot write to or read into it, but it is quite possible to store and compare to determine the type of data. Transfer to other actors is possible.
```
String iso // An isolated string
String trn // A transition string
String ref // A string reference
String val // A string value
String box // A string box
String tag // A string tag
```

Language appeal

Garbage collector

On board we have a very cool GC, which is fully competitive and does not have Stop the World. In fact, there are 2 of them, one is a link collector for each created actor and one global.

Actors Speed

Thanks to such a guy as Dima Vyukov, who made a huge contribution to lock-free algorithms and Go, a base appeared on which Pony emphasized when developing communication between actors. And that is why now the transfer rate between actors reaches 20kk per second, and the creation can reach 1kk per second.

Transparent competition

I gave this concept myself and was surprised when, in order to make the code competitive, we only need to change the name of the function. This method is even more modern than Go provided with its goroutines.

Pagers

Status and sitelinks

The language is in distant beta status, now the language version is 0.2.1. Developers are currently completing the remaining planned features, fixing bugs and stabilizing the language. There are plugins for almost all popular editors.

I am grateful that you read the article and may be interested in the language.

Tags: