Quote:Original post by Nathan Baum
This is called dimensional analysis.
...
However, I do see a flaw in your approach. Strictly, the dimensionality of an expression is distinct from its domain. You can measure metres with integers, but also with rationals.
Well, yeah. That was a bit of an oversimplification just to illustrate a point.
However, I think there are some cases where domain
should be explicitly constrained by the data type itself (as in the case of percentages) with additional, non-conflicting restrictions provided by individual functions that operate on that type. To nick an example from Sweeney, we need a way to express stuff like: function Foo(array a, index i [Where 0 <= i < a.count])
Ta for the proper terminology, by the way [smile]
Quote:Original post by Promit
Quote:Original post by ApochPiQ
I'd love to see a language with the library support and rapid-development potential of the .Net family, but with the contract expressivity of something like Eiffel.
I wonder if, just maybe, Eiffel.NET would fit the bill [grin]
I'll have to read that sometime when I'm less tired [grin]
Really, though, I think we need to quit trying to patch existing languages and technologies and start over from the beginning with a good philosophy in mind. Specifically, an emphasis on expressing abstract semantics will be important, and not just in the realm of data types - DBC, dimensional analysis, parallel processing, SIMD and the rest of the multi-data approach to parallelism... there's only so many hacks we can try to munge into C++.
Unfortunately, as many years of long, hard experience with languages has taught us, just having a brilliant language doesn't fix the problem. Languages like Eiffel and Lisp have their (often overly vocal) adherents, but don't take over the world. On the flip side, though, C# has taught us that, with the right hype machine and backing (i.e. probably Microsoft) and the right library (in C#'s case, .Net), a from-the-ground-up language certainly
can make significant inroads and acheive widespread usage.
Because of this, my personal feeling is that we're not going to see The Next Killer Language come from a garage, an open source project, or even a small consortium of developers who are looking to move beyond C++. Frankly I think C++ is useful because it confers so much power and freedom on the programmer (contrast with Java, for instance) while retaining enough low-level semantic expressivity to be useful for low-level and performance-critical applications. The language has had massive staying power despite its glaring flaws simply because it lets us get stuff done in the way we find most effective (within obvious boundaries of course).
I think where we'll see the Next Big Thing is going to be in a language that is designed for maximum freedom of expressivity, not maximum adherence to "good principles." By allowing for flexibility, while still subtly and powerfully encouraging good design (similar to, say, the way C++ encourages resource management via RAII), we can shape a language that remains suitable for low-level development
in the right hands, and yet remains safe and potent for high-level, intensely abstract applications - which is, of course, where productivity and reliability comes from.
OK, time to turn off the Brain Dump Switch [smile]
