And we're still using '*' for multiplication in our programming languages instead of '×' because using anything other than ASCII for programming is just too hard, or too weird, or whatever.
regarding keyboard presence, this is one of the things that irks me about Mac keyboards is the absence of the # character. I write little programs and scripts on my mac infrequently enough that I have to look up how to type it every blasted time. That, and how to take screenshots. The "Print Scrn" key on PCs spoils me.
X = Y x Z
B = T ^ F v T
P = Q n R u S
C = U cross V
D = U dot V
Area = Width by Height
L . R -> L dot R
L dot R -> Dot[L, R]--------
Related:
In Haskell, any 2-argument function can be used (or defined) infix by surrounding it with backticks, eg:
add 2 3
2 `add` 3
And you can use this to cleanly write curried functions (often predicates) with their arguments flipped, eg:
vowelCount = length . filter (`elem` "aeiou")
Note that functions named with punctuation characters are infix by default, and one can be used/defined prefix by surrounding it with brackets, eg:
(<$>) = fmap
toUpper <$> "aeiou" # => "AEIOU"
It's also convenient for resolving a subset of one of the harder problems in computer science: naming things. For a 2-argument function, use it infix and read it as a phrase in english. Which is clearer:
".jpg" `isSuffix` url
".jpg" `isSuffixOf` url
But unicode in code is terser. Instead of `elem`, we could use ∈ [U+2208].
To flip parameters, we could use the bidi-mirrored glyph, i.e. ∋ [U+220B, the bidi-mirror of U+2208]. In fact we could even make it a feature of the language grammar to automatically detect whether a mirrored glyph is being used, and perform the transformation.
We could even automatically detect and transform canonically equivalent graphemes using the non-spacing version of `not`, e.g. ∉ [U+2209, canonically equivalent to U+2208,U+0338], and ∌ [U+220C, mirror of U+2209 and equiv to U+220B,U+0338].
Everything is alien before it becomes familiar, I think a condensed guide to get people up to speed on the symbols is all that's necessary.
APL doesn't feel like a weird throwback, it feels like it is from the future.
When you say full-APL do you mean in one leap? Then I agree it's not a good idea, but how about going to APL in stages? First introduce just some operators (e.g. × ∧ ∨ ∈ ≥ ≤ ≠ → ⇒ only), then introduce more gradually until all APL operators are in use? Then keep on introducing other symbols from Unicode not in APL.