Click here to Skip to main content
13,146,376 members (46,316 online)
Click here to Skip to main content
Add your own
alternative version

Stats

6.4K views
72 downloads
2 bookmarked
Posted 12 Oct 2016

Natural Language Programming in the Ring Programming Language

, 12 Oct 2016
Rate this:
Please Sign up or sign in to vote.
Defining Natural Languages in the Ring programming language based on Object-Oriented Programming.

Introduction

In 2010, I developed a new programming language called Supernova. This language uses a code that looks similar to Natural Language statements to create simple GUI applications. After five years, In the Ring programming language, we can get similar results, but now we have the ability to create/use code similar to Natural language statements in any domain that we like or need.

The Ring programming language comes with the Supernova sprite, but with more generalization and with mix of other languages sprites.

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.

Using the Ring programming language, we can create Natural programming languages based on classes and objects.

In Supernova language we 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 we need a new language that are

  1. General Purpose
  2. Practical
  3. Can create Natural Languages very quickly.

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

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 the Ring language after the Supernova language.

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.

Why Natural Language Programming, We can do anything using Imperative, Object-Oriented and Functional Languages?

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 Languages is that they are Context Sensitive and this means we can use it and think different about how we can express our ideas.

Example (1) : 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. 

Example (2) : Accept 2 numbers then print the sum

 

Background

You can check this article about the Supernova programming language and this article about the Ring programming language.

Also check the next Tutorials about the Ring programming language

(1) Getting Started

(2) Control Structures

(3) Functions

(4) Lists

(5) Classes

Features in Ring language that help in supporting Natural Language

(1) Compact Syntax, No explicit end for statements (No ; or ENTER is required)

Example:

See "What is your name? " give cName see "Hello " + cName

Or in another style 

Put "What is your name? " Get cName Put "Hello " + cName

(2) Using braces { } we can access objects and use the attributes/methods directly as variables/functions

Example:

New point                       # create new object using the point class
{                               # access the new object attributes and methods
        x = 10                  # set the x attribute to 10
        y = 20                  # set the y attribute to 20
        z = 30                  # set the z attribute to 30
        print()                 # call the print method
}                               # end of object access


Class Point                     # define the Point class
        x y z                   # the class contains three attributes x, y & z
        func print              # define the print method
                see x + nl +    # print the x attribute
                    y + nl +    # print the y attribute
                    z + nl      # print the z attribute

(3) We can define methods to be used when we set and get object attributes.

Example:

o1 = new person

o1.name = "Mahmoud"  see o1.name + nl

o1 { name = "Ahmed"  see name }

Class Person

        name family = "Fayed"

        func setname value
                see "Message from SetName() Function!" + nl
                name = value + " " + family

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

Output:

Message from SetName() Function!
Message from GetName() Function!
Mr. Mahmoud Fayed
Message from SetName() Function!
Message from GetName() Function!
Mr. Ahmed Fayed

Using the code

The next example presents how to create a class that define two instructions

The first instruction is : I want window

The second instruction is : Window title = <expr>

Also keywords that can be ignored like the ‘the’ keyword

New App
{
    I want window
    The window title = "hello world"
}

Class App

    # Attributes for the instruction I want window
        i want window
        nIwantwindow = 0
    # Attributes for the instruction Window title
    # Here we don't define the window attribute again
        title
        nWindowTitle = 0
    # Keywords to ignore, just give them any value
        the=0

    func geti
        if nIwantwindow = 0
            nIwantwindow++
        ok

    func getwant
        if nIwantwindow = 1
            nIwantwindow++
        ok

    func getwindow
        if nIwantwindow = 2
            nIwantwindow= 0
            see "Instruction : I want window" + nl
        ok
        if nWindowTitle = 0
            nWindowTitle++
        ok

    func settitle cValue
        if nWindowTitle = 1
            nWindowTitle=0
            see "Instruction : Window Title = " + cValue + nl
        ok

Output

Instruction : I want window
Instruction : Window Title = hello world

What if we want to connect between the two instructions using ‘and’

We have a problem because in Ring ‘and’ is a keyword

We can change that using the ChangeRingKeyword command.

The ChangeRingKeyword command is executed in the scanner stage by the compiler (before parsing).

Note : Remember to restore the keyword again

Syntax:

ChangeRingKeyword  <oldkeyword>  <newkeyword>

Example :

ChangeRingKeyword       and  _and

New App
{
                I want window and the window title = "hello world"
}

Class App

                # Attributes for the instruction I want window
                                i want window
                                nIwantwindow = 0
                # Attributes for the instruction Window title
                # Here we don't define the window attribute again
                                title
                                nWindowTitle = 0
                # Keywords to ignore, just give them any value
                                the=0  and=0

