Ring Documentation, Release 1.

96.9 What are the advantages to using Ring over Tcl or Lua?

1. Clean Code (More Natural)

2. More Features (A lot of useful programming paradigms)

96.10 What are the advantages to using Ring over C# or Java?

1. Compact Code (Clean and Natural), More Productivity and Flexibility.

2. Better support for Declarative Programming and Natural Programming

96.11 The documentation says functional programming is sup-

ported, but then this happens?

The question was about this code

f = func {
a = 42
return func { return a }
}

innerF = call f()

call innerF()

Output:
Using uninitialized variable : a In function _ring_anonymous_func_16601()

The Answer:
Its Anonymous Functions, i.e. Not Closures.
Many developers asked about supporting Closures and during language development we may add new features
that doesnt 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 dont get everything from everywhere to be like others! We dont 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. Dont 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. its the sprite and
ability behind all of the features together.

96.9. What are the advantages to using Ring over Tcl or Lua? 1695
 Ring Documentation, Release 1.5

96.12 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?

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

96.13 Why you can specify the number of loops you want to break
out of?

The language supports 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 poorly code in any language if he/she wants to
do that. The idea is what must be done in 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. Im 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).

96.14 Why Ring uses See, Give, But and Ok Keywords?

See and Give are selected not to be opposite actions but to reflect what I want to do as a programmer.
When I want to see something on the screen I use See.
When I want to give some input to the program I use Give.
My selection of but and ok is based on selecting keywords that can be written quickly.
Also using but is easy to remember than elseif/elif/elsif where each language select a different keyword.
In Ring 1.1 and later versions All of this is just an option.
You can use Put and Get instead of See and Give
You can use elseif and end insetad of But and Ok
Its your choice. In Ring we have syntax flexibility where we provide more than one style.
Also you can change the language keywords and operators.
Also you can define new natural languages too.

96.15 What is the philosophy behind data types in Ring?

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.

96.12. Why the ability to define your own languages Instead of just handing over the syntax so1696
you
can parse it using whatever code you like?
 Ring Documentation, Release 1.5

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
So We have
A small and simple language that someone can pick in little days
A fast language that provide primitive types (String ? Number ? List ? Object)
A flexible language that can be extended using OOP to add new types according to the application domain

96.16 What about the Boolean values in Ring?

You can use true for 1 and false for 0

when you test the result of Boolean expressions in your code.
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
1. Number
2. String
3. List
4. 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.

96.16. What about the Boolean values in Ring? 1697

 Ring Documentation, Release 1.5

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

96.17 What is the goal of including the Main function in Ring?

The main function is very important, you need it when you want to write statements that uses local variables instead
of the Global scope.
Example:
x = 10
myfunc()
See "X value = " + X # here I expect that x will be (10)
# but I will get another value (6) because myfunc() uses x !
Func myfunc
for x = 1 to 5
See x + nl
next

Output:
1
2
3
4
5
X value = 6

Now using the Main function

Func Main
x = 10
myfunc()
See "X value = " + X

Func myfunc
for x = 1 to 5
See x + nl
next

Output
1
2
3

96.17. What is the goal of including the Main function in Ring? 1698
 Ring Documentation, Release 1.5

4
5
X value = 10

96.18 Why the list index start from 1 in Ring?

Its about how we count in the real world, when we have three apples in our hand
we say 1 2 3
We dont start from 0
The question must be why the other languages start from 0 ?
The answer is, because this is related to the machine and how we deal with values and memory address.
Example
we have array called myarray[5]
In memory : myarray will have an address
The first item will be stored in that address
The second item will come after that address and so on
Now when we need to point to the first item we need the address of myarray
So we type myarray[0] because myarray + 0 result will still point to the first item
for the second item myarray[1] because myarray + 1 result will point to the second item and so on
In Low Level languages or languages near to the machine its good to be like this
But for high level language designed for applications its better to be natural
Example
mylist = [1,2,3,4,5]
for x = 1 to len(mylist)
see x + nl
next

In the previous example we start from 1 to the length of the array if the index starts from 0 we will write
for x = 0 to len(mylist)-1

or remember the for loop in other languages

for(x=0 ; x<nMax ; x++ )

You will use the < operator !

96.19 Why Ring is not case-sensitive?

1. To be more human-friendly
2. Like Ada, SQL, Pascal, Delphi, Visual Basic, Visual FoxPro, etc.
3. To help in supporting Natural Language Programming.

96.18. Why the list index start from 1 in Ring? 1699

 Ring Documentation, Release 1.5

4. To be able to select your favorite style when writing the language keywords
see "lower case!"

SEE "UPPER case!"

See "First Letter is UPPER case!"

5. To avoid getting error message when writing quick tests then type variable instead of Variable.
6. To avoid getting error message when you type Dosomething() instead of doSomething()
7. In Ring, No conflict between Variables, Method Names & Classes Names
We can write person as variable name and Person as class name.
person = new Person
class Person
name address phone

96.20 Why the Assignment operator uses Deep Copy?

