• Steve Teale <steve.teale britseyeview.com> Apr 06 2009

Steve Teale <steve.teale britseyeview.com> writes:

Baas Wrote:

 In the past 10 motnhs, I completly rewrote the D Compiler in C#!
 
 Motivations:
 - LOVE THE D LANGUAGE!!
 - To be fully able to develop in a VS.NET like environment using D, with no
limmitations.
 
 Cons:
 - Requires Windows platforms (XP and above).
 - Requires P4+ CPU.
 - 2-4 times slower compiler (still need to be optimized).
 - No "_Identifier" allowed! (I hate that _ s##t!)
 - Removed "auto" types.
 - Removed some data types.
 - No documentation available :(
 
 Pros:
 - Faster overall application execution speed.
    - Tested against existing benchmarks.
 - Implemented full debug functionality. 
    - No more creapy asm stuff.
    - View/Modify ALL datatypes without any limitations or hassles.
 - Complete 128 bit ints/reals
    - Added Custom 256 bit ints/reals. (...who's gonna use it anyway?)
 - Dynamic keywords:
    - For example:
       - Can rename "else if" to ElseIf etc.
       - Can rename "{}" code block indicators to Begin/End etc.
    - Remain compatible with any older/newer "keyword set".
    - Can basically change keywords to adopt your style.
 - Includes "event handler" functionality
 - Includes dynamic binary modules (.ddbm)
    - Can automaticaly optimize itself on a target environment.
       - Can restructure its own code pattern (32/64/Multi-CPU)
       - Can physically relocate itself.
       - Can defrag itself in memory/disk.
    - Magnitudes faster then normal DLLs.
    - Can bind/execute across networks.
    - Can be initiated from a remote machine.
    - Includes full security features.
 - Includes pre-set configuration templates:
    - Custom Mode
    - Console Mode (exe)
    - Windows Mode (exe)
    - GL Mode (exe)
    - Library Mode (dll)
    - Dynamic Binary Module Mode (ddbm)
    - Windows Service Mode (exe)
    - Device Driver Mode (drv/sys)
 - Includes Code Convertion Utility (from C# to D).
    
 Tech info:
 - Parse the code into XML using Regular Expressions.
    - More code optimization is now possible.
 - Replaced the backend with HLA.
    - Code > HLA > OBJ > EXE/DLL
 - Removed GC, ...don't need it.
    - Variables allocate/deallocate themselfs.
    - Manual allocation/deallocation still possible.
 - Package/Module now require code block indicators
    - package somepackage.somewhere
      {
         module somemodule
         {
            ....
            module deep.beneath
            {
               ....
            }
            ....
         }
 
         module another.module
         {
            ....
         }
      }
    - More than one module per file is now possible.
 - Added inline HLA
    - Can now use asm{} or hla{}
 - Changed property syntax (similar to C#)
    - int something
      {
         get { return somevariable; }
         set { somevariable = value; }
      }
 - Renamed "mixin" to "macro"
 - Removed "imaginary" and "complex" types.
 - Changed/Added Types
    * ubyte > byte
    * byte > sbyte
    * char > compiler options determine which type to use (1/2/4 bytes)
    * short > short/int16
    * ushort > ushort/uint16
    * int > int/int32
    * uint > uint/uint32
    * long > long/int63
    * ulong > ulong/uint64
    * float > float/single/real32
    * double > double/real64
    + int128/decimal
    + uint128/udecimal
    + int256
    + uint256
    + real128
    + real256
    + string > compiler options determine which type to use (1/2 bytes)
    + date/time/datetime
 
 In Progress:
 - "native" .NET framework.
 
 Plan for the Future:
 - "VS.NET-like" IDE.
 - "true" Generic functionality.
 
 Sorry...
 NO CODE OR BINARIES INCLUDED WITH THIS MESSAGE! (yet)
 
 Baas
 


We could call it D#, but maybe I'm being charitable!

If you were going to implement D in C#, why didn't you do that first, then come
up with the alternative later?