|
所在平台: Udemy |
课程主页: https://www.udemy.com/course/pony-programming-language/
课程评论：没有评论
课程名称：Pony 编程语言 课程概述： 欢迎来到 Pony 编程语言课程，Pony 是一个开源的、面向对象的、基于演员模型的、安全能力的高性能编程语言。如果你想快速入门，可以通过 Pony Playground 在浏览器中试用。如果你对 Pony 的独特之处和为什么值得使用感兴趣，继续阅读。课程中还将讲述 Pony 的早期历史。 Pony 的不同之处： - 类型安全：Pony 具有真实的类型安全性，还有数学证明作为支持。 - 内存安全：没有悬空指针和缓冲区溢出，语言中甚至没有 null 的概念。 - 异常安全：没有运行时异常，所有异常都有明确的语义，且始终会被捕获。 - 数据竞争安全：Pony 不使用锁或原子操作，通过类型系统确保并发程序在编译时不会出现数据竞争。 - 死锁安全：因为 Pony 完全没有锁，所以不存在死锁问题。 - 原生代码：Pony 是一种提前编译(AOT)的语言，没有解释器或虚拟机。 - 与 C# 兼容：Pony 程序可以通过外部函数接口调用 C 库。 为什么选择 Pony？ Pony 使编写快速、安全、高效且高度并发的程序变得简单。Pony 的类型系统引入了“引用能力”的新概念，能够根据数据共享的方式标记不同的数据片段。这一机制结合 Pony 的演员模型为并发编程提供了强大支持。 Pony 的核心理念： - 共享可变数据难以处理，容易导致数据不一致或复杂的错误。 - 不可变数据可以安全共享，避免了并发问题。 - 孤立数据安全，多个线程之间安全传递。 - 每个演员是单线程的，通过确保单个演员中的数据更新不会引发问题。 - 引用能力强制执行安全数据处理，帮助开发者避免潜在错误。 总而言之，Pony 的设计理念致力于通过编译器的强制性检查来实现安全并发编程，这是非常重要且值得一试的理由。让我们一起学习这门新技能吧！
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.
