Draft:Pony (programming language): Difference between revisions

Pony
Paradigm	Actor model
Designed by	Sylvan Clebsch
First appeared	November 9, 2012; 12 years ago
Stable release	0.15.0 / August 7, 2017; 7 years ago
Typing discipline	strong, static, inferred, structural
Implementation language	C
License	BSD-2
Website	www.ponylang.org
Influenced by
	E, Rust
Influenced
	Encore

Browse history interactively

← Previous edit Next edit →

Content deleted Content added

VisualWikitext

Inline

Revision as of 15:35, 15 July 2017

Submission declined on 20 January 2017 by SwisterTwister (talk).

This submission's references do not show that the subject qualifies for a Wikipedia article—that is, they do not show significant coverage (not just passing mentions) about the subject in published, reliable, secondary sources that are independent of the subject (see the guidelines on the notability of web content). Before any resubmission, additional references meeting these criteria should be added (see technical help and learn about mistakes to avoid when addressing this issue). If no additional references exist, the subject is not suitable for Wikipedia.

If you would like to continue working on the submission, click on the "Edit" tab at the top of the window.
If you have not resolved the issues listed above, your draft will be declined again and potentially deleted.
If you need extra help, please ask us a question at the AfC Help Desk or get live help from experienced editors.
Please do not remove reviewer comments or this notice until the submission is accepted.

Where to get help

If you need help editing or submitting your draft, please ask us a question at the AfC Help Desk or get live help from experienced editors. These venues are only for help with editing and the submission process, not to get reviews.
If you need feedback on your draft, or if the review is taking a lot of time, you can try asking for help on the talk page of a relevant WikiProject. Some WikiProjects are more active than others so a speedy reply is not guaranteed.

How to improve a draft

Wikipedia:Contributing to Wikipedia – a basic overview on how to edit Wikipedia.
Help:Wikitext – how to use the markup
Help:Referencing for beginners – how to include references
Wikipedia:Article development – how to develop your article
Wikipedia:Writing better articles – how to improve your article
Wikipedia:Verifiability – make sure your article includes reliable third-party sources

You can also browse Wikipedia:Featured articles and Wikipedia:Good articles to find examples of Wikipedia's best writing on topics similar to your proposed article.

Improving your odds of a speedy review

To improve your odds of a faster review, tag your draft with relevant WikiProject tags using the button below. This will let reviewers know a new draft has been submitted in their area of interest. For instance, if you wrote about a female astronomer, you would want to add the Biography, Astronomy, and Women scientists tags.

Add tags to your draft

Editor resources

Easy tools: Citation bot (help) | Advanced: Fix bare URLs

This draft has not been edited in over six months and qualifies to be deleted per CSD G13.

Declined by SwisterTwister 7 years ago. Last edited by Autodidaddict 7 years ago. Reviewer: Inform author.

Resubmit

Please note that if the issues are not fixed, the draft will be declined again.

Comment: This would've needed all major reviews. SwisterTwister talk 19:29, 20 January 2017 (UTC)

Pony (often referred to as ponylang) is a free and open source, object-oriented, actor model, capabilities-secure, high performance programming language. Pony blends together the race-free guarantees of the Rust programming language, static typing, generics, traits, and the structural typing so well used by the Go programming language. Its reference capabilities^[2] system allows developers to be explicit about how data is shared among components and actors, visually indicating what can and cannot be read from or written to.

This allows Pony to reside somewhere between the strict rules of Rust's borrow checker and Go's flexible structural typing while still being able to make race-free and data sharing guarantees.

History

In 2011, Sylvan Clebsch created a C-based actor library in order to solve some real problems for software he was creating. Ultimately this library became the first implementation of Pony in 2012.

Language design

At its core, Pony is a systems language designed around safety and performance.

Type Safe - Pony is a very type safe language. For more details on why, check out the mathematical proof^[3].
Memory Safe - There are no dangling pointers and no buffer overruns. Like Rust, Pony does not even allow 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 does not have locks or atomic operations. Instead, the type system ensures at compile time that your concurrent program can never have data races. This allows developers to write highly concurrent code with less change of problems occurring in the use of concurrency primitives.
Deadlock-Free - Pony lacks language-level constructs to create locks. It is impossible to write code that compiles that will produce a deadlock.
Native Code - Pony is an ahead-of-time (AOT) compiled language. There is no interpreter or virtual machine
Compatible with C - Interop with C is enabled through FFI
Garbage Collected - Each actor's heap is collected separately, there is no "stop the world" collection.

References

^ https://github.com/ponylang/ponyc/blob/master/LICENSE
^ "Deny capabilities for safe, fast actors". 2015-10-26. {{cite web}}: Unknown parameter |authors= ignored (help)
^ https://www.ponylang.org/media/papers/fast-cheap.pdf

External links

Pony (programming language)

[1] ttps://github.com/ponylang/ponyc/blob/master/LICENSE

[2] "Deny capabilities for safe, fast actors". 2015-10-26. {{cite web}}: Unknown parameter |authors= ignored (help)

