I wanted to do blogging about development of my project that I've been working on for a long time. And I thought it's the time. Because I believed that I brought the project enough level to do that.
This micro-blog will be covering development journey of the project called "Neon" that I've been working on. And I want to talking about this project briefly for now. But the future posts will be covering detailed information and development phases.
This project contains a programming language design, and its's compiler and a virtual machine and runtime core that the compiled program runs on it. It is completely coding from the scratch and were not used any 3rd party libraries, code fragments etc. That was one of the project's goals when I started this project. As of November 29th, the project is pre-alpha phase. And I expect that in a month or two the project going to be alpha stage. After 2 years of work, the project will have reached a huge milesone.
The programming language will be aiming programmers to focusing productivity. That will be key feature of the language itself. To achieve that, the most of things will be integrated into the language's nature. For example threading. Today's modern programming languages does threading quite painful way except The Go programming language. (That's why I love so much the go :) ) You have to call threading library, class or API with a function reference/pointer or worker context, or at least you have to add extra piece of wrapper code on it. Some of these programming languages adds extra feature or classes to their frameworks to making easier to do that, but usually they are not really effective. Because their native approaches and rules does not allow it. Same as the synchronization primitives, shared memory I/O and IPC etc.
The programming language -- hereafter it will be referred as "neon" which is the project codename for now -- will be providing these capabilities it's natural way. Today's standards obviously requisites online approaches even in the programming area. Hence, the neon will be planned to make easier network oriented programming and let you focus to what you want to achieve it. I will dive deep about the language's details at the future post. The Neon is VM managed, statically typed language but it will be providing programming ability like as a system level languages like C. (That is still in design, I have to work very carefully on it)
Another design key about the Neon is simplicity. The simplicity lets programmers focusing their programming logic. For example the loops. The neon will be provided unified single loop keyword with flexible usage. The Neon's compiler (called NeonLight) knows type of the loop and optimizes code generation for it. Or synchronization primitives.. The neon will be providing traditional way of using synchronization primitives for more complex implementation cases but it also gives ability to quite simply way of these. Because the most of the time the synchronization primitives are used to protect or limit with the certain number of threads of a specific code blocks. In such a case, creating lock objects, initializing them, acquire and release steps are quite boring and time wasting things.And that prevents programmers from focusing their logic. The neon aims to bring a native solution to that kind of situations.
As an experiment, the language syntax will be also supported by the Turkish based keywords. But the mainly focused design and development of the language will be going with the standard english keywords. The Turkish keywords will be evaluate as an alias. So you may ask why is that? Let me answer this possible question shortly. Actually that was my utopia. I have been dreamed how would be like programming in the Turkish since I started programming. Another and the most important reason is to letting children who speaks the Turkish as the mother language like me, meet fast and easy with the programming logic in their mother language and providing the comparative way to do that and let them gaining programming skills at an early age. So the children can easily create programs with other programming languages in a quite short time. I thought.
The NeonLight compiles into the Common Instruction Set (CIS) which is being designed by me and the programs will be compiled as the native operating system's executable file format. So, the NeonLight will be able to compile into PE, ELF and Mach-O executable file formats.
Native executables initiates the Neon's Virtual Machine to run programs on the system. Virtual Machine and its runtime (will be referred as NeonCore) takes place and does its job. NeonCore's JIT Compiler rapidly translates CIS (Common Instruction Set) to the CPU Architecture's Instruction set that it working on.
That makes one core for all approach. So the same NeonCore binary can be run each scale of system. The NeonCore automatically examines the system that runs on it and scales resource usage efficiently.
The NeonCore designed to run multiple CPU architecture and multiple operating system. It supplies a lower level layer named "PAL" (Platform Abstraction Layer) to its higher level layer to implement it's work identical on every OS platform at once.
The planned OSes and architectures of the project are as follows:
- Intel x86
- Amd64 (aka x64, x86-64)
- ARM64 (aka AArch64)
- Windows (NT based)
- Linux Kernel based OSes
- macOS (XNU-Darwin)
- BSD based systems (FreeBSD, OpenBSD, NetBSD, Dragonfly etc.)
- Debian based systems (Raspbian for example)
IOT (Internet Of Things) and embedded devices
The NeonCore designed to work with the various type of embedded and IOT devices. The first fully supported device will be Raspberry PI and the NeonCore will be natively supporting GPIO programming capabilities.
I will share contents about the features and the development stages one by one over time but for now that's all. But before I finish, I want to share some statistic info about the project. I hope these stats gives you idea about the project's progression.
- This project have been developing for 2 years.
- The compiler part (NeonLight) is written in C#, the virtual machine and runtime core (NeonCore) part is written in pure C.
- Hosted on Github as private repository.
- Uses CMake to make the build process same on every platform. (Highly recommended)