DEV Community: Kray-G

Amazing Scratch World!

Kray-G — Wed, 05 Mar 2025 07:23:27 +0000

Introduction

Let me write about Scratch, which is the language created as building-block-based visual language. Honestly, it's so awesome. When I found this, I was so surprised at it because I feel infinite possibility to development. Of course, there're some problems as a programming tool. 😂

BTW, before talking something, please visit to my works of games that I made, and play it. The link is here below.

https://scratch.mit.edu/studios/35458610/

So far, the project having the most highest views and being the most popular is Attractive Drivers which is an homage to OutRun from SEGA, and its view is over 4,000. Even this is not that big amount, though.

Anyway, I'll mention about those at the bottom of this article with each screen image. 😄

What is Scratch!?

Okay, at the beginning of all, let's quote from the Scratch Site.

Scratch is a free programming language and online community where you can create your own interactive stories, games, and animations.

Scratch is the world’s largest coding community for children and a coding language with a simple visual interface that allows young people to create digital stories, games, and animations. Scratch is designed, developed, and moderated by the Scratch Foundation, a nonprofit organization.

That means, Scratch is known as a visual programming language like this.

I believe that you've got the feeling like building blocks and working all and it's been a new touch to your heart about a programming language that is so different well-known languages.

To be honest, I started it to teach it to my child, but it's really got me by that feelings.

BTW, there seems to be so many adults like me, there's a community for those adult people like me in Scratch, and I joined in it now. 😄

In addition to that, all materias used in Scratch is being licensed under CC-BY-SA2.0, so you can use all materials in Scratch under CC0-BY-SA2.0. In another way, you can't use something in Scratch with not CC0-BY-SA2.0 or that can't make it CC0-BY-SA2.0.

My Works

Scratch can work for not only games but also animation, poem, or something like some interactive stuffs. Currently, I tried to make games only, but you will be able to feel its quality and potential.

So let's show my works. I'll show you a lot of images, so it'd be so nice if you felt we could create such a game and it would be much better than what you think of.

G14 Great Fighter Jerrydog

This is my first project. SEGA After Burner inspired me and this is an homage to that.

As I mentioned above, all materials including music and graphics is provided under CC0-BY-SA2.0, so you can use those under CC0-BY-SA2.0. Especially also for music, all musics are composed by myself, soyou can use those under CC0-BY-SA2.0.

https://scratch.mit.edu/projects/1042567369

Air battle and survive!

Attractive Drivers

This is my most popular game and it's an homage to OutRun from SEGA. Of course, all musics are composed by myself. Moreover, I drawed a lot of graphics according to this game scenario.

https://scratch.mit.edu/projects/1092360558

This is OutRun homage, so you can choose the music during driving. But you can select 2 musics for stage 1 to stage 4 and for stage 5 to stage 8.

Each stage has a beautiful scene for driving. Please see that by playing this game.

Time Trial On Edge 2

This is 3D Racing game. At first, I created "Time Trial On Edge" by using the technic called Raycasting. I'll write about Raycasting in the future, but I felt it was not good for this type game. That's why I made the new version named as "Time Trial On Edge 2" and reeased by using the same rendering engine as Attractive Drivers.

https://scratch.mit.edu/projects/1140456987

Select some conditions and go battle on the circuit.

This is another condition, but let's win the race!

Galacy Fight

This is a 3rd story of a series.

https://scratch.mit.edu/projects/1128422722/

When you press the green flag, the words Galaxy Fight appear, seamlessly connecting from the thumbnail as usual, while the Start, Select Options menu and story appear.

Finally, we received a report that the Space Imperial Forces had launched an attack on Country B. We heard that several planets have already been invaded by the Space Imparial Forces. Since the communication network you have newly built with Country A is fully functional, you immediately request reinforcements from Country A and head out to rescur the planets. It seems that the Space Imparial Forces operates a huge control device called the Control Circle on each planet.

It was even discovered that by destroying the control circles on each planet, it was possible to stop the Space Imparial Forces from functioning. The equipment of his own fighter 'ZENO' is already in perfect condition.

Good luck.

This scene selection shows the point where this game is an homage to Galaxy Force from SEGA.

There are many scenes and you have to fight enemies like fighting in the space, avoiding a prominence or dragon's fire, and tornado or something like that.

Lastly, after completed all 3 missions, there is the last 4th mission and there are short movie about the story. Please check it out by playing. Of course, Ending also has a short animation, so I want you to play this until the end.

Problems

Okay, Scratch would be so attractive system and we can make a great game and something like interactive stuffs. But there are some problems as a programming language. I want the Scratch Team to improve such point of view and to improve Scratch itself.

Here are the problems that I think of.

No version control system.

We can't use the version control system like Git and we can't use Git as such tool. I think, by dividing an actual code and a meta data, it should be able to manage on the Git.

No diff-like tool.

There's no diff-like tool on Scratch. I don't have any idea right now, but if it was a programming language, everybody thinks that diff tool would be needed on Scratch. However, no.

Conclusion

I strongly feel that the Scratch is a great tool to make games or something like artistic works. In fact, my works that I tried to create makes so good.

Even though there are some problems, I feel you to try to use it and you to try to make an artistic works and activities!

Kinx v1.0.3 Relaeased.

Kray-G — Thu, 12 Aug 2021 10:20:05 +0000

Hello everyone!

I published Kinx v1.0.3 as an official release. See Release Page for details or I put the history since v1.0.0 at the bottom of this article.

Reference
- First motivation ... The post of introduction
  - Kinx, I wanted a scripting language with a syntax of C family.
- Repository ... https://github.com/Kray-G/kinx
  - I am waiting for pull requests.

Any comments are welcome.
And also I'll wait for a star on Github!

See you!

Change Log

Here is a change log since v1.0.0.

V1.0.3 (Officially Released) - 2021/08/10