[3] ttps://www.ponylang.org/media/papers/fast-cheap.pdf

[1]

[2]

[3]

@@ Line 9: / Line 9: @@
 | paradigm               = [[Actor model]]
 | designer               = Sylvan Clebsch
-| influenced by = [[E (programming language)|E]]
+| influenced by = [[E (programming language)|E]], [[Rust (programming language)|Rust]]
 | influenced = {{URL|https://www.gitbook.com/book/stw/the-encore-programming-language/details|Encore}}
+| latest_release_version = 0.15.0
+| latest_release_date    = {{start date and age|2017|08|07}}
+| typing                 = [[strong typing|strong]], [[static typing|static]], [[type inference|inferred]], [[structural typing|structural]]
 | website                = {{URL|http://www.ponylang.org}}
 | year                   = {{release date and age|2012|11|09}}
+| license                = [[BSD licenses|BSD]]-2<ref>https://github.com/ponylang/ponyc/blob/master/LICENSE</ref>
 | programming_language = [[C (programming language)|C]]
 }}
-Pony<ref>{{cite web|url=https://www.infoq.com/presentations/pony|title=InfoQ: Using Pony for Fintech}}</ref> is an [[Actor model|actor]] based language designed by Sylvan Clebsch, with the initial implementation starting in 2012<ref name="pony-initial-commit>{{cite web|url=https://github.com/ponylang/ponyc/commit/0192983a0f73d2d490cc901b952534b2d27915dd|title=initial git commit for ponyc}}</ref>. One of the languages unique features is to make it a [[Race condition|race-free]] programming language via the use of reference capabilities<ref>{{cite web | url=http://dl.acm.org/citation.cfm?id=2824816 |title=Deny capabilities for safe, fast actors |authors=Sylvan Clebsch, Sophia Drossopoulou, Sebastian Blessing, Andy McNeil |date=2015-10-26}}</ref> by the compiler<ref>{{cite web|url=https://github.com/ponylang/ponyc|title=github ponyc repository}}</ref> in order to enforce correct access to program state within the context of the natural high [[Concurrency_(computer_science)|concurrency]] supported by the [[Actor model|actor model]].
+'''Pony''' (often referred to as '''ponylang''') is a [[Free software|free]] and [[open-source|open source]], object-oriented, [[actor_model|actor model]], [[Capability-based_security|capabilities-secure]], high performance programming language. Pony blends together the [[Race condition|race-free]] guarantees of the [[Rust (programming language)|Rust]] programming language, static typing, generics, traits, and the structural typing so well used by the [[Go (programming language)|Go]] programming language. Its reference capabilities<ref>{{cite web | url=http://dl.acm.org/citation.cfm?id=2824816 |title=Deny capabilities for safe, fast actors |authors=Sylvan Clebsch, Sophia Drossopoulou, Sebastian Blessing, Andy McNeil |date=2015-10-26}}</ref> system allows developers to be explicit about how data is shared among components and actors, visually indicating what can and cannot be read from or written to.
+This allows Pony to reside somewhere between the strict rules of [[Rust (programming language)|Rust]]'s borrow checker and [[Go (programming language)|Go]]'s flexible structural typing while still being able to make race-free and data sharing guarantees.
+==History==
+In 2011, Sylvan Clebsch created a C-based actor library in order to solve some real problems for software he was creating. Ultimately this library became the first implementation of Pony in 2012.
+==Language design==
+At its core, Pony is a systems language designed around safety and performance.
+* Type Safe - Pony is a ''very'' type safe language. For more details on why, check out the mathematical proof<ref>https://www.ponylang.org/media/papers/fast-cheap.pdf</ref>.
+* Memory Safe - There are no dangling pointers and no buffer overruns. Like Rust, Pony does not even allow 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 does not have locks or atomic operations. Instead, the type system ensures at compile time that your concurrent program can never have data races. This allows developers to write highly concurrent code with less change of problems occurring in the use of concurrency primitives.
+* Deadlock-Free - Pony lacks language-level constructs to create locks. It is impossible to write code that compiles that will produce a deadlock.
+* Native Code - Pony is an ahead-of-time (AOT) compiled language. There is no interpreter or virtual machine
+* Compatible with C - Interop with C is enabled through [[Foreign function interface|FFI]]
+* Garbage Collected - Each actor's heap is collected separately, there is ''no'' "stop the world" collection.
 ==References==
@@ Line 24: / Line 45: @@
 * [http://www.ponylang.org Offical website]
+* [https://medium.com/@KevinHoffman/composition-over-inheritance-in-pony-33bbe107914 Composition over Inheritance with Pony]
 * [https://www.infoq.com/interviews/clebsch-pony InfoQ Interview: Sylvan Clebsch on the Actor-Model Language Pony, Garbage Collection, Capabilities, Concurrency]
 * [https://www.infoq.com/news/2016/03/pony-fintech InfoQ: Using the Actor-model Language Pony for FinTech]