DEV Community: Mohammad Amin Khakzadan

What is your comment about this programming language syntax?

Mohammad Amin Khakzadan — Thu, 10 Oct 2019 21:16:05 +0000

I'm working on a new programming language. I wrote some parts of the compiler. One time in java and one time in C and here is the source code.

I want to show you a piece of the language syntax, so comment on me about this syntax. I think you can understand the code is what about, but if you have a question ask me.

# comments

#- multi-line comments

builtins types:
    int                     123
    float                   1.23
    char                    'a'
    string                  "Hi"
    [int, char]             [10, 'a']            <- an array of one int and one
                                                    char
    array[int]              [10, 20, 30]         <- an array of ints
    {a: int, b: char}       {a = 10, b = 'a'}    <- a named tuple or structure
    function                def (a) = (a)        <- a lambda or function
    boolean                 true || false
    null                    null
-#

# any value type can be stored in a
var a = 100
a = "Hi"
a = 1.23

type null_string = null | string

# c can be null or a string
var c: null_string = null
c = "Hi"

def type uint = (self ?= int) && (self >= 0)

# the following line will throw a compiler error
# var b: uint = -100

# immutable variable
const d = 10

# lazy evaluation variable
let e = c + " World"

c = "Hello"
var f = e       # f == "Hello World"

let g = c

g = "Goodbye"
f = e           # f == "Goodbye World"


def range(const start: int, const end: int; const step: int = 1): array[int]
    var i = start

    if step >= 0
        let not_end = (i < end)
    if step < 0
        let not_end = (i > end)
    end

    while not_end
        yield i
        i += step
    end
end

def sum(var *args: int): int
    var sum: int = 0
    for var i = 0; i < args.len; i += 1
        sum += args[i]
    end
    return sum
end

def main(args: array[string])

    # print sum of 1 to 500
    print(sum(*range(1, 500)))

end

Write lisp in python

Mohammad Amin Khakzadan — Thu, 04 Jul 2019 12:29:32 +0000

I recently thought about how I can merge lisp programming language and python, and tried to write a lisp syntax like compiler in python. Some thing that can convert the following lisp code:

(repeat 2 (write-ln (+ 10 20)))

to this tree:

word: "repeat"
    int: 2
    word: "write-ln"
        symbol: +
            int: 10
            int: 20

And then write an executor for executing tree.

But I figured out that I don't need to write a lisp syntax parser. Instead I can use python builtins types directly.

for example:

('repeat', ('print', ('add', 10, 20)))

And then the result of my thoughts was that I wrote this simple python builtins types compiler. (pbtc for shorthand)

#!/usr/bin/python3

# filename: main.py

import itertools
import sys

def add(*args):
    result = args[0] if len(args) != 0 else None
    for arg in args[1:]:
        result += arg
    return result

def sub(*args):
    result = args[0] if len(args) != 0 else None
    for arg in args[1:]:
        result -= arg
    return result

def mul(*args):
    result = args[0] if len(args) != 0 else None
    for arg in args[1:]:
        result *= arg
    return result

def div(*args):
    result = args[0] if len(args) != 0 else None
    for arg in args[1:]:
        result /= arg
    return result

def true_div(*args):
    result = args[0] if len(args) != 0 else None
    for arg in args[1:]:
        result //= arg
    return result

def join(sep, args):
    return sep.join(args)

tuple_compilers = {
    'add': add,
    'sub': sub,
    'mul': mul,
    'div': div,
    'tdiv': true_div,
    'print': lambda *args: print(*args),

    'join': join,
    'repeat': itertools.repeat,
}

def compile_tuple(tree, memory, compile):
    if len(tree) == 0:
        raise ValueError('invalid tuple length: {}'.format(len(tree)))
    if not isinstance(tree[0], str):
        raise ValueError('invalid tuple instruction: {}'.format(tree[0]))
    if tree[0] not in tuple_compilers:
        raise ValueError('unknown tuple instruction: {}'.format(tree[0]))
    args = []
    for node in tree[1:]:
        args.append(compile(node, memory))
    return tuple_compilers[tree[0]](*args)

