I am a Linux developer that writes high performance radar applications. Hopefully, the guys on
this post are interested in these comments.
I have been following .NET for years, but I have not incorporated it into our systems.
Please ignore any ignorance I have on this subject. I am considering using .NET instead
of Java based systems for some of our software. I have developed some meta-data facilities
for our C-based radar applications that is similar in concept to the CLI, but it assumes C deserves
it’s own meta-data. It comes with a higher performance, flexible, self-descriptive serialization format that is used between our applications and could be mapped to .NET languages using meta-data.
I felt from the beginning that
The concept of CLI is a good idea, but some languages may warrant their own
meta-data. Languages that are dynamically typed (ie. smalltalk, MATLAB) and
native languages seemed like candidates.
MATLAB being an example of a language that either deserves it’s own meta-data or
some of the concepts in matlab ( flat multi-dimension arrays and vectorized language processing
features) need to be incorporated into the CLI.
Pure C++ with templates instead of generics being another example.
Unlike generics, C++ meta data for template instantiated classes would be
instantiated at compile time. In some situations, this can provide efficiency
C, which still has many customers in the UNIX world, deserves a different set of meta-data.
I doubt all languages can/should conform to CLI meta data unless it is very flexible and/or has
some concept of dynamic properties that can be customized for language differences.
Seamlessness and re-use between native, .NET, and other languages is the main difference
**between .NET and Java. Right now, it seems like this deserves a grade of a C **
C++/CLI and C++/cx seemed to have figured out that object references are needed in both worlds,
Neither works cross-platform and this is the key for people to move from Java to .NET.
There are high performance things that still can not be done in Java and C#. It would be nice
if there was a way to make native things available to other .NET languages in a relatively simple
I like STL and C++, but the direction of C++/CLI and C++/cx these languages seems to
suggest that moving away from templates to generics might be the right thing for native languages
or possibly something called C#/native that has C++/cx generics, object references, and
developer written memory allocation schemes instead of garbage collection built into the language.
Possibly keep something like smart pointers from C++.
I guess the primary reason for hanging onto C++ templates is backward compatibility.
Is there enough performance gain in templates vs. generics?