@HMK

Quote:

It's probably better to say that it is very good for solving generic problems in a few minutes, although I use it mostly for creating and maintaining full-sized applications. If your boss wants to do something with a simple user interface, REBOL is excellent for that.

So when Carl says on the website that he wants REBOL to have a rather clearly defined audience and be the tool of choice for a rather clearly defined set of problems, that's actually wishful thinking? I'm not saying this generality is bad, but as an upstart language you should probably pick your opponents wisely.

Actually it was precisely about bigger apps that I was in doubt. I mean I am used to overseeing large amounts of C++ for bigger projects, so I know it is possible to keep everything nicely structured and under control. But bigger amounts of REBOL code, doesn't it get out of hand, isn't this language designed for small-scale tasks? Well it seems that it isn't, but maybe you could shortly write how you feel about this point.

Quote:

- Power Point like presentation tool (didn't have MS Office or Open Office at hand and needed to present something).

And this goes quickly with this REBOL/View thing? Interesting.

Quote:

- Relations Engine

Very nice. I had a look at the website. From my limited understanding so far, it is precisely this flexible way of handling data which makes REBOL stand out. Although I don't know how it would compare to those other "very high-level languages" that CodeSmith mentioned above..

As a beginner, I have really enjoyed REBOL so far. I was recently learning Common Lisp and then a news post about REBOL on AmigaWorld.net made me investigate it again. Wow, I'm glad I did. The learning curve so far has been much faster and building a GUI seems so quick. I have now turned my attention towards REBOL instead of Common Lisp and I was enjoying Common Lisp.
I'm hoping I can start using it at my day job instead of Visual Basic.

While reading all kinds of information about Common Lisp, they mention the power of Macros. From what I understand, REBOL seems to have the same power and they call it Dialects. If I am incorrect, please correct me.

Anyway, I just wanted to mention what guided me to REBOL.

_________________
The AROS Show

Quote:

Actually it was precisely about bigger apps that I was in doubt. I mean I am used to overseeing large amounts of C++ for bigger projects, so I know it is possible to keep everything nicely structured and under control. But bigger amounts of REBOL code, doesn't it get out of hand, isn't this language designed for small-scale tasks? Well it seems that it isn't, but maybe you could shortly write how you feel about this point.

There is no IDE at this point (I've been thinking about building one, but with a networking twist), so if you want to manage large amount of source code, you have to do that yourself.

The SDK offers a preprocessor where you create make files in REBOL, run them through the preprocessor to collect all code into one script, and write out one big script that you can encapsulate into an executable or run it directly from REBOL/View. You can of course also evaluate code during preprocess time, to, say, build different versions of your script for different uses. I use that to create demo and full versions of the same applications.

Code headers allow you to use a bit of intelligence in how sources can be structured together, for example library dependencies and keywords. REBOL source code files must start with a header object. The code header is an object, which you can load separately and do operations on. It can contain any kind of REBOL loadable information.

As you can see this can be the start of providing your own scheme for managing the source code, freely and flexibly and you don't have to leave the REBOL language to do that.

With regards to REBOL 2 itself, there are issues with, say, providing libraries with a lot of functionality by one developer and another big library provided by another developer. You have to be careful that the two libraries don't clash and overwrite values and contexts provided by eachother. This is going to be solved in REBOL 3 with modules.

QTask has about 2 MB of source code in it so far. This is far bigger than any of my projects. I think I have about 4-500 KB source code total in my biggest project. REBOL source code generally does not take up much space, even when it's made very readable, pretty and commented.

So in short, I haven't reached the ceiling yet in terms of project size, and I think I could go way bigger than I do now.

Quote:

- Power Point like presentation tool (didn't have MS Office or Open Office at hand and needed to present something). And this goes quickly with this REBOL/View thing? Interesting.

You can build interesting and useful stuff in the time it takes to make a forum post. What I did was that I had some things I needed to present and they were generally all box diagrams and a few headlines. REBOL/View lets you show such graphics quickly with the builtin VID, Visual Interface Dialect, the thing used to build GUIs. So the diagrams are built as program code.

Each "slide" is a graphics layout, produced with the LAYOUT function.

The following will make 4 200 by 200 pixel boxes, with the numbers 1, 2, 3 and 4, in different colors. (You can copy/paste all of it in a REBOL/View console).

Quote:

slide1: layout [ across h1 "Groups of things in fancy boxes" return box 200x200 red "1" box 200x200 orange "2" return box 200x200 blue "3" box 200x200 yellow "4" ]

LAYOUT parses a block that is written in the VID dialect and produces a block of objects that contain information on how to draw it with the VIEW function. VIEW can be considered a rasterizer. It shows what's been generated with LAYOUT.

To show the slide temporarily, to see if it looks correct:

Quote:

view slide1

To use a series of slides, each slide is stored in a block:

Quote:

slides: []

Let's create another slide:

Quote:

slide2: layout [ box 700x600 "Amigaworld is great!" effect [gradient 0x1 60.60.60 150.150.150] font-size 60 ]

And then I can produce more slides with the LAYOUT function and each slide is then added to the slides block:

Quote:

append slides slide1 append slides slide2 ...

When I have all the slides I need, I can work on the presentation code itself. I need a fullscreen background and then some navigation buttons. This interface is provided with yet another layout:

Quote:

main: layout/tight/size compose [ origin 0 space 0 slide-panel: panel (system/view/screen-face/size - 0x30) [] panel [ across space 2 button "" [unless tail? next slides [slides: next slides show-slide]] button 150 "Back to console" [unview halt] ] ] system/view/screen-face/size

Then I need a SHOW-SLIDE function, which sets the pane of SLIDE-PANEL to the first layout stored in the SLIDES block:

Quote:

show-slide: does [ slide-panel/pane: first slides slide-panel/offset: 0x0 center-face first slides slide-panel show slide-panel ]

And then:

Quote:

start-presentation: does [ view/new main slides: head slides show-slide do-events ]

Start the whole thing with:

Quote:

start-presentation

There you go. One presentation program. (Works best in Windows)

Last edited by HMK on 06-May-2007 at 07:06 PM.

Quote:

While reading all kinds of information about Common Lisp, they mention the power of Macros. From what I understand, REBOL seems to have the same power and they call it Dialects.

Dialects are not like macros. A dialect is an entirely different language domain, where you can build code in your own way with your own syntax rules and structures to fit the data you need to describe.

VID is such a dialect, where you use a different syntax to describe a GUI:

Quote:

view layout [ origin 20 backdrop http://amigaworld.net/themes/default/images/logo-top.gif at 50x50 button "A" [print "A"] at 100x75 button "B" [print "B"] ]

It's a different language domain, because if you tried to enter the commands directly in to the console, they wouldn't work. Dialect code is words and values stored in a block. Then that block is parsed with a dialect parser, that you for example can build with the PARSE function.

One of the brilliant schemes of REBOL 3 is that Rebcode is in fact a dialect that reads like an assembly language. The parser is an internal one that converts your code to native CPU assembler. It's already been demonstrated on PPC and x86 with a special build of REBOL 2.

Last edited by HMK on 06-May-2007 at 07:22 PM.
Last edited by HMK on 06-May-2007 at 07:17 PM.

Quote:

view slide1

So REBOL is/includes also a vector drawing language in which you can just send commands to the view component? So it cannot only replace all the web stuff you mentioned but also WMF, in a sense...

What happens if you say "view nonsense" and nonsense is just some plain non-view REBOL code? Some sort of error message I guess. Access violation?

-- Edit: or probably nothing special happens at all, just that nothing is drawn..

Last edited by dirigent on 06-May-2007 at 07:40 PM.
Last edited by dirigent on 06-May-2007 at 07:38 PM.

Quote:

So REBOL is/includes also a vector drawing language in which you can just send commands to the view component?

Not exactly a vector drawing language. There is one called DRAW, but that is a separate dialect, which is useful for more flexible kinds of drawing.

VIEW is a function that displays a face on the screen. I said earlier that VIEW could be considered a rasterizer, which is not accurate, I'm sorry. SHOW is a function which exists inside VIEW. SHOW can be called the rasterizer, since it processes face objects into bitmaps on screen.

A face is an object which contains information on dimensions, offset, appearance, color, contained text and more for a rectangular region on screen. As such a face object is optimized for being used in GUIs. All parts of a GUI consists of face objects that exist in a big tree. This tree is defined by the LAYOUT function.

You can also create faces by hand, but that is more elaborate and difficult.

Quote:

So it cannot only replace all the web stuff you mentioned but also WMF, in a sense...

In a sense, yes. VID provides a way to show a graphical user interface that works like any other application, in the same sense that HTML provides a way to display text, tables, images, etc. inside
a webbrowser.
So when you are using REBOL, you can download a script and run it directly from the console. That is: Start REBOL/View and in the console, type in:

Quote:

do http://www.rebol.com/view/games/rebtris.r

Which will pop up an 8 KB Tetris game, if you are connected to the Internet. Alternatively, you can with the desktop (where REBOL/View starts by default), browse into REBOL/Games and start Rebtris from there. Carl calls this the X Internet, Executable Internet.

As if that's not enough, REBOL/Plugin works inside webbrowsers, though currently only IE, Firefox and Opera on Windows, but this makes REBOL behave like Flash or Java plugins and you can run the very same scripts inside webpages.

Quote:

What happens if you say "view nonsense" and nonsense is just some plain non-view REBOL code? Some sort of error message I guess. Access violation?

If nonsense is not set:

Quote:

>> view nonsense ** Script Error: nonsense has no value ** Near: view nonsense

If you insert something non-related:

Quote:

>> view 7 ** Script Error: view expected view-face argument of type: object ** Near: view 7

If you insert an unprocessed piece of otherwise correct VID dialect:

Quote:

>> view [button "hello world"] ** Script Error: view expected view-face argument of type: object ** Near: view [button "hello world"]

If your layout has a problem:

Quote:

>>layout ["Hello world" button] >> layout ["Hello world" button] Misplaced item: "Hello "

But, please, try it for yourself! It's a free download here.

Last edited by HMK on 06-May-2007 at 08:30 PM.

Quote:

A face is an object which contains information on dimensions, offset, appearance, color, contained text and more for a rectangular region on screen. As such a face object is optimized for being used in GUIs. All parts of a GUI consists of face objects that exist in a big tree. This tree is defined by the LAYOUT function.

Oh yes, you don't actually pass REBOL code itself to the view, so that would also answer my question above.

About datatypes.

Quote:

58 primitives?! Wow, I thought it's a pro for every programmer to have less as possible.

Carl understand, when and how to add features, so it's simple and at the same time doesn't limit the possibilities. It's much of the same Amiga philosophy. Simple things should be simple to do, but we don't like to have constraints. Having that many datatypes in a language actually makes lots of things very simple to do.

Let's take ADD as an example. ADD takes two arguments

add value1 value2

The values must be: number pair char money date time tuple
That is 7 of the possible datatypes. In reality, it's more, because number can be integer or decimal. Now I can write:

>> add 2 4
== 6
>> add pi 2.4 ; pi is a word with a meaning
== 5.54159265358979
>> add 100x100 5 ; here I combined two different datatypes
== 105x105
>> add 100x100 20x40
== 120x140
>> add EUR$120.00 87.50
== EUR$207.50
>> add 15-2-2004 30
== 16-Mar-2004
>> add 12:30:20 80
== 12:31:40
>> add 128.0.0 64.128.64
== 192.128.64
>> add 128.0.0 64 ; again a combination of two different types
== 192.64.64

All that is using the function ADD on different datatypes. It's very powerfull and at the same time simple! Many functions in REBOL act like this on different datatypes.

"Everything should be made as simple as possible, but not simpler."
- A. Einstein

About dialects.

Another very strong feature in REBOL is the ability to make your own dialects. To illustrate it, let's look at a Postscript dialect, I made last year. Code written in the dialect looks like this: test.txt

The dialect parser parse the dialect code and output Postscript code. In REBOL, you write something like:

do http://home.tiscali.dk/john.niclasen/postscript/postscript.r
write %test.ps postscript load http://home.tiscali.dk/john.niclasen/postscript/test.txt

Now there is a Postscript file named "test.ps" in your local directory, which you can send to the printer (also possible from REBOL with a line of code). The output looks like this: test.png

The dialect produce a subset of Postscript, but enough for many things. I've defined it here: postscript.html

A few tidsbits are trickling out from the REBOL Devcon in Paris, France:

The kernel will be 240 kb in size and is released on June 30th to developers (probably as beta) and then a full release on July 15th.

There is a live video stream at http://ead.ephe.sorbonne.fr/dess-capture.sdp, if you want to see Carl speak, but be quick as the next scheduled talk is in about 20-30 minutes after I post this message.

Quote:

>> add 100x100 5 ; here I combined two different datatypes == 105x105 >> add 100x100 20x40 == 120x140 >> add EUR$120.00 87.50 == EUR$207.50 >> add 15-2-2004 30 == 16-Mar-2004 >> add 12:30:20 80 == 12:31:40 >> add 128.0.0 64.128.64 == 192.128.64 >> add 128.0.0 64 ; again a combination of two different types == 192.64.64

Errm, I am not convinced that these are very good ideas.. Allowing too much flexibility in adding apples and pears together is *really* asking for trouble, don't you think? Reminds me of experiences with untyped languages without variable declarations (Matlab). What kind of datatype is 120x140, anyway? Coordinate? Extent? Although I generally like the language for its various features (your postscript 'dialect' is great!), in some areas it seems some restrictions could make sense.

Quote:

Errm, I am not convinced that these are very good ideas.. Allowing too much flexibility in adding apples and pears together is *really* asking for trouble, don't you think?

REBOL is a type safe language, so there is no risk in this regard.

There is exactly the amount of flexibility you need, in that you can perform operations on different datatypes where it makes sense to do that. REBOL will of course return an error in cases where it's not possible to perform the operation, such as adding a number with a string.
The only disadvantage may be that, it can be not so obvious what operations are possible, so you have to try it out in the console first, but there is much more than meets the eye. But it is not unpredictable or makes REBOL crash, if that's what you think.

When I was a beginner, I often discovered that certain operations could be done easier, by simply letting REBOL do the required conversions for you. And you slowly discover what operations make sense. To list them all would require probably several of sheets of paper.

For example: If you have the color 128.0.0 (dark red) and want to make it a full red, you can add 128.0.0 to it. If you want to add 128 across all three colors, just use the integer 128. It makes sense in a lot of places to do this and really shaves off a lot of code.

Also some series can be converted to number datatypes:

Quote:

>>to-tuple [1 2 3] == 1.2.3 >>to-tuple [1 2 3 4 5 6 7 8 9 10] == 1.2.3.4.5.6.7.8.9.10 >> to-pair [1 2] == 1x2 >> to-date [3 4 2000] == 3-Apr-2000

One thing that hasn't been mentioned is the concept of virtual datatypes. Since there are so many datatypes, it makes sense to put them into groups, so you can tell strictly whether you are dealing with a number, that you can perform math operations on, or a block or a string, you can perform series operations on.

Quote:

>> number? 6 == true >> number? "Caprica Six" == false

If you need better datatype "precision", you can ask for decimal, integer, etc. instead.

Quote:

Reminds me of experiences with untyped languages without variable declarations (Matlab).

You have total control over datatypes in REBOL:

Quote:

>> a: 1 == 1 >> number? a == true >> integer? a == true >> decimal? a == false >> type? a == integer! >> to-string a == "1" >> to-block a == [1]

Quote:

What kind of datatype is 120x140, anyway? Coordinate? Extent? Although I generally like the language for its various features (your postscript 'dialect' is great!), in some areas it seems some restrictions could make sense.

120x140 is a pair! datatype useful for coordinates, sizes, etc.

You can read a bit more about datatypes here.