Because its a poor tradeoff to add complexity for dubious performance gains, a good approach to deep vs. shallow
copies is to prefer deep copies until proven otherwise.
, Steve McConnell, Code Complete
1. Its more natural, When you use the assignment operator, You expect a deep copy.
2. If you dont need a deep copy, Just dont use it!
3. The Ring language is designed to reduce references usage as much as possible.
4. The Ring language is designed to make using references simple and possible in special cases where this make
sense.
5. We have references when this is natural, like passing lists and objects to functions, creating objects (Like
GUI Objects) from a C/C++ library, returning an object stored inside a list.
6. It is a feature, We can use it to create pure functions. The Value() function in the stdlib uses this feature to
pass lists & objects by value when we need this.
7. When we need references, Its recommended to create a class that manage sharing lists and objects.
8. Its more safe at the application level to avoid many logical errors.
9. In Ring, we start without thinking about the little details and concentrate on the application, You dont
have to write the type (Dynamic Typing), You dont have to write explicit conversions between numbers
and strings (Weakly Typed) and you dont have to select between using values or references, You dont
have to write the scope (Lexical Scoping).
10. In Ring, we have smart garbage collector (Simple & Fast), We can delete the memory directly at any
time using the Assignment operator too. Reducing references usage or using them through managers
helps a lot to achieve this goal. by doing this we have full control.
11. If you want to create references and avoid creating a manager, You can use Object2Pointer() and Pointer2Object() functio
But Its not the Ring way Sprite to do things.

96.20. Why the Assignment operator uses Deep Copy? 1700

 Ring Documentation, Release 1.5

96.21 Is there constructor methods in Ring?

When you create new object for example

new point

1 - Ring will allocate dynamic memory space to be used for the new object attributes that Ring doesnt know anything
about them.
2 - Ring will change the current local scope and the current object scope to use the object state created in step (1)
3 - Ring will move the execution to the class Region (After the class name and before any methods)
4 - Any Instructions/Code in the class region will be executed as any Ring code
5 - Control is moved from the class region to the location of (new point) once we reach the end of the class region or
we uses a Return command.
So All attributes that added to the object are dynamic attributes, this mean that you can control what attributes will be
added through the runtime.
Example:
$3D = False
see new point
$3D = True
see new point

class point
x y
if not $3D return ok
z

Output:
x: NULL
y: NULL
x: NULL
y: NULL
z: NULL

You have an option to call init() method directly when you create a new object
This method can do anything with the object attributes as it will be called after creating the object and executing the
class region code.
p1 = new point3d(100,200,300)
see p1

class point3d
x y z
func init p1,p2,p3
x=p1 y=p2 z=p3

96.22 What happens when we create a new object?

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

96.21. Is there constructor methods in Ring? 1701

 Ring Documentation, Release 1.5

2- Ring dont 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.
Example:
o1 = new point {x=10 y=20 z=30}
o2 = new point {x=100 y=200 z =300}

addmethod(o1,"print", func { see x + nl + y + nl + z + nl } )

o1.print()
o2.print()

class point x y z

Output:
10
20
30
100
200
300

96.23 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. Its your choice.
Example:
o1 = new Developer
o1.name = "Mahmoud" see o1.name + nl
o1 { name = "Gal" see name }
o1 { name = "Bert" see name }

o1.setname("Marino")
see o1.getname()

Class Developer

name language = "Ring Programming Language"

func setname value

see "Message from SetName() Function!" + nl
name = value + " - " + language

func getname
see "Message from GetName() Function!" + nl + nl
return "Mr. " + name + nl

Output

96.23. Can we use the attributes by accessing the Getter and Setter methods? 1702
 Ring Documentation, Release 1.5

Message from SetName() Function!

Message from GetName() Function!

Mr. Mahmoud - Ring Programming Language

Message from SetName() Function!

Message from GetName() Function!

Mr. Gal - Ring Programming Language

Message from SetName() Function!
Message from GetName() Function!

Mr. Bert - Ring Programming Language

Message from SetName() Function!
Message from GetName() Function!

Mr. Marino - Ring Programming Language

96.24 Why should a search of global names be made while defining

the class attributes?

The question is why we dont avoid conflicts with global variable names when we define the class attributes ?
At first remember that using the optional $ mark in the global variables names solve the problem. Also using the Main
function and avoiding global variables may help.
The Answer:
Ring is a dynamic language
We can in the run-time determine the class attributes (Add/Remove)
We can execute (any code) while defining the class attributes
Example (1)
oPerson = new Person
Class Person
See "Welcome to the Ring language"

Example (2)
Customize attributes based on global variable value
$debug = true
oPerson = new Person
see oPerson
Class Person
if $debug date=date() time=time() ok

In the previous example when we have the $debug flag set to true, we will add the Date and Time attributes to the
object state.
Example (3)
Store the object index based on global variable

96.24. Why should a search of global names be made while defining the class attributes? 1703
 Ring Documentation, Release 1.5

$ObjectsCount = 0
oPerson = new Person
see oPerson
oPerson2 = new Person
see oPerson2
Class Person
$ObjectsCount++
nIndex = $ObjectsCount

Output:
nindex: 1.000000
nindex: 2.000000

Common Example:
Connect to the database then get table columns (Using global Variable/Object).
Create class attributes based on the column names.
Later when you modify the database - you may dont need to modify your code.
Its flexibility but remember that power comes with great responsibility.

96.25 Why Ring doesnt avoid the conflict between Global Variables
and Class Attributes Names?

In this use case we have

1 - Global Variable defined without a special mark like $
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 dont 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 dont like changing the feature number (2) because I like this feature and I dont like forcing the programmer to type
self.attribute
I dont like changing the feature number (3) because its 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.

96.25. Why Ring doesnt avoid the conflict between Global Variables and Class Attributes Names?
1704