By Limin Fu. Released under the GNU Free Documentation License. [NAME] ALL.dao.feature [TITLE] Dao Feature Summary [DESCRIPTION] Key features: * Optional typing with type inference and static type checking: Optional typing allows variables to be declared with or without explicit types. Types will be inferred and checked whenever necessary and possible to allow early detection of bugs. Also explicit and inferred type information could be used do code and function specialization to make programs more efficient. * Just-In-Time (JIT) compiling: A standard module based on the Low Level Virtual Machine (LLVM) compiler infrastructure is provided to support JIT compiling. Currently this JIT compiler module is mainly developed for supporting numeric compuations. * Built-in support for concurrent programming: Concurrent programming is made simple by a number of concurrent code section methods and asynchronous classes. The basic concurrent computational unit is a tasklet which 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 communicate 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 easy embedding and extending. With the support of explicit type specification in function parameter list, boilerplate codes for checking and converting parameter values from Dao data types to C/C++ data types can be easily avoided. This means writing 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 of bindings for Dao. Other interesting features: * Syntax macro: Dao supports user-defined syntax by syntax macros, which can be expressed in a form similar to Backus-Naur Form (BNF). Dao allows syntax macros to be attached with "language" names, and provides a mechanism to avoid unexpected interference with the standard syntax. * 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 interface: An abstract interface is type that defines a set of abstract methods for static type checking. A combination of interfaces and classes could support more flexible software design by both compositions and inheritances. * Deferred block and exception handling by defer-recover: Deferred block is a code block whose execution is deferred to the time when the function 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 languages such as Python. It is syntactically similar to Ruby Code Block. * Typed function decorator: Function decorators are functions that modify the behavior of other functions. Dao function decorators support static type checking. * Anonymous function: Anonymous functions and closures can be created anywhere in a program. Their definition is very similar to the normal functions. * Mixin class, class decorator and aspect class: Mixin class supports composing new classes without inheritance. Class decorator supports 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 value of any of the combined types. * Coroutine and generator: Module support for coroutine makes collaborative multithreading simple, and allows static type checking across the yielding and resuming boundary. * Auxiliary methods: Any type can be attached with auxiliary methods that do not actually belong to the type, but can be invoked as its member methods. * 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; * Mixed programming with embedded C/C++ codes;