Learn Red - Fundamentals of Red

4 (1 reviews total)
By Ivo Balbaert
  • Instant online access to over 7,500+ books and videos
  • Constantly updated with 100+ new titles each month
  • Breadth and depth in over 1,000+ technologies
  1. Red's Mission

About this book

A key problem of software development today is software bloat, where huge toolchains and development environments are needed in software coding and deployment. Red significantly reduces this bloat by offering a minimalist but complete toolchain. This is the first introductory book about it, and it will get you up and running with Red as quickly as possible.

This book shows you how to write effective functions, reduce code redundancies, and improve code reuse. It will be helpful for new programmers who are starting out with Red to explore its wide and ever-growing package ecosystem and also for experienced developers who want to add Red to their skill set.

The book presents the fundamentals of programming in Red and in-depth informative examples using a step-by-step approach. You will be taken through concepts and examples such as doing simple metaprogramming, functions, collections, GUI applications, and more. By the end of the book, you will be fully equipped to start your own projects in Red.

Publication date:
May 2018
Publisher
Packt
Pages
252
ISBN
9781789130706

 

Chapter 1. Red's Mission

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
 

Technical requirements


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

 

A short history of Red


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.

 

What Red stands for

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 languagethat 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.

Some history

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.

 

What makes Red special?


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

A full-stack language – from the metal to the meta

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!

Code is data and data is code

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.

Note

It will become clear that [ ] are used a lot in Red. On English or US keyboards this is easy, with its dedicated keys for [ and ]. On my (Dutch) keyboard it is ALTGR + ^ and ALTGR + $. On some keyboards, it is Alt + 5 and Alt + 6. I find it easier to switch to US keyboard layout while coding.

Like LISP, it has a very powerful capacity—it is homoiconic, literallyself-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.

Data types built in

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

Small toolchain and executables

As we will see in the next chapter, when we're setting up, the complete toolchain (compilers, standard-library, docs, and REPL) comes packaged in a minimal 1 MB file, with no installation and configuration requirements—here we can see the reduction at work! Compare this with a Java runtime, which is about 150x bigger, or the Python runtime which also is 50 times bigger.

After compilation, Red produces executables of sizes typically around 0.5 to 1 MB, with no dependencies needed. This simplifies deployment of apps into production enormously. This aspect, combined with the low memory footprint, makes Red a very appealing choice for mobile and embedded apps. A garbage collector, which will be integrated in one of the next releases, ensures that memory consumption stays low.

Coding in Red is very expressive and concise, reducing script size, in the range of KBs. This will become apparent in the coming chapters. Just as an example, to read a web page into a string page you do the following:

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.

Dialects

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).

 

Red's main features


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.

Portability

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.

Like a Swiss Army knife

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
 

Summary


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.

 

Questions


  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.

 

 

About the Author

  • Ivo Balbaert

    Ivo Balbaert has been a lecturer in web programming and databases at CVO Antwerpen, a community college in Belgium. He received a Ph.D. in applied physics from the University of Antwerp in 1986. He worked for 20 years in the software industry as a developer and consultant in several companies, and for 10 years as project manager at the University Hospital of Antwerp. From 2000 onwards, he switched to partly teaching and partly developing software (at KHM Mechelen, CVO Antwerpen). He also wrote an introductory book in Dutch about developing in Ruby and Rails, Programmeren met Ruby en Rails, by Van Duuren Media. In 2012, he authored a book on the Go programming language, The Way To Go, by IUniverse. He wrote a number of introductory books for new programming languages, notably Dart, Julia, Rust, and Red, all published by Packt.

    Browse publications by this author

Latest Reviews

(1 reviews total)
It's a good introduction to Red. Maybe you can find the same information on the web, but you'd be doing a lot of searching and wasting time. Personally, I could do without the boilerplate in each chapter (each intro seems identical to the others), and I've never felt that a chapter recap was necessary. I do wish it would have covered linking with external libraries, and compiling for macOS apps. The Red cheerleading prose could be toned down. I disagree with categorizing the command line arguments as an advanced feature. And the vector! and map! types should have been kept with the other data types. Finally, the questions and problems were simplistic. It was annoying to jump from the text to find the question, and then jump back again. K&R (and the other UNIX folks) did it right - put well chosen and thoughtful questions at the end of the section to complement and extend the material and examples of that section. But having said all that, it's still a good book.