Improvements
- #308: Improvement of the stack usage.
- Some feedbacks from V1.1.0.
  - Supported putting a comma at the end of an argument's list for both declaration and calling.
Bug Fixed
- #302: Fixed a prblem of the string optimization.
- #305: Fixed a prblem of no POPC in try.

V1.0.2 (Officially Released) - 2021/05/21

Bug Fixed
- #284: Fixed a segmentation fault problem on Linux.
- #288: Incorrect message is displayed when File.open failed.
- #289: File.setFiledate does not work correctly.
- #293: Fixed a problem of a stack overflow with =~ or !~.

V1.0.1 (Officially Released) - 2021/04/22

Improvements
- Improved type analysis for the language server.
- Improved Array.keySet() for Array itself.
- #264: Supported to change directory.
- #265: Supported $pwd for getting a current directory.
Bug Fixed
- #235: Crash when using _ outside a function.
- #236: Can't specify the class as a return type of function.
- #237: Comparing between variables having a string is failed.
- #256: Comparison operator will be failed with an integer on LHS and a variable(double) on RHS.
- #257: Fails a destructuring assignment when declaration with const.
- #258: There is a case that the bytecode is not outputted.
- #267: Can't use a variable name using an upper case in debugger.
- #269: Object item is removed by flatten().

V1.0.0 (Official Release) - 2021/03/16

This is 1st official release version.

Kinx v1.0.1 and v1.0.2, Official Release Update!

Kray-G — Tue, 25 May 2021 13:31:33 +0000

Hello everyone!

I published Kinx v1.0.1 and v1.0.2 as an official release. See Release Page for detail.

Reference
- First motivation ... The post of introduction
  - Kinx, I wanted a scripting language with a syntax of C family.
- Repository ... https://github.com/Kray-G/kinx
  - I am waiting for pull requests.

Those are minor updates, but I will try to make it stable more and more.

I hope you'll try this language and it is useful for you. Of course I will welcome any feedback.

See you!

Kinx Library - JIT, Just In Time Compilation

Kray-G — Thu, 18 Mar 2021 11:41:28 +0000

Hello, everybody!

The script language Kinx was published as the version 1.0.0 here. The concept is, "Looks like JavaScript, feels like Ruby, and it is a script language fitting in C programmers."

But I realized there has been no article of JIT library in spite of a key feature, so I am going to post about JIT library.

If you were interested in JIT in Kinx, please see the document of JIT Compiler and Native for details.

Introduction

You can use JIT in Kinx for performance improvement. There are 2 ways to use JIT compilation below.

Use native keyword.
Use an abstracted assembler library.

I introduced native in some articles, for example, see Mandelbrot benchmark. It is a good start point to improve performance, so I will start this article from trying it with native.

When Not Using JIT

First of all, when it's the case without JIT, you will normally write the code below.

function fib(n) {
    if (n <= 3) return n;
    return fib(n-2) + fib(n-1);
}

This is very simple. Now, this code will be modified to improve performance with JIT.

When Using JIT

`native` Keyword

The first try is to replace function by native. The native keyword is a keyword to compile it to the native code directly.

native fib(n) {
    if (n <= 3) return n;
    return fib(n-2) + fib(n-1);
}

This will generate an assemble code below on Windows. This is a little long because it's including a type check and exception check. The pros is to write it easily, but the cons is that it can generate a little redundant code and it with some limitations. The code is redundant but necessary.

