In this chapter, we take a look at the main characteristics of Red, more specifically, what makes Red stand out compared to other programming languages. This will motivate you to start learning Red. Don't worry if some statements are a bit abstract at this stage; they will become clearer when we start using Red in the following chapters. It may be a good idea to come back to this chapter later.

We will cover the following topics:

• A short history of Red
• What makes Red special?
• Red's main features

You can find the code for this chapter here: https://github.com/PacktPublishing/Learn-Red-Fundamentals-of-Red/tree/master/Chapter01

Red is an open source, modern programming language and platform, designed and developed by Nenad Rakocevic. Red started out in early 2011 and is now at Version 0.6.3 (with 0.6.4 coming in the near future), aiming for a 1.0 release in the next year or so. In order to better understand its features, we have to explore its name and history a bit.

Red is short for Red[uced] REBOL, and that's why Red users proudly call themselves reducers. This points to two things:

• Red builds upon REBOL, a language that gained some fame around the millennium and was built by Carl Sassenrath. In fact, Red is syntactically and semantically a 95% clone of REBOL, but tries to improve and enhance it where possible. This also means REBOL scripts can be easily converted to Red.
• Red (like REBOL) wants to reduce today's code complexity—it aims to have compact runtime environments and dependencies (around 1 MB), instead of the hundreds of MB of the Java or .NET platform.

Development of Red started out with Red/System—this is a low-level language (like C) to enable programming at the full system level. Red/System is like an older sibling—it looks very much like Red, but it is aimed at lower-level programming so it is more restricted. We'll come back to it in Chapter 10, Advanced Red.

Gradually, Red evolved this foundation, adding with each release more and more data types, actions, and functions. A REPL interactive coding console, execution on ARM processors, a parsing engine, a cross-platform GUI dialect (working on Windows and macOS, and nearing completion on Linux and Android), reactive programming, and macros are among the hallmarks of this evolution.

From January 2015, the Fullstack Technologies company was formed to continue Red's ongoing development, together with an ever-growing community of open source contributors. The company raised capital from InnovationWorks and GeekFounders (Chinese VC early-stage investors) and has its headquarters in Beijing's Silicon Valley.

In January 2018, Red joined the blockchain revolution—through an Initial Coin Offering (ICO) with its own cryptocurrency, RED (Red Community Token) token, and it gained a vast amount of new funding capital to sustain and accelerate its completion. Using its unique capabilities, a special dialect of Red called Red/C3 is being built, specifically dedicated to blockchain and smart contracts programming.

Since spring 2018, the Red project has been managed by the Red Foundation, based in Paris (France), and also led by Nenad Rakocevic. This organization will also foster a new economic model for open source projects, using the RED token to drive development.

Here we concentrate on the characteristics that sets Red apart from other contemporary programming languages.

Together with its foundation Red/System, Red forms a full-stack language—this means it can be used to develop high-level applications (domain-specific languages, graphical frontends, and high-level scripting) as well as low-level programs (embedded systems, operating systems, and device drivers), as shown in the following diagram in comparison with other languages:

It is quite unique in programming history that a single language spans the whole programming stack. This means that you as a Red developer only have to know one language from low to high level coding!

Red is a modern descendant of the venerable LISP programming language. Instead of LISP's cumbersome parenthesis usage, it has taken Logo's simplified syntax. Everything in LISP is some kind of LISt Processing, and the same goes for Red—basically all code amounts to a combination of actions on blocks, which is the Red equivalent to LISP lists.

A block is simply a grouping of values between rectangular brackets [ ], such as [7 13 42]. You'll soon see that blocks are the fundamental building unit in Red code. This has the consequence that only a minimal syntax is used to represent code as well as data.

Like LISP, it has a very powerful capacity—it is homoiconic, literally self-representing. What this means is that Red can work with its code just as it does with its data values, because data and code are represented the same way, namely as blocks. This makes it possible for programs to write other programs, in other words, to do metaprogramming. We'll see several examples of this feature in the coming chapters.

