# D29, a prototype

Source: https://www.yegor256.com/2013/12/29/proto.html

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]({% pst 2016/nov/2016-11-29-eolang %})/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](https://en.wikipedia.org/wiki/Unified_Modeling_Language) and [OCL](https://en.wikipedia.org/wiki/Object_Constraint_Language)
 * [build automation](https://en.wikipedia.org/wiki/Build_automation)
 * [aspect oriented programming](https://en.wikipedia.org/wiki/Aspect-oriented_programming)
 * [continuous integration]({% pst 2014/oct/2014-10-08-continuous-integration-is-dead %}) and [delivery](https://en.wikipedia.org/wiki/Continuous_delivery)
 * [deployment](https://en.wikipedia.org/wiki/Software_deployment), incl. [staged one](https://en.wikipedia.org/wiki/Staging_site)
 * [collective code ownership](https://www.martinfowler.com/bliki/CodeOwnership.html)
 * [revision control](https://en.wikipedia.org/wiki/Revision_control)
 * [test driven development](https://en.wikipedia.org/wiki/Test-driven_development)
 * [integration testing](https://en.wikipedia.org/wiki/Integration_testing)
 * [serialization](https://en.wikipedia.org/wiki/Serialization) (to XML, JSON, binary)
 * [documentation](https://en.wikipedia.org/wiki/Software_documentation) preferably with [CNL](https://en.wikipedia.org/wiki/Controlled_natural_language)
 * [requirements traceability](https://en.wikipedia.org/wiki/Requirements_traceability)
 * [components repository](https://en.wikipedia.org/wiki/Software_repository) (a la Sonatype Nexus)
 * [RAII](https://en.wikipedia.org/wiki/Resource_Acquisition_Is_Initialization)
 * [tracing](https://en.wikipedia.org/wiki/Tracing_%28software%29) (aka logging)
 * [internationalization and localization](https://en.wikipedia.org/wiki/Internationalization_and_localization)
 * [generic programming](https://en.wikipedia.org/wiki/Generic_programming)
 * [software licenses](https://en.wikipedia.org/wiki/Software_license)
 * [multithreading](https://en.wikipedia.org/wiki/Multithreading_%28computer_architecture%29)
 * deep [objects immutability](https://en.wikipedia.org/wiki/Immutable_object)
 * [manual testing](https://en.wikipedia.org/wiki/Manual_testing)
 * [performance testing](https://en.wikipedia.org/wiki/Software_performance_testing) (and others)
 * [assertions](https://en.wikipedia.org/wiki/Assertion_%28computing%29)
 * [versioning](https://en.wikipedia.org/wiki/Software_versioning)
 * [class invariants](https://en.wikipedia.org/wiki/Class_invariant)
 * [design patterns](https://en.wikipedia.org/wiki/Software_design_pattern) (e.g. [Adapter](https://en.wikipedia.org/wiki/Adapter_pattern), [Bridge](https://en.wikipedia.org/wiki/Bridge_pattern) and [Decorator](https://en.wikipedia.org/wiki/Decorator_pattern))
 * object persistence
 * authentication and authorization
 * [ACID](https://en.wikipedia.org/wiki/ACID) transactions
 * [distributed objects](https://en.wikipedia.org/wiki/Distributed_object) and their [horizontal scalability](https://en.wikipedia.org/wiki/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?]({% pst 2014/jun/2014-06-09-objects-should-be-immutable %}))
 * no public/protected object properties
 * no static properties/methods ([why?]({% pst 2014/may/2014-05-05-oop-alternative-to-utility-classes %}))
 * no global variables
 * no pointers
 * no enums
 * no NULL ([why?]({% pst 2014/may/2014-05-13-why-null-is-bad %}))
 * no scalar types, like `int`, `float`, etc.
 * no unchecked exceptions ([why?]({% pst 2015/jul/2015-07-28-checked-vs-unchecked-exceptions %}))
 * no interface-less classes
 * no implementation inheritance ([why?]({% pst 2016/sep/2016-09-13-inheritance-is-procedural %}))
 * no operator overloading
 * all methods are either final or abstract
 * no mutability of method arguments
 * no [mocking](https://en.wikipedia.org/wiki/Mock_object) ([why?]({% pst 2014/sep/2014-09-23-built-in-fake-objects %}))
 * no [reflection](https://en.wikipedia.org/wiki/Reflection_%28computer_programming%29)
 * no `instanceof` operator ([why?]({% pst 2015/apr/2015-04-02-class-casting-is-anti-pattern %}))
 * 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](https://www.eolang.org).