Re: Seeking computer-programming job (Sunnyvale, CA)
On May 16, 1:05 am, Adlai <munchk...@gmail.com> wrote:
On May 16, 7:46 am, Series Expansion <sere...@gmail.com> wrote:
Obviously not Lisp; how can the compiler catch a type error in code
that has no types, just list atoms?
Go back and read what the guy said
How rude.
You can make type declarations in Lisp. They look like:
(declare (float x y z)
(list a b c))
Let me guess: using macros to try to graft on some sort of poor-man's
type-checking?
That seems to cement the case for static vs. dynamic typing -- users
of dynamic languages end up finding ways to emulate static typing!
Do what sort of stuff? Accidentally wind up with a Float in a pack of
Strings? Why would you want to? :)
Do things like have a pack of THINGS, rather than a pack of strings.
Java's List<?> doesn't float your boat? Why?
You can have a heterogenous list and
Lisp won't blink. You can have a function that returns some data, or
NIL if the data is unavailable. You can bind the result of that
function to a variable without worrying about types.
Sounds an awful lot like:
import java.util.*;
....
private Map<Object,String> nameMap = new HashMap<Object,String>();
....
public List<String> getNameList (List<?> list) {
List<String> result = new LinkedList<String>();
for (Object o : list) {
String s = nameMap.get(o);
if (s != null) result.add(s);
}
return result;
}
Lists of anything, methods that return some data or null, a variable
that can hold some data or null -- anything missing?
All of this is actually orthogonal to compiler checks.
No, of course not; without static typing, the compiler has no type
information to use when checking anything, since as far as it knows,
any variable might hold any value of any type whatsoever.
See the above
See above re: faking it.
This is a good example of what would happen if I were using Java (or
any statically typed language; I believe) to do meta-programming.
It's a good example of what would happen if you were to do meta-
programming, period.
At least Java meta-programming doesn't have the bane of macro-based
meta-programming: variable capture.
Variable capture is a useful tool sometimes, for example in anaphoric
macros.
Someone call the doctor -- Adlai has anaphoric macros!
Er -- what are anaphoric macros?
Useful tool? Even if so, variable capture is clearly a dual-edged
sword. Lisp macros? Dual-edged Swiss-army knife, maybe.
Like normal if, when, etc, except that they bind the result of
the test to the variable IT.
Global variables for fun and profit! I bet you guys get ...
*interesting* scaling problems with large projects. :)