Navigation

The language comes with better support for Natural Language Programming and Declarative
Programming. The innovation comes in supporting these paradigms with new practical techniques
on the top of Object-Oriented Programming and Functional Programming. Ring provide the programmers
with the tools required to build a Natural Language like Supernova or Declarative Language
like REBOL and QML without the need to know anything about (Compilers and Parsing). You get
the language constructs ready for use to create domain-specific languages in a fraction of time.

Check the Supernova programming language, In this language you can type
(I want window and the window title is hello world.) and it will create a GUI window
with “Hello, World!” as the window title. When I created Supernova language in 2010. I discovered
that using the Natural Code can be (Like English without limits and we can get the human
language power in programming) but to implement that You need a new language that are

General Purpose

Practical

Can create Natural Languages very quickly.

So we can get a System that can increase ease of use and productivity to the maximum level.

Ring is the best language to do that. So I created Ring to achieve this goal.

Supernova was just a test for the idea. To get a near view about what are the Advantages and
Disadvantages. After testing the new ideas you provide something practical. So we have Ring
after Supernova. A story that maybe similar to having Python after ABC. Python avoid ABC problems
but bring ABC advantages. Also Ring learn from Ruby and ROR story. The language power could
appears in Frameworks better than direct usage as a general purpose language. Also Ring comes
with a clear goal/motivation (Creating a new version of the PWCT Software) something learned
from designing the C language to create the Unix Operating System. You have a goal that direct
you in each design decision.

You will understand the value of our decisions once you start trying to solve the problem
that we will use Ring to solve. Could you enable any one in the world without knowledge
about computer programming concepts to create very powerful software? In science the answer
is (Visual Programming) and (Natural Programming). In practical we still away from switching
to these paradigms without introducing other problems. Ring is designed to solve this problem.
It’s designed to provide Natural Programming in a practical way. And to create a powerful
Visual Programming tool. Ring is designed to be a new world of programming after 10 years
of research in Visual Programming and Natural Languages.

The Ring Programming Language (Compiler+VM) is developed 100% using Visual Programming without
writing a single line of code. I used my tool (Programming Without Coding Technology) to design
everything and get the C code generated for me. Advantages ?

More Faster

No Syntax Errors

Easy to understand and manage the code because the Abstraction level is more higher

No Critical Disadvantages because you can control everything as writing your code.

From my experience in using Visual Programming for 10 years and Natural Programming for 5 years
I designed Ring to move the knowledge to mainstream programmers by providing a practical language
that support these ideas.

I agree that each programmer/developer has the freedom to form his opinions about any software
including programming languages. Ring is not an exception but you may miss the idea behind the
language. It’s innovative and may help you to think different about how to solve your problems.
Maybe this is not clear to many programmers because It’s practical language and includes many
features known to programmers and when a programmer look at a language he/she may think that
nothing new because it’s familiar. I created Ring to solve problems in a different way. Where I
will start programming just by describing the software using new natural interfaces that I will
implement later when I move from the design stage to the implementation stage.
(I don’t determine the time to switch between stages, You are free to use Agile methods).
Since Ring is a new language you have 3 options.

Just don’t care.

Think in the future of the language and help us if you understand the idea and want to contribute.

Wait and come back again in the future to use it.

Summary:

Ring is designed based on a need to develop a new version of the PWCT software.

Once we finish PWCT 2.0 we will have good and large software developed using Ring.

We will push Declarative and Natural paradigms many steps forward. Also in next versions

we have a plan to present a new paradigm for Network Programming and Concurrency. We tested this
new paradigm through simple prototypes during the last years and we will integrate it with Ring
in Future releases.

It’s a new language, just Ring version 1.4. A serious ecosystem comes along the way.

Because it’s more Natural, and Faster and this is important for the language goals. What
comes first is what you want. When you type “Print : ” + 5 , The String comes first then 5
will be converted to a String. while when you type 5 + “10” The number comes first so “10”
will be converted to 10. This help a lot to quickly convert between numbers and strings using
the same operator. If you want to prevent conversion (Write code that prevent conversion) In
these cases you will notice that what you are writing is less code (And can be removed).

Weakly Typed = Automatic Conversion and Automatic is Good Thing and is better than Manual
if you know how to use it correctly.

Smalltalk and Lisp are GREAT languages. I like many of the concepts behind them but I’m sure
that selecting the right programming language is based on the problem and comes after the problem
definition. I have a problem that I want to solve and these GREAT languages are not ideal for
this problem so I designed Ring.

When you design a new language, You can learn from the past but you must look forward and live
in the Future. What you know about Natural Programming maybe based on the Old Knowledge about
the power of these paradigms in the practical world and I agree with you but I see another
techniques that can be applied to get this to work in practical. What you miss about
Natural Language is that they are Context Sensitive and this means we can use it and think
different about how we can express our ideas.

example : I want window contains 3 buttons.

In one sentence I created 4 objects (The window and the three buttons) and added the buttons
to the window. The idea of Natural Programming is to get many things done like that.

