SylComp - Simply your language |
Someday all compilers will be made this way ... meanwhile ... enjoy being here helping to build the future. |
This site reflects the construction of SylComp, a general-purpose compiler for the Syl programming language. This will be done in its context, i.e. a mega-project including language specifications, compiler creation, IDE development, code generation, etc..
For now, Syl is a project. Anyone whishing to participate is welcome. The main goal is to produce a compiler anyone can use both in a low level perspective and in a high level perspective.
Let's face it : actually, low level compilers produce small and fast code but their syntax are generally ugly and hard to learn. On the other side, high level compilers have powerful instructions and can be learned rapidly, but often produces bloated code and don't allow user access to low level instructions.
Of course it can be "dangerous" (ultimately costy) to insert low level instructions leading to memory corruption and long time debugging sesssions but for the small parts of the application where speed is important, why a programmer - programming in a high level context - could have the only choices to make it in a separate application or, simply refrain from doing it, leaving the application slow at certain "moments".
In fact, some programmers knowing that parts of the application will need speed will chose "C" as THE development language. Ok, it eliminates the impossibilities, but it introduces a huge extra cost, cause the high level part of the application will be developped more slowly (even by experienced C programmers) and, the nigthmare part : usual C memory bugs will happen, NOT only in the "delicate" application part (a SMALL part), but ALSO in the "normal" part.
That's why overall, the ones who go high level all the way usually fulfill their mandates faster, better and cheaper, but sometimes lack new mandates because of the weakness of the application. Not only for speed concerns, sometimes for the lack of versatility : the impossibility of implementing some features not accessible by the chosen high level language (wich is not the case with low level languages like C).
The Syl language will address this problem. Low level and high level parts will co-habitate in a smooth way. It is a lot less "dangerous" than one can think when only small and precise parts have to be monitored. Even it's low level parts the Syl language will still be a programmer oriented language.
This is for the "language specification" part. For the functional part, there are a couple of innovative ideas at the programming level. To mention only one, the notion of live compilation is most interesting. (described later). If the feature is implemented, no doubt that the programmers using Syl will have a hyper fast way to develop AND to maintain applications, whatever their range (from small to pretty large).
In both stages of programming (program redaction and compilation), an important reduction of cost should be reached. But savings in code production will be a fraction of real cost saving, cause the code maintenance will be the main cost saving part and THE reason a lot of people will want to use Syl.
The idea behind the current project is special. This involves many "steps". But instead of waiting for the end of a step to discuss the achievement of the next step, all specifications will be discussed simultaneously. Of course, for a while the focal point will be the Syl language specifications, but even at this point some will have the option of working on something that is not directly related. Things will be clearer soon, when my minimum starting specs are laid out. I am starting to present these very incomplete proposals because I know that it may take some time before recruiting a lot of people ... because that is what it will take to make the progress of this mega-project possible.