fib: (native-base:0x1b96340010)
       0:   53                                          push rbx
       1:   56                                          push rsi
       2:   57                                          push rdi
       3:   41 57                                       push r15
       5:   41 56                                       push r14
       7:   41 55                                       push r13
       9:   55                                          push rbp
       a:   41 54                                       push r12
       c:   48 8b d9                                    mov rbx, rcx
       f:   48 8b f2                                    mov rsi, rdx
      12:   49 8b f8                                    mov rdi, r8
      15:   4c 8b 8c 24 a8 fd ff ff                     mov r9, [rsp-0x258]
      1d:   48 81 ec 58 02 00 00                        sub rsp, 0x258
      24:   48 8b 46 08                                 mov rax, [rsi+0x8]
      28:   48 83 c0 01                                 add rax, 0x1
      2c:   48 89 46 08                                 mov [rsi+0x8], rax
      30:   48 3d 00 04 00 00                           cmp rax, 0x400
      36:   72 2b                                       jb 0x63
      38:   48 c7 43 20 01 00 00 00                     mov qword [rbx+0x20], 0x1
      40:   48 c7 43 28 06 00 00 00                     mov qword [rbx+0x28], 0x6
      48:   48 c7 c0 00 00 00 00                        mov rax, 0x0
      4f:   48 81 c4 58 02 00 00                        add rsp, 0x258
      56:   41 5c                                       pop r12
      58:   5d                                          pop rbp
      59:   41 5d                                       pop r13
      5b:   41 5e                                       pop r14
      5d:   41 5f                                       pop r15
      5f:   5f                                          pop rdi
      60:   5e                                          pop rsi
      61:   5b                                          pop rbx
      62:   c3                                          ret
      63:   48 83 be 18 01 00 00 01                     cmp qword [rsi+0x118], 0x1
      6b:   0f 85 30 01 00 00                           jnz 0x1a1
      71:   4c 8b 4e 18                                 mov r9, [rsi+0x18]
      75:   4c 89 4c 24 20                              mov [rsp+0x20], r9
      7a:   4c 8b 74 24 20                              mov r14, [rsp+0x20]
      7f:   4c 89 f0                                    mov rax, r14
      82:   48 83 f8 03                                 cmp rax, 0x3
      86:   7f 1c                                       jg 0xa4
      88:   4c 8b 74 24 20                              mov r14, [rsp+0x20]
      8d:   4c 89 f0                                    mov rax, r14
      90:   48 81 c4 58 02 00 00                        add rsp, 0x258
      97:   41 5c                                       pop r12
      99:   5d                                          pop rbp
      9a:   41 5d                                       pop r13
      9c:   41 5e                                       pop r14
      9e:   41 5f                                       pop r15
      a0:   5f                                          pop rdi
      a1:   5e                                          pop rsi
      a2:   5b                                          pop rbx
      a3:   c3                                          ret
      a4:   4c 8b 74 24 20                              mov r14, [rsp+0x20]
      a9:   49 8d 46 fe                                 lea rax, [r14-0x2]
      ad:   48 89 44 24 40                              mov [rsp+0x40], rax
      b2:   48 c7 84 24 40 01 00 00 01 00 00 00         mov qword [rsp+0x140], 0x1
      be:   48 8b 4e 10                                 mov rcx, [rsi+0x10]
      c2:   48 89 d8                                    mov rax, rbx
      c5:   4c 8b 4e 08                                 mov r9, [rsi+0x8]
      c9:   4c 89 4c 24 30                              mov [rsp+0x30], r9
      ce:   48 89 4c 24 38                              mov [rsp+0x38], rcx
      d3:   48 8d 54 24 28                              lea rdx, [rsp+0x28]
      d8:   49 89 ca                                    mov r10, rcx
      db:   48 89 c1                                    mov rcx, rax
      de:   41 ff d2                                    call r10
      e1:   49 89 c6                                    mov r14, rax
      e4:   48 8b 43 20                                 mov rax, [rbx+0x20]
      e8:   48 83 f8 00                                 cmp rax, 0x0
      ec:   74 1b                                       jz 0x109
      ee:   48 c7 c0 00 00 00 00                        mov rax, 0x0
      f5:   48 81 c4 58 02 00 00                        add rsp, 0x258
      fc:   41 5c                                       pop r12
      fe:   5d                                          pop rbp
      ff:   41 5d                                       pop r13
     101:   41 5e                                       pop r14
     103:   41 5f                                       pop r15
     105:   5f                                          pop rdi
     106:   5e                                          pop rsi
     107:   5b                                          pop rbx
     108:   c3                                          ret
     109:   4c 8b 6c 24 20                              mov r13, [rsp+0x20]
     10e:   49 8d 45 ff                                 lea rax, [r13-0x1]
     112:   48 89 44 24 40                              mov [rsp+0x40], rax
     117:   48 c7 84 24 40 01 00 00 01 00 00 00         mov qword [rsp+0x140], 0x1
     123:   48 8b 4e 10                                 mov rcx, [rsi+0x10]
     127:   48 89 d8                                    mov rax, rbx
     12a:   4c 8b 4e 08                                 mov r9, [rsi+0x8]
     12e:   4c 89 4c 24 30                              mov [rsp+0x30], r9
     133:   48 89 4c 24 38                              mov [rsp+0x38], rcx
     138:   48 8d 54 24 28                              lea rdx, [rsp+0x28]
     13d:   49 89 ca                                    mov r10, rcx
     140:   48 89 c1                                    mov rcx, rax
     143:   41 ff d2                                    call r10
     146:   49 89 c5                                    mov r13, rax
     149:   48 8b 43 20                                 mov rax, [rbx+0x20]
     14d:   48 83 f8 00                                 cmp rax, 0x0
     151:   74 1b                                       jz 0x16e
     153:   48 c7 c0 00 00 00 00                        mov rax, 0x0
     15a:   48 81 c4 58 02 00 00                        add rsp, 0x258
     161:   41 5c                                       pop r12
     163:   5d                                          pop rbp
     164:   41 5d                                       pop r13
     166:   41 5e                                       pop r14
     168:   41 5f                                       pop r15
     16a:   5f                                          pop rdi
     16b:   5e                                          pop rsi
     16c:   5b                                          pop rbx
     16d:   c3                                          ret
     16e:   4b 8d 04 2e                                 lea rax, [r14+r13]
     172:   48 81 c4 58 02 00 00                        add rsp, 0x258
     179:   41 5c                                       pop r12
     17b:   5d                                          pop rbp
     17c:   41 5d                                       pop r13
     17e:   41 5e                                       pop r14
     180:   41 5f                                       pop r15
     182:   5f                                          pop rdi
     183:   5e                                          pop rsi
     184:   5b                                          pop rbx
     185:   c3                                          ret
     186:   48 c7 c0 00 00 00 00                        mov rax, 0x0
     18d:   48 81 c4 58 02 00 00                        add rsp, 0x258
     194:   41 5c                                       pop r12
     196:   5d                                          pop rbp
     197:   41 5d                                       pop r13
     199:   41 5e                                       pop r14
     19b:   41 5f                                       pop r15
     19d:   5f                                          pop rdi
     19e:   5e                                          pop rsi
     19f:   5b                                          pop rbx
     1a0:   c3                                          ret
     1a1:   48 c7 43 20 01 00 00 00                     mov qword [rbx+0x20], 0x1
     1a9:   48 c7 43 28 07 00 00 00                     mov qword [rbx+0x28], 0x7
     1b1:   48 c7 c0 00 00 00 00                        mov rax, 0x0
     1b8:   48 81 c4 58 02 00 00                        add rsp, 0x258
     1bf:   41 5c                                       pop r12
     1c1:   5d                                          pop rbp
     1c2:   41 5d                                       pop r13
     1c4:   41 5e                                       pop r14
     1c6:   41 5f                                       pop r15
     1c8:   5f                                          pop rdi
     1c9:   5e                                          pop rsi
     1ca:   5b                                          pop rbx
     1cb:   c3                                          ret

Abstracted Assembler Library

Kinx also has a JIT library to use an abstracted assembler.
That library can be available with using JIT at the head of source code.

Let's use it like this.

using Jit;