Yes UI creation is one of the important things in the language features because it’s designed
to create a visual programming tool, But the language is a multi-paradigm language where we can
select the programming paradigm based on the problem.

Ring is not designed to replace PHP, Lua and/or Smalltalk. And Ring support for Declarative
Programming and Natural Language Programming is very innovative and much better than staying
with Procedural, Object-Oriented and Functional Languages. Ring see the future in programming
without code (Using Natural Languages) and is designed to support that.

Ring provides a better way to mix between different programming paradigms in solving problems.

The different programming paradigms play well together in the same language.

It’s easy to switch from one programming paradigm to another one because the language constructs use similar syntax for similar concepts.

The paradigms are provided to interact and used together in different layers in the software.

for example you can create a game engine using object-oriented programming but write the game code using declarative programming or natural programming and behind the scene your declarative or natural code will use the object-oriented classes.

Ring is very productive and natural programming language than C/C++ languages.

Ring is a dynamic language. We can generate and execute code during the runtime. We have dynamic typing and weakly typed language for flexibility.

The Garbage collector is generational (escape analysis) and also use reference counting. it’s very fast and still provide control to the programmer who can delete memory at any time.

Ring Compiler and Virtual Machine is just 15,000 lines of ANSI C code that can be compiled and used in any platform.

You can use C/C++ libraries and Ring comes with code generator to create wrappers from C functions or C++ classes. so when you need more performance or when you need to use more libraries you can easily do that.

What is the difference between Ring and Python? And is Ring Open Source?¶

Yes the language is Free Open Source (MIT license)

In general I like Python and Ruby but I was looking for a language more suitable for creating the next version of
the Programming Without Coding Technology (PWCT) software so I started the Ring design.

Some simple changes that matters for my goal are

Not case sensitive

The list index start from 1

You can call functions before definition

Don’t use Python syntax like (indentation, using self, :, pass & _)

Weakly typed (convert automatically between types based on context)

The programs follow simple and constant structure (Statements then functions then packages and classes)

Using the ‘=’ operator for assignment and for testing values

Critical changes are

Small Language : The Ring compiler + Virtual Machine = 15K lines of C code , the other 85K lines are related to libraries and are optional when we go for using the language in C/C++ programs.

The Garbage collector : Uses Escape Analysis/Reference counting and give the programmer the ability to determine when to delete memory using the assignment operator

Compact Syntax : Ring is not line sensitive, you don’t need to write ; or press ENTER to separate between statements

Using { } to access the object then using the object attributes and methods directly

Natural Programming : It’s very easy to create natural interfaces using Ring based on OOP

Declarative Programming using Nested Structure

The Ring programming language is designed based on my experience from using many other
languages like C, C++, C#, Lua, PHP, Python, Ruby, Harbour, Basic and Supernova
And the language comes with innovative features added to achieve the language goal

Applications programming language.

Productivity and developing high quality solutions that can scale.

Small and fast language that can be embedded in C/C++ projects.

Simple language that can be used in education and introducing Compiler/VM concepts.

General-Purpose language that can be used for creating domain-specific libraries, frameworks and tools.

Practical language designed for creating the next version of the Programming Without Coding Technology software.

What are the advantages to using Ring over Perl, PHP, Python or Ruby?¶

Ring is New and Innovative. The language will let you think different about programming.

Ring is Smaller. (Lessons learned from the Lua language)

Ring is Simple. (Lessons learned from the BASIC and Clipper/Harbour languages)

Ring is more Natural. (Lessons learned from the Supernova language)

Ring is more Declarative. (Lessons learned from REBOL and QML languages)

Ring Implementation is Transparent, Visual and comes with Rich Features.

The documentation says functional programming is supported, but then this happens?¶

The question was about this code

f=func{a=42returnfunc{returna}}innerF=callf()callinnerF()

Output:

Using uninitialized variable : a In function _ring_anonymous_func_16601()

The Answer:

It’s Anonymous Functions, i.e. Not Closures.

It’s Just Ring version 1.4 (Many developers asked about supporting Closures) and during language development we may add new features that doesn’t go against the language goals or sprite.

You can use classes and objects when you want to merge between the state and functions to provide a clear solution.

You can use Lists and put the anonymous function inside the List then return the list that contains the state and the function. Pass the list to the function when you use it.

You can use eval() and substr() to add the variable value directly to the anonymous function before return.

We protect you from other scopes when you define the function. In Ring we provided the Three Scopes Rule where at each point you have only at maximum three scopes (Global, Object Scope and Local Scope).

We don’t get everything from everywhere to be like others! We don’t need to do that. If we will think like that then we will create a very complex language or we will save our time and use other languages.

When you think about learning or studying a new language concentrate about (What is new?) and (What is better in this language?) to know when to use it. Don’t compare a new language just released little months ago with languages started many years ago and expect to find everything that you used to have.

Each programming language miss features in other languages. The idea is not the Features. it’s the sprite and ability behind all of the features together.

Why the ability to define your own languages Instead of just handing over the syntax so you can parse it using whatever code you like?¶

