ultimately i think the issue comes down to this: i'm a primitivist by nature and expect programmers, like myself, to know EXACTLY what the machine will execute when i use high level languages like spad, lisp, or haskell. (and to send email by tapping on the correct wire pair in an ethernet cable with a battery.) i "understand clearly what is involved in the abstraction of types in high level languages" as i've implemented several languages, 4 of which were sold commercially and i've been involved in endless language "feature" discussions.
your approach to programming "from the other end of the telescope" tends to view the machine as a distant abstraction and expect programming languages to properly support their abstractions in all their various nuances. thus, you expect that type-thing := other-type-thing type-thing := (cast) other-type-thing type-thing := (coerce) other-type-thing type-thing := thing pretend other-type-thing to "do the right thing" and i tend to run (disassemble) to figure out what it ACTUALLY does on the machine. i'd have to be smoking guano in a batcave before i'd even think to code int-i := (cast int) float-f as this is fundamentally "lying" to the machine. (cast a 747 to an "airplane" and you can land it on any runway). if you approach a language with the expectation of "closed semantics" (that is, everything you write is well defined) you'd expect the previous statement to mean something. by nature i tend to expect languages to have "open semantics" where not everything you can write has meaning and a native speaker of the language will only write meaningful statements. so when you write: > Axiom is supposed to support strong static typing. This would not > be true of it where necessary to know exact internal representations > in order to use fundamental simple constructs in the language. > > When I write 'F pretend Integer' it should mean something that > can be expressed in the Axiom programming language without > reference to the internal representation. we're never going to see eye-to-eye because there is a telescope between us. your view is clearly correct but only if you start with your programming assumptions. Axiom DOES support strong static typing but (at least in my view) it isn't a closed semantics language so sometimes you have to know the internals. in your view the primitive domains would export operations that hide the implementation, fully support the abstractions and have closed semantics. i can build facade patterned structures using agent-based communication among network distributed backends in a functional programming language specified with full denotational semantics but i still need to know what's on the call stack. ultimately you want to appeal to the documentation to see what a language construct means. i kneel before the altar of the machine and see what it does. A pretend B is "knowledge-based lying" in my view and strong static typing in yours. our axioms of what it means to program differ and thus our views differ. t ps. i liked programming in high school. the wang mini with the hand-punched "toaster" card reader kicked ass. :-) _______________________________________________ Axiom-developer mailing list Axiom-developer@nongnu.org http://lists.nongnu.org/mailman/listinfo/axiom-developer