Pony Programming Language
Author: fullsoftcrack on 26-06-2023, 22:10, Views: 26
Free Download Pony Programming LanguagePublished 6/2023
MP4 | Video: h264, 1280x720 | Audio: AAC, 44.1 KHz
Language: English | Size: 2.18 GB | Duration: 2h 40m
The unicorn of programming languages
What you'll learn
Pony Programming Language
Programming
Windows Basics
Linux Basics
Requirements
Minimal programming knowledge
Windows machine
IDE for code development
Description
Welcome,Pony is an open-source, object-oriented, actor-model, capabilities-secure, high-performance programming language.If you are looking to jump in and get started with Pony right now, you can try it in your browser using the Pony Playground. Keep reading if you are interested in what makes Pony different and why you should consider using it.If you are interested in the early history of Pony and how it came into existence, you're in luck: "An Early History of Pony".What makes Pony different?Pony is type safe#Really type safe. There's a mathematical proof and everything.Pony is memory safe#There are no dangling pointers and no buffer overruns. The language doesn't even have the concept of null!Exception-Safe#There are no runtime exceptions. All exceptions have defined semantics, and they are always caught.Data-race Free#Pony doesn't have locks nor atomic operations or anything like that. Instead, the type system ensures at compile time that your concurrent program can never have data races. So you can write highly concurrent code and never get it wrong.Deadlock-Free#This one is easy because Pony has no locks at all! So they definitely don't deadlock, because they don't exist!Native Code#Pony is an ahead-of-time (AOT) compiled language. There is no interpreter nor virtual machine.Compatible with C#Pony programs can natively call C libraries using the foreign function interface.Why Pony?There's plenty to love about Pony, but more than anything else, what we love most is that Pony makes it easy to write fast, safe, efficient, highly concurrent programs. How? The Pony type system introduces a novel concept: "reference capabilities". Reference capabilities allow you to label different bits of data based on how that data can be shared. The Pony compiler will then verify that you are in fact correctly using the data based on the labels you provide. Reference capabilities combined with Pony's actor model of concurrency makes for a powerful pairing. Let's dig in and take a quick look:Mutable state is hard#The problem with concurrency is shared mutable data. If two different threads have access to the same piece of data then they might try to update it at the same time. At best this can lead to those two threads having different versions of the data. At worst the updates can interact badly resulting in the data being overwritten with garbage. The standard way to avoid these problems is to use locks to prevent data updates from happening at the same time. This causes big performance hits and is very difficult to get right, so it causes lots of bugs.Immutable data can be safely shared#Any data that is immutable (i.e. it cannot be changed) is safe to use concurrently. Since it is immutable it is never updated and it's the updates that cause concurrency problems.Isolated data is safe#If a block of data has only one reference to it then we call it isolated. Since there is only one reference to it, isolated data cannot be shared by multiple threads, so there are no concurrency problems. Isolated data can be passed between multiple threads. As long as only one of them has a reference to it at a time then the data is still safe from concurrency problems.Every actor is single threaded#The code within a single actor is never run concurrently. This means that, within a single actor, data updates cannot cause problems. It's only when we want to share data between actors that we have problems.Reference capabilities enforce safe data handling#By sharing only immutable data and exchanging only isolated data we can have safe concurrent programs without locks. The problem is that it's very difficult to do that correctly. If you accidentally hang on to a reference to some isolated data you've handed over or change something you've shared as immutable then everything goes wrong. What you need is for the compiler to force you to live up to your promises. Pony reference capabilities allow the compiler to do just that.If you ask us, that's pretty damn cool and a hell of a reason to give Pony a try.Let's learn something new.
Overview
Section 1: Introduction
Lecture 1 Introduction
Lecture 2 The Environment
Section 2: The Big Apple
Lecture 3 Setup on Ubuntu
Lecture 4 Hello World
Lecture 5 Primitives
Lecture 6 Actors
Lecture 7 Structs
Lecture 8 Type Aliases
Lecture 9 Type Expressions
Lecture 10 Traits
Lecture 11 Literals
Lecture 12 Variables
Lecture 13 Operators
Lecture 14 Arithmetics
Lecture 15 Control
Lecture 16 Methods
Lecture 17 Errors
Lecture 18 Equality
Lecture 19 Sugar
Lecture 20 Object literals
Lecture 21 Partial Application
Lecture 22 Generics
Lecture 23 Pattern matching
Lecture 24 Packages
Lecture 25 Testing
Section 3: The End
Lecture 26 The End
Beginner programmers
Homepage
https://www.udemy.com/course/pony-programming-language/
Buy Premium From My Links To Get Resumable Support,Max Speed & Support Me
Links are Interchangeable - Single Extraction
Comments
