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.

Some developing stuff for programmers wanting to participate

  • Syl programming language - specifications
  • Syl compiler - "live" compilation
  • Syl compiler - "native" compilation
  • Syl compiler - precompilation to C - native way (fixed chosen compiler)
  • Syl compiler - precompilation to C - custom (selectable compiler)
  • C to Syl translator - Open source project
  • SylEdit - The source code editor for the Syl programming language.

    Syl Language Specifications

  • speed : a near C speed is targetted
  • Addresses (pointers) manipulatation allowed
  • includes all C datatypes and more (see below)
  • real "string" datatypes (huge lack of it in C)
  • no ";" to end a statement (the C missing ";" error is a huge $$$ cost for every programmer of this planet)
  • no ugly "{}" for block statements. All programmers of this planet use indentation for code readability : no need to use bloated "{}"
  • a simple "." to end a block statement (useful for copying blocks and so much more relaxing for the eyes)
  • usual block statements( if, while, etc.)
  • minimalist object implementation (all objects will be fully C compatible, no C++ stuff)
  • and more to come ...

    The full description of the project is coming soon ...