Efectos Especiales

[I wrote about this before. For the definition of NADD, see this article.]

One of the signs of NADD is having a lot of windows open at the same time. I wonder if that isn't a sign of the times, for programmers, at least. Different developers use different tools, of course, so this will vary from person to person... but a modern programming job at least encourages to use a great many tools, which are often open during programming.

For example, here's what I regularly use when working on my main project (aka "work"):

• Mozilla Thunderbird. Necessary because I get a lot of mail during the day, often work-related. Error messages also come in via email.
• Charm, my homegrown Python editor. (It contains PyCrust, otherwise that would be an extra entry.)
• 4NT, for some decent command line power. Necessary because some programs I'm working on need to be started from the command line.
• Mozilla Firebird. Useful for webcomics looking things up, but also necessary for tracking bugs in Mantis.
• WinCVS. Necessary because all our code is in a CVS repository. (Someday somebody should install Subversion, aside, but that doesn't decrease the number of items in this list. :-)
• MS SQL Server: Enterprise Manager, for making database changes, looking up table definitions, etc.
• MS SQL Server: Query Analyzer.
• Delphi 7. (I try to close this whenever necessary, because it's a resource hog, but it often needs to be open.)
• Various folders with e.g. Python code, Delphi code, etc.
• gvim, for editing certain files (e.g. XML, or test data).
• Trillian, for communicating with clients and team members.
• Terminal Services, for connecting to the client's servers. (Isn't always open, of course, but I need it often.)
• The project's client and admin programs.
• Excel, to keep track of my timesheet (hours worked, etc).
• Xi (simple note-taking program). Necessary to jot down all those thoughts before they fly away.
• RocketLauncher (a small application launcher). Necessary to open all these things quickly (i.e. without having to dig through the Windows start menu).

In other words, having most of those apps open at the same time is a necessity... it's not just a matter of an obsessed mind trying to do 20 things at once. (That is just a pleasant side-effect. ) Closing these programs when you're "done" doesn't really make sense if you may need them again 5 minutes later.

I wonder if other developers have similar experiences. (Feel free to use the comment option; it's not just for spam... :-)

[Update #1] My point, by the way, was not that I want to reduce the number of open Windows... Well, I guess if it can be done without losing functionality or speed, that's OK. But the actual point was that having all those things open is not necessarily a sign of NADD... it may very well be a sign of a busy (programming) job instead. :-)

This spam seems like a haiku gone wrong:

Devised for:
Intensify sexual life ride
Encouragement intimate operation
Abundant and inflexible hard-on
Growth toughness & fortitude

Forms:
Improved solution
Works in less than 11 minutes
Lowest price on the Net

Also, I regularly get spam in languages other than English... Japanese, Russian, and Spanish are some favorites... but the other day I got one in Albanian! What were they thinking?

This looks like an interesting game. Maybe someday I'll get it. Not now, though; we are planning to move to a different state, and I don't really need any extra stuff to carry along.

Of course, this bit doesn't seem promising: "Two of the colors were indistinguishable to the colorblind member of our group, ..." Hmm.

This site has a number of documents, like rules, extended rules, a FAQ, card list, etc.

Advocates of rigid languages often claim that static typing catches a lot of bugs, because it checks types at compile time. Dynamic languages, on the other hand, check things at run time.

I don't know. If checking types was so important, then one would expect that this would be done a lot in unit tests. However, very rarely I write tests that explicitly check types, and I haven't seen it in other people's tests, either.

Maybe it's a bit of a self-fulfilling prophecy. Rigid languages make types important, so whenever you get a type "wrong" (i.e. different from the declared type signature), it's a bug, and the compiler balks loudly. No wonder a lot of these bugs are caught; the language sets the programmer up to make them. By contrast, in a dynamic language, what a type or object *does* is important, not if it matches a certain declaration. As a result, programmers can focus on the actual functionality without having to worry about ballast, and the language doesn't introduce extra opportunity for errors.

Or something like that.

There are more collectible card games than one might think.

It all started with Magic the Gathering, of course. Targeted at a geeky audience, with strong fantasy and D&D influences. It spawned a lot of copycats, and also some original and well-designed CCGs (L5R, Magi-Nation, etc).

These days, there are CCGs for everything. Some try to cash in on the success of certain themes: Pokemon, Harry Potter, Dragonball Z, Yu-Gi-Oh, Lord of the Rings. (But behind the poppy facade there actually might be a good game. For example, Pokemon may not be the most complex of CCGs, but it's rather good.) Other games cater to different audiences... the Bratz Fashion Party Fever Game, or WotC's Star Sisterz. There are also CCGs with a christian audience (Redemption).

By the way, the new Magi-Nation expansion seems to be called Traitor's Reach... not sure if it's actually going to be released, though. Some card previews can be found on insiider.com.

(Via Brainwagon:) The Complete Book of Cheese, on Project Gutenberg. A yummy interesting treatise on all kinds of cheeses, including Dutch ones of course. It also has a number of recipes.

This quote tickled my fancy: "Commodore Coe, of the Montevidian Navy, defeated Admiral Brown of the Buenos Ayrean Navy, in a naval battle, when he used Holland cheese for cannon balls." Hmm...

It's funny... when I don't write, I gain more Bloglines readers than when I do write. What does that tell me...

OCaml really is an interesting language. I am studying it because it's so different from what I'm currently using (mostly Python, a bit of Delphi). It teaches you to think differently about problems, although it's a different different than when studying Lisp or Scheme. :-)

The type system is ultra-strong, and currently gets in the way of my thinking, which is probably an indication that the problem at hand needs to be handled differently.

One example. (Hey, I have to write about *something*, right?) Let's say that in a far future, I would like to write a Lisp interpreter in OCaml. How would I go about that? How would you emulate Lisp-like lists in OCaml?

OCaml's built-in lists are not unlike Lisp's, consisting of pairs with a car and a cdr (or a head and a tail, if you will), and some syntactic sugar for convenience. However, these lists can only be of one type. Any type. So [1;2;3] is valid, and so is ["Guido"; "Larry"; "Xavier"]. But ["+"; 2; 3] is an error. So we cannot use these lists as-is.

Lisp lists aren't just pairs, though. There's also the empty list. So a list node can be either a pair, or the empty list. This can expressed like this:

type 'a lisplist = Nil | Cons of 'a * 'a lisplist;;

The 'a means "any type". A list element is either Nil, or a Cons, represented by a pair of which the first element is of type 'a, and the second of type 'a lisplist.

While this works, it still restricts the list to one type. We need something more. Lisp has many types. What if we define a type lisptype that handles these, and then use a list of lisptype?

type lisptype =
    Int of int
  | Float of float
  | Symbol of string
  | String of string
  | Rational of int * int
  ...
;;

Here, lisptype has several subtypes. E.g. Int is represented by an OCaml int, Symbol by an OCaml string, and Rational by an OCaml tuple int * int. This almost works. What's missing is that a list is also a Lisp type. We could do something like

type lisptype =
    Int of int
  | ...etc...
  | LispList of lisplist
  ...
;;

and

type lisplist = Nil | Cons of lisptype * lisplist;;

but the type checker won't let us define these separately. If we define lisptype first, we get an error because it refers to lisplist, which hasn't been defined yet... and vice versa.

The and construct to the rescue:

type lisptype =
    LispInt of int
  | LispFloat of float
  | LispSymbol of string
  | LispString of string
  | LispRational of int * int
  | LispList of lisplist
and
 lisplist = Nil | Cons of lisptype * lisplist;;

This allows us to have mutually recursive definitons. Nice.

[Note #1] It might be possible to get away with using regular lists... e.g. by using LispList of lisptype list. But that wouldn't give me user-defined pairs. At this point, I'm not sure if using OCaml lists would have the same effect.

[Note #2] The new type(s) can be used like this:

# let a = LispInt 4;;
val a : lisptype = LispInt 4
# let b = LispFloat 3.1415;;
val b : lisptype = LispFloat 3.1415
# let z = Cons (a, Cons (b, Nil));;
val z : lisplist = Cons (LispInt 4, Cons (LispFloat 3.1415, Nil))

(If you'd like to learn more about OCaml, this page has a number of tutorials. And stuff for other languages as well, by the way.)

[Other posts about OCaml: #350, #423, #683]

Available in the usual place.

Not much is new since 0.2.33. Some controls support more styles. Some support the size parameter, which is necessary in certain situations (i.e. setting the size after creating the control does not necessarily have the same effect). Added ShowMessage function (ala Delphi).

Note that some of the work on Wax is currently sponsored by Oasis Digital.