Introduction
Each programming language comes with it's style and syntax, where the programmer need to know about the language keywords, operators and rules. After many years of programming each programmer maybe used a lot of programming languages with different styles. At this stage each programmer may prefer a different syntax and find that this syntax is more natural, simple and/or productive.
Why the programming language force the programmer to use a specific syntax?
* Easy to Implement.
* Faster Implementation.
* Easy to read and understand programs written in the language.
What are the advantages/disadvantage of each different syntax?
* Some styles are easy to write.
* Some styles are natural (easy to read and understand)
Why some programmers like/dislike some languages because of it's syntax?
* Because they know another style that match their expectation in a better way.
What is your favorite syntax and why?
* I prefer natural styles that uses special keywords but I discovered that other styles are faster to write.
Note : Fell free to answer the previous questions and add more ideas/knowledge from your experience.
Background
As someone who used many programming language during the last years, I can say that some languages are simlar and some languages are very different. Many languages share the same concepts, Solve the same problem and use the same programming paradigms, but use a different syntax, tricks, libraries, frameworks and tools. To be a good programmer you may need to learn about different languages that uses different programming paradigms and let you think different about how to solve your problems in a better way.
In this article i will focus on one thing (The Syntax) and one programming language (The Ring Programming Language) and how this language provide different styles in the Syntax and enable the programmer to change the language keywords and operators. How to use different syntax styles in the same program. When and why this maybe useful. (You can download Ring from : http://ring-lang.net and the language source code from : https://github.com/ring-lang/ring )
Some other languages may use Preprocessor to support something like that. Some other language may use Syntax Sugar and Operator Overloading to work around this, But the Ring programming language comes with it's solution in a simple and direct way so you can do something useful from these features.
The Story
When I released Ring 1.0 in 2016.01.25, a lot of my friends (developers and programmers using many different languages) said that (I like the language concepts but I'm not very happy with the language syntax, could you change the syntax?). I asked them why? each one provided different answer like
* I want to use another keywords!
* I prefer braces { } over writing a specific keyword to end each control structure.
* I prefer using the 'end' keyword to close each control structure.
* I want to use Arabic keywords.
And many other things like that. Each one like the Syntax of a different language and want to use the Ring language concepts but still happy with his/her favorite syntax.
Using the code
The next program presents the "Hello, World!" program in the Ring language version 1.0
See "Hello, World!" + nl
The See keyword is used to print some output on the screen. Ring 1.0 uses See and Give for printing the output and getting the input from the user.
Ring 1.1 support another style too like
Put "Hello, World!" + nl
So using 'Put' and 'Get' we can print the output and get the Input.
Another style also provided by Ring 1.1
load "stdlib.ring"
print("Hello World")
So the first style (See/Give) was the start (trying to be natural to users), The second style (Put/Get) was an update (Trying to be more natural to native English speakers), The third style, Using stdlib.ring and print() function trying to be natural to programmers (Libraries/Functions instead of commands).
So what is the difference ?
(1) : Using See/Put is faster than using print() because the command comes with a special instruction in the Virtual Machine instructions set. While the print() function just call the See/Put command so we have the overhead of calling a function before calling the print instruction using See/Put.
(2) : The print() function is written in Ring, so you can easily modify this function.
(3) : The print() function accept escape characters like "\n" and "\t" while the See/Put commands doesn't provide this feature (more faster).
Now let us see the different styles for control structures
The First Style (Special Keywords to end each control structure)
if Expression
Block of statements
but Expression
Block of statements
else
Block of statements
ok
switch Expression
on Expression
Block of statements
other
Block of statements
off
while Expression
Block of statements
end
for identifier=expression to expression [step expression]
Block of statements
next
for identifier in List/String [step expression]
Block of statements
next
do
Block of statements
again expression
The Second style (Use the end keyword to close each control structure)
if Expression
Block of statements
elseif Expression
Block of statements
else
Block of statements
end
switch Expression
case Expression
Block of statements
else
Block of statements
end
while Expression
Block of statements
end
for identifier=expression to expression [step expression]
Block of statements
end
for identifier in List/String [step expression]
Block of statements
end
try
Block of statements
catch
Block of statements
end
The third style (uses braces)
if Expression {
Block of statements
elseif Expression
Block of statements
else
Block of statements
}
switch Expression {
case Expression
Block of statements
else
Block of statements
}
while Expression {
Block of statements
}
for identifier=expression to expression [step expression] {
Block of statements
}
for identifier in List/String [step expression] {
Block of statements
}
To change the language keywords
ChangeRingKeyword <oldkeyword> <newkeyword>
To change the language operator
ChangeRingOperator <oldoperator> <newoperator>
Example:
changeringoperator + plus
changeringkeyword SEE PRINT
Print 5 plus 5
You may store a group of ChangeRingKeyword and ChangeRingOperator commands in a file to use later in many source files.
File : StyleBasicOn.ring
ChangeRingKeyword see print
ChangeRingKeyword ok endif
ChangeRingKeyword next endfor
ChangeRingKeyword end endwhile
File : StyleBasicOff.ring
ChangeRingKeyword print see
ChangeRingKeyword endif ok
ChangeRingKeyword endfor next
ChangeRingKeyword endwhile end
Example:
LoadSyntax "stylebasicon.ring"
x = 10
while x > 0
print "x = " + x + nl
for t = 1 to 10
if t = 3
print "number three" + nl
endif
endfor
x--
endwhile
LoadSyntax "stylebasicoff.ring"
see "done" + nl
Output:
x = 10
number three
x = 9
number three
x = 8
number three
x = 7
number three
x = 6
number three
x = 5
number three
x = 4
number three
x = 3
number three
x = 2
number three
x = 1
number three
done
Note (1) : You can mix between styles in the same file.
Note (2) : Each file in the project may uses a different style
Note (3) : You can use eval() to execute code inside a string and change keywords/operators while using eval() only.
Points of Interest
(1) We can translate the language (English Keywords) to other languages and use for example Arabic/French Keywords.
(2) We can port code written in other languages to Ring and support these languages from Ring (other features are provided to help in doing this but not covered in this article to keep it small and simple).
(3) We can mix between styles in the same project where each programmer may use his/her favorite style in his/her code. This may help when each programmer work on his/her tasks alone like developing a library that others may use but not modify.
(4) Each team may use one style for the project, but this style is defined based on customization that match this team sprite.
(5) You can test different styles in the same language. This will give you better understanding about each style (Advantages and Disadvantages).
History
Ring 1.0 is released on 2016.01.25 with one syntax (no syntax flexibility).
Ring 1.1 is released on 2016.10.06 with many new features includes (Syntax Flexiblity).