var c = new Jit.Compiler();
var entry1 = c.enter();
    var jump0 = c.ge(Jit.S0, Jit.IMM(3));
    c.ret(Jit.S0);
    var l1 = c.label();
    c.sub(Jit.R0, Jit.S0, Jit.IMM(2));
    c.call(entry1);
    c.mov(Jit.S1, Jit.R0);
    c.sub(Jit.R0, Jit.S0, Jit.IMM(1));
    c.call(entry1);
    c.add(Jit.R0, Jit.R0, Jit.S1);
    c.ret(Jit.R0);

jump0.setLabel(l1);
var code = c.generate();

You can see the assembled code by code.dump(). Here it is.

       0:   53                                      push rbx
       1:   56                                      push rsi
       2:   57                                      push rdi
       3:   48 8b d9                                mov rbx, rcx
       6:   48 8b f2                                mov rsi, rdx
       9:   49 8b f8                                mov rdi, r8
       c:   4c 8b 4c 24 d0                          mov r9, [rsp-0x30]
      11:   48 83 ec 30                             sub rsp, 0x30
      15:   48 83 fb 03                             cmp rbx, 0x3
      19:   73 0b                                   jae 0x26
      1b:   48 89 d8                                mov rax, rbx
      1e:   48 83 c4 30                             add rsp, 0x30
      22:   5f                                      pop rdi
      23:   5e                                      pop rsi
      24:   5b                                      pop rbx
      25:   c3                                      ret
      26:   48 8d 43 fe                             lea rax, [rbx-0x2]
      2a:   48 89 c1                                mov rcx, rax
      2d:   e8 ce ff ff ff                          call 0x0
      32:   48 89 c6                                mov rsi, rax
      35:   48 8d 43 ff                             lea rax, [rbx-0x1]
      39:   48 89 c1                                mov rcx, rax
      3c:   e8 bf ff ff ff                          call 0x0
      41:   48 03 c6                                add rax, rsi
      44:   48 83 c4 30                             add rsp, 0x30
      48:   5f                                      pop rdi
      49:   5e                                      pop rsi
      4a:   5b                                      pop rbx
      4b:   c3                                      ret

It should be simpler than the native. It is very obvious because it is as you write. There is no type check and no exception check. The pros is that it can generate a simple and high-performance code, but the cons is that you have to care for everything.

Put It All Together and Benchmark

Let's put it all together and benchmark it.

using Jit;

/* ------------------------------------------------------------------------
    JIT
------------------------------------------------------------------------ */
var c = new Jit.Compiler();
var entry1 = c.enter();
    var jump0 = c.ge(Jit.S0, Jit.IMM(3));
    c.ret(Jit.S0);
    var l1 = c.label();
    c.sub(Jit.R0, Jit.S0, Jit.IMM(2));
    c.call(entry1);
    c.mov(Jit.S1, Jit.R0);
    c.sub(Jit.R0, Jit.S0, Jit.IMM(1));
    c.call(entry1);
    c.add(Jit.R0, Jit.R0, Jit.S1);
    c.ret(Jit.R0);

jump0.setLabel(l1);
var code = c.generate();

var n = 36;

var tmr = new SystemTimer();
var r = code.run(n);
var elapsed = tmr.elapsed();
System.println("[elapsed:%8.3f] JIT lib  fib(%2d) = %d" % elapsed % n % r);

/* ------------------------------------------------------------------------
    native
------------------------------------------------------------------------ */
native fibn(n) {
    if (n <= 3) return n;
    return fibn(n-2) + fibn(n-1);
}

tmr.restart();
r = fibn(n);
elapsed = tmr.elapsed();
System.println("[elapsed:%8.3f] native   fib(%2d) = %d" % elapsed % n % r);

/* ------------------------------------------------------------------------
    normal case
----------------------------------------------------------------------------- */
function fib(n) {
    if (n <= 3) return n;
    return fib(n-2) + fib(n-1);
}

tmr.restart();
r = fib(n);
elapsed = tmr.elapsed();
System.println("[elapsed:%8.3f] function fib(%2d) = %d" % elapsed % n % r);

Here is the result.

[elapsed:   0.074] JIT lib  fib(36) = 24157817
[elapsed:   0.158] native   fib(36) = 24157817
[elapsed:   2.472] function fib(36) = 24157817

Comparison

By the way, the result by cl -O2 without compilation time is below. And the result of my C interpreter by x64 JIT compilation is also below. By this, I feel the result of the JIT lib is almost same as the case when adding a compilation time.

[elapsed:   0.049] fib(36) = 24157817 // => cl -O2
[elapsed:   0.094] fib(36) = 24157817 // => kcs -j

Conclusion

native is very simple but there are some limitations. JIT Library will be very useful for some specific situation. You can see the document of JIT Compiler and Native for details.

I hope you will find a use case to use this library and it helps you.

Kinx v1.0.0, Officially Released!

Kray-G — Tue, 16 Mar 2021 11:54:17 +0000

Hi everyone!

I released Kinx v1.0.0 officially! Please see Release Page of Kinx

Introduction

The Kinx v1.0.0 is a 1st official release version including all features developed from the beginning of this project.

Reference
- First motivation ... The post of introduction
  - Kinx, I wanted a scripting language with a syntax of C family.
- Repository ... https://github.com/Kray-G/kinx
  - I am waiting for pull requests.

By the way, this is a top secret but the next goal is a syntax highlight on GitHub. It's so hard because I hear one of the criteria is that the Kinx is used in hundreds of repository...

...I hope a little you will create a repository which using Kinx if possible.

Small Description About Kinx

The Concept

The concept is, "Looks like JavaScript, feels like Ruby, and it is a script language fitting in C programmers."

Looks like JavaScript ... It provides C family syntax.
Feels like Ruby ... Enjoy programming.
Fitting in C programmers ... It is easy to use for many programmers.

"C programmers" in this context means "almost all programmers." Because I think almost all programmers have used or known C language at least. And "Providing C Like Syntax" as well also means "friendly for almost all programmers."