compilers = {
    tuple: compile_tuple,
    (list, dict, str, int, float, bytes): 
        lambda tree, memory, compile: tree,
}

def compile_tree(tree, compilers, memory = None):
    self = lambda tree, memory: compile_tree(tree, compilers, memory)
    for _type, compile in compilers.items():
        if isinstance(tree, _type):
            return compile(tree, memory, self)
    raise TypeError(type(tree).__name__)

with open(sys.argv[1]) as infile:
    globals_dict = {}
    exec('grammar = ' + infile.read())

compile_tree(grammar, compilers)

it's not safe, it's slow, but works.

testing:


# filename: lispy

('print', 
    ('join', ' ', ('repeat', ('join', ' ', ['hi', 'bye']), 10))
    )

$./main.py lispy:

hi bye hi bye hi bye hi bye hi bye hi bye hi bye hi bye hi bye hi bye

It's fun...

Maybe later, I wrote a more complete version of this and publish it somewhere, as open source.

Write Code That Writes Code

Mohammad Amin Khakzadan — Thu, 13 Jun 2019 16:50:06 +0000

We always write codes with our fingers, we always type on our keyboards, and we work hours and hours to create computer programs.

But things we write can be written by a computer. and currently, programming languages like C, C++, Python, Java, ... in the final compilation step will be translated to the machine byte codes, and that means programs that write codes.

But this should not be the end. We must write programs that can write codes in other programming languages like C, C++, Python, java, ruby or whatever else.

maybe that be a new programming language or some frameworks that change code structure or a text stream processor that translate text to something else.

I will show you a simple example for every subject I've mentioned, but that is not the only way you can do it.

a new programming language

During the time, we always hear about new programming languages that provide a set of features and obey a design philosophy, but most of them always copying other programming language principles, and they can't be used for the everyday use cases. But if we forget them, and try to create a new programming language from the zero ground with our creativity, that will bring us a whole of new ideas to accomplish our goals.

for example, think you want to make a simple text editor, a programming language for that purpose can be something like this:

OpenWindow
{
    text_area: TextArea[editable, fullsize]
    KeyPress('CTRL+s') =>
    {
        path = AskPath('Save As', 'Save', 'Cancel)
        open(path, 'wt').write(text_area.text)
    }
    KeyPress('CTRL+o') =>
    {
        path = AskPath('Open', 'Open', 'Cancel)
        text_area.text = open(path).read()
    }
}

or maybe you be an artist and want to draw some pixel arts:

use random, new_image

image = new_image([500, 500])
image.fill('Navy Blue')

repeat (40)
{
    image.draw_dot(
        random.position_range([0, 0], [image.width, 300]),
        random.color_range('bw:200', 'bw:256')
    )
}

image.draw_rectangle([0, 300], image.size, 'Dark Blue')

repeat(10)
{
    start = random.position_range([40, 200], [image.width - 40, 300])
    end = [start.x + random.choice(1, -1) * random.range(20, 35), 300]
    image.draw_rectangle(start, end, 'Dark Blue')
}

Can you guess what the program will draw?

or some programming languages like this one:

set total_words to zero.
open "article.txt" then,
    for each line,
        add number of words in line to total_words.
    end.
end.
print total_words.

Metaprogramming

If you understand how compilers work, what's really going on is not so much that Lisp has a strange syntax as that Lisp has no syntax. You write programs in the parse trees that get generated within the compiler when other languages are parsed. But these parse trees are fully accessible to your programs. You can write programs that manipulate them. In Lisp, these programs are called macros. They are programs that write programs.

Programs that write programs? When would you ever want to do that? Not very often, if you think in Cobol. All the time, if you think in Lisp. It would be convenient here if I could give an example of a powerful macro, and say there! how about that? But if I did, it would just look like gibberish to someone who didn't know Lisp; there isn't room here to explain everything you'd need to know to understand what it meant. In Ansi Common Lisp I tried to move things along as fast as I could, and even so I didn't get to macros until page 160.

source link: https://stackoverflow.com/questions/514644/what-exactly-is-metaprogramming

or a framework that can edit program structure, an example in python:

from auto_code_gene import python as py
import sys

writer = py.PyWriter(sys.stdout)
node = \
py.Function('parse_argv', 'argv', [
    py.For('arg', 'argv', [
        py.If("len(argv) == 0", [
            py.Raise('ValueError', py.Str('empty argument')),
        ]),
        py.If("arg == '-'", [
            py.Pass()
        ])
    ])
])

node.write(writer)

result:

def parse_argv(argv):
    for arg in argv:
        if len(argv) == 0:
            raise ValueError('empty argument')
        if arg == '-':
            pass

text stream processor

some programs that can translate this text:

INC stdlib.h
ST buffer:
    char *pntr, size_t start, size_t len, size_t size
    FN ${buffer}, allocate_buffer,
        pntr = malloc($size), start = 0, len = 0, size = $(size)

to this C file:

#include <stdlib.h>

struct buffer
{
    char *pntr;
    size_t start;
    size_t len;
    size_t size;
};

struct buffer *
allocate_buffer(size_t size)
{
    struct buffer *result;

    result = malloc(sizeof(struct buffer));
    if (result == NULL)
    {
        return NULL;
    }

    result->pntr = malloc(size);
    if (result->pntr == NULL)
    {
        free(result);
        return NULL;
    }

    result->start = 0;
    result->len = 0;
    result->size = size;

    return result;
}

Conclusion

Never write programs with your fingers, always write programs that make codes. and do it for each time you want to write something. because computers can automate the job.

introducing a new programming language

Mohammad Amin Khakzadan — Fri, 07 Jun 2019 20:05:18 +0000

I'm designing a new programming language. And I want to write a compiler for that. That will be open source and free and will be hosted here. But I haven't passion and motivation for writing that. so I decided to write a tutorial, and introduce language design and philosophy. So I can get motivated and continue writing that.

I named it, codescript:
codescript is an interpreted, high-level, general-purpose programming language. codescript is a mixture of dynamic typed and static typed language.

the code below is a tutorial that explains the concepts of language by examples. I can't write good English sentences, code examples are the best way for me to explain something.

Maybe I will update this post over time. so check out for updates.

-- comments start with two '-'., and end with a newline.

++
block comments start with two '+', and end with two '+'.
++

**
I'm not sure about block comments, it may be better with two "*".
**

--# statements:

-- `;` can be used to separate statements, but they aren't mandatory.
-- `\n` (newline) will be considered as a statement separator, when needed.

a = 1 + 2
-- or
a =
1 +
2

-- ' ' can be used where you need to beautify your codes. can't be used between
--  digits of a number or letters of a variable name.

a_float = 10    .   3                           -- valid

variable    .   attribute_of_variable = 5       -- valid

a_number = 4493   9283                          -- two integers: 4493, 9283

-- `~` can be used to continue statements.

very_long_ling_long_long_long_long_long_long_long_and_long_variable_name = 10 ~
.30
-- very_..._variable_name = 10.30

--# variable names:

-- variable names must math regex pattern '[_a-zA-Z][_a-zA-Z0-9]*', and they 
--  can't be 'T', 'F', 'N' constants.
-- at start of a file, no variable defined.

-- none of these variables previously defined:

_abc1 = 1       -- valid
abcd = 1        -- valid

if = 1          -- valid
while = 1       -- valid
for = 1         -- valid
else = 1        -- valid

char = 1        -- valid
integer = 1     -- valid
int = 1         -- valid
float = 1       -- valid
string = 1      -- valid
True = 1        -- valid
NULL = 1        -- valid

print = 1       -- valid
puts = 1        -- valid
io = 1          -- valid
sys = 1         -- valid
stdio = 1       -- valid
stdlib = 1      -- valid
stdin = 1       -- valid
system = 1      -- valid

1good = 1       -- invalid
her-b = 1       -- invalid
her_b = 1       -- valid

--# types:

char = 'a'
int = 10
float = 12.3

-- 'T', 'F', 'N' characters are constant values.

bool = T || F
none = N

array = [1, 2, 3]           -- an array of any type
string = "abc"              -- an array of only char type

object = {}

code = #{a = $b}            -- a code object

function => 10;             -- a lazy evaluation, or function
-- or
function = @ => 1;          -- anonymous function

module = [# name]           -- a module, for external files and libraries

--# simple types:

english_first_letter = 'a'
seconds_in_a_year = 60 * 60 * 24 * 365
pi_number = 3.14159265

true = T
false = F
-- and
none = N

-- we can't compare none and booleans

T == F                      -- no error
N == T                      -- error: can't compare N and T

--# length of arrays:

var1 = "Hello"
var1_len = var1.len             -- var1_len = 5

var2 = [1, 2, 3]
var2_len = var2.len             -- var2_len = 3

--# append arrays:

var1 = "Hello"
var1 += " World"                -- var1 = "Hello World"

var2 = [1, 2, 3]
var2 += [4]                     -- var2 = [1, 2, 3, 4]

--# multiply arrays:

var1 = "-" * 5                  -- var1 = "-----"

var2 = "bye" * 3                -- var2 = "byebyebye"

--# defining objects:

-- objects are likes classes or structures, or maybe name spaces.

var1 = {
    name = "John"
    age = 45
}

var1_name = var1.name           -- var1_name = "John"
var1.color = "white"            -- set color attribute of var1

-- can be used for defining temporary variables:

var2 = {                        -- var2 = 160
    sum = 1 + 3 + 5 + 7
    result = sum * 10
}.result

--# defining code object:

define_var = #(var = 10);

define_var;                     

is_ten = (var == 10);           -- is_ten = T

--# defining lazy evaluations or functions:

sum a b => a + b;
-- or
sum = @ a b => (a + b);         -- anonymous function

--# check type of variables:

-- get type of variables by placing a '?' after them. they will be returned as
--  strings.

var = 2.3
var_type = var?                 -- var_type = "float"

var1 = [1, 2, 3]
is_array = (var1? == "array")   -- is_array = T

var2 = [1, 'a', "abc"]

var2_type = var2?               -- var2_type = "array"

-- get full type notation by placing two '?' after them. they will be returned 
--  as strings.

var2_full_type = var2??         -- var2_full_type = "[int, char, string]"

var3 = [[1], [1, 1.0]]
var3_full_type = var3??         -- var3_full_type = "[[int], [int, float]]"

var4 = {
    name = "John"
    age = 30
}
var4_type = var4?               -- var4_type = "object"
var4_full_type = var4??         -- var4_full_type = "{name: string, age: int}"

--# dynamic typed:

var1 = 10
var1 = "Hello"                  -- no error

--# static typed:

int_type value => (value? == "int");

number :: int_type;            -- type declartion
-- or
number :: (number? == "int");   -- same thing
-- or
number :: int_type = 1;          -- type declartion and variable assignment

number = 10                     -- no error
number = "bye"                  -- error: `number` assign assertion failed.

--# program flow:

--# branches:
-- mnemonic:                LABEL:

loop:
end:

--# jump to branches:
-- mnemonic:                -> LABEL

-> loop
-> end

--# conditional branches:
-- mnemonic:                ( CONDITION ): STATEMENT;

(a == N): a = 1;

(a >= 0): 
(
    a = a + 1;
    b = a + 2;
)

--# algorithm examples:

-- check whether a number is even or not

print = [# io].print

is_even num => (num % 2 == 0)

(is_even 10):
(
    print "even"
    -> end
)
print "old"
end:

-- find max number in a list

list = [1, 5, 2, 6, 3, 8, 0]

max = list[0]
index = 1

loop:
(index < list.len):
(
    (list[index] > max): max = list[index];
    index += 1;
    -> loop;
)

How can I attract a group of developers for open source projects?

Mohammad Amin Khakzadan — Sat, 01 Jun 2019 02:30:43 +0000

I want to create a new open source programming language and I need a group of programmers to help me.

How can I attract developers and explain the idea of my programming language for them?

I need your feedback about a new programming language idea to improve its design.

Mohammad Amin Khakzadan — Wed, 29 May 2019 15:41:36 +0000

Hello, I want to create a new programming language named codescript. It will be open source and free. This repository is where I started.

I need your feedback about it. So I can improve the design of the language.

It will be a scripting language and will be compiled into its own byte code.

DISCLAIMER: I'm not very well at speaking the english language, but I am an experienced programmer, so I can do a better explanation of it by code examples.

ok, let's start.

imagine you opened a file named main.code for writing codescript.

At the first you start writing a file, there is no variable or function defined, and there is no if, else, else if, for or while token that can be understood by compiler. program flow and other stuff will be written just by symbols. Also, there is no print or puts function for writing text to stdout. (they can be accessed by [# system] module). So there's no limit for your variable names except that they should match the Regex pattern [_a-zA-Z][_a-zA-Z0-9]* and also they can't be T, F or N constants.

Now, data types that can be stored in the variables:

// comments start with two slashes.

char = 'a'
int = 10
float = 2.3

bool = T                 // or F
none = N

// `;` can be used to separate statements, but aren't mandatory.

array = [1, 'a', T];
string = "abcd";
code = #(a = 10);

object =
{
    name = "jack"
    age = 10
};

function num => 10 * num;

// `function` is not a keyword. you are defining a function named `function`.

char, int, float

char,int, float are simple data types that you may know.

english_first_letter = 'a'
seconds_in_a_year = 60 * 60 * 24 * 365
pi_number = 3.14159265

bool, none

bool and none are for boolean, and none, respectively. you can't and (&&), or (||) between bool and none data types:

boolean = T || N            // error: `bool` and `none` can't be Or-ed.

also between other data types:

boolean = "Hello" && 5      // error: `string` and `int` can't be And-ed.

They were allowed only between bool data types:

true = F || T
false = true && F

// we can also xor between booleans

var = T ^^ F            // var = T

array, string

array and string data types just exist because of the computer memory data model. I want to design codescript as simple as possible. And let the developer do the extra work with his own creativity. the only difference between string and array is that string data type can only store char.

name = "John"
name_len = name.len            // name_len == 4

numbers = [2, 4, 6]
numbers_len = numbers.len      // numbers_len == 3

code

code data type is just a piece of code. that means when you type:

code = #(a = 10)

you are storing a variable definition statement into another variable.

Ok, let me give you examples:

define_var = #(var = "Hello");

define_var;                      // it's the same as: var = "Hello"

hello_world = var + " World";    // hello_world == "Hello World"

We can also store calculation statements:

var1 = #(2 * 3);
var2 = 2 * 3;
// type of var1 is `code`, but var2 contains `6`, which is an `int`.

a = var1;
b = var2;
// now, `a` and `b`, both are of the type `int`.

or store multiple statements:

code_object = #(name = "Jack"; age = 20;);

code_object;
// now, `name` and `age` are defined.

Or defining a variable based on previous definitions:

define_b = #(b = a * 10);
a = 3;

define_b;
// now, b == 30

It's worth that we can store code statements into a variable, and I will show you the advantages of this later.

object

object data types are just like namespaces, or maybe classes. you can define variables inside them, and you can access them or assign them by . member access.

object = 
{
    name = "Jack"
    age = 20
}

// object.name == "Jack"
// object.age == 20

// assign color member of object, not previosly defined:
object.color = "white"

objects can be used for a block of code, for example:

array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

ten_times_array_len = 
{
    result = 10 * array.len;
}.result;

// you might have guessed that ten_times_array_len is equal to 100.
// and there is no variable defined named `result`.

function

function data types are just functions. They can be called, and return any type of data.

I'm not very sure about the function definition style, I'm thinking of some styles:

// --- style 1 ---

// function declaration:
sum a b => a + b;

// anonymous declaration:
sum = (a b) => a + b;

// --- style 2 ---

// function declaration:
sum a b = a + b;

// anonymous declaration:     
sum = (a b) = a + b;

// or anything else...

if you want to create a new programming language, which style you prefer? In my opinion, the lack of use of semicolons between arguments is less costly. they can be separated by spaces.

This post is not over and I try to complete it over time.