For you as a developer to work with data efficiently, Red has more than 45 and counting built-in data types, from common types such as integers, chars, and strings to less common ones, such as pairs, tuples, files, URLs, emails, and so on. Moreover, you use the same set of operations to work with them, which greatly eases the learning curve. To do that in other languages, you would have to create objects from specialized classes to start working with them, or even import a library. As a first example, you can add and subtract days from a date value simply as follows:

;-- see Chapter01/special.red:
1-Feb-2018 + 14         ; == 15-Feb-2018
1-Feb-2018 – 42         ; == 21-Dec-2017

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

In 2013, the Redmonk website published an article (which you can view here: http://redmonk.com/dberkholz/2013/03/25/programming-languages-ranked-by-expressiveness/) examining the expressiveness of languages. The results were summarized in the following diagram:

On the vertical axis, the number of lines of code per commit are depicted. We see that REBOL (Red's direct parent) scores very low compared to mainstream languages, indicating that fewer lines are needed in coding comparable tasks.

One of Red's greatest strengths is the ability to easily create domain-specific languages (DSLs) or dialects. These are small and optimized sub-languages designed for a specific task, such as parse for transforming text (see Chapter 8, Parsing Data), view and draw for composing graphical user interfaces (see Chapter 9, Composing Visual Interfaces), and Red/C3 for blockchain programming (see Chapter 10, Advanced Red).

As a programming language, Red embraces nearly all paradigms:

• Imperative: Providing everything needed for controlling code execution and error-handling (see Chapter 4, Code Controlling Structures and Chapter 5, Working with Series and Blocks)
• Functional: With functions as first class values (see Chapter 6, Using Functions and Objects)
• Object-oriented: Complete with inheritance, but not class-based (see Chapter 6, Using Functions and Objects)
• Concurrency: With async task support and an actor model (from v 0.9.0)
• Symbolic: Being able to manipulate its own code as if it was plain data (all chapters)
• Reactive: Included in the GUI (Graphical User Interface) system (see Chapter 9, Composing Visual Interfaces and Chapter 10, Advanced Red)

Aside from REBOL and LISP, Red has taken inspiration from the following:

• Forth and Logo for its syntax
• Lua, for its capabilities as an embedded language, and its JIT (Just-In-Time) compiler
• Self, for its prototype object-model
• Scala, for its type inference engine and compilation

Although it can be statically compiled, Red has a graphical REPL console (Read Evaluate Print Loop) like other dynamic and scripting languages, to experiment with code interactively. We will explore this console in Chapter 2, Setting Up for Development.

In contrast to REBOL, which is an interpreted language only, Red also compiles to native code through Red/System, thus achieving much better performance, something like Crystal compared to Ruby. Compared to C, at this moment Red/System is 2-4x slower.

Red runs in the Windows, Linux, Android, macOS, and FreeBSD environments in a 32-bit version (the 64-bit version is planned) with cross-compilation capability. Furthermore, it runs on ARMv5 processors and on the Raspberry Pi and Arduino boards.

The versatility of the Red platform makes it suitable for apps on the entire spectrum, such as:

• High-level scripting (for example, glue code such as Lua)
• Web apps
• GUI desktop applications
• Android apps (from Version 0.7 onward)
• 2D games
• Data processing
• Grammar parsing and constructing specialized languages
• Network/system programming, IoT devices programming, robotics

In this chapter, we looked at Red's main characteristics, and examined its place among other programming languages. In the following chapter, we will set up an environment to start up our development with Red.

1. Why does Red have a Red/System component?
2. What is a full-stack language, and why is Red an example of that?
3. What do the the Red and LISP languages have in common?
4. Give three ways in which Red reduces software complexity.
5. What is a dialect in Red? Give some examples.
6. Why is Red faster than REBOL?
7. Name some of the environments in which Red can run.