Features

Mainly there are features below.

Dynamic typing and Object-Oriented programming.
Classes and inheritance, Higher order functions, Lexical scoping, Closures, Fiber, Garbage Collection, and so on.
Native function by JIT compiling supported with some limitations. Very fast.
Useful libraries are provided as All-In-One.

Libraries

Kinx is including useful libraries below in the standard package as All-In-One.

Zip ... Zip/Unzip with not only zip password but also AES password.
Xml ... Supporting XML as DOM structure.
libCurl ... Only HTTP has been already implemented.
SSH ... SSH login and you can execute commands.
Socket ... Supporting a simple TCP/UDP socket.
Iconv ... Converting between text encodings.
SQLite3 ... Database class as a useful library wrapping SQLite3.
Regular Expression ... Regular expression is of course supported.
Parser Combinator ... Exactly original implementation of Parser Combinator named as Parsek like Parsec.
PDF ... PDF core library based on HaruPDF.
JIT ... JIT library for various platforms by an abstracted assembler library.

Installation

Windows/Linux

You can download an installer from Releases page.

Scoop (for Windows)

Or you can also install it by scoop.
Type the following.

# scoop bucket add is needed only at the first time.
scoop bucket add kinx https://github.com/Kray-G/kinx
scoop install kinx

How To Run

After confirming the command path of kinx or kinx.exe, run your script as follows.

# For Windows
$ kinx.exe [options] [<script-file>]

# For Linux
$ kinx [options] [<script-file>]

Specification

Specification will be mostly completed so far for v1.0.0. Please look at this and try to use Kinx.

See Kinx Specification (v1.0.0) for details.

Examples

There are a lot of examples in the document on the repository, but I will only show a small example in this section. Please see the document.

hello, world.

Here is the 1st script that everyone should write.

System.println("hello, world.");

Fibonacci

You will think it seems to be a JavaScript.

function fib(n) {
    if (n < 3) return n;
    return fib(n-2) + fib(n-1);
}

System.println("fib(34) = ", fib(34));

Fibonacci in `native`

Replacing function by native, that makes faster. Please try it now.

native fib(n) {
    if (n < 3) return n;
    return fib(n-2) + fib(n-1);
}

System.println("fib(34) = ", fib(34));

Closure

The function object has a lexical scope and you can use a closure.

function newCounter() {
    var i = 0;          // a lexical variable.
    return function() { // an anonymous function.
        ++i;            // a reference to a lexical variable.
        return i;
    };
}

var c1 = newCounter();
System.println(c1()); // 1
System.println(c1()); // 2
System.println(c1()); // 3
System.println(c1()); // 4
System.println(c1()); // 5

Lambda

Anonymous function is easy to be written.

function calc(x, y, func) {
    return func(x, y);
}

System.println("add = " + calc(10, 2, { => _1 + _2 }));
System.println("sub = " + calc(10, 2, { => _1 - _2 }));
System.println("mul = " + calc(10, 2, { => _1 * _2 }));
System.println("div = " + calc(10, 2, { => _1 / _2 }));
// add = 12
// sub = 8
// mul = 20
// div = 5

Class

Of course, a class is available.

class A {
    var flag_ = false;  // a local private variable.
    public flagOn() {
        @flagOnActual();
    }
    public flagOnActual() {
        @flag = true;   // a public variable.
    }
}

var a = new A();
a.flagOn();
System.println(a.flag ? "true" : "false");  // => true

Module

Module can mixin into a class.

module M {
    public method1() {
        System.println("This is a method1");
    }
}

class A {
    mixin M;
}

new A().method1();  // => This is a method1

Fiber

You can use Fiber.

var fiber = new Fiber {
    System.println("fiber 1");
    yield;
    System.println("fiber 2");
};

System.println("main 1");
fiber.resume();
System.println("main 2");
fiber.resume();
System.println("main 3");
// main 1
// fiber 1
// main 2
// fiber 2
// main 3

Spread/Rest Operator

It was introduced by ES6 of JavaScript. I wanted it so much, and it is so useful. There's a lot of use cases, but here is a simple example.

function sample(a1, a2, ...a3) {
    // a1 = 1
    // a2 = 2
    // a3 = [3, 4, 5]
}

sample(1, 2, 3, 4, 5);

Pattern Matching

It supports an assignment by pattern matching. Of course it can be also used in declaration and a function argument.

[a, b, , ...c] = [1, 2, 3, 4, 5, 6];
{ x, y } = { x: 20, y: { a: 30, b: 300 } };
{ x: d, y: { a: e, b: 300 } } = { x: 20, y: { a: 30, b: 300 } };

System.println("a = ", a);
System.println("b = ", b);
System.println("c = ", c);
System.println("d = ", d);
System.println("e = ", e);
System.println("x = ", x);
System.println("y = ", y);

// => .y.b requires 300, but it is 3 in actual.
{ x: d, y: { a: e, b: 300 } } = { x: 20, y: { a: 30, b: 3 } };

// a = 1
// b = 2
// c = [4, 5, 6]
// d = 20
// e = 30
// x = 20
// y = {"a":30,"b":300}
// Uncaught exception: No one catch the exception.
// NoMatchingPatternException: Pattern not matched
// Stack Trace Information:
//         at <main-block>(test.kx:14)

Pipeline Operator

Pipeline operator is also supported.

function doubleSay(str) {
    return "%{str}, %{str}";
}
function capitalize(str) {
    return str.toUpper(0, 1);
}
function exclaim(str) {
    return str + '!';
}

var result = exclaim(capitalize(doubleSay("hello")));
System.println(result); // => "Hello, hello!"

var result = "hello"
  |> doubleSay
  |> capitalize
  |> exclaim;

System.println(result); // => "Hello, hello!"

Function Composition Operator

You can also composite functions!