ChangeRingKeyword       _and  and

                func geti
                        if nIwantwindow = 0
                                nIwantwindow++
                        ok

                func getwant
                        if nIwantwindow = 1
                                nIwantwindow++
                        ok

                func getwindow
                        if nIwantwindow = 2
                                nIwantwindow= 0
                                see "Instruction : I want window" + nl
                        ok
                        if nWindowTitle = 0
                                nWindowTitle++
                        ok

                func settitle cValue
                        if nWindowTitle = 1
                                nWindowTitle=0
                                see "Instruction : Window Title = " + cValue + nl
                        ok

                func getand
                        see "Using : and" + nl

Output

Instruction : I want window
Using : and
Instruction : Window Title = hello world

What if we want to define a new behavior for any operator like the “=” operator.

We can do this change using the ChangeRingOperator command to hide operator (change it’s name)

Then we can use the operator as identifier that we can handle it’s behaviour

Syntax:

ChangeRingOperator  <oldoperator>  <newoperator>

Now we will change the ‘=’ operator to ‘is’

Example:

ChangeRingKeyword       and  _and
ChangeRingOperator      =    is

New App
{
                I want window and the window title is "hello world"
}

ChangeRingOperator      is    =

Class App

                # Attributes for the instruction I want window
                                i want window
                                nIwantwindow = 0
                # Attributes for the instruction Window title
                # Here we don't define the window attribute again
                                title
                                nWindowTitle = 0
                # Keywords to ignore, just give them any value
                                the=0  and=0

ChangeRingKeyword       _and  and

                func geti
                        if nIwantwindow = 0
                                nIwantwindow++
                        ok

                func getwant
                        if nIwantwindow = 1
                                nIwantwindow++
                        ok

                func getwindow
                        if nIwantwindow = 2
                                nIwantwindow= 0
                                see "Instruction : I want window" + nl
                        ok
                        if nWindowTitle = 0
                                nWindowTitle++
                        ok

                func settitle cValue
                        if nWindowTitle = 1
                                nWindowTitle=0
                                see "Instruction : Window Title = " + cValue + nl
                        ok

Eval() Function

We can execute code during the runtime from string using the Eval() function

Syntax:

Eval(cCode)

Example:

Eval("nOutput = 5+2*5 " )
See "5+2*5 = " + nOutput + nl
Eval("for x = 1 to 10 see x + nl next")
Eval("func test see 'message from test!' ")
test()

Output:

5+2*5 = 15
1
2
3
4
5
6
7
8
9
10
message from test!

Using Eval() with our Natural Code

func Main

  cProgram = ' I want window and the window title is "hello world" '

  MyLanguage(cProgram)

Func MyLanguage cCode

  # We add to the code the instructions that change keywords and operators
  # Because Eval() uses a new Compiler Object (the original keywords and operatos).

  cCode = '
        ChangeRingKeyword  and  _and
        ChangeRingOperator  =    is
  ' + cCode

  New App
  {
          eval(cCode)
  }


  Class App

          # Attributes for the instruction I want window
                  i want window
                  nIwantwindow = 0
          # Attributes for the instruction Window title
          # Here we don't define the window attribute again
                  title
                  nWindowTitle = 0
          # Keywords to ignore, just give them any value
                  the=0

          ChangeRingKeyword  and  _and
                  and=0
          ChangeRingKeyword  _and  and

          func geti
                if nIwantwindow = 0
                  nIwantwindow++
                ok

          func getwant
                if nIwantwindow = 1
                  nIwantwindow++
                ok

          func getwindow
                if nIwantwindow = 2
                  nIwantwindow= 0
                  see "Instruction : I want window" + nl
                ok
                if nWindowTitle = 0
                  nWindowTitle++
                ok

          func settitle cValue
                if nWindowTitle = 1
                  nWindowTitle=0
                  see "Instruction : Window Title = " + cValue + nl
                ok

BraceStart() and BraceEnd()

We can write code that will be executed before/after using { }

Example:

o1 = new test {
        see "Hello" + nl
}

o1 {}

class test

        func bracestart
                see "start" + nl

        func braceend
                see "end" + nl

Output:

start
Hello
end
start
end

Using BraceExprEval() 

The next example demonstrates how to use the “BraceExprEval” method to get expressions in Natural code.

Example:

new natural {
        create 5
}

class natural
        create=0
        lkeyword = false
        func braceexpreval r
                if lkeyword lkeyword=false return ok
                see "expr eval" + nl
                see "type: " + type(r) see nl
                see "value : " see r see nl
        func getcreate
                lkeyword = true
                see "create" + nl

Output:

create
expr eval
type: NUMBER
value : 5

Real Natural Code

The next example is a more advanced example

# Natural Code
new program {
        Accept 2 numbers then print the sum
}

# Natural Code Implementation
class program
        # Keywords
                Accept=0 numbers=0 then=0 print=0 the=0 sum=0

        # Execution
        func braceexpreval x
                value = x
        func getnumbers
                for x=1 to value
                        see "Enter Number ("+x+") :" give nNumber
                        aNumbers + nNumber
                next
        func getsum
                nSUm = 0
                for x in aNumbers nSum+= x next
                see "The Sum : " + nSum
        private
                value=0 aNumbers=[]

