ponyc
Halide

ponyc | Halide | |
---|---|---|
66 | 46 | |
5,782 | 5,967 | |
0.6% | 0.5% | |
9.1 | 9.4 | |
5 days ago | 6 days ago | |
C | C++ | |
BSD 2-clause "Simplified" License | GNU General Public License v3.0 or later |
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
ponyc
-
Can We Get the Benefits of Transitive Dependencies Without Undermining Security?
> Capabilities taken literally are more of a network thing (it's how you prove you have access to a computer that doesn't trust you). On a language, you don't need the capabilities themselves.
You may be thinking of the term in a different context. In this context, they are a general security concept and definitely apply to more than the network, including languages:
https://en.wikipedia.org/wiki/Capability-based_security
http://habitatchronicles.com/2017/05/what-are-capabilities/
https://www.ponylang.io/
etc...
-
Thinking in Actors – Part 3 – Using the Actor Model to Track Aircraft
Actors immediately made me think of Pony. https://www.ponylang.io
- Pony (Programming Language)
- Firewalling Your Code
-
Multitasking, parallel processing, and concurrency in Swift
Or give up and erase all the type information by saying `throws Exception` or `throws Throwable`.
Genericizing throws in particular was tried in Midori [2] and worked out really well (by report). In addition, several less-than-completely-obscure languages are starting to experiment with the algebra of effects in general (as opposed to error handling in particular). Pony (https://www.ponylang.io/), OCaml (https://ocaml.org/manual/5.2/effects.html) and others are experimenting with bringing what Koka (among others; https://koka-lang.github.io/koka/doc/index.html) to the masses.
[1]: https://www.artima.com/articles/the-trouble-with-checked-exc...
- Old Version
-
The problem with general purpose programming languages
For example, the actor's model is not used by a lot of languages, Pony (https://www.ponylang.io/) and Elixir are the only ones that I know, but they address the concurrency problem quite well, while it's a pain to deal with in other languages at large scale.
-
Found a language in development called Vale which claims to be the safest AOT compiled language in the World (Claims to beSafer than Rust)
And that last point is critical. If the language flatly can't represent some concepts it uses, they have to be implemented somewhere else. I had a similar discussion with a proponent for Pony once- the language itself is 100% safe, and fully dependent on C for its runtime and data structures. One of Rust's core strengths is being able to express unsafe concepts, meaning the unsafe code can expose a safe interface that accurately describes its requirements rather than an opaque C ABI. Vale doesn't seem to do that.
-
The Rust I wanted had no future
"Exterior iteration. Iteration used to be by stack / non-escaping coroutines, which we also called "interior" iteration, as opposed to "exterior" iteration by pointer-like things that live in variables you advance. Such coroutines are now finally supported by LLVM (they weren't at the time) and are actually a fairly old and reliable mechanism for a linking-friendly, not-having-to-inline-tons-of-library-code abstraction for iteration. They're in, like, BLISS and Modula-2 and such. Really normal thing to have, early Rust had them, and they got ripped out for a bunch of reasons that, again, mostly just form "an argument I lost" rather than anything I disagree with today. I wish Rust still had them. Maybe someday it will!"
I remember that one. The change was shortly after I started fooling with Rust and was major. Major as in it broke all the code that I'd written to that point.
"Async/await. I wanted a standard green-thread runtime with growable stacks -- essentially just "coroutines that escape, when you need them too"."
I remember that one, too; it was one of the things that drew me to the language---I was imagining something more like Pony (https://www.ponylang.io/).
"The Rust I Wanted probably had no future, or at least not one anywhere near as good as The Rust We Got."
Almost certainly true. But The Rust We Got is A Better C++, which was never appealing to me because I never liked C++ anyway.
-
How long until Rust becomes mandatory, and use of any other language opens the developer up to Reckless Endangerment charges
Pony or bust.
Halide
-
Compiling Array Languages for SIMD [pdf]
> Hence it becomes a game of scheduling. You already know what you need to optimise but actually doing so gets really hard really fast.
This immediately makes me think of Halide, which was specifically invented to make this easier to do by decoupling the algorithm from the scheduler.
Kind of sad that it doesn't see to have caught on much.
[0] https://halide-lang.org/
- Halide – a language for fast, portable computation on images and tensors
- Halide: A language for fast, portable computation on images and tensors
-
Show HN: Flash Attention in ~100 lines of CUDA
If CPU/GPU execution speed is the goal while simultaneously code golfing the source size, https://halide-lang.org/ might have come in handy.
- Halide v17.0.0
-
From slow to SIMD: A Go optimization story
This is a task where Halide https://halide-lang.org/ could really shine! It disconnects logic from scheduling (unrolling, vectorizing, tiling, caching intermediates etc), so every step the author describes in the article is a tunable in halide. halide doesn't appear to have bindings for golang so calling C++ from go might be the only viable option.
-
Implementing Mario's Stack Blur 15 times in C++ (with tests and benchmarks)
Probably would have been much easier to do 15 times in https://halide-lang.org/
The idea behind Halide is that scheduling memory access patterns is critical to performance. But, access patterns being interwoven into arithmetic algorithms makes them difficult to modify separately.
So, in Halide you specify the arithmetic and the schedule separately so you can rapidly iterate on either.
- Making Hard Things Easy
-
Deepmind Alphadev: Faster sorting algorithms discovered using deep RL
It is not the sorting per-se which was improved here, but sorting (particularly short sequences) on modern CPUs with really the complexity being on the difficulty of predicting what will work quickly on these modern CPUs.
Doing an empirical algorithm search to find which algorithms fit well on modern CPUs/memory systems is pretty common, see e.g. FFTW, ATLAS, https://halide-lang.org/
-
Two-tier programming language
Halide https://halide-lang.org/
What are some alternatives?
gleam - ⭐️ A friendly language for building type-safe, scalable systems!
taichi - Productive, portable, and performant GPU programming in Python.
tab-rs - The intuitive, config-driven terminal multiplexer designed for software & systems engineers
futhark - :boom::computer::boom: A data-parallel functional programming language
Phoenix - wxPython's Project Phoenix. A new implementation of wxPython, better, stronger, faster than he was before.
triton - Development repository for the Triton language and compiler
Celluloid - Actor-based concurrent object framework for Ruby
Image-Convolutaion-OpenCL
gentoo-overlay - Gentoo overlay
png-decoder - A pure-Rust, no_std compatible PNG decoder
prolog-to-minizinc - A Prolog-to-MiniZinc translator
maxas - Assembler for NVIDIA Maxwell architecture
