D29, a prototype

@misc{bugayenko2013blog1229,
  author = {Bugayenko, Yegor},
  title = {{D29, a prototype}},
  howpublished = {\url{https://www.yegor256.com/131229.html}},
  year = {2013},
  month = {dec},
  note = {[Online; accessed 15-12-2024]}
}

D29 is a prototype of a new programming language and a development platform. Well, actually, not a prototype yet, but just an idea. As it looks to me, the languages we have now (even the most modern ones) are still close to COBOL/C and far from being truly elegant and modern.

Would be great if we can design a language/platform, which will be a mix of object oriented programming and functional programming, and will have all the features listed below, out-of-the-box.

Key principles:

• everything is an object
• byte and bytes are the only built-in types
• strict compile-time static analysis

Native support of:

• UML and OCL
• build automation
• aspect oriented programming
• continuous integration and delivery
• deployment, incl. staged one
• collective code ownership
• revision control
• test driven development
• integration testing
• serialization (to XML, JSON, binary)
• documentation preferably with CNL
• requirements traceability
• components repository (a la Sonatype Nexus)
• RAII
• tracing (aka logging)
• internationalization and localization
• generic programming
• software licenses
• multithreading
• deep objects immutability
• manual testing
• performance testing (and others)
• assertions
• versioning
• class invariants
• design patterns (e.g. Adapter, Bridge and Decorator)
• object persistence
• authentication and authorization
• ACID transactions
• distributed objects and their horizontal scalability
• asynchronous methods
• backward compatibility of runtime platforms
• object metadata, like life time, ownership, etc.

Maybe native support of:

• cloud computing

Features:

• no mutable objects (why?)
• no public/protected object properties
• no static properties/methods (why?)
• no global variables
• no pointers
• no enums
• no NULL (why?)
• no scalar types, like int, float, etc.
• no unchecked exceptions (why?)
• no interface-less classes
• no implementation inheritance (why?)
• no operator overloading
• all methods are either final or abstract
• no mutability of method arguments
• no mocking (why?)
• no reflection
• no instanceof operator (why?)
• no root class (like, for example, Object in Java)
• instant object destruction instead of garbage collection

Maybe:

• native support of Java classes/libraries
• compilation into Java byte code

If interested to contribute, email me. Maybe we’ll do something together.

Update: We created it, it’s called EOLANG.