doublec

Self gets used by the enthusiasts in production, for a suitable definition of production. I believe the Self website is served by a webserver written in Self for example. I've also served my blog in the past from a Self webserver.

I found the comment in the post about how a few lines of code would be better than the object interactions in the GUI interesting. I thought this would be the case when I started using Self too but even with the GUI you still write code. The method bodies for example are all textual code that feels like programming in any other language.

Where the GUI excels is exploring systems, prototyping designs - and then refactoring the design towards a production implementation. It also makes the applications 'live' for users. They can drill down into the application objects and see how things work. The line between OS, application, and development is very blurry in Self.

I have some short screencasts showing using the Self user interface here if interested: http://bluishcoder.co.nz/tags/self/

Also a short animated gif of a Self VNC morph I worked on: http://bluishcoder.co.nz/self/self_vnc2.gif

I like the 'live soup of objects' feel of Self.

Correct, spawn is built in in Alice ML. Haskell wins on all the ways it can be used beyond built in functionality compared to it.

Alice ML:

    val (page1, page2, page3) = (spawn getURL "url1",
                                 spawn getURL "url2",
                                 spawn getURL "url3")

The requests are concurrent. Spawn returns a future and 'page1', etc are futures immediately. When the value of 'page1', etc is requested later the requesting process either blocks until the getURL for that value is complete, or transforms into the value implicitly if it's already done.

I think it's just as nice as the Haskell example. I do agree that Haskell is a great language though.

Also worth looking at "Parallel and Concurrent Programming in Haskell" http://chimera.labs.oreilly.com/books/1230000000929

I used Factor quite a bit in the early days. It's a great language and exploratory programming environment.

IIRC, one of the ideas of lojban was to develop a group of speakers of the languge during a frozen baseline period where the language couldn't change. Then changes could be made by the speakers of the language in lojban itself and see how it evolved.

Lojbanists have written poetry in lojban. Some writings on the matter:

http://arj.nvg.org/lojban/poetry.html http://mw.lojban.org/papri/lojban_literary_forms

I've been working on minor fixes and keeping bitrot away in the github repository mentioned on the main page in the News section: https://github.com/aliceml/aliceml

I wrote about the updates a while back here: http://bluishcoder.co.nz/2014/11/12/revisiting_alice_ml.html

It builds with 4.02.

Or Firefox Hello: https://www.mozilla.org/en-US/firefox/hello/

And Microsoft Hello: http://blogs.windows.com/bloggingwindows/2015/03/17/making-w...

Alice ML, an SML variant that Andreas Rossberg worked on mid-2000, also has first class modules.

I much prefer explicit over implicit so I'm not a big fan of RAII. I find it hides things that are happening in the code which makes it hard to find performance and other problems from inspection. ATS has tail call optimisation and destructors would make it hard to tell when TCO can't be done due to the hidden destructor calls.

Another nice thing ATS has is the ability to specify the API for a C function to a level of detail that enables removing a whole class of erroneous usage of the C API. I have an example of this where I start with a basic API definition and tighten it up by adding type definitions:

http://bluishcoder.co.nz/2012/08/30/safer-handling-of-c-memo...

I can help with a Rust vs ATS.

ATS is more like a safe version of C wrapped in ML syntax vs Rust as a safe version of C++.

ATS is lower level. You can do memory safe pointer arithmetic whereas in Rust you'd use unsafe blocks.

Some things are implicit in Rust but explicit (and more verbose) in ATS. For example, Rust has destructors for RAII whereas ATS requires manually calling functions to clean up resources. The type checker tells you when you need to do this (via linear types) but programmer still needs to do the call.

Borrowing is automatic in Rust. In ATS it requires keeping track of borrows in proof variables and manually giving them back. Again the type checker tells you when you get it wrong but it's more verbosity.

ATS has a restricted form of dependent types - Rust is not dependently typed.

With current implementations, ATS compiles to C which can be compiled independantly of an ATS install. You can ship the C code to someone to build without them needing ATS. Rust uses LLVM.

The two languages feel very differently when programming.

ATS is another language that uses linear types: http://www.ats-lang.org/

I think this from the Shen site describes it: http://www.shenlanguage.org/learn-shen/shendoc.htm#Kl

I haven't looked at the ability to have dependent types in Shen - it'd be great to see some examples. A quick search on the mailing list found:

https://groups.google.com/d/msg/qilang/lokvvf0xLJc/20y8ZkzoN... https://groups.google.com/d/msg/qilang/D3tmhQvfnOE/qcsXhRomF...

I believe it came from a discussion where to draft a new license would require the original developer to pay a lawyer. Someone suggested raising money to pay the developer the money to transition to BSD, a known license, instead of to a lawyer for yet another unknown license.

Release notes have been updated to say Windows only now.

ATS had macros: http://ats-lang.sourceforge.net/htdocs-old/TUTORIAL/contents...

I'm not sure if these made it into ATS2 though.

The original developers thoughts on GPL have been discussed at length on the Shen mailing list during the BSD licensing donation period. If you look through the archives you'll be able to read their thoughts.

This link may be a start: https://groups.google.com/d/msg/qilang/mVSJIyp-OhM/FjcAOAWUi...

It's unfortunate that the original authors views on licensing takes so much discussion away from Shen itself as it's an interesting language.

Do you have any addons related to video or blocking? You may need to unblock mediasource support in noscript.

Not so much buggy as less tested. I use it on my linux laptop and have relatively few issues.

It's only enabled on Windows in this release. If you're on Linux or Mac that will probably why you are seeing the setting is defaulting to false.

MSE is only enabled by default on Windows for this release. You can enable it manually for other platforms via the about:config setting.

MSE support is Windows only for this release. You can turn it on for other platforms manually via an about:config setting but it is less tested.

I'm not aware of one but there might be something in the Servo wiki.

Factor is still maintained and there is activity in the mailing list. I still use it. Recently I restored from backup an old project of mine that is written in factor, http://tinyvid.tv. It was fun hacking on it again - reminded me of what a great language it is.

Haha, yes I'm a big fan of ATS and I use it in projects. What motivates the dabbling in Rust is that it'll be possible at some point to use Rust in Gecko, and Servo is an interesting project to contribute to.

"Scientific and Engineering C++" by Barton and Nackman had a good example of doing units in C++ using templates. This blog post describes the basic approach http://learningcppisfun.blogspot.com/2007/01/units-and-dimen...