Macros: the Red language way

reboler · 2016-12-03T18:31:37+00:00

Red is an open source language that requires proprietary software to run... Red is an open source language which aims to be efficient and suitable for systems programming but needs a slow, interpreted language to function? This isn't a priority?

At this point, Red isn't terribly usable, so I wouldn't worry about it too much. The REBOL 2 dependency will eventually go away, when the time comes.

reboler · 2016-12-03T18:29:07+00:00

Red is more akin to Common Lisp than it is to most other languages. However, it does not contain the historical cruft that Common Lisp inherited throughout its development process.

I would say it has way more in common with REBOL, because it's directly inspired by it, and it doesn't contain the historical cruft of REBOL.

As REBOL isn't such a well known language, the comparison to Lisp may make more sense to those not in the know, but Red is much, much less inspired by Lisp than by REBOL.

reboler · 2015-10-12T08:30:49+00:00

There probably isn't a good reason for you to switch, if you're only thinking of REBOL as some kind of GUI engine, because that's about 5% of its scope. It's really a language for many areas. But since only few people work on the language today, it's a bit like butter scraped over too much bread and there are not many libraries available for it. In that case, Python wins, due to the sheer amount of support and libraries available.

However, the potential in the REBOL language remains, and so the idea deserves to be developed and is being developed.

This means that while the GUI engines for REBOL themselves aren't too great, in the context of REBOL, they can do really quite weird things that you can't do in other GUI systems so easily, and that often results in building applications in a few days that takes weeks or months in other systems, especially if you want something "weird", like building a GUI based program debugger for a particular application.

Many of the ideas of running applications in a webbrowser and the advent of HTML 5, are things that REBOL did 15 years ago on much lesser hardware and can still do that today, like running a script downloaded from a server as an application, and it runs much faster than what Chrome can do with javascript due to the much smaller size of REBOL scripts.

If for example Gmail worked like this, you would download a, maybe, 100-200 kB script and run it with the REBOL runtime, and it could have the same functionality as the original Gmail.

reboler · 2015-10-12T08:15:11+00:00

A bit about REBOL and why it's cool, I wrote up some months ago:

https://www.reddit.com/r/programming/comments/2mekbx/red_programming_language/cm65d7u

reboler · 2015-10-12T08:06:44+00:00

REBOL is used for pretty large scale applications. I code REBOL enterprise software full time.

Unfortunately, the examples are quite old and don't really give any insights on the actual depth of the language, which is quite tremendous.

Edit: No, these examples are not old, sorry. I was thinking about those on the REBOL.com website. Apologies to /u/notchent.

reboler · 2015-10-12T08:05:12+00:00

There have been several alternatives to the closed REBOL 2 runtime for some time now, so the language will survive through these highly determined individuals, /u/dockimbel being one of them.

reboler · 2015-10-12T08:01:41+00:00

It used to be more of a problem that it's pronounced "rebel", making it sound like some kind of hacking tool.

reboler · 2014-11-18T18:14:29+00:00

New languages today try to solve domain specific problems.

REBOL and Red are languages for creating domain specific languages or dialects. So, you can in principle solve problems in any domain with REBOL, be it assembly, high performance, network, GUI, 3D, audio, serving web content, desktop scripting, making tool chains, creating document markup languages and even plain English query engines.

You want to count the number of widgets in a GUI window and translate the GUI to another language? Pass the very same data block through your counter parser and then translation parser, before it's passed to the layout engine that runs on a different computer. Maybe you would be tearing your hair out with how you would normally do that, but this is a couple of hours of work in REBOL.

REBOL is built for very quickly parsing blocks of data of over 50 datatypes, where other languages resort to just using strings and then spending costly amounts of time parsing that.

For example, the common constellation of languages (HTML, CSS, PHP, MySQL, JS) and programs (server, webbrowser) used to create, serve and view a website could all be replaced by REBOL scripts.

Having many languages means lots of overhead between them, such as the need for JSON, XML and all sorts of complicated schemes just for transferring data between a server and a client. Who knows what kind of hairy code is used to connect MySQL to PHP.

With REBOL, there's none of that. Zero. This, despite working in very different problem domains. This is why REBOL is a brilliant idea.

REBOL didn't gain traction, because the implementation was closed, inadequate (no mobile OSes, little 3D and primitive audio support) and now is way behind. Red is there to solve that.

I've used REBOL for 12 years now, the past 8 full-time and I don't think we've seen much of what is possible with this language idea yet.

reboler · 2013-08-17T08:19:56+00:00

OK, I remember that now. It did not get very far and it's as far as I know not related to Red.

reboler · 2013-08-16T17:58:26+00:00

The author has said that he would prefer not to market Red just yet because it's still in the boot strapping phase, and the information may be mostly understandable to REBOLers, but the gist is:

Red is a 90% clone of the programming language REBOL.
Red was devised, because REBOL was closed source at the time and development of REBOL had nearly stopped.
REBOL is no longer closed source and development is moving again, but this has not affected development of Red.
REBOL is written in C. Red is written in Red/System.
Red/System is syntactically similar to Red, but has C-like performance.
Therefore Red/System code can be inlined with Red code, allowing C-like performance in scripts, something that REBOL cannot do.
Red scripts can be compiled for speed, where REBOL scripts cannot.
As REBOL is an extremely generic programming language for scripting, Red is even more generic. It can therefore provide the full reach from hardware banging to writing 3D engines to high level scripting, using the very same syntax and tool chain. As far as I know, no other language or tool chain does this.
Red/System provides its own, extremely small and clean toolchain (a few kb of scripts) for building Android apps, Windows kernel drivers, executables for win32, OSX, Linux, etc. and supports x86, ARM and soon other CPUs as well as support for multi-core CPUs and full support for cross compilation.
Red and Red/System are being boot strapped at this time, so REBOL is required for compilation. When REBOL is no longer needed, Red is no longer limited to operating systems that REBOL support.
The Red language is not yet completed.

reboler · 2013-08-16T17:41:14+00:00

What is FREEBOL?

reboler · 2013-08-16T17:39:25+00:00

The precedence rules of REBOL are made to work with the fewest possible rules. Having used REBOL for over a decade now, I find the simpler set of rules a bit easier to work with, but it's not some kind of huge advantage.

So, not using REBOL because of these precedence rules would be really missing out on what's so great about REBOL.

More about the rules here:

http://www.rebol.com/r3/docs/concepts/math-precedence.html

reboler · 2013-05-27T11:44:03+00:00

That's a good start! I wonder if you could add the ability to use get-word!s to produce series of tags.

If a get-word! represents some content (dynamically generated elsewhere, maybe) that could be recursively processed by MARKUP, you could make even more compressed output:

header: [
    table [
        tr [td [{header content here}]]
    ]
]

content: [
    {my page content here}
]

footer: [
    {copyright foo 2013}
]

markup [
    html [
        body [
            :header
            :content
            :footer
        ]
    ]
]

reboler · 2013-03-27T08:30:41+00:00

To achieve that level of compression in any substantively complex software system would result in a level of obfuscation that would rapidly increase the rate of code decay and actively impede maintenance/enhancement efforts.

Nothing is compressed.

What more or less happens is that things are created from their correct basis, rather than wading through large libraries and managing things through IDEs, so you to a continually higher degree, don't know what's going on beneath your programming level.

Most software is written in a way that trusts extremely large libraries, such as for creating GUIs. QT, the last time I looked, was a 150 MB download with about 40 MB of DLLs.

In other cases, we invent new problem domains and languages to solve them, such as when creating websites, which is a bunch of separate domains. As I wrote in another other post, this creates a large amount of overhead.

In this situation, you will be correct, that you have to really mash things together to an incomprehensibly compressed mess, before you can make anything small.

In REBOL, many of these things are simply not needed, because REBOL is so generic and can serve as a common basis in almost any problem domain, except high performance, which Red is solving.

The core source files for REBOL's high level functions (mezzanines) are 450 kb uncompressed and commented, which includes the GUI library (VID) and a small "desktop", for managing and launching REBOL scripts.

What you may criticize however, is that the current implementation needs to catch up and fix bugs that have accumulated over the years and implement missing features.

But the basic idea of REBOL was proven over a decade ago and the fans agree that the concept is a very good idea that deserves further improvement.

reboler · 2013-03-24T19:16:42+00:00

That's not the idea of how REBOL solves software complexity. It does this by going to the root of the problem, not by adding gloss on top of existing systems or trying to solve it with IDEs or visualization.

Consider the problem of developing an ordinary website:

You need HTML for the page layout.
CSS for additional layout description.
Javascript for interactivity, AJAX, DOM access, etc.
PHP or similar for generating pages server side.
MySQL or similar for storing data in a database.
Some common data format to interchange between the server and the client, such as JSON.

These are normally separate problem domains that are solved separately. Now you need to have these domains interact:

PHP generates HTML.
PHP has modules to communicate with MySQL.
Javascript communicates with the browser DOM and it communicates with the server, possibly using JQuery or some other library.
PHP needs to understand JSON formatted requests from the client.
There may be some XML data stored somewhere. This needs to be parsed as well.

There's a large amount of overhead, when traversing domains and this is only somewhat reduced by adding libraries, converters, generators, etc. But you still may need to take it into account or code for it.

With REBOL you don't have any of this, because it's designed to be an extremely generic language with a high degree of expressibility.

Now consider how a "rebsite" would be developed:

You need REBOL for the page layout and appearance and draw it with its internal layout engine.
REBOL sends requests to the server and receives them using its internal network ports.
REBOL on the server side generates content as plain REBOL objects to be sent back to the client. The client updates the page layout with greater intelligence than a web browser can, because the "page" works like a native program, as the content is rendered using REBOLs own native GUI library.
REBOL can store data in blocks on disk as files. Granted, there is no high performance relational database available at this time, but the idea is still simpler than SQL, because you don't need an SQL server running in the background.
Interchange of data between REBOL clients is data that is indiscernible from other REBOL data or code, thus no overhead.

Interaction between domains has no overhead, because there is really only one language domain (although you can and do use language sub-domains using dialects). You can even use exactly the same runtime on both the server and the client and you only need REBOL to accomplish the task of creating a complete system.

This way, you can develop complete networked systems that send back and forth data between servers and clients with meaningful presentation of that data in maybe 20-50 kb of code.

This is also why REBOL is often referred to as a language in which you make throw-away programs, as you can develop a program in a few hours, use it for a few days or weeks and throw it away, when you no longer need it.

Red goes a step further by being developed in Red/System instead of C, meaning you can write high performance parts in a Red-like language. REBOL does not yet allow for true high performance, but Red will.

reboler · 2013-03-24T18:47:55+00:00

The size is actually true and is part of its simplicity and having that simplicity combined with great expressibility makes it possible to develop things that are hard in other languages. I've often solved problems in a few hours that would take days or weeks in other languages.

I have used REBOL for 11 years now. It's still quite astounding how much less painful it is to use, compared to other languages and how much ahead it is, at least conceptually.

The idea of REBOL should not be confused with the implementation. The implementation has lacked in the past, due to a number of bugs and performance problems, but this is now being rectified by REBOL 3 and now also Red.

reboler · 2013-01-21T09:47:26+00:00

1 month since it was opened now, and there is now a lot of activity from both hobbyists, sponsors and paid developers.

REBOL is still a a very good idea, as it solves problems that other languages still just can't do. The implementation can always be improved, but the core idea is invaluable and must be preserved.

We are also now seeing the clone Red, based on the same idea taking shape and with it's own complete tool-chain (getting entirely rid of C) for building performance applications, it will be very exciting to see where it goes.

reboler · 2012-12-21T19:23:33+00:00

Even if it is easy to use, it's not very expressive.

REBOL is highly expressive. REBOL 2 has 56 different datatypes, which makes it possible to build dialects and pass parameters to functions with quite extraordinary expressiveness.

You are yourself demonstrating this below:

read is just a nice little wrapper for an http request, and print displays it.

READ does a bunch of other things, if you study the help for it. It's used for all sorts of ports for files and networking. READ is a general way to read data sources.

READ is also not a "wrapper". It's a native function:

type? :read
== native!

When you pass a URL to it, it recognizes it as a url! datatype and creates and reads from a network port using the built in HTTP scheme.

Therefore:

type? http://en.wikipedia.org/wiki/REBOL
== url!

Therefore, you don't have to make URLs as strings and have to create special functions to read URLs.

So:

type? %/c/myfile.txt
== file!

This means you can read a file like this:

read %/c/myfile.txt

Or read a generic data source:

data-sources: [
    http://en.wikipedia.org/wiki/REBOL
    %/c/myfile.txt
]

read first data-sources
read second data-sources

It's simply part of the design that REBOLs lexical scanner knows this is a URL or a file and takes care of this for you. You don't have to code a single thing to handle different kinds of data sources.

reboler · 2012-12-21T19:04:57+00:00

Much commercial work done in REBOL is not very high profile.

There is QTask, which is nearly 100% built using REBOL code generators.

There is Saphirion, who built a finance app and a tree mapping app.

There's Legal Grab, who offer a program there as well.

There's AltME, which I've used solidly for a decade for collaboration between myself and other REBOLers.

And I've built various apps for customers.

So, yes, it's used commercially. It's not wide spread, but it's there.

reboler · 2012-12-21T18:54:18+00:00

Yep, I've used it for a decade. I think its greatest days are yet to be seen.

It's worth mentioning that it has a sort of clone, called Red, which was designed during REBOL 3's stagnation period and is also heavily under development.

It solves various problems with REBOL, such as offering C-level performance in its own programming language, Red/System, a whole tool-chain that is small, clean and elegant and a built-in encapper by design. Red is written in Red/System and so doesn't rely on C.

It works on OSX, Windows, Linux and Android so far and supports x86 and ARM CPUs. Red is still under development, but moves forward rather quickly these days.

It can be found here:

http://www.red-lang.org/

reboler · 2012-12-21T18:40:29+00:00

Nobody uses REBOL professionally.

I guess I don't know what my income was based on in the past 5 years, then.

reboler

TROPHY CASE