Output:

Enter Number (1) :3
Enter Number (2) :4
The Sum : 7

Using BraceError()

The next examples demonstrates how to use the “BraceError” method to handle errors when accessing the object using braces {}.

Example:

func main
        o1 = new point {
                x=10 y=20 z=30
                TEST
                SEE test
        }

class point x y z
        func braceerror
                see "Handle Error!" + nl
                SEE "Message :" + cCatchError + nl
                if ( left(cCatchError,11) = "Error (R24)" ) and not isattribute(self,"test")
                        see "add attribute" + nl
                        addattribute(self,"test")
                        test = 10
                ok
                see "done" + nl
                return

Output:

Handle Error!
Message :Error (R24) : Using uninitialized variable : test
add attribute
done
10

Example:

new point {
        x=10 y=20 z=30
        test()
        see "mmm..." + NL
}

class point x y z
        func braceerror
                see "Handle Error!" + nl
                see "Message :" + cCatchError + nl
                see self
                see "Done" + NL

Output:

Handle Error!
Message :Error (R3) : Calling Function without definition !: test
x: 10.000000
y: 20.000000
z: 30.000000
Done
mmm...

Clean Natural Code

Instead of typing the literal as “literal” we can accept the words directly.

Example:

The next example accept hello world instead of “hello world”

ChangeRingKeyword       and  _and
ChangeRingOperator      =    is

New App
{
        I want window and the window title is hello world
}

ChangeRingOperator      is    =

Class App

        # Attributes for the instruction I want window
                        i want window
                        nIwantwindow = 0
        # Attributes for the instruction Window title
        # Here we don't define the window attribute again
                        title
                        nWindowTitle = 0
        # Keywords to ignore, just give them any value
                        the=0  and=0
        # Data
                        literal = ""

ChangeRingKeyword       _and  and

        func geti
                if nIwantwindow = 0
                        nIwantwindow++
                ok

        func getwant
                if nIwantwindow = 1
                        nIwantwindow++
                ok

        func getwindow
                if nIwantwindow = 2
                        nIwantwindow= 0
                        see "Instruction : I want window" + nl
                ok
                if nWindowTitle = 0
                        nWindowTitle++
                ok

        func settitle cValue
                if nWindowTitle = 1
                        nWindowTitle=2
                ok

        func braceend
                if nWindowTitle = 2
                        see "Instruction : Window Title = " + literal + nl
                        nWindowTitle = 0
                ok

        func braceerror
                c= substr(cCatchError,":")
                while c > 0
                        c= substr(cCatchError,":")
                        cCatchError=substr(cCatchError,c+1)
                end
                literal += substr(cCatchError,1)

 

 

Points of Interest

In 2010 I developed the Supernova language in 9 months, Now using Ring I can implement a language like Supernova in little days. The ability to define natural languages based on classes instead of creating a compiler is a big deal. This increase the productivity and decrease the complexity of the problem. You can create large natural programming language and still control the project. Think of implementing your next natural programming language using Ring! 

History

There are many great work done in Natural Programming Languages, The Ring programming language is a practical programming language that try to push Natural Language Programming a step forward. Ring is a new language released on 2016.01.25

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Share

About the Author

No Biography provided

You may also be interested in...

Pro
Pro

Comments and Discussions

 
GeneralMy vote of 5 Pin
Cryptonite14-Aug-17 5:42
memberCryptonite14-Aug-17 5:42 
GeneralRe: My vote of 5 Pin
Mahmoud Samir Fayed15-Aug-17 11:40
memberMahmoud Samir Fayed15-Aug-17 11:40 
QuestionThoughts Pin
Nelek10-Aug-17 3:37
protectorNelek10-Aug-17 3:37 
AnswerRe: Thoughts Pin
Mahmoud Samir Fayed10-Aug-17 7:54
memberMahmoud Samir Fayed10-Aug-17 7:54 
GeneralMy vote of 5 Pin
Mr. Tamer Radwan15-Oct-16 22:08
memberMr. Tamer Radwan15-Oct-16 22:08 
GeneralRe: My vote of 5 Pin
Mahmoud Samir Fayed16-Oct-16 21:44
memberMahmoud Samir Fayed16-Oct-16 21:44 
QuestionAwesome Pin
martin.nedopil12-Oct-16 22:24
membermartin.nedopil12-Oct-16 22:24 
AnswerRe: Awesome Pin
Mahmoud Samir Fayed12-Oct-16 22:36
memberMahmoud Samir Fayed12-Oct-16 22:36 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Praise Praise    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

Permalink | Advertise | Privacy | Terms of Use | Mobile
Web01 | 2.8.170915.1 | Last Updated 13 Oct 2016
Article Copyright 2016 by Mahmoud Samir Fayed
Everything else Copyright © CodeProject, 1999-2017
Layout: fixed | fluid