stchacademy

Short answer: it does (yep, both on Windows AND Android).

Long answer: Arturo's aim is to be able to run, easily and effortlessly, on anything you can imagine.

Right now, it supports macOS, Linux, Windows, Raspberry (ARM-based Linux), FreeBSD + Web/JS.

Windows support may leave a tiny bit to be desired, but that's exactly what I'm here for: to make Arturo better. And better.

Looking forward to your feedback! :)

Thanks! It means a lot to me.

Please, let me know in case you have any issues or questions. I'm all ears! :)

I totally understand what you mean.

However - and not because I'm the author of the language - once you get the general idea of Arturo (or any of the languages of the Rebol family: be it Rebol, Red, or Arturo), I assure you that you will find it very tempting not to ever go back to the C-inspired languages.

If I could sum up the whole (not-so-)syntax of Arturo, I would say that every "command" takes takes the necessary parameters on its right. And that's pretty much it.

print 10 ; that's a valid function call for example

or

print add 1 2 ; that's also a valid function call (or 2, to be precise)

and...

a: 1 + 2 ; that's how you "assign" meaning to a symbol

other than these super-basics, having a look into the library is pretty much all you'll need in order to get started.

I guess this isn't that difficult. :)

P.S. Feel free to ask any question you want. Feedback and input of any kind is more than welcome too. Also, our Discord channel is fairly active, so... I would even invite you there, so that we could actually exchange ideas about it in a more... interactive way.

Thanks a lot for your kind words. I really appreciate it! :)

Regarding "?"-functions.

Yes, the idea was this: to separate "normal" functions (that is, functions returning something or altering a value in-place) from functions returning a boolean values - let's call them predicates. That's not a rule, it's merely by convention (at least in the built-in library).

Re: "if" vs "if?", as I said before... the second one is a predicate, meaning: it does return a boolean value (that of the passed condition parameter). And the main use is... chaining with an "else". ;-)

Thanks a lot for your nice comments.

I've done my best. As for the inspiration, as I've said before, although the two languages (or the 3 of them, if I include Red) did end up looking quite similar, when I started out I had no knowledge of Rebol (other than the name). So, basically, I designed something from scratch, with its own characteristics. Now, given that, afterwards I sure have studied Rebol/Red a lot, and I must admit that both have served as an interesting source of ideas as well.

Looking forward to your feedback once you play a bit with it! :)

If you have any comments/ideas/questions/suggestions, please feel free to shoot me! :)

You are also welcome in our "official" Discord channel: https://discord.gg/YdVK2CB

Good question.

As a matter of fact, the question has been asked again (see here @ our "official" discord channel: https://discord.com/channels/765519132186640445/765519132186...)

As I mention in that specific request, socket programming support is planned but not yet in. But I'll work in it.

And yes, given that you're talking about async operations, probably this is the most challenging part to be dealt with.

Stay tuned!

No offence taken. I guess this (quite common) question could go for a wide variety of things... but then, many things would have been left without been invented or even tried. Now, to try to properly answer your question: I guess the simple answer was that I couldn't find what was I was looking for - in a language, in this case. So, I decided to create it myself. :)

Thanks a lot for your kind words! I've worked very hard on it - both the language and the website - so, I definitely appreciate it. Feel free to join the community and let me know in case you have any questions whatsoever! :)

FYI, I've just published the first complete reference (language reference + full library reference, with tons of examples): https://github.com/arturo-lang/arturo/wiki

Let me know what you think! :)

FYI, I've just published the first complete reference (language reference + full library reference, with tons of examples): https://github.com/arturo-lang/arturo/wiki

Let me know what you think! :)

FYI, I've just published the first complete reference (language reference + full library reference, with tons of examples): https://github.com/arturo-lang/arturo/wiki

Let me know what you think! :)

FYI, I've just published the first complete reference (language reference + full library reference, with tons of examples): https://github.com/arturo-lang/arturo/wiki

Let me know what you think! :)

FYI, I've just published the first complete reference (language reference + full library reference, with tons of examples): https://github.com/arturo-lang/arturo/wiki

Let me know what you think! :)

FYI, I've just published the first complete reference (language reference + full library reference, with tons of examples): https://github.com/arturo-lang/arturo/wiki

Let me know what you think! :)

FYI, I've just published the first complete reference (language reference + full library reference, with tons of examples): https://github.com/arturo-lang/arturo/wiki

Let me know what you think! :)

FYI, I've just published the first complete reference (language reference + full library reference, with tons of examples): https://github.com/arturo-lang/arturo/wiki

Let me know what you think! :)

:)

Regarding if returning a value - and thus, being able to use it as part of an expression - is an absolutely interesting idea I've been thinking of implementing. However, I still don't know how.

One idea would be to add an .attribute, e.g. if.get - and then have it return a value.

Or, use a different function altogether.

But then we'd have, 3-4 if's. That sounds like a bit of an overkill, I admit.

I'm absolutely open to ideas :)

Basically, the idea behind "?" is "functions that return a boolean". But done in a consistent way. So, practically EVERY function that returns a boolean is - by convention - terminated with a "?".

Now, why the two "if"s:

Obviously, as you yourself mentioned, 'if? returns a boolean (the result of the condition) and 'if doesn't.

So that's one use.

The next use - which I will obviously have to make crystal clear in the Language Reference - is that if? (with the ?) is a must if you want to pair with an "else".