const double = &(n) => n * 2;
const increment = &(n) => n + 1;

// Normal case.
var r1 = double(increment(double(double(5)))); // 42
System.println(r1);

// Function composition operator is higher priority than a pipeline operator.
var r2 = 5 |> double +> double +> increment +> double; // 42
System.println(r2);

Conclusion

I finally release it officially, but of course there may be a bug or some unexpected behavior.

If you try to use it, I am very appreciated. When you faced a problem, please let me know via Issues in the repository. I will welcome any report.

Again, please see Kinx specification for details.

Many thanks.

Kinx v0.22.0 Preview Released

Kray-G — Wed, 10 Mar 2021 13:38:38 +0000

Hello everybody!

I published Kinx v0.22.0 preview release! Please see Release Page of Kinx

Introduction

At the version 0.22.0 it newly supported a pipeline/composition operator and some functional methods.

Reference
- First motivation ... The post of introduction
  - Kinx, I wanted a scripting language with a syntax of C family.
- Repository ... https://github.com/Kray-G/kinx
  - I am waiting for pull requests.

There are mainly 4 updates from v0.21.0.

Pipeline Operator

This is based on the proposal of JavaScript. a |> b means exactly same as b(a). In the same as that, a <| b which means a(b) is also available.

Here is a simple example of pipeline.

function doubleSay(str) {
    return "%{str}, %{str}";
}
function capitalize(str) {
    return str.toUpper(0, 1);
}
function exclaim(str) {
    return str + '!';
}

var result = exclaim(capitalize(doubleSay("hello")));
System.println(result); // => "Hello, hello!"

var result = "hello"
  |> doubleSay
  |> capitalize
  |> exclaim;

System.println(result); // => "Hello, hello!"

Please see Pipeline Operator for details.

Function Composition Operator

The functions can be composited as a new function. a +> b means { => b(a(_1)) }. And a <+ b means { => a(b(_1)) }.

Let me tell you something a little about the syntax for people who doesn't familiar with Kinx function syntax. { => b(a(_1)) } means function(arg) { return b(a(arg)); } in JavaScript like syntax. Yes, _1 is a first argument.

Here is also a simple example of a function composition operator.

function doubleSay(str) {
    return "%{str}, %{str}";
}
function capitalize(str) {
    return str.toUpper(0, 1);
}
function exclaim(str) {
    return str + '!';
}

var result = exclaim(capitalize(doubleSay("hello")));
System.println(result); // => "Hello, hello!"

// Generates a new composed function.
var doubleSayThenCapitalizeThenExclaim
   = doubleSay +> capitalize +> exclaim;

var result = "hello" |> doubleSayThenCapitalizeThenExclaim;
System.println(result); // => "Hello, hello!"

Please see Function Composition Operator for details.

Functional Library

The Functional is a global instance to deal with functional methods. In general, when you use a method of some object in pipeline, you should do it as a following example.

obj |> { &(obj) => obj.map({ => _1 * 2 }) }
    |> { &(obj) => obj.method() }
    |> // ... and so on.

The Functional instance will wrap the actual function object and pass it into the pipeline.

For example, you can write it as follows against the example above.

obj |> Functional.map { => _1 * 2 }
    |> Functional.method()
        // Note that it needs a `()` to use an actual function object
        // which receives an object at a first argument.
    |> // ... and so on.

The Enumerable is also useful in pipeline. The Enumerable is not only as a module but also a global instance having functional enumerable methods which is useful in a pipeline.
For example, when multiple values are passed to the next function via pipeline, a method in Enumerable can fetch a value one by one and pass the value to a next function in order.

Therefore, Enumerable can handle an infinite sequence. This is an example below.

1..
    |> Functional.enumerable
    |> Enumerable.drop(10)
    |> Enumerable.filter { => _1 % 3 == 0 }
    |> Enumerable.take(10)
    |> Enumerable.toArray
    |> System.println;

The Functional.enumerable is a magic function to make a sequence change to an item which Enumerable methods can use.

Please see Functional for details.

Clipboard

Reading/Writing of clipboard is supported. Here is a simple usage of reading/writing of clipboard.

var cb = new Clipboard();
cb.write(str);
var r = cb.read();

Please see Clipboard for details.

Conclusion

I stopped implementing a new feature, and I am going to make Kinx become v1.0.0 soon. I am now working hard on the release!

I hope you will be a user of Kinx.

Many thanks.

Kinx v0.21.0 Preview Released

Kray-G — Tue, 16 Feb 2021 02:47:47 +0000

Hello everybody!

I published Kinx v0.21.0 preview release! Please see Release Page of Kinx

Introduction

At the version 0.21.0 it newly supported an assignment by a pattern matching, case-when, and switch-when syntax.

Reference
- First motivation ... The post of introduction
  - Kinx, I wanted a scripting language with a syntax of C family.
- Repository ... https://github.com/Kray-G/kinx
  - I am waiting for pull requests.

Pattern Matching

The pattern matching is very useful. For example, you can use it in a declaration like this.

var [a, b, , ...c] = [1, 2, 3, 4, 5, 6];
var { x, y } = { x: 20, y: { a: 30, b: 300 } };
var { x: d, y: { a: e, b: 300 } } = { x: 20, y: { a: 30, b: 300 } };

System.println("a = ", a);
System.println("b = ", b);
System.println("c = ", c);
System.println("d = ", d);
System.println("e = ", e);
System.println("x = ", x);
System.println("y = ", y);

// => .y.b requires 300, but it is 3 in actual.
var { x: d, y: { a: e, b: 300 } } = { x: 20, y: { a: 30, b: 3 } };

At the last case, the right hand side is not matched by the pattern of the left hand side. Therefore you will see an exception of NoMatchingPatternException.

