Efectos EspecialesRamblings, rants, musings, ideas and observations. Topics include (but are not limited to): programming (especially Python), books, games (especially CCGs and board games), astrology, design, writing, painting, etc.
I always wanted to write about astrology, but never knew how to start. Well, this post is as good a starting point as anything. To quote the final sentence:
If you honestly think that a human being's personality or destiny is shaped by the fact that some guy looked up at a pattern of dots in the sky a few thousand years ago and thought "Ooh! Horsey!", then I'm sorry, you're an idiot.
Neither this Charles person nor the obnoxious astrology fan mentioned in the post seem to actually know much about astrology. Also, I'm aware that astrology has many premises that are unscientific or that scientists frown upon, sometimes rightfully so. But that is not the point (although I might write a separate post about this with some explanation).
The real issue is: why are people, anno 2004, still not allowed to believe whatever they want? If I would write on my blog: "If you honestly think that a supernatural being created you and the world, then I'm sorry, you're an idiot", then this would get me in trouble with christians and people from all kinds of other religions... and maybe some non-religious people as well, because I'm deliberately hurting people's feelings. But if I write a scathing remark about astrology, then it's met with mass approval, especially from the scientific and skeptic crowd.
Like I said, I have wanted to write about astrology for a long time. But even the slightest introduction of it in my old weblog gained me comments such as "Say hello to Santa for me" and the like. Apparently there is quite a lot of venom when you admit you believe in astrology, or even bring up the topic. The aforementioned post is only the latest demonstration of this.
Why is that? Why aren't people allowed to believe in astrology? For the sake of argument, let's say somebody *proves* that all astrology is nonsense and therefore is no more than a belief based on incorrect claims and assumptions. OK, so what? Does that mean I am not allowed to believe in it, or practice it, or talk about it? It does not harm anyone, certainly not to the point that organized religion is harmful. I don't know of any wars fought in the name of astrology, or people being killed in its name. Astrologers don't go door to door, trying to force their beliefs upon you. Nor do they try to curtail the rights of non-astrologers.
Sure, if somebody from religion X takes an obnoxious and fundamentalist stance, they might also meet with hostility and ridicule. But if someone says they went to church, do they get picked on for that? Usually not, partially because we are (supposed to be) taught to be respectful of the beliefs of others. Somehow this doesn't extend to astrology, though.
So, again: why are we, in the year 2004, still not allowed to believe what we want?
[Update #1] Ben Last comments: "You are allowed to believe what you want, as are all of us (at least in my country, and in yours). However, your being granted the right to believe in astrology (to whatever extent you do) does not imply the removal of anyone else's right to disagree with you, attempt to persuade you that your opinions are wrong or to ridicule your beliefs. Sounds like you're asking for the right to believe anything you like without contradiction, which you don't have."
His point is well taken. Maybe I should rephrase my question: Why is it acceptable to ridicule belief in astrology, but less acceptable to do the same with other beliefs (like mainstream religions)? Especially considering that astrology is relatively "harmless", while certain other belief systems are not.
I wrote about Zoids before, though that was a while ago. In short, they are both model kits and toys. Building them is fun, especially if you're not too comfortable building regular model kits, which require glue and paint. Zoids don't. All the part of a Zoid are designed to fit together, without glue. When necessary, rubber caps are used to hold things together. In spite of this, building them is challenging enough to keep you busy for a while.
Also, (most) Zoids move, either by a wind-up mechanism or by batteries. Even if you don't use this feature, it's nifty that they can. It's obvious that a lot of thought went into each Zoid's design.
Most Zoids have one or more "cool" features, from a technical point of view... something that sets them apart from the rest, or from other toys, aside from the different shapes. For example:
- Krark (released by Hasbro as Pteramander) is the only two-legged Zoid that is designed to stand on one leg. The original version had springs in the back guns, so you could actually "shoot" the missiles.
- The early aquatic Zoids (Aquazoid, Hydrazoid, Z-Ray) could actually swim. (Meaning, they float on water, and are capable of moving around there.)
- The original Gorgon had a metal weight in its tail, probably to keep it balanced. (For some reason, Hasbro's release of this Zoid, called Gordosaur, does not have this.)
- Slime, a snail-like Zoid, has hidden compartments in his shell. The snail itself is able to hide in its shell or peek out of it.
- More recent: Energy Liger has "railguns" that use compressed air. (A nice Zoid, by the way, feature-laden, not too easy to build, not too hard, and still for sale at Target and TRU for around $15.)
- Some recent Zoids, like Dark Spiner, Berserk Fuhrer and Gojulas Giga, have two modes in which they can stand or walk.
And so on. If you don't get what's cool about this, then that is probably because you don't understand Zoids.
As seen in this interview with the authors of Programming Ruby:
AW: What are your predictions for Ruby in the U.S. market?
RAs: 1. Ruby will experience explosive growth during 2001-02.
2. Sometime in late 2001, someone will release a Ruby browser similar to VisualAge and the Smalltalk browsers.
3. Ruby will be used increasingly for "live modeling," in place of UML or other static techniques.
4. Ruby will be embedded as a scripting language within other products, as Python was intended to do.
5. Ruby will overtake Python within four years.
This was written in 2001. They still have a year to make #5 come true. Good luck.
I am not bashing Ruby: it is a cool language, and I probably would be using it if I didn't use Python already. But at this point, there's really no compelling reason to switch. So this prediction seems a bit over the top.
Has #2 ever been released? That would be an interesting thing to have...
It's not always clear to newbies how controls are laid out in Wax. Here's a mini-FAQ that answers the most common questions.
To be honest, I often forget what expand and stretch do too... Something simpler and cleaner would be better. Maybe
expand should take a string as well, the first letter of which can be "h" (horizontal), "v" (vertical) or "b" (both). You could then write
which would be clearer to write and to read. The current behavior will not become invalid, by the way, it will just be augmented. (If I choose to do it this way... does anybody see any problems with this approach?)
As for packing, maybe it's possible to pack containers automatically, e.g. when they're added to another container, or maybe after a
Body(). If it works, this feature should be optional, I think.
Not new, but still interesting: Perligata. Writing Perl in Latin.
The Latin is a bit dubious here and there ("countere"?), but it's great/terrible/sick (delete where appropriate) that something like this is possible in a programming language. It cannot be done in Python, not even anything that looks like it. Something similar can probably be written in Lisp, though. (Of course, the question is why you would *want* to, aside from having something interesting to hack on.)
Although it's probably possible to write some kind of preprocessor that translates Latin to Python code... Then again, there's no reason to stick to Latin. Why not Esperanto, for example? Or Japanese?
A link to the "Romanes Eunt Domus" sketch seems appropriate here.
(via Patrick Logan) Quite an arrogant article here: The Dangers of End-User Programming. The article suggests that "dabblers" are somehow responsible for the lack of security in contemporary software, or that they make the problems worse.
First of all, dabblers didn't put the leaks and security risks in Outlook, IIS, Internet Explorer, MS Office, or Windows, to name some of the software that make the news most often. Professionals are responsible for that... people who should know better.
If you have someone write software of critical importance (whether it be for retirement funds, credit histories, etc), you have to make sure it is done by a competent programmer, team or company. Whether that competent programmer is, or started out as, an "end-user programmer", is irrelevant. The people who have this software written are responsible for choosing the right person or company for the job, just like the programmer is responsible for doing his job well.
End-user programmers also have benefits, which are not mentioned in the article. If a programmer writes, say, an accounting package, it helps if he knows something about accounting. Assuming he or she is sufficiently competent in both areas, such a person can be a great boon... programmer and end-user in one. The large gap between programmer and user, that so often occurs, is less of an issue here.
Being self-taught seems to trigger vastly different reactions in people. Some have much respect for the fact that you learned all that stuff on your own. Others think you're not up to snuff because you don't have that diploma (even if you do have the experience). I think that if you're serious, motivated, and have some common sense (qualities that are not guaranteed by a diploma or job title), your software writing abilities can be as good as the next guy's.
Thanks to everybody who replied. I learned a lot. I was under the impression that
lambda was a special form, but this turns out not to be the case. The way I understand it now,
- a "lambda expression" is just a list with
lambdaas its first element.
functionspecial form can evaluate a lambda expression (and turn it into a function, I presume). In addition, it can also look up names in the function namespace.
- You can usually write
(lambda ...)as a shorthand for
(function (lambda ...)), because
lambdais also a macro.
(lambda ...)expands to
(function (lambda ...)).
#'expris expanded to
(function exp)at read time.
lambda is a different beast from Scheme's
lambda. In Scheme it's a special form; in Lisp you have lambda expressions and the
lambda macro. Interesting.
This might be a good question for
comp.lang.lisp, but I'm reluctant to post there.
Lisp has a special form called
function, which can be abbreviated with
#'. At first, I assumed -- to phrase things in Python terms -- that it looked up a name in the function namespace, and returned the function found there. CLTL2 has a different definition, however:
The value of function is always the functional interpretation of fn; fn is interpreted as if it had appeared in the functional position of a function invocation. In particular,
if fn is a symbol, the functional definition associated with that symbol is returned; see symbol-function. If fn is a lambda-expression, then a "lexical closure" is returned, that is, a function that when invoked will execute the body of the lambda-expression in such a way as to observe the rules of lexical scoping properly.
The key here is the usage of
#' with lambda expressions. This has always puzzled me. A lambda already returns a function; there's nothing to look up. But wait, according to this definition, it returns a lexical closure. This suggests that using a lambda expression with
#' produces different results than using it without one.
However, I'm still looking for a code example that demonstrates this. The examples provided by CLTL can be rewritten without
function and still produce the same results:
> (defun adder (x) (lambda (y) (+ x y))) ADDER > (setq add3 (adder 3)) #<CLOSURE :LAMBDA (Y) (+ X Y)> > (funcall add3 5) 8
> (defun two-funs (x) (list (lambda () x) (lambda (y) (setq x y)))) TWO-FUNS > (setq funs (two-funs 6)) (#<CLOSURE :LAMBDA NIL X> #<CLOSURE :LAMBDA (Y) (SETQ X Y)>) > (funcall (car funs)) 6 > (funcall (cadr funs) 43) 43 > (funcall (car funs)) 43
(This output is from CLISP 2.33.1, but running this code in Poplog's Common Lisp produces the same results.)
It seems that
lambda produces a closure with or without
function. So... what am I missing? Is this an archaic convention that once made sense but is now obsolete? Are there Lisp implementations that produce different results for the examples above? Or are there other situations where
lambda makes a difference?
Well, the results are clear... I guess I should stay with this weblog. The problem is more to find interesting topics to write about... but I'll do my best. :-)
Tao of the Machine isn't really "dead", it will stay online, and EE is actually its successor... hence the post numbers starting at #550.
Let's move on...
See the previous post and its comments.
Should I move back to my old blog? Vote "yes" or "no" in the comments. If I get no votes, I will try to get my answer from elsewhere, like the I Ching. ;-)
If you vote "yes": Should I keep the old design, use this one, or maybe use a mixture?
Voting closes Saturday 0:01 AM, EST. (Read: Saturday when I wake up :-)
Design and content © 2004 Electric Shock / Hans Nowak