It’s innovation - You create natural statements without the need to learn about parsing.
You just use Classes which is intelligent decision (where later we can mix between classes to
support more statements based on the context - We can change and translate the defined
statements and many more!). Also the statements are added in Ring World where you can use
any Ring statement.

The language support programming in the small and programming in the large. The selection
of what features to use is based on what are you going to do. Any programmer can write
bad code in any language if he/she wants to do that. The idea is what must be done from
the language design to prevent errors without causing other problems like killing flexibility.

Read some source code in the Linux Kernel and Ruby Implementation for example, You will find good
usage for GOTO as a practical example that General Rules are not for All Use Cases and great
programmers know when to break the rules. I’m not saying go and use GOTO or saying Ring add
things like that. But the ability to break more than one loop and/or the ability to break the
loop from sub functions is practical for small programs.

Anyway these are some of the small new things added by the language (Not the big idea).

The Ring programming language is designed to be SMALL.
The language provides the basic constructs that you need to do anything!
One of the goals is to keep the basic constructs simple and small as possible.

Using Lists in Ring you can

Create Arrays (one data type)

Create Lists (Mix of data types)

Create Tree (Nested arrays)

Use String Index (Looks like Dictionary/Hash Table)

The same principle is applied to Numbers

You can use the number for int value

You can use the number for double value

You can use the number for Boolean value (True/False)

The sample principle is applied for Strings

You can use the string for storing one character

You can use the string for storing text (one or many lines)

You can use the string for storing binary data

You can use the string for storing date

You can use the string for storing time

You can use the string for storing NULL values (empty strings)

And we have Object Oriented Support + Operator Overloading where the programmer
can define new data types and use them as default types defined by the language

Just when you print the value using the see command you will see 1 for (true) and 0 for (false)

Why ?

Because Ring contains only 4 types of variables

Number

String

List

Object

The first type (Number) is used to represent int, double and Boolean values.

The second type (String) is used to represent char, array of characters, date and time.

The third type (List) is used to represent Arrays of one type, Arrays of more than one type, Hash (Dictionary), Tree, etc.

The object can be an object created from a Ring class (Any Class) or just a C Pointer that we get from calling a C/C++ function/method.

Why ?

The Ring is designed to give the programmer/developer the most simple constructs that can be used to do everything.
The programmer/developer can customize the language by creating new classes (and use operator overloading) to get more types that he care about according to the problem domain.

Why ?

Because simple is better, and easy to learn and remember!
And this provide flexibility to convert between high level types that can be represented using the same basic type

1- When you create an object, the class region code will be executed and you will have the object attributes based on the code in that region

2- Ring don’t care about the object methods until you start calling a method

3- When you call a method, Ring will check the object class and the class parent (if you are using inheritance) and will collect the methods for you to be used now or later from any object that belong to the same class.

4- Since methods are dynamic and each object get the method from the class, you can after creating objects, add new methods and use it with the object or any object created or will be created from the same class.

Can we use the attributes by accessing the Getter and Setter methods?¶

Yes we can, The setter/getter methods are called automatically when you start using the attributes from outside the class
Also you can call the methods instead of using the attributes. It’s your choice.

2 - Class contains Attributes defined using a special syntax (where we type the attribute name directly after the class)

3 - The Attributes are defined in the class region that allows writing code and using global variables

If I will accepted your proposal about changing how Ring find variables in the class region I must break one of the previous three features which will lead to more problems that are more important than this problem.

I don’t like changing the feature number (1) because I would like to keep Ring code more clean and let the programmer decide when to use $ or not.

I don’t like changing the feature number (2) because I like this feature and I don’t like forcing the programmer to type
self.attribute

I don’t like changing the feature number (3) because it’s very important in many applications to access global variables in the class region.

So what was my decision ?

I decided to leave this case for the programmer who will decide what to do to avoid this special case

1 - The programmer can avoid using global variables (Better) and can use the Main function (Optional)

2 - The programmer can use $ before the variable name or any mark like global_ or g_

3 - The programmer can use self.attribute after the class name to define the attributes

In general, for small programs you can use global variables and functions.
For large programs, use classes and objects and small number of global variables or avoid them at all.

WhileTrueSee"MainMenu(1)SayHello(2)Exit"Option=GetChar()GetChar()GetChar()# End of line# the previous two lines can be replaced with the next line# Give OptionifOption=1see"Enter your name : "givecNamesee"Hello "+cNameelsebyeokEnd

We uses GetChar() Three times

The first time we get the user option

Option=GetChar()

But in the second and the third times (We accept the new line characters from the buffer)

GetChar()GetChar()# End of line

Example : when the user select the option number 1 then press ENTER

We have Three Characters

The first character is : Number 1

The second character is : CHAR(13)

The third character is : CHAR(10)

Because Windows uses CHAR(13) and CHAR(10) for each new line ( i.e. CR+LF )

Using () after the class name means calling the init() method in the class and passing parameters to this method.

If we used () while no init() method in the class we get the expected error message.

The class qApp don’t have this method while the other classes have it because they need it to
create an object using a function that return a pointer to that object and this pointer will
be stored in an attribute called pObject, for more information see ring_qt.ring file
which contains the classes.