a = 1
b = 2
c = [4, 5, 6]
d = 20
e = 30
x = 20
y = {"a":30,"b":300}
Uncaught exception: No one catch the exception.
NoMatchingPatternException: Pattern not matched
Stack Trace Information:
        at <main-block>(test.kx:14)

You can use a same feature also at an assignment, an argument of a function, and case-when.

Please look at the description for the related features as follows.

declaration ... https://github.com/Kray-G/kinx/blob/master/docs/spec/statement/declaration.md
assignment ... https://github.com/Kray-G/kinx/blob/master/docs/spec/statement/expression/assign.md
function argument ... https://github.com/Kray-G/kinx/blob/master/docs/spec/definition/function.md
case-when ... https://github.com/Kray-G/kinx/blob/master/docs/spec/statement/expression/case_when.md

Switch-When

I thought I would like to make a case-when being not fallthrough be substitute of a switch-case being fallthrough.
But there was a problem for the performance on it.

case-when has been designed that the condition is evaluated by a pattern matching. This means the order of evaluating a condition is sequential from the top.
On the other hand, switch-case is designed the order of evaluating a condition is not defined. This means, it will be translated to just a if-else, or it will be translated to a binary search, or it will translated to a jump by table. In particular, a jump by table is important at the point of a performance.

Therefore I have introduced switch-when instead of switch-case. You can use a when label instead of a case label. If you use a when label, the break statement will be automatically inserted after the last statement of when clause.

Of course you can use an else: label instead of a default: label. An else: label means a default: with break.

If you want to use a fallthrough in when, you can also use a fallthrough keyword at the last statement in when.

Conclusion

I sometimes received a reaction like ''Why did you select a fallthrough in switch-case?'', and ''It is a bad selection.'' I believe switch-when will be an answer for that. One of weakpoints in Kinx will be eliminated.

I hope you will be a user of Kinx and try something with this language. I will welcome any feedback.

See you!

Kinx v0.19.3 Preview Released

Kray-G — Tue, 19 Jan 2021 12:57:01 +0000

Hello everybody!

I published Kinx v0.19.3 preview release. It newly supported a Debugger. A Debugger manual is here

Reference
- First motivation ... The post of introduction
  - Kinx, I wanted a scripting language with a syntax of C family.
- Repository ... https://github.com/Kray-G/kinx
  - I am waiting for pull requests.

If you have some kind of interest on it and you want to try to use it, don't hesitate to use it.

Thank you in advance.

See you!

How to add a path to environment variable?

Kray-G — Wed, 16 Dec 2020 06:06:12 +0000

Hello, everyone.

Introduction

How do you add/delete the path to/from Path environment variable in your installer?

In fact, I released the version 0.17.0 of Kinx and I implemented an installer.

But the path will NOT be added to the environment variable.

After wrote this article, I released v0.17.1 which automatically adds the path to the Path environment variable. I did also write a test code for addpath.exe, but I will be glad for you to review the source code anyway. Thanks in advance.

I researched how to do it on the web, but I didn't find it as I want. I was searching it with...

Simple Source Code
Easy to Use
Useful License

I wanted to use it in the NSIS script, but there seems to be some problems in NSIS.

Conclusion

I created a simple program. Look at this.

https://github.com/Kray-G/addpath

This is...

Simple Source Code ... Just one file there!
Easy to Use ... Simple command line interface to use.
Useful License ... That is MIT! ...did set it by me, although.

But...

This program will modify the system environment, so I feel a little scared. Therefore I want a lot of people to check the source code and I want to fix a problem if there is a problem.

If you are interested in it or you have time, I will be very happy for you to look at the source code.

And also, please let me know if you have any better solution for this problem.

See you!

P.S.
If you feel good to this, please push a star!

How do you test your code?

Kray-G — Thu, 10 Dec 2020 23:20:59 +0000

Hello, everyone!

I am sometimes tired to write a specification.
I am also tired to write a test code.
Don't you think so?

SpecTest

That is why I setup a test system that I named SpecTest.

Look at the following site.

https://kray-g.github.io/kinx/

This is published as a specification of my scripting language, but it will also become a test code as is.

This means that to write a specification with examples is that you can get a test code.

In almost all cases, there are many examples when people write a document.
SpecTest will test those examples as is.

What do you get?

There are 2 good points for developpers.

Reduce your cost for creating 2 different documents . All you have to do is to create just 1 document.
You can check if your examples you write in a document is correct. Sometimes there is an example which does not work correctly in the world.

If you think it is good, push a star on Github. It will make me happy. 😄

And also any pull request, issue, or suggestion will be welcome anytime.

Thanks for reading this article until the end.

See you!

Updates of KiTTy (Kinx Tiny Typesetting)

Kray-G — Wed, 14 Oct 2020 00:56:53 +0000

Hello everyone!

This is an update of KiTTy. What is KiTTy?
Before going to the main topic, let me start with the introduction as usual.

The script language Kinx is published with the concept of Looks like JavaScript, Feels like Ruby, Stable like AC/DC(?).

Reference
- First motivation ... The post of introduction
  - Kinx, I wanted a scripting language with a syntax of C family.
- Repository ... https://github.com/Kray-G/kinx
  - I am waiting for pull requests.

Let's start about KiTTy first.
Yes, you are right, you don't know KiTTy.
It is because I named it recently and I said it to nobody.

That is Kinx Tiny Typesetting. What is Kinx?
Please visit to the above linked website, and you will see that.

I believe you will find KiTTy as an update from Kinx Tiny Typesetting.

This is still working in progress.
But I did work and I have got some good result.

Here is an original Markdown document.

https://github.com/Kray-G/kinx/blob/master/examples/typesetting/KiTTy_en.md

When KiTTy has processed a typesetting for above Markdown document, you will get the PDF file below.

https://github.com/Kray-G/kinx/raw/master/examples/typesetting/KiTTy_en.pdf

Please visit to the Release Page to see the link to the KiTTy's User Guide generated by KiTTy. The above PDF is also the KiTTy's User Guide in English, though.

