1,389 karma · joined September 11, 2008
That's what I used for my post. There's "Shen Professional" which is a closed source subscription based product getting rapid development http://shenlanguage.org/professional.html
I have not used "Shen Professional" though.
You end up with a definition that checks at compile time that:
* We don't exceed the memory bounds of the source buffer
* We don't exceed the memory bounds of the destination buffer
* The destination buffer is at least the minimium size required by the function documentation
* We can't treat the destination buffer as a string if the function fails
* We can't treat the destination buffer as an array of bytes if the function succeeds
* Off by one errors due to null terminator handling are removed
* Checking to see if the function call failed is enforced
And there's no overhead at runtime.
One nice thing about the Pony GC is it can GC actors that are waiting for messages but will never receive one. In some other languages I've used I end up with processes idling in a receive on channel living forever but never able to exit because nothing is going to put a message in the channel.
The two major things that I stumbled on when I first started using Pony was that there is no blocking constructs in the language and dealing with capabilities.
I've had exposure to memory safe languages using types before (ATS, Rust) so the Pony system of capabilities wasn't too difficult to understand once I was able to map them to things I was familiar with. Before that I struggled to understand why things weren't compiling. Now that things have somewhat clicked I'm pretty productive with the language.
Dealing with writing non-blocking code was a matter of thinking in terms of callbacks and promises - something familiar to a lot of Node programmers I suspect.
Once I got past those two things I find the language very nice to write in and easy to reason about the code. Sometimes I hit walls of struggling to work out why things aren't compiling and they eventually end up being the compiler showing me what I was trying to do would be unsafe due to data races, etc.
The language is still young though so definitely something to approach with a bit of understanding that things may break.
My list of catches would be:
* Reference capabilities take a while to grasp. No more than Rust's borrowing or ATS viewtypes though.
* Garbage collection occurs between behaviour calls only. If you do something in a loop that allocates a lot in a single behaviour then you'll get memory issues.
* There's no blocking calls. You need to structure your code so that actors receive notifications of things occurring instead.
* Behaviours don't return anything as they are asynchronous. This requires using promises or passing callbacks.
That said, once you grasp these it's nice to program in. Fast, readable, and makes concurrent/parallel code easy to write and safe to pass data around. The C FFI is easy to use. You can package Pony code as a library callable from C too.
Does this mean they installed malware on the devices before the messages were exchanged?
Here's an example of using it for the backing store for my blog: https://bluishcoder.co.nz/2015/09/14/using-freenet-for-stati...
Here's a series of articles on writing dynamic apps for Freenet - in this case chat-like things http://www.draketo.de/light/english/freenet/communication-pr...
There were client side JavaScript continuation like things. Back in the mid-2000's there was Narrative JavaScript. I used it to implement threads and Alice ML style futures/promises on the client side: https://bluishcoder.co.nz/2006/06/05/more-concurrency-in-nar...
"Inverting back the inversion of control" describes the idea (in Scheme) https://pages.lip6.fr/Christian.Queinnec/PDF/www.pdf
Paul Graham used the idea in ViaWeb - and apparently got a patent on some aspect of it https://web.archive.org/web/20060323211251/http://paulgraham...
http://www.slideshare.net/master_q/safer-iot-using-functiona...
ATS is a functional programming language that does not use a garbage collector and uses dependent and linear types to do safe system programming. It provides a similar level of safety to Rust with the ability to drop down to C: http://www.ats-lang.org/
I've used Alice ML on a couple of projects for a while and didn't want to see it die so I got permission from the original authors to host a mirror on github and keep the bitrot away. I forked from work that Gareth Smith did on bitbucket a few years back (with his permission) that fixed some issues and added features. I'm the only one working on it at the moment but hopefully others join in. It's survived this long!
It's great to see you keeping /r/sml active!
[1] https://cdn.rawgit.com/darach/my_little_pony/master/my-littl...
It's a fairly steep learning curve for people new to types. Given exposure to SML it's not too hard to just use that side of things plus linear types. Dependent types and proofs add complexity but hopefully you can avoid it while learning.
This removes much of the burden of wondering if you got the resource management right. Especially when maintaining existing applications. If you refactor things the compiler tells you when you got it wrong.
There is overhead since you are managing resource manually - both syntax-wise and mental though.
For concurrency they enable 'solving' shared state by making it difficult to share state. You really have to pass ownership of the resource to the other thread so it can no longer be accessed anywhere else.
They're for the previous version of ATS but are still pretty relevant.
I started off mirroring my blog on Freenet and and now I'm experimenting with storing it there first and using a reverse proxy to make it available on clearnet [1]. This approach would work on IPFS and Morphis too. If the clearnet site gets taken down it's always available on the distributed store and it's simple to spin up a proxy somewhere else to provide clearnet access.
For systems where unpopular data goes away over time the access via the clearnet proxy provides more access to it to make that less likely since clearnet is full of crawlers, bots, search engines etc constantly hitting it.
[1] http://bluishcoder.co.nz/2015/09/14/using-freenet-for-static...