By Limin Fu. Released under the GNU Free Documentation License. 

Feature Summary


Key features: 
  *  Optional typing with type inference and static type checking:
     Optional typing allows variables to be declared with or without  explicit types. Typ
     es will be inferred and checked whenever  necessary and possible to allow early dete
     ction of bugs.  Also explicit and inferred type information could be used  do code a
     nd function specialization to make programs more efficient. 
  *  Just-In-Time (JIT) compiling:
     A standard module based on the Low Level Virtual Machine (LLVM)  compiler infrastruc
     ture is provided to support JIT compiling.  Currently this JIT compiler module is ma
     inly developed for supporting  numeric compuations. 
  *  Built-in support for concurrent programming:
     Concurrent programming is made simple by a number of concurrent  code section method
     s and asynchronous classes.  The basic concurrent computational unit is a tasklet wh
     ich consists  of a virtual machine process (context) and a future value (handle).  A
     tasklet is mapped to a native thread only when it becomes active.  Tasklets can comm
     unicate and synchronize with each other by channels.  Concurrent garbage collection 
     is supported by the virtual machine  to make concurrent program safe. 
  *  Transparent C programming interfaces:
     The C programming interfaces of the virtual machine are specifically  designed for e
     asy embedding and extending. With the support of explicit  type specification in fun
     ction parameter list, boilerplate codes for  checking and converting parameter value
     s from Dao data types to C/C++  data types can be easily avoided.  This means writin
     g Dao wrapper functions is significantly simpler than  writing wrapper functions for
     other languages without explict typing  in parameter list. 
  *  ClangDao for automatic wrapping of C/C++ libraries:
     ClangDao uses the C/C++ frontend of Clang to parse C/C++ header files  and generates
     proper wrapping codes for Dao. It has been used successfully  to generate a number o
     f bindings for Dao. 

Other interesting features: 
  *  Object-Oriented Programming (OOP):
     Object-Oriented Programming support in Dao is class based. Dao classes are  similar 
     to C++ classes in several ways with a few new features. 
  *  Abstract and concrete interface:
     An abstract interface defines a set of abstract methods for  static type checking.  
     An concrete interface defines a set of implemented methods for a particular  abstrac
     t interface and attaches itself to a target type such that the target  type can be u
     sed as if it conforms to that abstract interface.  A combination of interfaces and c
     lasses could support  more flexible software design by both compositions and inherit
  *  Deferred block and exception handling by defer-recover:
     Deferred block is a code block whose execution is deferred to the time  when the fun
     ction exits. Defer-recover is a mechanism to handle exceptions  in deferred blocks. 

  *  Code section methods:
     Code section/block method is an alternative to functional methods in other  language
     s such as Python. It is syntactically similar to Ruby Code Block. 
  *  Anonymous function:
     Anonymous functions and closures can be created anywhere in a program.  Their defini
     tion is very similar to the normal functions. 
  *  Mixin class:
     Mixin class supports composing new classes without inheritance.  Class decorator sup
     ports compiling time modification of classes,  and support Aspect-Orient Programming
     through automatic application  of class decorators. 
  *  Enum/flag/symbol type:
     The enum type in Dao is more or less a combination C++ enum and Ruby symbol.  It has
     the advantage of both, and can be used in situations where C++ enum  or Ruby symbol 
     are typically used. 
  *  Variant or disjoint union type:
     Variant type is a combination of two or more types. A variant variable  can hold a v
     alue of any of the combined types. 
  *  Invariable (immutable variable):
     Invariable can be declared with the invar keyword,  as parameters, local variables, 
     global variables and field variables. 
  *  Coroutine and generator:
     Module support for coroutine makes collaborative multithreading simple,  and allows 
     static type checking across the yielding and resuming boundary. 
  *  Customized for-in iteration;
  *  Built-in multi-dimensional numeric array;
  *  Built-in support for string pattern matching;
  *  Built-in hash map type;
  *  Template-like C data type;
  *  Standard help system;
  *  Data serialization;