If you feel it is good, please give me a star on GitHub 😄.

P.S.
By the way, I found a strange point... I have to fix it!

By the way, the above pdf is generated by the latest commit of master.
Note that there are some updates from the released version on it.

Kinx Library - Getopt

Kray-G — Thu, 24 Sep 2020 13:06:59 +0000

Hello, everybody!

The script language Kinx is published with the concept of Looks like JavaScript, Feels like Ruby, Stable like AC/DC(?).

This time it is Getopt. It is simple but useful.

Reference
- First motivation ... The post of introduction
  - Kinx, I wanted a scripting language with a syntax of C family.
- Repository ... https://github.com/Kray-G/kinx
  - I am waiting for pull requests.

You can also use a long option style.

Getopt - `System.getopt`

How to use

Look at an example below. You put it in the while condition part, and specify the array of argument, the option string, and the object for long options. You can omit to specify the object for long options.

var opt, add, check;
while (opt = System.getopt($$, "a:df", { add: 'a', delete: 'd', help: null, "do-check": '=' })) {
    switch (opt.type) {
    case 'a':               // Returns 'a' when a user specified '--add'.
        add = opt.arg;      // ':' means the option has an argument.
        System.println('-a with "%{add}"');
        break;
    case 'd':               // Returns 'd' when a user specified '--delete'.
        System.println('-d');
        break;
    case 'f':               // This means that a user specified '-f'.
        System.println('-f');
        break;
    case 'help':            // This means that a user specified '--help'.
        System.println('--help');
        break;
    case 'do-check':        // This means that a user specified '--do-check'
        check = opt.arg;    // '=' means the option has an argument.
        System.println('--do-check with "%{check}"');
        break;
    case '-':               // This means that the argument is not an option.
        list.push(opt.arg);
        break;
    }
}

// Displaying arguments which is not an option.
System.println("Program options: ", list);

Details for an option string.

If you specify the option with an argument but there is no argument to the option, ArgumentException will be raised.
When it is an option without an argument, the options can be combine within one option like -df instead of -d -t.
When it is an option with an argument, you can combine the option and the argument like -aARG. This means it is same as -a ARG.
By above mechanism, you can write -d -a ARG as either -da ARG or -daARG.

Details for a long option.

If you specified a long option with the option character of an option string, the argument style is following an option string parameter.
If you specify the option with an argument but there is no argument to the option, ArgumentException will be raised.
The argument for a long option is specified as the style of --long-option=argument. When it is a long option, the empty argument is also acceptable.

Execute an example.

Here is an example for some cases.

$ ./kinx examples/option.kx -d -a arg
-d
-a with "arg"
Program options: ["examples/option.kx"]

$ ./kinx examples/option.kx -da arg
-d
-a with "arg"
Program options: ["examples/option.kx"]

$ ./kinx examples/option.kx -daarg
-d
-a with "arg"
Program options: ["examples/option.kx"]

$ ./kinx examples/option.kx --help something
--help
Program options: ["examples/option.kx", "something"]

$ ./kinx examples/option.kx --do-check=
--do-check with ""
Program options: ["examples/option.kx"]

$ ./kinx examples/option.kx --do-check=abc
--do-check with "abc"
Program options: ["examples/option.kx"]

$ ./kinx examples/option.kx -a
Uncaught exception: No one catch the exception.
ArgumentException: Needs an argument for -a
Stack Trace Information:
        at <main-block>(examples/option.kx:2)

$ ./kinx examples/option.kx --unknown
Uncaught exception: No one catch the exception.
ArgumentException: Unknown option: --unknown
Stack Trace Information:
        at <main-block>(examples/option.kx:2)

Conclusion

There are a lot of style for analyzing arguments, and getopt has a long history. But getopt is still active. I think it is easier to use by the point of view of Most fitting in C programmers.

To display a help, boost::program_options is also useful. But getopt is minimum but very simple and useful for almost all purpose. I might support more useful method in the future.

See you next time.

DEV Community: Kray-G

Amazing Scratch World!

Introduction

What is Scratch!?

My Works

G14 Great Fighter Jerrydog

Attractive Drivers

Time Trial On Edge 2

Galacy Fight

Problems

Conclusion

Kinx v1.0.3 Relaeased.

Change Log

V1.0.3 (Officially Released) - 2021/08/10

V1.0.2 (Officially Released) - 2021/05/21

V1.0.1 (Officially Released) - 2021/04/22

V1.0.0 (Official Release) - 2021/03/16

Kinx v1.0.1 and v1.0.2, Official Release Update!

Kinx Library - JIT, Just In Time Compilation

Introduction

When Not Using JIT

When Using JIT

native Keyword

Abstracted Assembler Library

Put It All Together and Benchmark

Comparison

Conclusion

Kinx v1.0.0, Officially Released!

Introduction

Small Description About Kinx

The Concept

Features

Libraries

Installation

How To Run

Specification

Examples

hello, world.

Fibonacci

Fibonacci in native

Closure

Lambda

Class

Module

Fiber

Spread/Rest Operator

Pattern Matching

Pipeline Operator

Function Composition Operator

Conclusion

Kinx v0.22.0 Preview Released

Introduction

Pipeline Operator

Function Composition Operator

Functional Library

Clipboard

Conclusion

Kinx v0.21.0 Preview Released

Introduction

Pattern Matching

Switch-When

Conclusion

Kinx v0.19.3 Preview Released

How to add a path to environment variable?

Introduction

Conclusion

But...

How do you test your code?

SpecTest

What do you get?

Updates of KiTTy (Kinx Tiny Typesetting)

Kinx Library - Getopt

Getopt - System.getopt

How to use

Details for an option string.

Details for a long option.

Execute an example.

Conclusion

`native` Keyword

Fibonacci in `native`

Getopt - `System.getopt`