Db - The Future Is Coming
<FONT color=#0000ff>Download Full Demonstration Application - 1 byte
<FONT color=#0000ff>Download Full Documentation And Examples - 4.01 Terabytes
This article describes the next generation object oriented programming language, called Db (pronounced D-flat), which is a minor but key improvement to the C# (pronounced C-sharp) language. I'm not going to cover all of Db's improvements, just a few to get you started thinking about what's down the road.
First off, classes have always been confusing with all those pubic, protected, and private fields, properties, and methods. To make it easier for simple-minded programmers, and to make it more visual (since we use visual tools), the creators of the Db language have decided to create three different kinds of classes: lower, middle, and upper classes.
LowerClass is differentiated from all other classes in that they have no property and all their interaction is done in fields. Another differentiation is that a
LowerClass has no methods. Other classes interact with a
LowerClass only through its fields, which of course are publicly accessible to the
UpperClass instances. A typical
LowerClass would look like this:
MiddleClass has some methods and some private property. The distinguishing feature here though is that a
MiddleClass doesn't have any fields. A
MiddleClass however can own a
LowerClass, providing the necessary access to fields. For example:
UpperClass has completely private property and methods. In fact, an
UpperClass is so private that its property and methods are completely inaccessible to other class types. All property is not only private but also secured and insured. An
UpperClass only interacts with other
UpperClass instances, usually through design patterns such as
BoardRoom. For example:
In C++, classes could be "friends". Db has a similar concept, automatically applied to
UpperClass instances, called the "
UpperClass instances to communicate with each other.
In C#, exception handling is used to unroll the stack with the "throw" keyword. In Db, this is again made more visually intuitive with the following keywords:
These convey different levels of exception severity and can be used by your application to determine the size of the
bucket needed to catch the exception.
Db includes two exceptions that are used by the .TEN framework to convey exceptional severity:
You will need a very big bucket for these exceptions, as they generally connote a total system failure of the .TEN framework. Sometimes the
bucket can overflow, so you'll need to stack
buckets so they catch the overflow.
Delegates And Events
LowerClass object never has any delegates, but usually has many events. For example:
UpperClass object never has any public events, but many delegates. For example:
anonymous delegate Wife;
Db gives you access to generic
Crystal, and other useful collections. These are cheaper implementations than those found in C#, reducing (if not actually eliminating) memory requirements, and in fact, the new generics actually accelerate the performance of your application. All the generics are handled in the
StreetCorner.Pharmacy namespace. Another benefit to the new generics is that they automatically spawn additional threads. The programmer should be careful that these other threads do not result in schizophrenic or psychotic behavior of the application. However, used in moderation, they can definitely enhance your end-user experience.
The creators of Db took the advice of "Nine Reasons Not To Use Int" to heart, and have therefore omitted the integer value type. All numbers are expressed as rational factorials, in the form of n! + m! ... / a! + b! ... This approach handles real, imaginary, rational, and irrational expressions. It seems those monks were right. By the way, generics are useful when working with these value types. It makes the concept a lot more understandable.
The creators of Db also took the advice of "Nine Reasons Not To Use Serialization" to heart, by omitting all ability to actually save any of your data in any format whatsoever. There is absolutely no serialization support in the .TEN framework, and in fact, it actively ensures that you do not write your own. This completely eliminates any issues with versioning, mysterious operations, etc., and should be welcomed by all programmers. No more serialization hell!
The following keywords, found in C#, have been replaced with better ones.
All classes in Db are automatically abstract. If you really need to do something real, you have to use the "
concrete" or "
In C#, the "as" keyword is way of casting, and will return null if the object cannot be cast to the desired type. In Db, the "
like, you know" keyword is used instead. This keyword will only fail if you are actually working with concrete classes.
The catch keyword has been replaced with "
bucket", so that throwUp can be properly handled.
C#'s lock keyword has been replaced with
lockdown. This immediately prevents any I/O from occurring, safely ensuring that nothing can come in or out of your application until the security administrator removes the
lockdown. This also prevents non-concurrent threads from simultaneously accessing the same fields and creating mass confusion and hysteria among the
The C# try keyword has been replaced with "
hope" (alternatively, "
pray"), as in (see below for brace syntax):
All the "C" languages have been plagued with confusion regarding brace style. Db completely and forever resolves this problem by enforcing different brace styles depending on what the code is doing. For example, there are three kinds of loop expressions, "for", "do", and "while". In Db, these require different brace styles:
This has the wonderful advantage of not needing to put those stupid // end "for" comments at the end of a loop, because know you know what kind of loop is being used by the brace format! This format is enforced by the compiler and will generate a syntax error if you do not comply.
To differentiate with other code blocks, like "if" and and "hope-bucket", the following brace styles are used:
As you can see, the bracing style now conveys useful information.
This extension should only be used if you, and everyone on your team, speaks with a lisp. Otherwise, mixing Lamb-huh and Db will simply result in a lot of confused looks.
Linq stands for Language INtegrated Query. We prefer that you simply don't ask. That way, we don't have to tell you. Ignorance is bliss, as they say. What do you want to query anyways that you don't already know if you just meditated?
Refactoring--sounds like a remake of a B-rated movie. OK, so maybe your code is a B-rated movie. But do you really want to just remake your code with some MaxFactor lip gloss? The Integrated Everything Environment! (IEE!) provided with Db comes with a revolutionary new technology called NEUROFACTOR (trademarked, patented, copyrighted, we'll sue your unborn child before he's a bulge in your pants. Some restrictions may apply. Works only on the male brain. The male rodent brain to be precise. No animals were harmed in testing). With NeuroFactor, simply type what you mean, and the IEE! will automatically translate it into beautiful, fully functional, no need to test, code. Throw away your unit tests, improve productivity by 10000%! Warning. Entering Visual Basic code with NeuroFactor enabled will permanently damage the heuristic AI algorithms.
We hope this has given you a taste of the advancements coming your way in computing languages! And as a final note to the Db language, we'd like to thank the language creators for writing this article in time for the April Fools Day deadline.