1 files changed, 64 insertions, 0 deletions
diff --git a/devel/cobra/DETAILS b/devel/cobra/DETAILS
new file mode 100755
index 0000000000..4f1ccbeb2b
--- /dev/null
+++ b/devel/cobra/DETAILS
@@ -0,0 +1,64 @@
+           SPELL=cobra
+         VERSION=0.9.6
+          SOURCE="Cobra-${VERSION}.tar.gz"
+   SOURCE_URL[0]=http://${SPELL}-language.com/downloads/${SOURCE}
+     SOURCE_HASH=sha512:9fbf5ffb35db3895d74176013f023e6f3c390bc0208a6e02aed6f9f168a85f03b85026452ffe03354b502682803479fb49e429ab3411cf40e477f813d87caf52
+SOURCE_DIRECTORY="${BUILD_DIRECTORY}/Cobra-${VERSION}"
+        WEB_SITE="http://cobra-language.com/"
+      LICENSE[0]="MIT"
+         ENTERED=20140913
+        KEYWORDS=""
+           SHORT="Cobra Programming Language"
+cat << EOF
+$SHORT
+
+There are plenty of object-oriented programming languages in existence
+including C#, Python and Ruby. So why use Cobra? This document addresses
+that question.
+
+Right now, if you want software contracts in your language, how can you
+get them? The answer is to use Eiffel or D. What if you want static and
+dynamic binding? Use Objective-C or Boo. What if you want expressiveness
+and quick coding? Use Python, Ruby or Smalltalk. What if you want runtime
+performance? Use C#, Java, C++, etc. What if you want first class language
+support for unit tests? Use D.
+
+But what if you want all of those? ... You can't get them! And that's
+frustrating because none of those productivity-boosting features are
+incompatible with each other. You shouldn't have to choose between C++'s
+speed, Python's expressiveness and Eiffel's contracts. There's no theoretical
+reason that you can't have it all. There's "just" a lot of work required to
+make it happen.
+
+One way to characterize Cobra is with these high level points:
+
+* Quick, expressive coding
+* Fast execution
+* Static and dynamic binding
+* Language level support for quality
+
+Cobra achieves 1 by following Python and Ruby (but not religiously). It
+achieves 2 by favoring static typing ("i = 5" means "i" is an integer and
+always will be) and leveraging .NET|Mono for machine code generation. It
+does 3 by using the .NET typing system at compile-time for static types,
+and using the .NET run-time for dynamic binding. It takes language features
+for 4 from multiple sources including Eiffel, Python and its own compile-time
+nil tracking.
+
+There are additional refinements in Cobra such as defaulting to accurate
+decimal math and providing detailed postmortem exception reports.
+
+So the "what's new" in Cobra is not the individual elements such as contracts,
+classes, etc. It's the combination of everything that goes into it. Consider
+what would happen if you were coding in Cobra, then switched to another
+language:
+
+    If moving from Cobra to Python, you would give up optional static typing,
+    contracts, compile-time nil tracking, closures and more.  If moving from
+    Cobra to C#, you would give up native contracts, clean collection literals,
+    expressive syntax, uniform compile-time nil tracking, mixins and more.
+
+Note that Cobra has few new elements because it was never intended to be
+experimental. It's a practical synthesis of already-proven features that
+are currently scattered across multiple languages.
+EOF