Think of it this way. If?-else may appear as a language construct, but in fact they are two separate commands. The if? is an if - that pushes the result of the condition of the stack. And "else" is actually a reversed-if: it checks what is at the top of the stack (see: returned by the if? above) and if that is false - that is: the above if-condition was not true - it executes its block.

So, in that case, you have to use an "if?" (and not a simple "if")

The same thing happens with a case/when? construct (only, in that case, the condition blocks are actually concatenated),e .g.

case [x] when? [<3] [print "it was less than 3"] when? [=3] [print "it was equal to 3"] else [ print "it was greater than 3"]

:)

:)

Hmm. Nice. Thanks a lot for letting me know - I had no idea. Inspiration is always useful :)

Hmm... I had no idea. Thanks a lot for the suggestion :)

P.S. A little bit of trivia: my choice of the scorpion logo was no random selection at all. Arturo was my little (well, not so little) Black Emperor scorpion that passed away in February. Hence, the name. And the logo...

Well, the details remain to be finalized but the general idea is a generator DSL. Think of HAML in regards to HTML for example: you can write nice DSL-specific code that gets translated into valid HTML code. (There is already a relevant module for that for Arturo, thought at a very experimental level: https://github.com/arturo-lang/art-html-module).

I'm thinking of the same thing for LaTeX (and perhaps even more sophisticated). One of my main "businesses" is centered around typesetting and electronic publishing, hence I'm a heavy ... LaTeX user.

Feel free to ask anything else. All suggestions and contributions are welcome! :)

Well, it's obviously not your fault - I should have explained it better in the Language Reference (but it's a work-in-progress and I definitely will explain it thoroughly).

So...

The command "if?" takes two arguments: a boolean and a block.

Think of it like if? <something> [do something-else].

In this example, something is `even? x` and something-else is `print [x "is even"]`.

And yes, regarding the right-arrow symbol you are absolutely correct: it's syntactic sugar for wrapping a command in a block (provided that it's just ONE command - if there are more than one, you will have to use a block).

But it's still syntactic sugar as ALL symbols being used in Arturo. Pretty much like ".." is the symbol infix-alias of the command "range".

I want that too - I mean to elaborate more on these aspects with real-use examples, but I guess I'm putting it off until I deal with other small issues.

Regarding "homoiconicity", the way I would succintly put it is that: the line between what is considered code and what is data is super-fine. Basically, anything can be anything - depending on the context. Thus, an Arturo script can manipulate its own code, the way it can manipulate any other type of data.

Regarding Arturo's implementation: It's written in Nim (though I have written it in the past in almost every language you can think of... lol started with C++, went to D, then to Nim, back to C, and now in Nim again). Basically it's a Stack-based Bytecode Virtual Machine. And yes, Forth's influence is also important - although (intentionally) not that obvious at first sight.

The source text is parsed to an abstract structure/tree of words and symbols. That's the part that happens in translator/parse.

Then if it's an executable block, it is evaluated (as valid Arturo code) into Bytecode (this happens in translator/eval), and then this bytecode is executed by the virtual machine (in vm/exec).

(I'm replying here, since I don't seem to be able to reply directly)

@9214 Since you are knowledgeable about the topic (included but not limited to Rebol/Red), I would be glad if you joined the effort. Even testing bits here and there would be great. You're welcome :)

This is one of the main things I'm working on. For now, what does work is a webview-type of GUI application - another thing I'm very focused on.

Let me put it like this:

- Just open the REPL (Arturo's terminal) - Write: webview "Hello World!"

Although super-minimal, you already have a Webview-based GUI app with something in it. It's a starting point :)

Btw, have you managed to compile it on NetBSD? (It should run fine, I think, though I haven't tried it yet...)

Well, the main difference is that - although we do use strings (for files, urls, etc) - the appropriate datatypes are constructed implicitly, that is: no need for newFile("someFile") or %someFile. "someFile", if it is a file path, will be automatically handled as such. If it is a url, accordingly.

The point is to keep the syntax clean. (Ok, that would be an argument of going all the way, like Tcl, where everything ends up being a string - but let's just get the best of every world without overdoing it :) )

Yes, you are right.

And this is the way it works throughout, with different functions - 'do' aside, that is.

For example, there is the very powerful 'read' function.

This may take a simple string (text), a file location or a URL. You obviously know what it is and the interpreter will figure it out itself as well.

Now, let's say you want to read a file:

read "myfile.txt"

"Reading" a webpage:

read "http://somewebsite.com/somewebpage"

Parsing JSON from a remote source:

read.json "http://somewebsite.com/data.json"

Or parsing it from a string:

read.json "[1,2,3]"

And 'read' also can take different attributes, e.g. .csv (for parsing CSV files), .html etc etc...

Basically you pass a string with its options and the interpreter figures out where to get it from and what to do with it... :)

Thanks a lot for your nice words! :)

Regarding 'parse', it's absolutely in my to-do list. Although, already, the language by its very nature has the means to do it (even you, as a user, could) - but I have to prioritize things.

Regarding reference, it's obviously a work-in-progress. However, what you mean is probably already available @ GitHub Wiki: https://github.com/arturo-lang/arturo/wiki

Have a look :)

Looking forward to hearing your feedback. Anything is welcome, ideas or suggestions :)