Qwertie's Scribblings

Complicated SWIG polymorphic return

2011-04-11T10:08:00.006-06:00


////////////////////////////////////////////////////////////////////////////////
// TODO: make this macro compatible with .NET Compact Framework, in which you
// can't return a structure over PInvoke.
//
// There is a problem in case you want to wrap a function that returns a pointer 
// to a base class in SWIG, if that base class could refer to some derived 
// class. For example suppose these classes are defined:
//   class Actor { virtual ~Actor(); ... };
//   class HumanActor : public Actor { ... };
//   class RobotActor : public Actor { ... };
//   class DogActor   : public Actor { ... };
// 
// And there is this function that could return any of the above:
//   Actor* GetActor() { ... }
//
// The problem is that on the C# side, GetActor() will always return a new
// base class object (Actor), instead of the derived class (such as HumanActor).
// There is no easy way to deal with this, but I've written a macro that can
// help if you really need it. To use it, first, invoke the macro:
//
// %cs_return_derived_proxy_by_code(Actor, ActorOrDerivedClass, 0)
// 
// The second name is a special typedef name that tells SWIG when to use the
// macro's special behavior. In order to make the macro apply to GetActor(), 
// change the function declaration to this:
//
// typedef Actor ActorOrDerivedClass;
// ActorOrDerivedClass* GetActor() { ... }
//
// Next, you have to write a global function that obtains a code that will
// be put in a "SwigPtrAndTypeCode" structure to represent the derived type:
//
// %{
//   int GetSwigTypeCode(Actor* a) 
//   {
//   if (dynamic_cast<HumanActor*>(a) != NULL) return 1;
//   if (dynamic_cast<RobotActor*>(a) != NULL) return 2;
//   if (dynamic_cast<DogActor*>  (a) != NULL) return 3;
//   return 0;
//   }
// %}
// 
// Now, when you call GetActor() from C#, the C-side wrapper will return
// SwigPtrAndTypeCode, a special 8-byte structure, instead of Actor*. 
// SwigPtrAndTypeCode contains the pointer to the Actor together with the
// type code returned from your function.
//
// Finally, the C# side will call a function that you must write called 
// NewActorProxy() inside the P/Invoke class. Define it by inserting something
// like the following into your main .i file:
//
//  %pragma(csharp) imclasscode=%{
//   internal static Actor NewActorProxy(SwigPtrAndTypeCode p, bool memoryOwn)
//   {
//    switch(p.TypeCode) {
//    case 1:  return new HumanActor(p.Ptr, memoryOwn);
//    case 2:  return new RobotActor(p.Ptr, memoryOwn);
//    case 3:  return new   DogActor(p.Ptr, memoryOwn);
//    default: return new      Actor(p.Ptr, memoryOwn);
//    }
//   }
//  %}
//
// The third argument is an integer flag saying whether the object is reference-
// counted via %counted_obj. If you use %counted_obj for this type, then set
// IsCountedObj=1. They both change csout, so they are not compatible without this
// little hack.
//
// Note: this macro assumes IntPtr is used instead of HandleRef, but it only
// makes a difference if BaseClassPtrType is used as an input argument type.
//
// Finally, sometimes you may want to return more information to C++ than just
// a type code. In that case you use your own structure in place of struct
// SwigPtrAndTypeCode, and use %cs_return_derived_proxy_by_code2() to specify
// two extra arguments: the name of your structure on the C++ side, then the
// name of the structure on the C# side. Use SwigPtrAndTypeCode as an example.
%define %cs_return_derived_proxy_by_code(BaseClass, BaseClassPtrType, IsCountedObj)
 %cs_return_derived_proxy_by_code2(BaseClass, BaseClassPtrType, IsCountedObj, SwigPtrAndTypeCode, $imclassname.SwigPtrAndTypeCode)
%enddef
%define %cs_return_derived_proxy_by_code2(BaseClass, BaseClassPtrType, IsCountedObj, CppPtrAndTypeCode, CsPtrAndTypeCode)
 typedef BaseClass BaseClassPtrType;
 %typemap(ctype, fragment="CppPtrAndTypeCode", out="CppPtrAndTypeCode") BaseClassPtrType* %{ BaseClassPtrType* %}
 %typemap(in)       BaseClassPtrType* %{ $1 = (BaseClassPtrType*)$input; %}
 %typemap(varin)    BaseClassPtrType* %{ $1 = (BaseClassPtrType*)$input; %}
 //%typemap(memberin) BaseClassPtrType* %{ $1 = (BaseClassPtrType*)$input; %}
 
 %typemap(imtype, out="CsPtrAndTypeCode") BaseClassPtrType* "IntPtr"
 %typemap(cstype) BaseClassPtrType* "$csclassname"
 %typemap(csin)   BaseClassPtrType* "$csclassname.getCPtr($csinput)"
 %typemap(csout, excode=SWIGEXCODE) BaseClassPtrType* {
  CsPtrAndTypeCode p = $imcall;$excode
  #if IsCountedObj
  return $imclassname.New ## %mangle(BaseClass) ## Proxy(p, true);
  #else
  return $imclassname.New ## %mangle(BaseClass) ## Proxy(p, $owner);
  #endif
 }
%enddef

// REAL LIFE EXAMPLE (redacted for simplicity)

// Allow Element* to be returned using the correct proxy class.
// Not Compact Framework compatible.
%cs_return_derived_proxy_by_code2(Element, ElementOrDerived, 1, ElementPtrEtc, $imclassname.ElementPtrEtc)
%fragment("ElementPtrEtc","header") {
 struct ElementPtrEtc
 {
  ElementPtrEtc() {}
  ElementPtrEtc(Element* p) { *this = p; }

  void* ptr;
  ElemType elemType;

  void operator= (Element* p) {
   ptr = p;
   if (p) {
    try {
     elemType = (ElemType)p->Type();
    } catch(...) {}
   }
  }
 };
}
%pragma(csharp) imclasscode=%{
 // Used by %cs_return_derived_proxy
 [StructLayout(LayoutKind.Sequential)]
 internal struct ElementPtrEtc {
  public IntPtr Ptr;
  public ElemType ElemType;
 }
%}
%pragma(csharp) imclasscode=%{
 // Name comes from New ## %mangle(Element) ## Proxy
 internal static Element NewElementProxy(ElementPtrEtc p, bool memoryOwn)
 {
  Element e;
  switch((ElemType)p.ElemType) {
   case ElemType.ITSC:         e = new ItscElem(p.Ptr, memoryOwn); break;
   case ElemType.NAMEDPOINT:   e = new NamedPoint(p.Ptr, memoryOwn); break;
   case ElemType.NAMEDLINE:    e = new NamedLine(p.Ptr, memoryOwn); break;
   case ElemType.NAMEDPOLYGON: e = new NamedPolygon(p.Ptr, memoryOwn); break;
   default: e = new Element(p.Ptr, memoryOwn); break;
  }
  return e;
 }
%}

Changing the FOV in Mass Effect 2

2011-03-19T22:05:00.010-06:00

By default, Mass Effect 2 has a narrow field-of-view, and you may find that the lowest mouse sensitivity setting (apparently called "Camera Sensitivity" in the game) is too high for many mice. Tweaking these settings requires that you change a file called Coalesced.ini. If you installed Mass Effect 2 via Steam, this file will probably be located at one of these two paths:

C:\Program Files (x86)\Steam\steamapps\common\mass effect 2\BioGame\Config\PC\Cooked
C:\Program Files\Steam\steamapps\common\mass effect 2\BioGame\Config\PC\Cooked

This strange file is a binary file that contains numerous text files embedded within it. The file must not be edited with Notepad (which corrupts it if you save changes). It can be edited with Notepad2 (an excellent replacement for Notepad), but there are reports that doing so will cause Mass Effect 2 to crash on startup (I didn't actually verify this, I just assume the reports are true). I don't mean that you shouldn't edit it with Notepad2, just that if you do, then you need to run a special utility that "fixes" the file after you edit it. Apparently the "binary" part of the file needs to be updated whenever the "text" part is updated. It's not possible to do this manually, so you need a special program to do the job for you.

Before changing Coalesced.ini, make a backup, in case you don't like your changes, make a serious mistake, or you can't figure out how to do the "fixing" process.

There are at least three programs that can fix Coalesced.ini: a C++ program, a Ruby program which is, apparently, no longer on the web, and a program called ME2CoalescedEditor. The last one is the one I use. ME2CoalescedEditor is actually intended to help you view, search and edit the various parts of Coalesced.ini, but its user interface is somewhat confusing.

Therefore, you may wish to edit Coalesced.ini with Notepad2 instead, and only use ME2CoalescedEditor to "fix" the file so that Mass Effect 2 can load it correctly without crashing. If you choose this approach,

edit and save Coalesced.ini with Notepad2
Start ME2CoalescedEditor, click the Commands menu, and choose Rebuild Coalesced.
Exit ME2CoalescedEditor (and perhaps start ME2 to test your changes.)

There is actually a fourth option for editing Coalesced.ini, the "Coalesced Compiler", but it comes with its own special "split" version of Coalesced.ini, so apparently it does not let you edit your own original copy of Coalesced.ini.

Changing the field-of-view

My best friend and I play ME2 on a very big screen and we can't stand the default FOV. We need more peripheral vision... a lot more. The default actually 70 degrees; we use 100 or even 110 degrees instead. There is a line in Coalesced.ini that says FOVAngle=90, but apparently this line has no effect.

I found a command that does change the FOV; it's called simply FOV. This command, apparently, must be part of a key binding (Command="....FOV 100...."). Unfortunately, this command overrides the FOV permanently, instead of just changing the default FOV. When you right-click to aim, your view is supposed to zoom in, but if you have already issued an FOV command then it sticks, and your view does not zoom in at all! My solution to this problem is to issue a FOV command when you right-click, and another FOV command when you release the right mouse button.

My solution involves changing the Shared_Aim binding under BIOInput's [SFXGame.SFXGameModeBase] section. It looks like this originally:

Bindings=( Name="Shared_Aim", Command="SwapWeaponIfEmpty | TightAim | OnRelease StopTightAim" )

Change it as follows (change FOV 50 and FOV 100 to match your personal preference):

Bindings=( Name="Shared_Aim", Command="FOV 0 | SwapWeaponIfEmpty | TightAim | OnRelease StopTightAim | OnRelease FOV 100" )

The "FOV 0" command allows the game to revert to its normal FOV.

During cutscenes the FOV will not work correctly correctly. In order to change the field-of-view whenever you want, I suggest binding some FOV commands to an unused key or to the number pad. Under the BIOInput heading [SFXGame.SFXGameModeBase], add lines such as the following:

Bindings=( Name="NumPadOne", Command="FOV 30")
Bindings=( Name="NumPadTwo", Command="FOV 40")
Bindings=( Name="NumPadThree", Command="FOV 50")
Bindings=( Name="NumPadFour", Command="FOV 60")
Bindings=( Name="NumPadFive", Command="FOV 70")
Bindings=( Name="NumPadSix", Command="FOV 80")
Bindings=( Name="NumPadSeven", Command="FOV 90")
Bindings=( Name="NumPadEight", Command="FOV 100")
Bindings=( Name="NumPadNine", Command="FOV 110")
Bindings=( Name="NumPadZero", Command="FOV 0")

Now you should be able to zoom in or out whenever you want by pressing a button on your keyboard's number pad... higher numbers give you more peripheral vision. Particularly important is the num-pad zero key, which releases your FOV override so that the game can choose the FOV. Actually, you'll want to push this key every time you start dialogue with someone, and every time a cutscene starts, so you might want to bind "FOV 0" to a more convenient key... I leave that as an exercise to the reader.

In our apartment we have no need of the lower FOV settings, so we use these fun commands instead:

Bindings=( Name="NumPadOne", Command="Ghost" )
Bindings=( Name="NumPadTwo", Command="Walk" )
Bindings=( Name="NumPadThree", Command="shot")

The "Ghost" command lets you float in any direction, even through walls; "Walk" restores normal walking ability; and "shot" supposedly takes a screen-shot, although I haven't tried it yet. I got stuck in two places in Mass Effect 2, and Ghost allowed me to get un-stuck.

Changing the mouse sensitivity

To make the mouse less sensitive in-game, find the MouseSensitivity line under [SFXGame.BioPlayerInput]:

MouseSensitivity=1.0

Change this to a lower number. For me,

MouseSensitivity=0.5

worked best.

Novial+English

2010-12-30T11:44:00.003-07:00

To continue my thoughts on a Novial-derived IAL... well, I have a couple of ideas. One idea is to create a North American IAL based on English, Spanish and French. This would be an excellent language for unifying the Americas. But how to market it, I am not sure. Another idea is to emphasize English in the language, using other languages only when the English way of saying something is ambiguous (e.g. "hard", "like", "just"), cumbersome due to its length ("understand", "approximately", "mutually exclusive"), or problematic because of its vowels.

Novial has only 5 vowels, while English has 9 or 10 "basic" vowels plus several diphthongs. Now, when we "compress" an English word down to 5 vowels, problems often appear. Either we can import the English spelling, e.g. "meat" pronounced "MEE-at" or "MEE-aht", or we can use the English pronunciation, e.g. "mit" (MEET) for "meat". If we use the spelling, at least two problems appear:

What do we do with double vowels? I don't think we can ask people to pronounce "meet", "see", "book", and "foot" with two separate vowels, and if we say that the vowel is extra-long, people will disagree about how long is long enough. If we change "ee" to "i" and "oo" to "u", conflicts or false friends will appear: consider "boot" vs. "but", "beet" vs. "bit", etc. Likewise if we simply remove the duplicate vowel, "lok" could mean "look" or "lock", "bet" could mean "beet" or "bet", etc.
Some spellings will sound like a different English word: "but" sounds like "boot", "sit" sounds like "seat", and "pan" may sound like "pawn" depending on how you say it ("aw" in "pawn", pronounced the same as "a" in "father", is an acceptable way to pronounce the Novial vowel "a"; it can also be pronounced like the Spanish vowel "a" which is slightly different).

If we use the pronunciation instead, there are even more problems:

Homonyms. English has many words that are spelled differently but sound the same: would/wood, meat/meet, so/sew, two/to/too. One cannot tell these words apart if we only use their pronunciation.
Many unrelated English words would map to the same word in the 5-vowel system. For example, "bit" could be "beet" or "bit", "mit" could be "meet" or "mit", "pan" could be "pan" or "pawn", "nuk" could be "nuke" or "nook", etc.
Some words would look like other English words when spelled phonetically. For example, rid=read, bot=boat.

Clearly, it will be necessary to take words from other languages when these conflicts arise. I consider some of the conflicts minor because one of the words involved in the conflict is minor; for example, the English word "meet" is much more common than "mit", so if we respell "meet" as "mit" then it's not difficult to teach learners that it means "meet", because hopefully they will not naturally confuse it with the uncommon word "mit". "mit" would also sound like "meat", but if we normally choose spellings based on English spellings (instead of the pronunciation), then students will develop an intuition that "meat" should be spelled "meat", not "mit". This, I hope, will reduce the amount of confusion.

In any case, we would mix Novial with English (instead of just using Novial unchanged) purely for the sake of marketing, in accordance with my principles of IAL design. Novial is a very nice language, but it has not succeeded on its own. It needs a hook: something to make people want to learn it. By infusing it with English, it could be marketed at English beginners worldwide.

In my next post I think I will sketch out some ideas for what this mixed language would look like.

Principles of IAL design

2010-12-30T10:52:00.005-07:00

I was conversing recently with Bruce Gilson, who was once part of a committee of 5 to 8 people who were unhappy with the original Novial and wanted to reform it. They made numerous changes which were to be known as "Novial 98"; some I see as beneficial (such as making it possible to easily distinguish nouns from verbs), but for the most part I didn't like N98, firstly because I liked the original Novial design, and secondly because making major changes would discourage the formation of a Novial community by causing dischord between those of differing opinions about the language.

Anyway, in that conversation I suggested a set of principles for IAL design that I would like to share, starting with the three most important:

Sellability: a plausible plan is necessary to get the language adopted by a large population. In my view, the plan should be inherent in the design of the language itself, so as to convince people that it is worth learning due to similarity with some language they want to learn, or to convince people it is so close to their own language that it is "easy". But it could also be a totally separate advocacy plan: convincing the UN or some organization to adopt the language for practical reasons, getting media coverage, convincing philanthropists to donate, finding a business model, etc. Really, both advocacy and language design should be part of the equation.
The greatest good for the greatest number: for example, it's good to take word roots from major living languages and even better to take common roots from multiple languages, so that the IAL is easy to learn for the greatest number of people. (However, designers often disagree about the exact formulation of this principle.)
Expressiveness: the language should be able to express most of the nuances possible in national languages, but this principle is subordinate to (1) and (2): every new word root adds a learning burden, particularly to those who do not know a language from whence the root came, but even familiar roots may need to be looked up in a dictionary in case they turn out to be "false friends". Therefore, adding roots to gain expressiveness can harm (1) and (2), while subtracting roots and senses improves (1) although not necessarily (2). For example, Esperanto religiously minimized the number of word roots. I'm sure this makes Esperanto easier to learn for all kinds of non-Europeans, but clearly the first market for Esperanto was Europeans, so this minimization didn't help the language sell.

Note that it is often possible to increase expressiveness substantially by adding a single word or affix to the language. For example, Esperanto has a suffix "-ema" which means "having a tendency". Because of this, there are a series of words that are easy to learn, such as "amema" (loving, tending to love), "felicxema" (tending to be happy, as in "li estas felicxema" he is a happy person), "parolema" (talkative), and "mangxema" (having a tendency to eat). In English we have special words or ways of saying this, such as "talkative" and "he is generally a happy/sad person", but this single suffix makes Esperanto more expressive, more regular and more concise than English for expressing this particular idea.

Conciceness: One thing that ticked me off about Esperanto was what I called its "longeco", longness. While often EO text was shorter, or the same length as an English equivalent, it took longer to speak. The word "estas" surely should have been shorter, and there were a lot of other examples, for example the "jn" endings made words longer even without adding syllables, "cent" is awkward compared to "sent" so it takes longer to say - I mean, the phonotactics of EO are as bad as English, but unfamiliar to us, and therefore annoying. And the compound words added to its length. I spoke more about conciseness in my previous post.

Now, I put these principles in what I think ought to be the priority order. The number one priority is one that is missing from existing language designs. Some interlinguists in the early 20th century, including Otto Jespersen (designer of Novial) seemed to think it was inevitable that an easy international language would eventually be adopted across the world, but this has proven to be untrue. Clearly, adoption of an interlanguage will not happen without some clever marketing and a lot of effort by a lot of people. Moreover, it is my belief that the language design itself can be a key part of that marketing strategy.

In regard to "the greatest good for the greatest number", I do not interpret this to mean simply that we look at word roots and pick the most common one among several languages. That's not a bad thing at all, but I think it's wrong to limit oneself to that approach and none others. After all, it's rare that you can find a word root used (in the same sense!) by more than a billion people; thus for each word there are at least five billion people who would be unimpressed or baffled by each of your word choices. Therefore, in my view, using existing roots is as much about principle (1) as it is about (2), if not more so. Using existing roots makes it easier for us to get our foot in the door by saying "look how much international vocabulary you'll learn by leaning [IAL X]!" or "look how similar [IAL X] is to [language you want to learn]" or "look how easy this will be to learn because it's so much like your mother tongue".

Note how these benefits disappear when the root comes from a source that a potential learner doesn't care about: for instance, most English speakers don't care to learn Norwegian, Danish or Swedish, and therefore won't like the false friend "at" (which means "to" [infinitive verb marker] in Scandinavian languages and Novial 98). I don't think it will matter to most Englishmen whether the word is "natural" or "a priori" (made up); in either case it is outside their realm of interest, as (I suspect) typical English speakers would rather learn Spanish, French, Japanese, German or even Mandarin before a Scandinavian language. Heck, in America a lot of English speakers might not care to learn anything at all besides more English (evidently, dedicated monoglots are not our target market).

Now, of course, the Scandinavians will doubtlessly like the word choice "at". But a serious project should keep principle (1) in mind and ask itself: what word choices are more likely to lead to more "sales", that is, more people choosing to learn the language? It is sensible for an IAL to focus on one group of languages, such as European languages or languages around India, than to attempt mashing every single major world language together. The result of the latter approach just wouldn't interest enough people, in much the same way that an "a priori" language wouldn't interest enough people.

In the end I would like to see billions of people adopt an IAL. But before that can happen, a community of millions must be built first. It makes sense, therefore, to design a language specifically to appeal to a particular group of 100-1000 millions or so, and once the design is complete, to market the language only to those millions. It doesn't matter much what that group is, as long as you have a plausible plan.

Now, I have no objection to Scandinavian word roots. Nor do I object to "a priori" forms. I just doubt that Scandinavian words would fit very well into a plausible plan required by (1). If I'm right, then Scandinavian words and roots should not be considered much more valuable than a priori forms during language design. Sure, such words are good for (2), but principle (1) means keeping your eye on the prize: building a large community--and I mean large in terms of the number of speakers, not largely dispersed throughout the world, for the sheer distance between Esperanto speakers hasn't helped that language grow.

"a priori" forms have their place because sometimes national languages lack an unambiguous word for a given idea, or a regular system of derivation. The preposition "ye", and the IAL standard of including part-of-speech markers or hints at the end of each word, are good examples. Surely no organic language in the world has a regular, unambiguous system of part-of-speech markers. Yet for the sake of (1) and (2), part-of-speech markers are very valuable, whether a priori (like Esperanto) or only partly a priori (like Novial). In addition, if you believe as I do that the value of a "friend" in one national language is negated somewhat by a "false friend" in another,
it may happen that a neutral a priori form is the safest choice overall.

Bruce opined, "If a language is truly going to be an INTERNATIONAL auxiliary language, it cannot mimic English TOO closely."

I responded: well, that depends on what you think "international" means. I've heard more than one person say that there is already an international language: poor English. I kind of wince when I hear that, since I know that English doesn't function well as an IAL. "International" can mean "international flavor", i.e. resembling several languages, or it can mean "internationally used". I want to see a good IAL meet the second definition more than the first. If it can meet both at once, great. If not, surely it is more important for an IAL to be widely used than for it to be nominally "international".

Novial

2010-12-09T14:35:00.009-07:00

I have been thinking lately about how difficult it is to simplify English enough to make it into a viable international auxilliary language (IAL), Haf Inglish. It can be done, although Haf Inglish would certainly be more difficult than other constructed languages such as Esperanto and Novial. However, although I could make Haf English superficially very close to English, I am concerned that the changes necessary to make Haf Inglish easier to learn also make it so different from English that English speakers would find it hard to learn and use correctly. I worry that their English brains would constantly want to use English phrases that would be illegal in Haf Inglish. For example, I have noticed that certain English words are challenging to learn because they have many meanings, such as "tip". Observe the many meanings:

I gave her a tip of 2 dollars.
I gave her a tip of my hat.
I gave her the tip of my pencil.
I gave her a tip about how to do her job.
I will tip her two dollars.
I will tip her chair. Her chair will tip over.
The sound will tip off the police.

Clearly, if "tip" were to exist in Haf Inglish then it could not have this many meanings, because it would create major difficulties. Besides the sheer difficulty in learning so many definitions, the ambiguities would spill over into any derived forms that you might want to create. For example, would "tippic" mean "related to tips (money)", "related to tipping over", "related to tips (pointy ends)", "related to advice", or (if I may allude to a separate issue) "typical"?

Today, I have been reading again about Novial in this book; and the more I learn about it, the more I like it. Although some of its rules are more complicated than Esperanto, in most ways it is more regular and just plain better. After having learned some Spanish, I am finding that I understand Novial after very little study, probably because a large percentage of Novial closely resembles parts of Spanish and English. In the case of English, Novial usually keeps the spelling and not the pronounciation, but some words, such as "tu" (to), "did" (did) and "vud" (would), also sound similar to English. Novial's author, Otto Jesperson, makes arguments about why his language is designed the way it is, and why he chose particular word forms... unlike Esperanto, which "just is" the way it is.

Another thing I like is that Novial is a compact language like English--you usually don't need a lot of syllables to express something. When learning Esperanto, I often complained about its longness--the fact that I had to say "li estas feliĉa", 6 syllables, to express an idea that is only 3 or 4 in English: "he's happy" or "he is happy". And then there are the redundant grammatical markers, such as "jn" in "Mi ŝatas viajn blankajn ŝuojn" (I like your white shoes), which do not add syllables but still take extra time to pronounce.

In fact, due to its regularity, I suspect that clear speech in Novial will typically be shorter than English, because in English we must use longer words to express our ideas formally or unambiguously. For example, informally I could say that something is "hard", but since this word has two meanings, I need to use the word "difficult" or "hard as a rock" if I want to speak unambiguously. English (and Spanish, by the way) also has some "holes" where no short word exists for a simple idea. For example, the common phrase "I don't understand" is 5 syllables (including long syllables "don't" and "stand"), which is just too long for such a common expression. No wonder English speakers sometimes shorten it to "I don't get it" or simply "what?". Likewise we shorten "simply" to "just", "because" to "as"/"for", "also" to "too", and so forth. These shortenings "overload" the small words with many meanings, which makes English harder to learn. At the same time, it is bad for a language to be too short, if the small words become so tiny that the listener can't hear them anymore. For example, in English "can't take" can be mistaken for "can take"; it's hard to hear the word "is" in "The dog's skillful"; and "Isn't that John smug?" could be mistaken for "Isn't that John's mug?"

Now, Novial probably has some longness issues too, but clearly fewer than Esperanto and probably fewer than English. At the same time, it is probably long enough that a listener won't often "miss" the short words. Only the words "e", "o" and "a" (and, or, to/toward) concern me in that they might be too short, but I'll give them the benefit of the doubt. One thing I don't like is the contraction del = de li, like the Spanish contraction del = de el (which makes more sense--note that you cannot contract Spanish "de la" to "del"), and the fact that you can omit the "i" suffix from most adjectives. The suffix helps the listener (who, remember, is not a native speaker) to clearly understand what is being said. Besides, if there are two ways to say the same word then it'll be harder to find that word on the web (at least until search engines support Novial specifically). Note, however, that Novial words are more invariant than words in most other languages including English. Sure, they change forms when the part-of-speech changes, but in contrast to most other languages, there is only a single verb form. Besides, I consider it largely an advantage, both for communication and searching, that the word form changes when the part-of-speech changes. Anyway, I plan to always include the "i" ending in both these cases.

I also like the fact that Novial almost always uses subject-verb-object word order (e.g. in Novial you say "I love you", and usually not "I you love" or "love I you" or "you I love".) Obviously as an English speaker I am biased, but this and other similarities between English and Novial make me wonder whether Novial can plausibly serve the same goal that I intended to pursue with Haf Inglish. Specifically, I wonder if I could get into the English-teaching business and convince learners that learning Novial would help them learn English. I have no doubt that Novial would help a person learn any major European language, especially English, and like Esperanto, I think Novial could help anyone who is learning a foreign language for the first time, but the trick is to convince others. Haf Inglish has a clear hook, that's why I pursued the idea in the first place, but could Novial suffice? If it can, then it should, for surely Novial is superior as an IAL, even if it is inferior as an approximation of English.

My goal, after all, is not that everyone should learn English or Haf Inglish or any particular language, but that everyone should be able to communicate with one another. How this goal is accomplished doesn't matter much. We can't realistically ask billions of people to learn an enormous language like English, but it would be realistic for billions of people to learn Esperanto or Novial. It would also be realistic to imagine that when one wants to learn English, one starts by learning an easier dialect first (Haf Inglish), and that once Haf Inglish has a hundred million speakers or so, a billion more people will want to learn it instead of English.

Here are some example sentences in Novial and their translations. You'll see two translations; I always like to give a roughly direct translation first, in addition to a paraphrase. Yet Novial is similar enough to English that the direct translation is usually clear by itself.

es plu agreabli tu viva kam tu ha viva o tu sal viva.
Is more agreeable* to live than to have live or to shall live.
It is better to live than to have lived or to live someday.
* Novial lexike lacks a translation for this word
Hir es multi roses: ob vu prefera li blankis o li redis?
Here are many roses: do* you prefer the whites or the reds?
* If we want to be picky, "ob" literally means "whether" and is used to make yes/no questions. "Ob" replaces "do" in questions like "Do you like it?". In questions like "Is it big?", and "Are you happy?", you use "ob" in addition to "es", the word for "is/are": "Ob lum es grandi?" (Whether it is big?) and "Ob vu es felisi?" (Whether you are happy?)
Li blanki es plu bel kam li redi.
The white is more beautiful than the red.
The white one is prettier than the red one.
Li porte non es klosat nun; lum bli klosa chaki vespre e sal anke bli klosa dis vespre.
The door not is closed now; it gets* close every evening and will also get close this evening.
The door is not closed now; it gets closed every evening and will also get closed this evening.
* "bli" only means "get" as in "to become", not "to obtain". "bli" is easier to remember if you think of it as "being": bli klosa = "being closed".
Me non ha e non sal responda.
I not have and not shall* respond.
I have not and shall not respond.
* Technically "sal" means "will", but usually "shall" is an acceptable translation which helps you remember what "sal" means.
Ob vu ha manja? No, non ankore, ma men fratre ha ja e me sal bald.
Whether you have eat? No, not yet, but my sibling has already and I will soon.
Have you eaten? No, not yet, but my sibling has already, and I will soon.
...After studying Spanish (which has something like 100 unique regular verb conjugations plus numerous irregular conjugations), the verb constructions in Novial, which are like English but simpler, are a welcome relief.
Me ama la kom me ha men matra e kom* me sal men filies.
I love her as I have my mother and as I shall my children.
...It may not look like English, but it's nice that the word-for-word translation is perfect English.

As you can see, Novial's grammar and some of its words are often very close to English, just with (perhaps optional) differences in the placement of "not". Of course, when the words look like English words they still don't sound like English words, but at least the pronounciation system is very easy to learn, easier than Esperanto and much easier than Haf Inglish (to say nothing of Full English).

Haf Inglish proegram iydias

2010-10-26T14:27:00.006-06:00

Note: the prefix "dis-" means "oppisit of". "Werdery" means "dictionary" (litterully, "place for werds".)

Soundic uttack

Haf Inglish has soundic spelling, but like English, it has diseasy spelling rules. I woood like to make a vidio game to help persuns to practis to decode spellings.

Base.d on Tetris Uttack, Soundic Uttack woood sho yoo piles of blocks. Each block is labullated with up to five letters and/or simbuls (puncchuayshun). One letter is bold, uujhoolly a vowl or dipthong. Yor goal is to remember the sound that the secund letter makes (which chainjes base.d on the after.ic letters), fiynd uther blocks thut represent the same sound, and moov the relate.d blocks into lines to make them disuppear (gaining points at the same time). The cullers of the blocks under the pointer are sho.d temporerrily. A simmiller game coood be made base.d on Dr. Mario.

Spelling checker/grammer highlighter/werdery

A smaal proegram that checks each werd ugainst the Haf Inglish werd data.set. It coood identifyy misspell.d werds (with red underlines), uuz cullers to identifyy vowls, and uuz styles to identifyy parts of speakness (speshully verbs, the center.ic part of eny sentunce). Nowicly, I myyself often make Haf Inglish spelling errors cuz byy habbit I uuz English spellings. This kiynd of proegram woood be helpful for myy oen writing, not oenly for uthers. Allso, when there be th.ree vowls (or speshul disvowls) in a row, it is less clear which soundic rules applyy, so a proegram woood help to disambiguuify.

The proegram shoood include a werdery with define.shuns. I woood allso like to hav a data.set of fotoes of nouns, so that meaning can be sho.d seeicly.

Metro 2033 graphics bug

2010-09-13T20:51:00.002-06:00

How it's supposed to look

Haf Inglish

2010-08-31T08:00:00.014-06:00

Haf Inglish is my idea for a simplified, one-way-phonetic form of American English designed as either a stepping stone for those learning full English, or as an international language in its own right. It would be marketed as the fastest way to learn English, because you can pick it up much faster than normal English, particularly for those without English immersion.

Its first target audience would be Latin American people, so I'll take advantage of the fact that they can type accents, encouraging (but not requiring) use of accents on stressed syllables other than the second-to-last.

The most common words of Haf Inglish would be pronounced like Standard English, with spelling adjusted to be phonetic. It would be phonetic in the same sense Spanish is: you can predict the pronounciation from the spelling, but not the other way around. The spelling changes are designed so that native English speakers can still recognize the words after the spelling changes, and so that many words are spelled the same way. Consequently, the spelling rules are complex, but not nearly as bad as English.
Haf Inglish does not have the words "am", "are" and "were". Replace these words with "be", "be" and "was" respectively. It still has "is", "was" and "been".
A fixed number of spelling exceptions (under 20) will be allowed for common words like "I" and "the". Exceptions are reserved for very common words, especially those which are hard to recognize (by English speakers) when spelled phonetically, or whose spelling would no longer be unique among synonyms (e.g. be vs bee). Currently I've chosen 14 exceptions: the, of, to, I, be, some, do, their, two, come, know, does, put, knew. Notice that 8 of these (to, I, be, some, their, two, come, know) have homonyms, and if they were spelled phonetically they could be confused with their homonym.
In addition to these exceptions, there are a few words that could be pronounced as they are spelled, but usually/often are not: a, an, been, for. Also, there are a few words which are spelled with an "s" that is pronounced "z": is, ease, always, has. However, in these cases the words are still understandable if the speaker uses an "s" sound, so I don't respell them for that reason alone. I replace "s" with "z" only if the word must be respelled for some other reason.
There are several short English words that end in "e": be, he, me, she, we. We could respell he, me, she, and we as "hee", "mee", "shee", and "wee", but I already decided "be" should be kept the same to distinguish it from "honey bee", and these words seem common enough to justify a special pronounciation rule just for them.
Phonetic rules are based on existing patterns, e.g. a silent e can make a so-called "long" vowel ("bite", "fate" vs "bit", "fat"), vowels sound different at the end of a word ("pot" vs "so"), and double letters force a "short" vowel ("better" vs "meter", "filling" vs "filing"). However, sometimes normal English spelling provides no way to distinguish between two sounds, like the "oo" in book and loot, and for these situations a new rule is required and one category of words must be respelled.
The rules for forming past tense and plurals would be regular with only a small number of exceptions: foot to foots, flyy to flyy.d, read to read.d, etc.; yet still, is to wuz, do to did, and this to these.
A dot (.) is used to separate morphemes to keep spellings phonetic. For example, it is clear in the word "same" that the "e" is silent. However, when forming the compound word "sametimely" (meaning simultaneously), Haf Inglish rules would require the "e"s to be pronounced unless a dot is added to separate the parts: same.time.ly. Two other important issues are past tense and plurals. I think for plurals, there should be a rule that the "e" in "es" is silent, or pronounced "uh" when the plural rules require it. When you consider that 3rd-person singular verb conjugations also use the plural ending, you realize that this ending is very common in English and therefore should be emulated in Haf English. However, I currently think past tense should be marked more regularly, with ".d" for all past tense (and past participle) endings regardless of their pronounciation.
Spelling changes would be designed so that a native English speaker can easily recognize the original word despite the changed spelling, e.g. "hee" for "he", "wuz" for "was". Being a slang spelling, the latter might strike a nerve with some, but you no doubt recognized the word, yes? If possible, a word is made phonetic by adding, removing or changing one letter, e.g. "unit" => "uunit" (where "uu" is pronounced "yoo"), "learn" => "lern".
Uncommon and international words (for example, the word "international") would keep their spelling the same, and pronounciation would follow the HI rules.
There should be a set of about 1000-1500 word roots to be learned for everyday communication; some words would be excluded specifically from the language so that English speakers learning Haf English can specifically learn not to use them. Words could be divided into "beginner" and "intermediate" roots.
The oo in book and the oo in boon would be allophones, but I'm thinking of using an extra letter to indicate the former ("boook")
The th in then and thin could also be allophones, but can we distinguish between them in writing? I notice that when a word ends with "th", it is usually unvoiced: bath, path, hath, myth, wrath; but it is usually voiced otherwise: them, that, they, bathe, lathe. Therefore, in the rare case that "th" is unvoiced but is not at the end, it could be marked with a dot (.): "th.in", "th.ick", "th.ink", "th.ing". However, since "th.ink" and "th.ing" are very common words, inserting the dot every time is a significant burden, so perhaps it should be optional.
The g in dog, age and garage must be distinguished. I propose "g" for gift, "j" for "gist" and "jh" for usual. However, I think the spelling of "usual" should be left unchanged because its phonetic spelling "uujhool" is too far from the original spelling.
s and z are not allophones. With the exception of plurals that are still spelled with an s, s and z must be distinguished by changing some words spelled with "c" or "s" to use "z" instead. Less important words will not be respelled if there is no name collision; instead the learner will be allowed to pronounce the z as an s. For example, you can say "thousund" instead of "thouzund", but you must not pronounce "lose" (looz) as "loose".
Contractions of "is" are allowed, but not "was" or "are" or "am". "don't", "didn't", and "won't" are also allowed. I am reluctant to allow "can't" because it can cause confusion when someone says something like "I can take it"--and listener might think he/she said "I can't take it". Maybe contractions of "have" and "has" should be allowed, but only if it's the helping verb: I've seen and she's seen, but not I've a car or she's a car. Then again, "He's" can mean "he is" or "he has", so if the contraction for "has" is allowed, one must infer the meaning from the context. He's blue and he's eating clearly use "is", but many sentences are ambiguous: "he's leave.d" could mean "he has leave.d" or "he is leave.d".
Words with many meanings make English harder to understand, so to lighten the burden, certain meanings are banned in Haf Inglish. The word pronounced "too" has five meanings in English: "two apples", "to the store", "to eat", "too large", and "you too". The last of these is banned; you must say "yoo allso" instead of "yoo too". The other meanings can be distinguished by their spelling, but are harder to distinguish in voice communication. The word "that" has at least two meanings: (1) "I ate that" versus (2) "I think that you are right" and "the thing that you see". The first is a nounoid (it plays the role of a noun), the second is a connecting word (it is debatable whether the different grammars of the two phrases should be considered different meanings of "that"). I think these two meanings should be distinguished, so I will be using "that" for (1) and "thut" for (2): "I eat.d that" but "I th.ink thut yoo be right".
In the same vein, English allows many words to be either verbs or nouns, which I believe can make it harder for a learner to decode sentences. Haf Inglish will segregate nouns and verbs. Tentatively, "ate" is a suffix to change nouns into verbs, and "ing" changes verbs into gerunds or nouns: verbs "kick", "bite", "see" become "a kicking", "a biting", and "a seeing" and not "a kick", "a bite" and "a view" as in English. The nouns "immij" (image), "Google", and "sex" become the verbs "immijate" or "immijify" (make an image or imagine), "Googlate" (search the web), and "sexate" (have sex).
There will be several minor grammar changes. Usually English-style grammar is correct, but some ways of speaking are correct in Haf Inglish that are wrong (or archaic) in English, e.g. both "I eat.d not the sandwich" and "I didn't eat the sandwich" are correct.
Vowels are of course a disaster in English spelling. So I'm making this post to experiment with a spelling system that is phonetic by translating a short story by Terry Bisson....

They're Made Out Of Meat

They Be Made Of Meat.

"They're made out of meat."

"They be made of meat."

"Meat?"

"Meat?"

"Meat. They're made out of meat."

"Meat. They be made of meat."

"Meat?"

"Meat?"

"There's no doubt about it. We picked several from different parts of the planet, took them aboard our recon vessels, probed them all the way through. They're completely meat."
"Therr's no dout ubout it. We picked sevral frum diffrent parts of the werld, toook them ontoo our scout ships, exammin.d them all the way thru. They're cumplete.ly meat."

"That's impossible. What about the radio signals? The messages to the stars."

That's dispossible. Wut ubout the radio signals? The messijjes to the stars."

"They use the radio waves to talk, but the signals don't come from them. The signals come from machines."

"They uuz the radio waves to tawk, but the signuls don't come frum them. The signals come frum mushéens."

"So who made the machines? That's who we want to contact."
"So hoo made the mushéens? That's hoo wee wont to contact."

"They made the machines. That's what I'm trying to tell you. Meat made the machines."
"They made the musheens. That's wut I be tryying to tell yoo. Meat made the musheens."

"That's ridiculous. How can meat make a machine? You're asking me to believe in sentient meat."
"That's ridicuulus. How can meat make a musheen? You be asking me to beleve in sentient* meat."
* Not phoneticized due to its rarity in English, plus the fact that it is still understandable when sounded out as "senteent".

"I'm not asking you, I'm telling you. These creatures are the only sentient race in the sector and they're made out of meat."
"I'm not asking yoo, I'm telling yoo. These creachurs are the ohnly sentient race in the erria and they be made of meat."

"Maybe they're like the Orfolei. You know, a carbon-based intelligence that goes through a meat stage."
"Maybee they're like the Orfolei. Yoo know, a carbun-base.d intéllijjence that goes thru a meat stage."

"Nope. They're born meat and they die meat. We studied them for several of their life spans, which didn't take too long. Do you have any idea the life span of meat?"
"No. They be born meat and they diy meat. We study.d them for sevral of their life-lengths, which didn't take too much time. Do yoo have eny iydia ubout the life length of meat?"

"Spare me. Okay, maybe they're only part meat. You know, like the Weddilei. A meat head with an electron plasma brain inside."
"Keep me frum it. Okay, maybee they be ohnly partly meat. Yoo know, like the Weddilei. A meat hed with an electron plasma brain inside."

"Nope. We thought of that, since they do have meat heads like the Weddilei. But I told you, we probed them. They're meat all the way through."
"Nope. We th.ink.d of that, since they do have meat heds like the Weddilei. But I told yoo, wee exammin.d them. They be meat all the way thru."

"No brain?"
"No brain?"

"Oh, there is a brain all right. It's just that the brain is made out of meat!"
"Oh, therr is a brain all right. But the brain is made of meat!"

"So... what does the thinking?"
"So... wut does the th.inking?"

"You're not understanding, are you? The brain does the thinking. The meat."
"Yoo be not understanding, be yoo? The brain does the th.inking. The meat."

"Thinking meat! You're asking me to believe in thinking meat!"
"Thinking meat! Yoo be asking me to beleve in th.inking meat!"

"Yes, thinking meat! Conscious meat! Loving meat. Dreaming meat. The meat is the whole deal! Are you getting the picture?"
"Yes, th.inking meat! Conscious* meat! Luvving meat. Dreaming meat. The meat is the hol deal! Are yoo getting the immij?"

"Omigod. You're serious then. They're made out of meat."
"Oh myy god. Yoo be serious then. They be made of meat."

"Finally, Yes. They are indeed made out of meat. And they've been trying to get in touch with us for almost a hundred of their years."
"Fiynully, Yes. They be indeed made of meat. And they hav been trying to get in tuch with us for allmohst a hundrud of therr years."

"So what does the meat have in mind?"
"So wut does the meat hav in mind?"

"First it wants to talk to us. Then I imagine it wants to explore the universe, contact other sentients, swap ideas and information. The usual."
"First it wonts to tawk to us. Then I imajjin it wants to explore the uunivverse, contact sentients, exchainj iydias and informayshun. The uujhool."

"We're supposed to talk to meat?"
"We be expect.d to tawk to meat?"

"That's the idea. That's the message they're sending out by radio. 'Hello. Anyone out there? Anyone home?' That sort of thing."
"That's the iydia. That's the messij they're sending out byy radio. 'Hello. Enywun out there? Enywun home? That sort of thing."

"They actually do talk, then. They use words, ideas, concepts?"
"They acchoolly do tawk, then. They uuz iydias, concepts?"

"Oh, yes. Except they do it with meat."
"Oh, yes. Exceptly they do it with meat."

"I thought you just told me they used radio."
"I th.ink.d yoo just tell.d me that they uuz.d radio."

"They do, but what do you think is on the radio? Meat sounds. You know how when you slap or flap meat it makes a noise? They talk by flapping their meat at each other. They can even sing by squirting air through their meat."
"They do, but wut do yoo th.ink is on the radio? Meat sounds. Yoo know how--when yoo hit or wave meat tugether--it makes a noise? They tawk byy waving tugether therr meat at each other."

"Omigod. Singing meat. This is altogether too much. So what do you advise?"
"Oh myy god. Singing meat. This is alltugether too much. So wut do yoo advise?

"Officially or unofficially?"
"Uffishully or nonuffishully?"

"Both."

"Officially, we are required to contact, welcome, and log in any and all sentient races or multibeings in the quadrant, without prejudice, fear, or favor. Unofficially, I advise that we erase the records and forget the whole thing."
"Uffishully, we are reequire.d to contact, welcum, and log in eny and all sentient races or multi-beings in the quorter, without prejudice, fear, or fayverness. Unuffishully, I advise that we erase the reckerds and forget the hol thing.

"I was hoping you would say that."
"I wuz hoping yoo woood say that."

"It seems harsh, but there is a limit. Do we really want to make contact with meat?"
"It seems harsh, but therr is a limmit. Do wee truely wont to make contact with meat?"

"I agree one hundred percent. What's there to say? 'Hello, meat. How's it going?' But will this work? How many planets are we dealing with here?"
"I ugree wun hundrud percent. Wut's therr to say? 'Hello, meat. How be yoo?' But will this werk? How meny planuts be we manijjing here?"

"Just one. They can travel to other planets in special meat containers, but they can't live on them. And being meat, they only travel through C space. Which limits them to the speed of light and makes the possibility of their ever making contact pretty slim. Infinitesimal, in fact."
"Ohnly wun. They can travul to uther planuts in speshul meat cuntainers, but they can not liv on them. And, being meat, they ohnly travul thru C-space. Which limmits them to the speed of light and makes the possible.ness thut they ever make contact verry slim. Infittessimal, in fact."

"So we just pretend there's no one home in the universe."
"So we simply pretend therr's no wun at home in the uunivverse."

"That's it."

"That's it."

"Cruel. But you said it yourself, who wants to meet meat? And the ones who have been aboard our vessels, the ones you have probed? You're sure they won't remember?"

"Cruel. But yoo say.d it yorself, hoo wonts to meet meat? And the wuns hoo hav been ontoo our ships, the wuns you hav prob.d? Yoo be shur they wo.n't remember?"

"They'll be considered crackpots if they do. We went into their heads and smoothed out their meat so that we're just a dream to them."
"They will be th.ink.d to be dissane if they do. We went intoo their heds and smoothate.d their meat so that we be ohnly a dream to them."

"A dream to meat! How strangely appropriate, that we should be meat's dream."

"A dream to meat! How strainjly fitting, thut we be meat's dream."

"And we can mark this sector unoccupied."

"And we can mark this sector nonocuupy.d."

"Good. Agreed, officially and unofficially. Case closed. Any others? Anyone interesting on that side of the galaxy?"

"Goood. Agreed, uffishully and nonuffishully. Case cloze.d. Eny uthers? Enywun intresting on that side of the galaxy?"

"Yes, a rather shy but sweet hydrogen core cluster intelligence in a class nine star in G445 zone. Was in contact two galactic rotations ago, wants to be friendly again."

"Yes, a rather shyy but sweet hyydrogen core cluster intéllijjence in a class-nine star in G445 zone.

"They always come around."

"They allways warm up to us."

("come around" is an idium not likely to be comprend.d. I th.ink "warm up" can be clear in-context.)

"And why not? Imagine how unbearably, how unutterably cold the universe would be if one were all alone."

"And whyy not? Imajjify how nontolerably, how nonspeakably cold the uunivverse woood be if wun wuz all alone."

The Ultimate 3D Home Theater PC

2010-07-15T12:02:00.004-06:00

The biggest problem with this article by Maximum PC is their suggestion to buy a $95 video card. Friends, there is very little 3D movie and TV content available and you'll probably pay a ton of money for it. Why not spring for a 3D video game PC instead? NVIDIA's 3D Vision will retrofit most of your existing games to 3D. For that you'll need at least a $350 GeForce GTX 470, because 3D mode cuts the framerate in half or worse.

At my place we already have the ultimate budget 3D home theatre system. We got a PJD6531w which is probably the lousiest 3D projector on the market (with e.g. its lower brightness in 120Hz mode), but it cost just $800 (plus over $300 for 2 pairs of glasses including the NVidia 3D kit). Sit 5 feet away from your 100-inch screen, Crank up the field of view of your game to 100 degrees, play around with the "advanced" hotkeys to make objects pop out of the screen, and it's nothing like what you've played before!

Caprica review

2010-07-12T23:14:00.005-06:00

My take after the first 9 episodes: simply put, Caprica sucks.

As a fan of Battlestar, I found Caprica to be huge disappointment from the pilot onward, certainly worse than BSG's final season. BSG, I thought, started great but took a turn for the worse in season 3 and got still worse in season 4. It went uber-dark, characters became increasingly dysfunctional, and the main plot never really came together. Caprica is a couple of notches below BSG Season 4 in every possible way.

Scientifically, the show demonstrates a shocking ignorance of all the science, technology and biology it is based on; any educated person should be offended. It starts with angry teenager Zoe Graystone creating a seemingly perfect replica of herself in cyberspace using little more than various computer records and videos of herself. The absurdity gets worse after Zoe dies, when her father Daniel finds out what Zoe had done and, in just a day or two, builds a completely convincing intelligent being (Tamara Adama) with an accurate and seemingly complete personality and memory, based on nothing more than whatever random database records he could find about this dead person. And that's just the beginning. The show just goes on and on and on with asinine "syfy" that is blissfully unaware of how face-palmingly stupid its technical aspects are.

So the human race developed hyper-intelligent AI using... nothing more than a couple days work from Daniel and a maybe a year of her dead terrorist daughter's free time? Really? That's their explanation for the origin of the Cylons? The same cylons that try to exterminate the human race for no clear reason? Surely backstories don't get dumber than this. This show craps on the memory of BSG, friends.

All the main characters are flawed, unethical to some degree, not all that likable, somewhat bland, and not well developed, so that none of them really stands out from the others. The few meaningful relationships between characters are dysfunctional to the point of being annoying, like Daniel Graystone's passing familiarity with his wife. The plot moves almost glacially slowly, as if they just can't think of anywhere to go with it.

On the plus side, the acting is good and there's enough drama to keep one from falling asleep. But I hate to see a great show like BSG leaving behind nothing but a turd like this.

Charmaine's Tokyo

2010-01-22T10:05:00.004-07:00

If home is where the heart is, then my heart is lost at sea
And I, I have built my palace where the sand and waters meet.

I've been living on this island, I saw you pass me by
Calling out to me, hope within your eyes
Love is an adventure, I'll take my chance on you, on you

Chorus
Rio, France, meet me in Mexico
Chinatown then off to Tokyo
It doesn't matter cause anywhere's perfect with you

City lights, colors of indigo
Sun or snow don't matter where we go
It'll be perfect cause it's all amazing with you

We're singing,
Oh Oh Oh Oh
Oh Oh Oh Oh

Home is where the heart is, and my heart is in your hand
n' you, you can build Your Kingdom in the center of this life.

And I, I'm stepping off this island,
never looking back, you're my only home

Rio, France, meet me in Mexico
Chinatown, then off to Tokyo
It doesn't matter cause anywhere's perfect with you

Oh Oh Oh Oh
Oh Oh Oh Oh
Oh Oh Oh Oh
Oh Oh Oh Oh

(Instrumental 0:23)

Santa Fe, Chile, Romania
Africa then to Australia
It doesn't matter cause anywhere's perfect with you

Open skies, freedom is beautiful
Rain or shine, no matter where we go
It'll be perfect cause it's so incredibly true
It'll be perfect cause it's so amazing with you

We're singing oh oh oh oh-uh-oh-uh-oh
Whoh oh oh oh
Whoh oh oh-uh-oh-uh-oh
Whoh oh oh oh

Fastest Routing Algorithm Ever

2009-04-22T16:43:00.014-06:00

It's called Contraction Hierarchies and it's so awesome.

Contraction Hierarchies: Faster and Simpler Hierarchical Routing in Road Networks.

This paper is 70 pages ... note that there is another paper that has exactly the same title, but is only 15 pages. The latter is pretty much incomprehensible so make sure to only use the long version.

Oh and the same group of German researchers has come up with even faster algorithms, but I think they all use Contraction Hierarchies as a starting point. Dominik Schultes (et al?) made an older algorithm called Highway Hierarchies, but I have the impression Contraction Hierarchies makes it obsolete.

How awesome are Contraction Hierarchies? They're so fast that (assuming you use plain CHs with no further optimizations) it may take longer merely to enumerate (traverse) the shortest path than to find it in the first place! This is possible because CH uses "shortcuts" that skip past most of the individual road segments on the route on the way to the destination.

Important update: there are a couple of things the inventors will not tell you about CHs.

First, although you may have only 100 nodes settled in a CH search compared to 100,000 in a normal highway graph, the fan-out of each node is greater, and there is a performance penalty for that. On the whole it is very fast, but I'm just telling you that while the inventors like to tout the nodes settled ratio (100,000/100), it doesn't reflect the speedup you're actually going to get. Especially not if you're already using heuristics to avoid searching the whole graph.

Second, and more importantly, real-world street-network routing requires a node for every street segment, and an edge for each transition from one road segment to another. This is necessary to model turn restrictions (and turn costs), as there is no other known way to support them. In street networks, this typically makes the graph about 3 times larger (in terms of the number of nodes and edges) than the graphs that the inventors usually operate on (which have a node for each intersection, and an edge for each road). They did make a paper explaining this, "Route Planning in Road Networks with Turn Costs"; however the paper does not explain the performance penalty for using this kind of network. You might think because the network is 3 times larger that it will be 3 times slower, and I assumed as much. However, I found out after implementing a whole system based on this kind of road network that CHs actually perform about 30 times slower, not 3 times slower.

This second problem actually made CHs too slow for large road networks on our mobile devices. When we used Dijkstra's algorithm we could present a partial solution to the user after 5 seconds (a "best guess" about the first few turns the user should make), but a CH does not provide partial solutions nor guesses--in general, you must wait for a unique solution before reporting the first turn instruction. You can present a turn instruction before fully unpacking the route, but in a road network with turn costs, the initial search takes more time than the unpacking. Thus, in the real world CHs are only suitable for faster machines (let's say 800MHz), unless your code is carefully optimized for the specific task of dealing with the CH (unlike my code, which fit the CH into general purpose data structures that were also used by the rest of the system, yielding compute times of 30+ seconds, not including route unpacking).

Far Cry 2 Review (PC version)

2009-02-03T10:36:00.017-07:00

Everyone agrees that the graphics of FC2 are lovely, immersive (if your system is beefy enough), and really well done overall. While some people prefer linearity, I do not--I thought the extreme linearity of Half-Life 2 was the worst part about the game--so I enjoy having the freedom that FC2 gives you to go anywhere at any time. However, the game's storyline is somewhere between nonsensical and nonexistent, none of the characters have much depth, the voice acting is mediocre at best, the missions are repetitive, and there are some problems with the control scheme. Some points to consider:

(1) Perhaps what throws away the game's immersive qualities more than anything else is that even though you're supposedly a "no-name scumbag", the game clearly revolves around you. Ostensibly you are just some guy caught in a civil war between two sides (UFLL and APR), but in fact the supposed two sides are indistinguishable (you can't tell if you are fighting UFLL or APR guys), there are no front lines, and you almost never see AIs fighting each other. Instead, they only fight you. The war does has two sides: you (and occasionally one of your "buddies") against nearly everyone in the entire country. These guys are vicious, too; they are without exception happy to get themselves killed if it means they might put one more bullet in you--even though, again, you're supposed to be some anonymous guy with malaria. In the second battle I was in, the AI aimed their Jeep directly at me going full speed. I jumped out of the way, and they slammed directly into a large tree. That's how obsessed they are! Plus, especially if you play in Hardcore mode, the enemies can somehow recognize your face at 300 yards away so they know it's you (therefore they have to kill you) and not somebody else (who they would allow to pass freely). Just as in the first Far Cry, the enemies often seem able to see you in the bushes, but you can't see them (regarless of whether it's you or them hiding behind behind a bush). PontifexPrimus on /. puts it more colorfully:

The enemies are incredibly annoying. And I know that a FPS needs enemies that harass the player, and I can accept that - but here it is getting ridiculous. Every time you pass through the dense, dimly-lit jungle and any of the faction catches sight of you they will catch your scent AND THEY WILL NOT LET UP UNTIL YOU HAVE GUNNED EVERY LAST FUCKING ONE OF THEM DOWN! I mean, seriously, let's talk realism, since that seems to be the great selling point: imagine you're a member of the Imaginistani Militia, posted in the deep forest, told to keep an eye out for your mortal enemy, the Imaginistani Rangers. You spy a single person creeping through the jungle, trying to bypass your guard post without being noticed. So now you sound a general alarm, alert every patrol in a two-mile-radius, call in reinforcements on the radio, tag that creeping guy with a giant "please shoot me" neon sign, grab your weapon and go with every other person in that outpost on a single-minded suicide mission trying to KILL THAT ONE GUY whatever the cost, leaving the guard post... unguarded? Does that sound realistic?

(2) Ostensibly you're in the country to kill the "Jackal" guy who keeps the war going, so ostensibly you're the good guy, but for some reason you reach this goal by killing hundreds of random people that have nothing to do with this supposed objective.

(3) The control scheme has issues. For example if you want to run for cover, you are only allowed to run straight forward (strafing disables running) and if you are reloading, the game forces you to finish reloading before you can run or switch weapons.

(4) The bus stations that take you long distances have no staff. No ticket agent, no bus drivers, riding the bus is free, it's perfectly safe, there are no other passengers, and it gets you to your destination much faster than driving. Make sense?

(5) Virtually everyone in the country is male and heavily armed. There are practically no civilians (occasionally you'll see a few unarmed people sitting down in an "underground" safehouse) and there are absolutely no children. Setting aside how unlikely this is, the lack of civilians means that you don't have any missions where your job is to save a village or do something good--it's always "kill this person" or "blow this up". And even though you have the freedom to go anywhere, the game doesn't advance until you complete these "prove-what-a-douchebag-you-are" missions.

(6) There are magic boxes all over the map. Put your gun in a magic box and pull the same gun out of another box 20 miles away. Or how about the gun shop (which is normally unstaffed) where you buy the guns on a computer and the guns you bought magically appear in a warehouse next door. Make sense?

The problem is that while the graphics are highly immersive, the gameplay mechanics are absurd enough to pull you out of the immersion.

Finally, if you were expecting Far Cry 2 to be a sequel to Far Cry, you will be disappointed. Not only is the storyline unrelated, but certain elements that made the original Far Cry memorable have been deleted. Most notably, no longer do the bad guys make humorous conversation as you watch them with your binoculars (actually your monocular). Also gone is futuristic technology, mutants, and palm trees. Crysis is certainly closer to the original Far Cry than Far Cry 2, but Crysis also lacks the comical-mercenary elements that, to me, directly added to the fun of what is, after all, a Rambo game.

Oh, and the FOV is quite poor, but there is a hack so you can increase it to your liking.

Ahh, DRM!

I almost forgot the evil DRM! Like most games today, you must play with the DVD in the drive even though the entire game is stored on your hard drive. The SecuROM copy-protection software that you, as a paying customer, are forced to install and cannot uninstall, will not let you play the game if a copy of the disc rather than the original is in the drive. But the worst part is that the damn thing can't reliably tell the difference between a copy and the original! Several times now the game has refused to run with the bona fide original disc in the drive; luckily I have been able to get around this by moving the disc to the other drive (as we have two DVD drives).

I am seriously considering a vow to pirate any game that treats its paying customers to this DRM in the future.

Verdict: 6/10, or 4/10 if you count SecuROM.

For more reviews by disappointed fans, click the title of this entry, and scroll down to the player reviews.

English-esperanto dictionary for Pocket PC

2008-12-13T12:33:00.004-07:00

Quite some time ago I wrote this little dictionary program for Pocket PCs (Windows Mobile). It translates words between English and Esperanto and you can even modify entries in your own personal copy, or create new entries.

I don't remember where I got the dictionary itself. It isn't high-quality. There are many errors, unhelpful translations, and some words missing, but this is typical of the Esperanto-English dictionaries I have seen.

The dictionary is stored as a trivially simple text file, which means it is possible to edit the dictionary in Notepad or, if you are a programmer, you could easily write a program that transforms other dictionaries into a text format that this program would understand.

It's very easy and quick to use. Just type the first few letters of a word and the dictionary will instantly search both the English-EO and EO-English dictionaries at once. The definitions are shown in a large font, in case you have a small Pocket PC phone or poor eyesight. When it shows the list of results, just press up and down on the Pocket PC's directional pad.

However, I never released this program before because I never polished it. The biggest problem is that it takes at least 30 seconds to start up (on the Pocket PC).

The program is written in C#. The cool thing about this is that the same program runs equally well on your PC!

Download Interdictionary.cab
To install it on your Pocket PC, open your device in My Computer, and copy the CAB file to the device. Then, on the device, run File Explorer and find the same CAB file. Double-tap to install it, and then it will appear in your Programs list.
Download Interdictionary.zip
This zip file contains the cab file above, plus the contents of the cab file so you can run the dictionary on your PC. To use, unzip this file, then double-click PPCDictionary.exe. Please note that the .NET Framework 2.0 must already be installed (it is installed on most computers already).

If you want the source code, just email me (gmail.com, qwertie256 at). You could also use Reflector to decompile it, which is always fun.

In ATL, you can't derive one coclass from another.

2008-11-25T14:06:00.002-07:00

Click heading for discussion.

> I understand why you might want to have a deep hierarchy of
> implementation classes (this style was popular at one point - witness
> MFC - but has fallen out of fashion lately). But why would you want a
> deep hierarchy of _interfaces_?

Because the derived classes add additional functionality [and there must be a new interface to invoke the new functionality]. In my case--without going into irrelevant proprietary details--I have a 'painter' class that paints stuff, a 'control-base' class which implements a basic GUI control around the painted stuff, and a 'control' class which adds extra standard functionality.

Typically the user would either instantiate 'control-base' and customize it (picking and choosing the functionality desired and composing that functionality manually), or just use 'control' for a standard set of functionality. While I suppose this doesn't *have* to be designed as a hierarchy, the code was already written that way before I knew I would have to turn it into a COM component.

>You are busy confusing interface inheritance and implementation
>inheritance. These are two different things.

Actually I never confused the two, although I may have presented my thoughts in a highly confusing manner. Sorry about that! When I said IA and IB share a common interface, the common interface I meant was IA.

Anyway, I have now implemented my COM hierarchy and it's working great. Thanks for your help. I ended up doing pretty much what it says to do at http://vcfaq.mvps.org/com/8.htm -- to summarize what I did, I have

1. Implementation non-template classes A, B, and C (C derives from B derives from A) which don't necessarily use ATL or COM at all
2. COM interfaces IA, IB, IC (IC derives from IB derives from IA)
3. Wrapper classes CImpl, BImpl and AImpl (CImpl derives from BImpl derives from AImpl derives from I); AImpl contains a pointer to an object of type A, B, or C depending on which ATL class is using it
4. ATL classes CA, CB, and CC which are totally separate and unrelated. CA, CB, and CC have base classes AImpl<IA>, BImpl<IB>, and CImpl<IC> respectively.

MIDL changing your property name to lowercase?

2008-11-24T13:39:00.004-07:00

I had a "FileName" property in my interface...

interface IMyFile : IDispatch {
   ...
   [propget, id(6)] HRESULT FileName([out, retval] BSTR* pVal);
}

and somehow in the TLB this came out as "filename" - all lowercase.

It turned out to be a really weird bug in MIDL. It was triggered because I had a method that takes a parameter called "filename". I had a method like this:

interface IMyFile : IDispatch {
   [id(1)] HRESULT OpenFile(BSTR filename, long reserved);
   ...
   [propget, id(6)] HRESULT FileName([out, retval] BSTR* pVal);
}

See, MIDL changes the case of the property (or method?) to match the case of the parameter. The solution was to rename the parameter "filename" to "FileName". This even happens if the matching parameter name appears in an unrelated interface!

.NET Compact Framework unmanaged callbacks: bool not invited

2008-09-17T11:07:00.004-06:00

The .NET Compact Framework 2.0 is supposed to support unmanaged callbacks: you pass a delegate into C/C++ code via P/Invoke and the Framework converts it to a thunk. It passes the thunk to C/C++, and when the C/C++ code calls the thunk, the thunk calls your delegate.

Previously I had success passing strings:

// C# declaration
public delegate void ExceptionArgumentDelegate([MarshalAs(UnmanagedType.LPWStr)] 
    string message, [MarshalAs(UnmanagedType.LPWStr)] string paramName);
// C++ declaration
typedef void (__stdcall* ExceptionArgumentCallback_t)
    (const wchar_t *, const wchar_t *);
void SetCallback(ExceptionArgumentCallback_t callback);
// P/Invoke declaration
[DllImport("DllNameHere", EntryPoint="SetCallback")]
public static extern void SetCallback(ExceptionArgumentDelegate callback);

But I couldn't pass the following delegate type:

// C# declaration
public delegate bool ProgressCallback([MarshalAs(UnmanagedType.LPWStr)] 
    string message, int itemsProcessed, int totalItems);
// C++ declaration
typedef bool (__stdcall *ProgressCallback)(PCTSTR, int, int);

I get a NotSupportedException with the rather vague error message "0x80131515". Thanks Microsoft! Well, it turns out that a callback is not allowed to have a bool return type. The solution: change the return type on the C# side to int, then return 0 instead of false and 1 instead of true. Just to be on the safe side, you might want to change the C++ side to return int also. But that wasn't needed in my case (XScale PXA processor).

Interestingly, my cursory examination suggests you are allowed to pass bool as an argument, and even ref bool works (ref bool corresponds to bool* on the C++ side).

Simulating covariant return types

2008-09-12T00:44:00.005-06:00

For several years, Microsoft engineers have refused to add support for covariant return types, a trivially simple feature that should have been in the CLR from the beginning.

Suppose you want to write a Clone() method that returns a copy of the current object. If implementing an interface, you can use this workaround in C# that uses explicit interface implementation:

class MyCloneable : ICloneable {
    public MyCloneable Clone() { ... }
    object ICloneable.Clone() { return Clone(); }
}

The above workaround is okay for implementing an interface, but what if you are writing a class hierarchy, and you want a Clone() method that is virtual but has the appropriate return type?

class BaseNode : ICloneable
{
    object ICloneable.Clone() { return Clone(); }
    public virtual BaseNode Clone() { ... }
}
class ComplexNode : BaseNode
{
    override BaseNode BaseNode.Clone() { return Clone(); } // Error!
    public ComplexNode Clone() { ... }
}

Oops, the workaround that you use for interfaces is illegal for class inheritance. There is still a solution, though:

class BaseNode : ICloneable
{
    object ICloneable.Clone() { return Clone(); }
    public BaseNode Clone() { BaseNode c; Clone(out c); return c; }
    protected virtual void Clone(out BaseNode clone) { ... }
}
class ComplexNode : BaseNode
{
    public new ComplexNode Clone() { ComplexNode c; Clone(out c); return c; }
    protected override void Clone(out BaseNode clone) { clone = Clone(); }
    protected virtual void Clone(out ComplexNode clone) { ... }
}

That's right. You need six Clone() methods. The last method is virtual in case you want to make a class derived from ComplexNode, e.g. VeryComplexNode:

class VeryComplexNode : ComplexNode
{
    public new VeryComplexNode Clone() { VeryComplexNode c; Clone(out c); return c; }
    protected override void Clone(out BaseNode clone) { clone = Clone(); }
    protected override void Clone(out ComplexNode clone) { clone = Clone(); }
    protected virtual void Clone(out VeryComplexNode clone) { ... }
}

Without covariant return types, you have to to define an additional virtual function for each additional derived class.

Integer conversion from HSL to RGB

2008-06-25T12:41:00.003-06:00

A hue-saturation-lumination to RGB conversion that uses no floating point.

Inputs and outputs are in the range 0 to 255.

Derived from an incredibly old floating-point algorithm.

void HSL_to_RGB(int hue, int sat, int lum, int* r, int* g, int* b)
{
    int v;

    v = (lum < 128) ? (lum * (256 + sat)) >> 8 :
          (((lum + sat) << 8) - lum * sat) >> 8;
    if (v <= 0) {
        *r = *g = *b = 0;
    } else {
        int m;
        int sextant;
        int fract, vsf, mid1, mid2;

        m = lum + lum - v;
        hue *= 6;
        sextant = hue >> 8;
        fract = hue - (sextant << 8);
        vsf = v * fract * (v - m) / v >> 8;
        mid1 = m + vsf;
        mid2 = v - vsf;
        switch (sextant) {
           case 0: *r = v; *g = mid1; *b = m; break;
           case 1: *r = mid2; *g = v; *b = m; break;
           case 2: *r = m; *g = v; *b = mid1; break;
           case 3: *r = m; *g = mid2; *b = v; break;
           case 4: *r = mid1; *g = m; *b = v; break;
           case 5: *r = v; *g = m; *b = mid2; break;
        }
    }
}

Circular Template References in C++

2008-06-04T19:14:00.003-06:00

I wanted to have three template classes, designed to work together, that could use facilities in one another, in such a way that any of the three classes could be replaced with a different version--something like what "Boris" describes here, just more complex.

It didn't seem possible and I had just about given up--I decided instead that I would give each class a non-template base class with limited functionality, and then each class would access the other two classes through this more limited interface. But on the train on the way home from work it hit me: a special "traits" class would make it possible to use circular references between templates. Here is an example:

#include <stdio.h>

template<class Combo> struct A
{
  typedef typename Combo::b_t B;
  B* b;
};

template<class Combo> struct B
{
  typedef typename Combo::a_t A;
  A* a;
};

struct MyCombo {
  typedef A<MyCombo> a_t;
  typedef B<MyCombo> b_t;
};

int main(int argc, char* argv[])
{
  A<MyCombo> a;
  B<MyCombo> b;
  a.b = &b;
  b.a = &a;
  return 0;
}

Showing current line number of a TextBox (Windows Forms)

2008-03-26T10:12:00.004-06:00

You need code like:

label.Text = string.Format("Line {0} Col {1}",
txt.GetLineFromCharIndex(txt.SelectionStart) + 1,
txt.SelectionStart - txt.GetFirstCharIndexOfCurrentLine() + 1);

But the above needs some adjustment because it doesn't work correctly when the user selects multiple lines (eg the column may be negative).

You need to update the line/column number upon these events:

Click
KeyDown
KeyUp
KeyPress (maybe? not sure)
TextChanged

No event is fired if the cursor position changes programmatically.

When the user presses arrows or Home/End/PgUp/PgDn, KeyDown is fired before the cursor position actually changes, so you trap it only to show the line number changing when the user holds down a key. KeyUp is fired after the cursor position changes to you can show the correct value.

You might want to show line numbers beside the text box, e.g. using a series of labels on the left side of the TextBox. This is not possible, at least not using pure Windows Forms code, because TextBox does not generate any events (not even click events) when it is scrolled via its scrollbars.

Dif between "attributed" and "unattributed" ATL projects (VS 2005)

2007-08-07T14:25:00.001-06:00

I'm trying to figure out how to make COM objects (note that the Microsoft-approved way to make them is with ATL). First obstacle: what's this "attributed" nonsense?

Only the attributed version defines _ATL_ATTRIBUTES in the project settings.
Attributed version doesn't include a .tlb file from its .rc resource file.
In the main .cpp file (ProjectName.cpp), the attributed version has just one empty class (CProjectNameModule) with a [module] attribute attached. The nonattributed version has the same class without the attribute, and this time the class is derived from CAtlDllModuleT<CProjectNameModule> (instead of nothing) and uses DECLARE_LIBID and DECLARE_REGISTRY_APPID_RESOURCEID inside it. In addition, the nonattributed version has DllMain, DllCanUnloadNow, DllGetClassObject, DllRegisterServer, DllUnregisterServer. All these functions make calls into an object called _AtlModule of type CProjectNameModule; oddly there is no such object in the attributed project.
Only the nonattributed project has ProjectName.def and ProjectName.idl. The .def mentions DllCanUnloadNow, DllGetClassObject, DllRegisterServer and DllUnregisterServer; the .idl has a single construct, "[...] library ProjectNameLib {...}".
Only the nonattributed project has the generated files ProjectName.h and ProjectName_i.c which define a few mysterious things.
When you make an ATL project you get a sibling project with a "PS" suffix. This extra or "bonus" project is not compiled by default and starts with only one source file, ProjectNameps.def. 'PS' evidently stands for Proxy/Stub.
Other files are generated that I'm not mentioning (see readme.txt in the generated project)

As they build, both projects spend time processing a bunch of mysterious ".idl" and ".acf" files that are not in the project. Then it looks like the generated DLL's GUID(s?) are automatically registered in the registry.

The docs say "An attributed project does not allow support for MFC or merging of proxy/stub code." but it doesn't give any reason, so I'm baffled.

This attributed/nonattributed stuff is in effect permanently:

When you go to create a new COM class on the attributed project (right click project, choose Add => Class, then ATL Simple Object), you get an "__interface IMyComClass" and a "class CMyComClass" derived from it in your C++ header file (MyComClass.h), with attributes attached that cause code to be generated in "_ATLProjectAttributed.idl" and in other files (files that are not in the project's list of files).
When you create the same COM class on the unattributed project, you get something quite different. In the header (MyComClass.h) you only get a definition for CMyComClass, not IMyComClass; and this time CMyComClass has three base classes, and uses the DECLARE_REGISTRY_RESOURCEID and BEGIN_COM_MAP(...) ... END_COM_MAP() macros inside the class. IMyComClass is defined in ProjectName.idl (the attributed project has no .idl listed). The .def file is unaffected.

In both cases, the MyComClass.cpp file starts empty and gets filled as you add functions/properties (by right-clicking COM interfaces in Class View). Interestingly, Class View lists the interfaces just as well for the unattributed project, even though the interfaces are declared in an .idl file, not a C++ file. Here's something I find very intriguing: just after you generate a "MyComClass" class with a wizard, IMyComClass immediately shows up in the Class View. If you refer to IMyComClass in code and press F12 you are taken to the definition in the .idl file. However, after you compile your project, put the cursor on IMyComClass and press F12 again. This time you're taken to the definition of IMyComClass in the generated C++ header file. In Class View you'll see IMyComClass listed twice; one refers to the .idl and one refers to the .h file. An intellisense member list for the interface won't appear until after the project has been compiled.

Links:

What's wrong with Java

2007-07-12T10:59:00.000-06:00

When I see the features added recently to Java, I'm sure glad I'm using .NET, C# and boo. Even though Java is a lot older than .NET, .NET seems to get the good features first. Care in point: Generics. For a former C++ developer, it seems stupid to give up type-safe collections; I don't know how many years it took before Java got generics (10?) but .NET got them in much less time (less than 4 years, I do believe) and Java was left playing catch-up. In fact, most of the "new" features in Java 5.0 seem to be things that C# had from the beginning:

enhanced for loop (foreach in C#)
autoboxing/unboxing
enums
varargs (variable argument lists - "params" in C#)
annotations (much like .NET attributes)

Java generics aren't even supported by the JVM, so you get the same performance penalty from casting that you did before. I've always been unhappy with Java's performance (especially for GUI programs), whereas .NET just doesn't seem slow.

Look, Sun, if nothing short of competition from Microsoft can prompt you to improve Java, you must not care very much much about it.

Let's see, what else...

Value types (structs). This is a big one for me because can offer a big performance boost in many situations. You don't want to allocate a new object if that object contains nothing more than an integer and some methods, do you? A new object sucks up at least 16-20 bytes of memory even if it just contains one integer or reference; creating it requires multiple method calls and all those bytes have to be initialized. Useful value types include

A "Point" type that has X and Y coordinates
A "FixedInt" type that contains a fixed-point number (the language must support operator overloading to make it easy to use, of course.)
A "BigInt" type that contains a small integer normally, but allocates a memory block for a large integer if necessary.
A "Handle" type that contains an opaque reference to something else
A "Symbol" type that contains a numeric identifier that represents a string (symbols are a built-in feature of Ruby and are typically used like enums, except they are more flexible)
A Pair type that contains a pair of values A and B; often you get better performance by not allocating memory for this purpose.

Multi-language support. Well, the JVM can certainly support multiple languages, but only .NET is specifically designed for it. Admittedly, the design isn't that great, but at Microsoft specifically considers the needs of other languages.
Delegates. The Java equivalent is using interfaces with one function in them, but this is relatively inflexible and certainly more annoying to use. Java provides inner (even anonymous) classes to help people use the pattern, but delegates are way better.
Closures (functions inside other functions, where the inner function can access local variables of the outer function). Java doesn't have that, does it? You can access "final" variables from a function-inside-a-class-inside-a-function, but that's all. By the way, .NET itself doesn't actually support closures, but C# fakes it well.
Iterators. Now this may be my favorite feature of C# 2.0; it would be hard to choose between iterators and generics. I love them not only because you can create enumerators easily (which is great) but also because you can approximate coroutines with them.
Swing. Ugh! It's ugly, it's slow, and the Windows "skin" isn't very convincing. There often seem to be glitches in Swing that you don't find in other programs, such as the failure to resize a window fluidly (i.e. the window doesn't redraw itself until you let go of your mouse button). Finally, and worst of all, developing Swing GUIs is a huge pain in the ass. I absolutely can't stand it. The .NET counterpart, Windows.Forms, doesn't seem all that well designed, but it looks good, it's relatively fast, and it's easy to write code for it. Plus, of course, a good Forms designer is a standard feature of any .NET IDE.

Right now I wish I could have the C# 3.0 "var" feature because I'm sick of typing

SomeJerkGaveThisClassALongName foo = new SomeJerkGaveThisClassALongName();

Obviously we should be able to write simply

var foo = new SomeJerkGaveThisClassALongName();

And there's a lot of other great stuff in C# 3.0 [.doc]:

Lambda expressions (syntactic sugar for anonymous inner functions) with type inference
Type inference for generic method calls
Extension methods (they are not well thought out, but I'd rather have them than not)
Object and collection initializers (to make code more brief)
Anonymous POD ("plain old data") classes, which work like tuples except that the fields have names.

Suddenly, C# is starting to seem a lot more like boo.

Having said all this, there are a couple of things from Java that I might like to have in C#:

The assert statement. Typing Debug.Assert() all the time is driving me nuts.
Inner classes that have an implicit link to the outer class

And let's see, if I could have some more features I think they would include

Traits
The ability to supply a default implementation for a member of an interface
Preconditions and postconditions on methods
Static and run-time unit checking (units as in metres, litres, bytes, pixels, etc.)

2 or 3 major bugs in ANTLR 3

2007-07-05T23:10:00.000-06:00

No matter what I do I can't seem to make a lexer that works correctly. Weird things have been happening constantly, starting with the multi-megabyte lexer that I always end up with if I use LL(*). So I've been using LL(4) but am still running into a number of problems.

I've been testing with the demo lexer below. Before I show it, I want to point out what's going on with the backslash:

in my language, backslash is an escape for producing identifiers out of punctuation, so "\&" is an identifier, as is "\a\b\c" as well as ordinary things like "abc".
backslash is punctuation (PUNC) if followed by a space. The space is NOT included in the token.

By the way, should these rules be equivalent (behaviorally)? I think they should:

BUG: ('_' | {false}? . | {false}? .)+; // Version 1
BUG: ('_' | {false}? .)+; // Version 2
BUG: ('_')+; // Version 3

But as you'll see, three different behaviors may result. Another thing I've noticed is that ANTLR seems to use more lookahead than necessary to do prediction, and because of this is somehow more likely to make incorrect predictions.

I've isolated a small set of rules to demonstrate some of the problems I've been having. Note that I usually use predicates like

{input.LA(2) == ' ' || input.LA(2) == '\t'}? '\\'

instead of

('\\' (' ' | '\t')) => '\\'

because as discussed recently, the latter does not work. And it seems that often the former doesn't work either. I've included examples of both apparently failing. Here's the grammar:

/////////////////////////////////////////////////////////////////////////
lexer grammar Bug1;

options
{
       language = 'CSharp';
       k = 4;
       TokenLabelType = CommonToken;
}

@lexer::members {
       public bool IsWS(int LA)        { int c = input.LA(LA); return c == '
' || c == '\t'; }
       public bool IsNewline(int LA)   { int c = input.LA(LA); return c ==
'\r' || c == '\n'; }
       public bool IsCtrlChar(int LA)  { int c = input.LA(LA); return c < 32; }
       public bool IsBackslash(int LA) { int c = input.LA(LA); return c == '\\'; }
}

WS: WS_CHAR+;
fragment WS_CHAR: ' ' | '\t';

BUG: ('_' | {false}? . | {false}? .)+; // Version 1
//BUG: ('_' | {false}? .)+; // Version 2
//BUG: ('_')+; // Version 3

ID: ID_LETTER+;
fragment ID_LETTER
       : ('a'..'z' | 'A'..'Z')
       | {IsBackslash(1) && !IsWS(2) && !IsCtrlChar(2)}?=> '\\' .
       ;

PUNC: PUNC_CHAR+;
fragment PUNC_CHAR:
         {IsWS(2)}? '\\'                     // Version 1
       //{IsBackslash(1) && IsWS(2)}?=> '\\' // Version 2
       //('\\' WS_CHAR)=>'\\'                // Version 3
       | (':'|'.'|'~'|'!'|'@'|'$'|'%'|'^'|'&'
         |'*'|'-'|'+'|'='|'|'|','|'['|']'|'?');
/////////////////////////////////////////////////////////////////////////

Next, here's the testing code:

/////////////////////////////////////////////////////////////////////////
public static void Main(string[] args)
{
       ParseBug(@"ab");
       ParseBug(@"ab& ");
       ParseBug(@"ab&\");
       ParseBug(@"ab&\cd");
       ParseBug(@"ab\ cd");
}
static void ParseBug(string s)
{
       System.Console.WriteLine(s);
       ANTLRStringStream input = new ANTLRStringStream(s);
       Lexer lexerBug = new Bug1Lexer(input);
       IToken t;
       while ((t = lexerBug.NextToken()).Type != Bug1Lexer.EOF) {
               System.Console.WriteLine("{0} [{1}]",
                       FooParser.tokenNames[t.Type], t.Text);
       }
       System.Console.WriteLine("");
}
/////////////////////////////////////////////////////////////////////////

N.B. All of these test strings should work, but they don't. ANTLR gives no warnings. The output is:

ab
ID [ab]

ab&
line 1:0 required (...)+ loop did not match anything at character 'a'
line 1:1 required (...)+ loop did not match anything at character 'b'
PUNC [&]

ab&\
line 1:0 required (...)+ loop did not match anything at character 'a'
line 1:1 required (...)+ loop did not match anything at character 'b'
line 1:3 rule PUNC_CHAR failed predicate: {input.LA(2) == ' ' ||
input.LA(2) == '\t'}?

ab&\cd
line 1:0 required (...)+ loop did not match anything at character 'a'
line 1:1 required (...)+ loop did not match anything at character 'b'
line 1:2 required (...)+ loop did not match anything at character '&'
ID [\cd]

ab\ cd
ID [ab]
line 1:2 no viable alternative at character '\'
line 1:3 required (...)+ loop did not match anything at character ' '
ID [cd]
/////////////////////////////////////////////////////////////////////////

Now switch to Version 2 of BUG. The output is:

ab
ID [ab]

ab&
line 1:0 rule BUG failed predicate: {false}?
line 1:1 rule BUG failed predicate: {false}?
PUNC [&]

ab&\
line 1:0 rule BUG failed predicate: {false}?
line 1:1 rule BUG failed predicate: {false}?
line 1:2 rule BUG failed predicate: {false}?
line 1:3 no viable alternative at character '\'
WS [ ]

ab&\cd
line 1:0 rule BUG failed predicate: {false}?
line 1:1 rule BUG failed predicate: {false}?
line 1:2 rule BUG failed predicate: {false}?
ID [\cd]

ab\ cd
ID [ab]
line 1:2 no viable alternative at character '\'
line 1:3 rule BUG failed predicate: {false}?
ID [cd]
/////////////////////////////////////////////////////////////////////////

It is worth noting that this grammar is LL(1) because all other lookahead is done with semantic predicates. However, the above symptoms only occur if k>1. If k=2 then two errors remain; if k=1 then the result is the same as when using Version 3 of BUG.

Without further ado, here's Version 3 of BUG:

ab
ID [ab]

ab&
ID [ab]
PUNC [&]

ab&\
ID [ab]
PUNC [&\]
WS [ ]

ab&\cd
ID [ab]
line 1:3 rule PUNC_CHAR failed predicate: {IsWS(2)}?
ID [cd]

ab\ cd
ID [ab]
PUNC [\]
WS [ ]
ID [cd]
/////////////////////////////////////////////////////////////////////////

That's much better! But there's a problem with the predicate because it is not getting hoisted for some reason. mPUNC() sees a backslash and decides that's all it needs to run mPUNC_CHAR. In fact, mPUNC_CHAR() itself doesn't run the predicate until after it's predicted the result. It escapes me why it would decide that the alternative succeeds, then runs the predicate afterward - which fails, of course.

Now let's try Version 3 of PUNC_CHAR - something slightly different happens:

ab
ID [ab]

ab&
ID [ab]
PUNC [&]

ab&\
ID [ab]
PUNC [&\]
WS [ ]

ab&\cd
ID [ab]
line 1:3 no viable alternative at character '\'
ID [cd]

ab\ cd
ID [ab]
PUNC [\]
WS [ ]
ID [cd]
/////////////////////////////////////////////////////////////////////////

This time, mPUNC decides that a backslash alone is enough to predict a backslash, so it calls mPUNC_CHAR. mPUNC_CHAR actually bothers to run the predicate and, of course, it fails, causing a no viable alt error.

Only Version 2 works as it should:

ab
ID [ab]

ab&
ID [ab]
PUNC [&]

ab&\
ID [ab]
PUNC [&\]
WS [ ]

ab&\cd
ID [ab]
PUNC [&]
ID [\cd]

ab\ cd
ID [ab]
PUNC [\]
WS [ ]
ID [cd]
/////////////////////////////////////////////////////////////////////////

This concludes my little bug report.

ANTLR 3 - Customizing token numbers

2007-07-02T10:51:00.000-06:00

> I'm not sure if lexers support vocabulary importing (I know
> parsers do), but if they do then you should be able to do it that
> way -- make a tokens file and import it into the lexer. Worth a
> try, anyway :)

Ahh, of course, I should have tried that.

And happily, it works! But I found the following caveats.

There is a bug that occurs when ANTLR imports and then exports a backslash. So if I have

parser grammar FooParser;
options {
   tokenVocab=Foo;
...
lexer grammar Foo;
options {
   tokenVocab=Foo2;

// In Foo2.tokens
'\\'=25
// In the generated Foo.tokens
'\'=25
'\\'=31         // Added by ANTLR

This causes a syntax error when compiling the parser. And I guess there is another bug in ANTLRWorks because after the syntax error, ANTLRWorks will keep repeating the same error every time you try to Generate Code, until you quit and restart the program.

By the way, I found that

'\\\\'=25

Seems to work as a single backslash.

There is another important caveat: ANTLR cannot handle "holes" when importing tokens into the parser, i.e. unused numbers in the list of tokens. You must start numbering tokens at 4 and continue up from there with consecutive integers. The problem is that the token names array called tokenNames[] in your parser will not have any empty elements in it, so if your tokens are

APPLE=4
GRAPE=5
LEMON=9
PEAR=10

then your token array will be

public static readonly string[] tokenNames = new string[]
{
   "[invalid]",
   "[eor]",
   "[down]",
   "[up]",
   "APPLE",
   "GRAPE",
   "LEMON",
   "PEAR"
};

Therefore, token name lookups will not work correctly.

On the plus side, you do not have to define all tokens in your .tokens file; ANTLR can add any additional tokens you define in the lexer and will number them correctly.

P.S. I'm using the C# target; perhaps YMMV for Java etc.

ANTLR Warning suppression workaround

2007-07-01T11:08:00.000-06:00

On p.285 of the ANTLR book it implies that you cannot suppress warnings in ANTLR v3 like you could in v2.

However, it appears that a semantic predicate works nicely as a workaround:

// Strings
SQ_STRING: '\''! ({true}? ESC_SEQ | ~'\'')* '\''!;
DQ_STRING: '"'!  ({true}? ESC_SEQ | ~'"')* '"'!;
BQ_STRING: '`'!  ({true}? ESC_SEQ | ~'`')* '`'!;
fragment ESC_SEQ: '\\' ~('\n'|'\r');

The generated code now contains LL(2) lookahead for no reason, and some redundant code. For example, code that originally read

   if ( (LA19_0 == '\"') )
  {
     alt19 = 1;
  }

Now says

   if ( (LA19_0 == '\"') )
  {
     int LA19_1 = input.LA(2);
     if ( (true) )
     {
         alt19 = 1;
     }
  }

However, its behavior appears to be the same.

The compiler will emit some "unreachable code" warnings. In C# you can disable them like this:

grammar Expr;
options {
  language=CSharp;
}
@lexer::members {
  #pragma warning disable 0162
}
@parser::members {
  #pragma warning disable 0162
}

ANTLR 3 C# runtime - source code found!

2007-06-30T11:37:00.000-06:00

> Does anyone know why the source code is not available? Is it closed
> source? What's the licence?

While these questions remain unanswered, I have found an amazingly good tool called "Reflector" and a disassembly helper. For more information see

http://www.aisto.com/roeder/dotnet/
http://www.codeplex.com/reflectoraddins
http://www.denisbauer.com/NETTools/FileDisassembler.aspx

I have discovered that the assembly contains full symbol information including local variable names, and the tool outputs suprisingly high-level code. If you don't want to reconstruct it yourself, you can get it here:

http://qwertie.net/misc/Antlr3.Runtime-Disasm.zip

The add-in even creates a project file! Right on!

SharpDevelop add-in system

2007-06-04T06:55:00.000-06:00

I'm having tremendous difficulty understanding SharpDevelop's add-in system. Although they offer a free book (Dissecting a C# Application: Inside SharpDevelop), I find its explanation of Codons/addins/etc. to be almost incomprehensible. So I'll investigate them and put my tentative findings here.

The add-in tree: Basics

See below for locations (in the source code distribution) of classes mentioned here.

All extensions to #develop (and most core features including the entire GUI, except the splash screen) are add-ins. All addins are stored in C:\Program Files\SharpDevelop\2.1\AddIns\AddIns, except one whose XML file is in the parent folder.
Each add-in must have an XML file that describes it, with an .addin extension. Addins use "XCopy deployment"; to add an addin to SharpDevelop, simply create a folder that contains the add-in, then copy your folder to any appropriate subfolder of the AddIns folder mentioned above. The code of an addin is placed in one or more DLLs.
The AddIn tree is a tree of AddInTreeNode objects. Informally, a distinction is sometimes made between nodes that have "Codons" and those that don't: An AddInTreeNode is called a "path" if there is no "Codon" attached or a "node" if there is. However, this is confusing terminology because a route to a AddInTreeNode is often called a "path" regardless of whether the object at that path has a codon; meanwhile, according to its name, an AddInTreeNode is a node (even if it lacks a codon).
The AddInTreeNode.ChildNodes property returns the child nodes as a Dictionary{string, AddInTreeNode}. The AddInTreeNode class lacks a link to its parent node.
"Codon" appears to refer to the code of an add-in, whereas an AddIn seems to refer to (a) the XML file that contains the codon and (b) an instance of ICSharpCode.Core.AddIn which represents the XML file in memory. Ironically, AddInTreeNodes do not contain add-ins, only Codons. An add-in can contain multiple codons (at different places in the add-in tree). Also, an add-in can have "conditions" and "doozers" (discussed later).
ICSharpCode.Core.AddInTree (a static class) contains the root of the Add-In tree, which can be reached by calling AddInTree.GetTreeNode(null). However, usually you want to look up something deep in the tree, so call AddInTree.AddInTreeNode("/path/to/the/node"). The path to use is specified in an addin's XML file.
All codons are stored in the add-in tree, whereas all AddIns are stored in a flat list returned by the AddInTree.AddIns property.
According to doc\technotes\AddInTree.rtf (in the souce distro), "In the ICSharpCode.Core implementation, the AddInTreeNode class has a Codon property which is null for paths and points to a Codon instance for nodes." But in fact, the Codon property returns a List{Codon} and I don't know why.

TODO

ICSharpCode.Core.AddInTree: src\Main\Core\Project\Src\AddInTree\AddInTree.cs
ICSharpCode.Core.AddInTreeNode: src\Main\Core\Project\Src\AddInTree\AddInTreeNode.cs
ICSharpCode.Core.AddIn: src\Main\Core\Project\Src\AddInTree\AddIn

"The Definitive ANTLR reference" is not definitive

2007-05-30T14:54:00.000-06:00

I bought the PDF of this book for $US25, which is not a bad deal, but it should be mentioned that the book is lacking some important information like

an overview of changes from v2 (e.g. shouldn't we be given a few small v2 and v3 grammars side-by-side, highlighting the differences? what kinds of real-world grammars work in v3 that didn't work in v2? other than left recursion, what sorts of grammars still cause trouble?)
yes, LL(*) can handle lots of grammars, but at the cost of scanning a token or character stream repeatedly. How can a grammar be designed instead for good performance?
a complete reference of all the things you can put in a grammar file. There's a "basic structure" on p.90, but it's VERY brief. There's no complete list showing all available sections like options {}, @header {}, @namespace {}, @members {} ... How can it be a "definitive reference" without this?
a class heirarchy diagram and a summary of the methods in important classes like CommonToken, Lexer, Parser, etc. Again, "reference"? The lack of reference material in the book is quite annoying because as far as I know, the book is the only reference there is.
how to make a lexer-only or parser-only grammar. To do this you must write "lexer grammar foo;" or "parser grammar foo;" instead of "grammar foo;" but this is never pointed out specifically. On p.64 there is a sentence that sort of implies lexers should start with "lexer grammar", while "parser grammar" is mentioned for the first time in a code example on p.134, but it is treated like something the reader should have already known.
how to use ANTLR in a non-Java environment. Yeah, you use options{language=CSharp;} or whatever, but then what? where do I get the runtime? how are the runtimes of other languages different from the Java runtime? The book ignores non-Java issues completely.
how to create "unknown" tokens, i.e. tokens for groups of characters that the lexer has no specific rule for. There's a "filter" option to discard unrecognized characters, but in my compiler, I want to create tokens for them and actually give them to the parser.
how to support all kinds of text file encoding schemes: UTF8, UTF16, ASCII, files using specific "codepages", MBCS, ...
complete examples. Mostly just snippets are shown with links to complete source files online. Unfortunately, as of this writing, example grammars online (such as this one) have no line breaks in them.
the discussion of lexers is a bit impoverished. No discussion of the proper way to tell apart '/*' from the sequence of two tokens '/' '*', for example. Normally tokens contain the indexes of the starting and ending character; so what happens when I use the ! suffix? Can I have a catch-all rule, invoked only if the other rules fail (because I need one)?
an overview of the whole system - I mean there's an overview of concepts on p.22, but there isn't a concise overview of basic nuts & bolts that people need to know such as: how do the lexer and parser get connected together; what are the basic classes and their capabilities/responsibilities in the system (CommonTree, Token, Parser, Lexer, ...); how can ASTs and lists of tokens be traversed manually, inside semantic actions and outside ANTLR grammar files; what functionality is provided by ANTLR (e.g. line-number counting and error message generation) versus what must/should/can be written by the user.

Perhaps a lot of this information is in the book, it's just not organized how I might like. The information you need to write a complete lexer-parser and run it is interspersed with explanations of the basic concepts of recursive-decent parsing--explanations I don't want to read because I'm already an experienced programmer who has used v2 before. The babysitting and nitty-gritty details are mixed in such a way that it's hard to skim the text looking for the technical details I want. There may be some things in the list above that are in the book but that I just haven't been able to find yet.

I suspect the book would be much more useful if it were separated into sections according to use cases. I mean, there are lots of different reasons a person would use ANTLR:

Translating code from one syntax to another, with or without StringTemplate
Taking an AST (or a token list), doing modifications/transformations on it, and outputting the result while keeping original spacing and comments intact (apparently you can't use ANTLR to transform an AST, but keeping the spacing and comments intact is supposed to be "easy" with ANTLR v3, right? But how do you do it? Can't I do it without StringTemplate?)
Gathering information from a source file without necessarily doing a complete parse
Writing a compiler/interpreter for a small, simple domain-specific language
Writing a complex full-scale compiler--this may require "pulling out all the stops", using all of ANTLR's syntax and many of the classes in ANTLR's runtime. Since this is my use case, it's the one I would most like to read about.
Writing an extension to an existing compiler
Creating a new language target for ANTLR using StringTemplate

Perhaps there should have been a section for each specific use case, with a quick overview of ALL the things a user might need to do to complete his/her task. Since the use cases overlap, each one perhaps should be pretty short and consist mostly of pointers to other parts of the book where more details can be found.

(Note: certainly there are a sections geared toward specific use cases, but in general if you're trying to accomplish task X, there isn't a island paradise made just for you within the book.)

Now I wouldn't put such a high standard on free documentation of course, but this is a paid-for book entitled "The Definitive ANTLR Reference". It's a title that gives the impression that

it contains all the information you need
it is a complete reference

well, it doesn't and isn't.

But I guess I'm being overly harsh. I probably am. There are a lot of people in the world that yell "You did it all wrong! I know how things should be done!", when in fact if they were in charge, we'd all be worse off. And then some of those people end up getting elected, but I digress.... the point is, I haven't read the book that carefully and I'm just letting off steam.

Terence has put a lot of his free time into the book and ANTLR (or so I would assume) and he deserves compensation for it. I certainly don't regret paying for the book... but the fact remains, I'm disappointed. There's lots of space in the margins, maybe the extra information I want to see could go there...

Here's some helpful ANTLR information from Manuel Abadia
Useful notes about ANTLR3 lexers

Boo Compilation Steps

2006-10-21T23:19:00.000-06:00

This post contains notes about how booc compiles boo programs. The boo compilation process is not complicated, but it is mostly undocumented and therefore can only be understood by inspecting the source code. Also, boo's developer (Rodrigo B. de Oliveira) is, sadly, allergic to comments. Here are my detailed observations - more to come later. See also the boo build process. A useful thing to know about the boo codebase is that (so far as I've seen) it follows the java conventions of "one public class per file", "name the file after the class", and "the namespace name corresponds to the actual path in the directory tree". For example, src\Boo.Lang.Compiler\Resources\EmbeddedFileResource.cs contains a class called EmbeddedFileResource in the namespace Boo.Lang.Compiler.Resources. A source file may contain other classes, structs and enums, but they are either internal to the file where they are declared (not used elsewhere), or they have a minor role. BTW: this convention holds for the C# part of the compiler, but I don't yet know about the boo part.


A list follows of things that booc does. To kick things off, Main() calls App.Run().

App.Run():
- I don't know what this is for:
  AppDomain.CurrentDomain.AssemblyResolve += new ResolveEventHandler(AssemblyResolve);
- CheckBooCompiler(): Emits warning if nonlocal Boo.Lang.Compiler.dll is being used
- _options = new CompilerParameters(false)
- ParseOptions():
 - Builds "response file list" (App._responseFileList). It is empty when cmdline 
   args is just a src file name - _responseFileList is related to args that start 
   with '@'. The default response list is automatically loaded from booc.rsp by 
   AddDefaultResponseFile(), unless -noconfig is specified.
 - Processes command-line arguments. Most cmdline args alter the configuration
   of _options; some alter flags/variables in App itself.
 - The list of input files is added (one at a time) with _options.Input.Add()
 - Assigns the _options.Pipeline (-p option), or makes default pipeline, 
   CompileToFile(). In WSA mode, 
  _options.Pipeline[0] = new Boo.Lang.Parser.WSABooParsingStep();
 - debug-steps adds App.StepDebugger as AfterStep event handler.
 - prints header ("Boo Compiler version 0.7.6.2237 (CLR v2.0.50727.42)")
- fragility: assumes there are two standard library paths (which are moved to the bottom 
  of the lib path list)
- creates a Boo.Lang.Compiler.BooCompiler (.cs), "The compiler: a facade to the
  CompilerParameters/CompilerContext/Pipeline subsystem."
- Unless -nostdlib specified, calls _options.LoadDefaultReferences() to add default references.
  The default references are mscorlib, System, the currently loaded Boo.Lang, and the currently
  loaded Boo.Lang.Compiler.
- LoadReferences(): loads assemblies previously requested with -r on cmd line; calls
  _options.References.Add() to add each assembly
- CompilerContext context = compiler.Run();
  This one line compiles the code and (I think) generates the output assembly, although 
  Warnings/errors are not printed yet. Run() with no args creates a new CompileUnit (the 
  top-level AST class) and passes it to 
 public CompilerContext Run(CompileUnit compileUnit)
- Prints warnings from context.Warnings (a Boo.Lang.Compiler.CompilerWarningCollection) and 
  errors from context.Errors (a Boo.Lang.Compiler.CompilerErrorCollection)
 
Boo.Lang.Compiler.BooCompiler.Run(CompileUnit compileUnit):
- Creates a new CompilerContext(_parameters, compileUnit) where _parameters is the 
  Coo.Lang.Compiler.CompilerParameters object with which the object was originally initialized.
- _parameters.Pipeline.Run(context): (Boo.Lang.Compiler.CompilerPipeline.Run())
 - virtual stub: Prepare(context)
 - calls RunStep(context, step) for each step in the pipeline. step is a parsing step, 
   e.g. BooParsingStep
  - fires this.BeforeStep event
  - calls step.Initialize()
  - calls step.Run() & catches exception if any
  - fires this.AfterStep event
 - calls Dispose() on each step

-------------------------------------------------------------------------------
ASTs:
- Automatically generated classes are named Boo.Lang.Compiler.Ast.Impl.*Impl
- Each has a derived class named Boo.Lang.Compiler.Ast.*
- Boo.Lang.Compiler.Ast.Node is the base class for every node in the AST. Its data content is
 protected LexicalInfo _lexicalInfo = LexicalInfo.Empty;
 protected SourceLocation _endSourceLocation = LexicalInfo.Empty;
 protected Node _parent;
 protected string _documentation;
 protected System.Collections.Hashtable _annotations = new System.Collections.Hashtable();
 protected bool _isSynthetic;
- Top-level AST element is called CompileUnit. At this point I am assuming, since only one 
  CompileUnit is created by Boo.Lang.Compiler.BooCompiler.Run(), that all boo source files 
  given to booc are merged into the same CompileUnit object. Data:
 protected ModuleCollection _modules;

-------------------------------------------------------------------------------
The standard set of compiler steps follows directly from the implementation of
CompileToFile and its base classes.

CompileToFile's entire implementation is
 class CompileToFile : CompileToMemory { CompileToFile() { Add(new SaveAssembly()); } }
inherited from:
 class CompileToMemory : Compile { CompileToMemory() { Add(new EmitAssembly()); } }
inherited from:
 public class Compile : ResolveExpressions {
  public Compile() {
   Add(new UnfoldConstants());
   Add(new OptimizeIterationStatements());

   Add(new CheckIdentifiers());
   Add(new StricterErrorChecking());

   Add(new ExpandDuckTypedExpressions());

   Add(new ProcessAssignmentsToValueTypeMembers());
   Add(new ExpandProperties());
   Add(new RemoveDeadCode());
   
   Add(new CheckMembersProtectionLevel());

   Add(new NormalizeIterationStatements());
   
   Add(new ProcessSharedLocals());   
   Add(new ProcessClosures());
   Add(new ProcessGenerators());

   Add(new ExpandVarArgsMethodInvocations());
   
   Add(new InjectCallableConversions());
   Add(new ImplementICallableOnCallableDefinitions());

   // TODO:
   //Add(new InjectCastsAndConversions());
  }
 }
inherited from:
 public class ResolveExpressions : Parse {
  public ResolveExpressions() {
   Add(new InitializeTypeSystemServices());
   Add(new PreErrorChecking());
   
   Add(new MergePartialClasses());
   
   Add(new PreProcessExtensionMethods());
   Add(new InitializeNameResolutionService());
   Add(new IntroduceGlobalNamespaces());
   Add(new TransformCallableDefinitions());
   Add(new BindTypeDefinitions());   
   Add(new BindNamespaces());
   Add(new BindBaseTypes());
   Add(new BindAndApplyAttributes());
   Add(new ExpandMacros());
   Add(new IntroduceModuleClasses());
   Add(new NormalizeStatementModifiers());
   Add(new NormalizeTypeAndMemberDefinitions());
   
   Add(new BindTypeDefinitions());
   Add(new BindEnumMembers());
   Add(new BindBaseTypes());

   Add(new ResolveTypeReferences());
   
   Add(new BindTypeMembers());   
   Add(new ProcessInheritedAbstractMembers());
   Add(new CheckMemberNames());
   
   Add(new ExpandAstLiterals());
   Add(new ProcessMethodBodiesWithDuckTyping());
  }
 }
inherited from:
 public class Parse : CompilerPipeline {
  public Parse() { Add(NewParserStep()); }
  ...
  ...
 }
 
The job of NewParserStep() is to dynamically load Boo.Lang.Parser.dll (using
System.Reflection.Assembly.Load()/LoadFrom()) and to create an instance of 
Boo.Lang.Parser.BooParsingStep (using System.Activator). Fragility: the code 
relies on the fact that the current assembly is named Boo.Lang.Compiler.dll.

All of the above classes are compiler pipelines, defined in 
src\Boo.Lang.Compiler\Pipelines.

inherited from: CompilerPipeline, which serves as a collection of steps and 
includes functions to run the steps (Run(), RunStep())

ENCM 599 Project Ideas

2006-08-17T15:15:00.000-06:00

The first two projects would certainly require two semesters (and beyond); the last two might be small enough that I could make something useful in one semester.

1. A note taking program

This would be a word processor tailored to in-class note-taking on a laptop or tablet PC. This would be an experiment in making computer note-taking feasible and useful. Features could include:

- Diagram sandboxes - you could draw a diagram in a full-screen window, and when you're finished, the drawing would be shrunk down to a smaller size within the main document.
- Automatic tablemaking - making tables of data is time-consuming in a conventional word processor. Making use of the tab and space keys, my note-taking program could allow users to create and arrange tables on-the-fly without opening menus or dialog boxes.
- Minimizing the number of drawing tools by giving more than one capability to tools. For example, the basic freehand pen tool would normally just put ink on the screen. But if you draw in a particular fashion, other actions could happen instead:
- Scribble out text to erase it and place the text cursor in its place.
- When you click on a point, a dot is created on the screen (as you would expect from a freehand tool); but if you then begin to type, the dot is replaced with what you typed. In other words, the pen could also do cursor placement.
- Draw a freehand line from one margin to another to "rip" the virtual page in half. You could then drag the line to create new virtual paper.
- After you draw a line or circle something, you could run commands that change your action from drawing to something else, such as deleting or selecting. In other words, the program could support noun-verb interaction in addition to verb-noun interaction.
- Keyboard-based diagramming - diagrams could be drawn quickly with a keyboard.

I could come up with a great many ideas, but they won't all fit in a one- or two-semester project. I suppose I will have to decide whether I want to focus on laptop-based usage (keyboard bound) or tablet PC usage (pen bound).

2. Designing a computer language/compiler

I am not really happy with any existant language, so I would like to attempt my own design.

The main focus of the language would be extensibility, and this would be primarily a research project--just trying to figure out how to make a sufficiently extensible language. I would start by making a large and diverse list of features that I think should be possible in an "ideal" language. It would include all the major features of all the major languages, e.g.:

- Object-oriented programming
- Multiple inheritance
- Interfaces with single inheritance
- Templates (C++) - time-efficient genericity
- Generics (C#) - space-efficient genericity with runtime specialization
- Inner functions
- Closures
- Coroutines (Stackless Python)
- Garbage collection
- Dynamic typing
- Static typing
- Functional programming (Haskell)
- Static type inference (Haskell)
- Unit type checking (e.g. giving an error if the programmer attempts a + b where "a" is measured in metres and "b" in square feet.) and inference (e.g. metres * seconds / seconds = metres), and syntax to allow this feature.
- Interface reconfiguration & extension (changing/extending an object's interface without changing its identity - I can explain better if you like)
- High performance & low-level programming (C/C++/Asm)

I would then attempt to design an appropriate set of compiler modules with a well-defined interface between them. The idea would be to design an open compiler architecture so that one could write 'plug-ins' that add features to the compiler.

In addition to language features, I would like to consider extensible syntax. The fondest dream here is a language which can take on the syntax of another language (e.g. Java), but provide additional features not found in that language, and also to allow code using different syntax to interoperate on an intimate level. .NET is a step toward that ideal, but inter-language interoperability is limited to a specific set of features defined by Microsoft, and (seemingly) every language used must be compiled to a DLL separate from code in other languages.

3. Something involving a dictionary

Last semester I made a user-editable interdictionary web application: see http://qwertie.net/

I would like to continue working on this project somehow, or another related project.

One idea is to attempt to import some large part of Wiktionary (http://www.wiktionary.com) into my dictionary, so that the features of my application can be used to browse Wiktionary. Perhaps a better idea is to actually contact the developers of Wiktionary, and see if I could help add features to their website.

Finally, it would be nice to make a PocketPC version of my dictionary.

4. PocketPC keyboard extension

Some time ago I wrote a keyboard application for Palm pocket computers (see http://millikeys.sourceforge.net/). But my Palm broke a couple years back, and MilliKeys has not been updated since.

PocketPCs have handwriting recognition, which is very cool, but handwriting is simply not as fast as typing can be.

Recently I was inspired by an input method on a cell phone: each number key is assigned several letters (e.g. 2=ABC). You can input a word using just numbers and the phone automatically figures out the intended word, so you type "43556" and it figures out that you want "hello".

I would like to do something related, with a sort of fuzzy logic. The on-screen keyboard on a PocketPC has very small buttons, so you must type on it, you must type carefully. I would like to implement a keyboard with probabalistic input, that would allow you to miss keys and still get the intended output. So if it were a Qwerty keyboard, you could hit the keys "gwklo" and it would automatically output "hello". For each character, it would use Fitts' law to model the input and determine the likelihood that various characters were intended. Using probability formulas, in conjunction with a dictionary, it would then determine the most likely intended word. It would also allow the user to use what he actually typed instead.

Additionally, it could support features of MilliKeys, such as the ability to make a short stroke to type punctuation, capital letters, etc.

My new fake identity

2006-07-17T20:17:00.000-06:00

Why should I give my name, address, phone number and birthday to every stupid company from which I buy a product, just for the unknown "benefits of registration"? Here's my identity from http://www.fakenamegenerator.com/.

David T. Rudd
2337 50th Street
Edmonton, AB T6B 2W9

Email Address: David.T.Rudd@spambob.com

Phone: 780-203-2861
Mother's maiden name: Holmes
Birthday: August 17, 1983 [ 1983-08-17 ]

Visa: 4556 3352 0574 3891
Expires: 7/2008

Haskell: how to show tuples with more than 5 arguments

2006-04-07T16:57:00.000-06:00

If you try to convert a long tuple with 6 or more components to a string in GHC, you get an error like

file.hs:17:5:
    No instance for (Show ___)
      arising from the 'deriving' clause of a data type declaration at file.hs:17:5
    Probable fix: add an instance declaration for (Show ___)
    When deriving the `Show' instance for type `___'

You can fix it with a show declaration for the number of arguments in your tuple. For example, this gives you support for 6-tuples:

instance (Show a, Show b, Show c, Show d, Show e, Show f) => Show (a,b,c,d,e,f) where
    show (a,b,c,d,e,f) = "("++(show a)++", "++(show b)++", "++(show c)++", "++
                              (show d)++", "++(show e)++", "++(show f)++")"

Konqueror feature request

2006-03-01T12:07:00.000-07:00

In MS Windows, users are only given four or five file view modes, while in Konqueror the user has a multitude of options. This could be a good thing, but it can be quite inconvenient, because the user has to do too much to get from one desired style of display to another.

For example, the "Icon View with Large icons and even larger previews" is nice, but if I go to a folder with many files and I quickly scan through the file names, look at all the trouble required to switch to the equivalent of the Windows list view:
- Click View | View Mode | Multicolumn View
- Click View | Icon Size | Tiny
- Click View | Preview | Disable Previews

It is highly unlikely that the average user wants to use many combinations of these options. Even a power user would probably use only three to five combinations regularly.

Therefore, I propose to create a set of presets to replace this multitude of options. The view menus "View Mode", "Icon Size" and "Preview" would be replaced by a single "View Mode" menu which would contain a customizable list of presets like this:

==========
Large icons (= Icon View, large, with previews)
Small icons (= Icon View, medium)
Multicolumn list (= MultiColumn view, tiny, no previews)
Tree (= Tree view, tiny)
Et cetera
Other...
----------
Customize views...
==========

The "Customize views" item would display a dialog box that allows the user to customize the views. This dialog box would allow the user to select one of the existing views and modify settings for it. Views could also be created or deleted. For each view modes, the following options would be available:

- List of view modes (icons, multicolumn, etc.)
- Any options that are specific to the view mode
- List of icon sizes
- Checkbox: "Show previews"
- Checkbox: "Increase size of previews relative to icons"
- OR: a list of sizes for previews
- Checkbox: "Change sort order when entering this mode", and a list of sort orders
- Checkbox: "Use a custom background in this mode", and a button to bring up the "Background settings" box.

All this could fit on one dialog box if the lists of options are combo boxes.

The "Other..." menu item would bring up a smaller dialog box to change the current view settings, but without saving the changes as a new preset.

More ideas:
- Views could be hidden from the menu by having a checkbox beside each item in the list of views
- Each of the built-in views could be hidden but not deleted.

P5GD1 CD booting & linux followup

2006-02-23T11:30:00.000-07:00

I had just decided it was impossible to boot from an internal CD drive that Linux would recognise, but for some reason I decided to try again.

There are many possible combinations of settings that can be tried with this mobo:

Upper or lower IDE connectors
Master or slave
"Enhanced" or "Compatible" IDE mode
"PATA+SATA", "SATA", and "PATA" modes
ITE IDE controller "enabled" or "disabled", and if enabled, "quick" or "normal" detection mode

Assuming the distinction between "quick" and "normal" is irrelevant, that makes 48 ways you can set up a single drive on this motherboard, although 12 of those ways won't work at all (one of the IDE connectors is disabled when ITE is disabled.)

Well, I found a configuration that would let me install Kubuntu 5.10 on a "regular" IDE hard disk. I could not install Fedora Core 4 under the following configuration; a kernel panic occurs in FC4 during the kernel init process.

IDE hard disk as primary master (attached to upper connector)
CD/DVD drive as primary slave
"Enhanced" mode, subtype "SATA"
ITE can be enabled or disabled. If enabled, drives attached to the lower connector will work in Windows once a special driver is installed. However, as far as I can tell, Linux cannot use these "ITE" devices (lower connector) under any circumstances.
Also, a SATA hard drive was attached, although this is probably irrelevant to whether it works or not.

What is wrong with people who write about functional programming?

2006-02-09T01:35:00.000-07:00

A couple years ago, after hearing here and there about "functional programming", I decided to learn about it and got a book from the library. I found a book on OCaml and began to read. An hour or two I gave up, finding the book both dry and hard to understand.

Later I attended a course on "programming paradigms" where I learned basic Haskell. After studying Haskell for a little while, I came across the paper "Why Functional Programming Matters" (WFPM). Its objective was to convince the reader that functional programming is good, and it started off well enough, but utterly failed as soon as it started talking about how to write functional code. I found myself baffled when it introduced the line "sum = reduce add 0" on the fifth page. I examined the paper carefully for several minutes to figure out what it meant, and continued reading. Unfortunately, every new line of code was a new puzzle, and I soon gave up on it.

Now that I know Haskell and lambda calculus a little better, I have tried to learn about Haskell's type system by reading "A Gentle Introduction to Haskell" (GIH). It quickly struck me that this "introduction" wasn't "Gentle" at all! I can't see how anyone could understand it without already having a knowledge of lambda calculus and at least one functional programming language--preferably Haskell.

What strikes me about all these explanatory materials is that they are unaware of their own obtuseness. WFPM uses phrases like "It is now obvious that" and "can be derived just by parameterising the definition" (my emphasis). GIH's very name suggests easiness, and its introduction says it is "for someone who has experience with at least one other language, preferably a functional language". But excluding Haskell, I know at least 5 programming languages, none of which could prepare me for GIH at all.

So to be blunt, I wonder if there is something wrong with the brains of the people who write this stuff. How can they fail to see that their writing cannot be understood without a solid prior understanding of the subject matter, and that it suffers from excessive brevity? Functional programming does matter, and I do believe a gentle introduction to Haskell is possible, but I don't know if there are any writers out there who have explained these things properly.

Beware the Asus P5GD1-VM motherboard!

2006-01-30T20:27:00.000-07:00

In a nutshell, I replaced this mofo of a mobo because of one simple problem: it could not boot from an IDE CD-ROM drive, so I could not fix my computer. I thought there was something defective with my motherboard, so I replaced with with exactly the same one--and the new one had exactly the same problem.

However, there is exactly one scenario in which I was able to boot a CD. I was able to boot my Windows 2000 CD correctly under the following conditions:

The CD-ROM drive must be on the primary IDE channel (it worked as Slave for me).
In the BIOS, the "IDE mode" option must be set to "Compatible" (not "Enhanced", which is the default). You can tell when you are in "Compatible" mode because the BIOS screen shows only "Primary" and "Secondary", with no 3rd IDE pair.

Now, there is one tricky thing you have to deal with. "Compatible" mode changes the definition of "Primary". There are two IDE connectors on the motherboard. In Compatible mode, "Primary" means the upper IDE connector. However, in Enhanced mode, "Primary" is the lower IDE connector. Therefore, when you switch modes, you must physically swap the upper and lower connectors!

There are a couple more caveats.

I could not boot any Linux CD correctly under any circumstances. I tried Damn Small Linux, Knoppix and the Kubuntu Live CD (I used the current version of each CD as of Jan. 20, 2006). Even if the boot process starts, the Linux CD will be unable to mount the CD filesystem, or it will crash or freeze during startup. You can boot Kubuntu from an external USB 2.0 drive, but not DSL or Knoppix. I also tried a RIP Linux floppy disk, and it was unable to see the CD drive.
The Windows 2000 CD will not see the hard drive unless it is on the Primary IDE channel. So put your HDD on Primary Master and your CD on Primary Slave. Kubuntu could not see the hard drive either when I tried it, but I don't remember what configuration I was using at the time.

What is the basis of a "free market" when copies are free?

2006-01-22T20:47:00.000-07:00

A basic and fundamental economic note about my "free everything" idea:

I believe in a free market for creative works, but one that works differently from traditional free markets. A normal free market balances supply and demand of "units", where producers make one unit for every unit used by consumers. But in the world I want to see, this concept of supply is irrelevant. There is no reason to limit supply when the incremental cost of additional units is virtually zero, as is the case on the internet. Supply in the traditional sense, therefore, should be virtually infinite; as a result, this free market I envision is better served by a different notion of supply, which is, approximately, the supply of distinct works (unique works, not copies). The balance in the intellectual free market should be between the supply of distinct works and the demand for distinct works.

Today, of course, the market is based on balancing supply and demand of copies only, which in my view is just plain wrong. If copies were free, it would utterly change the face of both content industries and technologies. The changes to technology have already begun in a limited fashion (e.g. the 60 GB IPod), but it remains to be seen whether the content industries will be willing to allow this new world, or whether they will enact ever-stronger laws to ensure we will be stuck in the 20th century forever.

IAL list

2006-01-11T12:25:00.000-07:00

Marginally interesting languages from LangMaker.com

Arlipo (site is in Arlipo)
Atlango (not much English)
Babm (not much documentation)
Bahasa Tumilenia
Basic English
Blitz English
Bonjang
Bibliography of planned languages
Canis
Celltiecc (celtic aux language)
ceqli (CHENG-lee)
Choton and others by Pascal A Kramm
Common Germanic
Qôsmianî
Cyberyak: (#1) (#2)
Dunia
Dutton
e2 (zip file - a "tweak" of esperanto)
Earth Language
EDA
Ekspreso: (#1) (#2)
Esperanto de DLT
Essential World English
Eurolang
Europeano
Fasile
Folkspraak
Frater & Frater 2
Gilo
Globish
Glosa
Ido
Inrilan
Baza (a 'unification of esperanto derivatives')
Interglosa
Interlingua
Interlingue (Occidental)
Kali-sise
KOD
Konya

Counterpart conjunction?

2006-01-09T11:59:00.000-07:00

A conjunction 'X' to indicate a relationship between nouns, dependant on the context?

He traded his shirt X shoes. (X=for)
The difference between men X women. or: men X women differ (X=and)
Balls and chains X prison bars serve the same purpose.

Ruby's Grand Variety

2005-12-09T13:28:00.000-07:00

I'm starting to learn Ruby and it does seem as though it may fulfill its promise of "making programming fun again", but Ruby has a very unusual design philosophy. A lot of languages take the stance that on a syntactic level, and in the standard library, there should be One Way to do everything--one syntax, one idiom, one function.

Ruby says "to hell with that!" There are often several ways to do something, which should make programming comfortable to a variety of programmers, but I suspect it may be difficult to understand other people's code, if they use some of the more obscure features. Here are some of the duplicated language features you'll find in Ruby:

Two syntaxes for closure blocks, "{ ...code... }" and "do ...code... end"
Control structures before or after inner code, like in Perl: "x += 7 while (x % 13 != 0)" or "while (x % 13 != 0); x += 7; end"
You can choose betwen "and"/"&&", and "or"/"||". What's peculiar about these are their precedence rules: && has higher precedence than ||, and "and"/"or" have higher precedence than both of them. However, "and" and "or" have equal precedence. Similarly there are "!" and "not" operators.
The regular expression support in the language mimics Perl, offering such opaque variable names as $&, $', $` and $1. These variables are aliases for an object-oriented regular expression information bundle in a MatchData object called (you guessed it!) "$~".
Several syntaxes for strings, the most common being single-quoted and double-quoted, which have different syntax rules (but multiple string types is actually useful and common in new languages, although I'm a little disappointed that Ruby has no equivalent of C#'s @"literal\string")
There seem to be two exception-handling mechanisms, "raise...rescue" and "throw...catch". The relationship between them is not clear to me.

A more distressing aspect of Ruby's design is that it usually does not attempt to "save the programmer from himself": there are many mistakes you can make for which the interpreter will give no warning or error. Here are some examples.

'Tuple assignments' don't have to be balanced. "a,b,c = 2,3,4" sets a=2, b=3, and c=4. But you can also write "a,b,c = 2,3" or "a,b = 2,3,4" or "a = 0,1,2". Can you guess the results?
Similary, the number of arguments to a closure doesn't have to match the number of arguments the closure accepts.
Problems caused by scoping rules. For one thing, assignable methods are normally invisible to members of the same class, so that you have to write "self.property = 10" instead of "property = 10"; the latter unexpectedly creates a local variable called "property". For another thing (which Ruby's creator called "the single biggest design flaw in Ruby), the scoping rules for blocks are weird.
Because Ruby is dynamically typed and interpreted, most errors occur only at run-time and are not detected if the bad code is not executed, even when it would be theoretically possible. This, of course, is a vice of all dynamic interpreted languages.

Finally, Ruby has a number of features that can make it incomprehensible to programmers of other languages--rules that you won't find in many other languages. Here are some examples:

Return values are implicit. The value of the last statement in a method is the return value of the method. "if" statements and loops can also return values this way.
Hidden variables and state: I haven't quite figured out how this works yet, but the special variable $_ can be implicitly used for comparisons in control constructs (if, while, etc.), and range variables (and even range literals such as 1..10) seem to have an internal boolean state that can also be used implicitly.
Enforced naming conventions (whether an identifier starts with an uppercase letter affects its meaning; also, use @ to name member variables, @@ to name static (class) member variables, and $ to name globals)
In addition to the aforementioned regex variables, there are many other "punctuation variables" such as $@ and $/. The "$" indicates that they are global, but in fact, some of them are locally scoped variables.
"Parallel assignment" has a lot of rules and features.
Two operators ".." and "..." with slightly different meanings.
There are numerous string and pseudo-string types that begin with "%". For example, %x{blah} is equivalent to `blah`, and %Q!hi! is equivalent to "hi".
There are three different equality operators, ==, eql? and equal?, plus some "sort-of-equals" operators: === and =~.
Plenty of other stuff. Things are just done differently in Ruby.

By all of this, I don't mean to suggest that Ruby is "bad" (in fact, I think most of this stuff is mostly good), but I do think that if you're an experienced programmer, you should study Ruby explicitly before attempting to understand or write Ruby code, because your knowledge of other langauges might not be enough. Luckily, the book Programming Ruby is designed for you.

Incidentally, while you can write clear and readable code in Ruby, you can also obfuscate it nearly to the extent of C code. There should be a Ruby obfuscation contest...

An Epiphany?

2005-11-12T13:26:00.000-07:00

I just realized today, after seeing the linked document, that there is no reason everyone shouldn't have free access to all intellectual property: software, movies, music, books, educational materials, and to a lesser extent, drugs (which, measured by price, overwhelmingly consist of IP).

I should be able to view as many movies, TV shows, and books as I want; listen to as many songs; and install as much software as I want. It shouldn't matter what my income is. I shouldn't have to pay for anything but the hardware (and perhaps any unavoidable overhead costs of the "free access system").

I should do a main blog entry on this.

IP exists as "property" for one reason only: to get money into the hands of owners. But it works by artificially limiting the amount of material to which people have access, and by limiting the means of access and the means of searching through available material. Today's technology allows virtually anything to be transported to anyone at near zero cost, yet we are still using an "intellectual property scheme" that has remained largely unchanged (except for scope and time extensions) for centuries.

The new reality is that with different systems in place, everyone with a certain level of technology could have free access to all software and all media, and the authors of the programs and songs and books and shows could still be paid for their work. This is a truly new reality. It wasn't true in 1993, when internet access was rare, and when computers weren't capable of processing high-definition video, and infastructure wasn't capable of delivering unlimited content at low prices. But it's true now, or will be very soon (provided that the MPAA and RIAA don't get their way).

Furthermore, as detailed in the article, software development and medical research today involves immense duplication of effort by different organizations who cannot pool their efforts or knowledge because the IP system keeps them apart as competitors. Open Source Software (OSS) shows that these problems are unnecessary, but because it is difficult to make money from Open Source under the current IP regime, Open Source recieves relatively little funding compared to proprietary software.

The basic purpose of IP is (or should be) to encourage creation of works that are valuable to the people, and the basic means of doing so is to pay authors for their works. The basic problem with the IP system, however, is that authors are not paid for making works; but rather, income is generated from selling copies (or by other means which, in any case, involve money changing hands between IP providers and IP users.)

This restricts everyones' access to information. The poorer you are, the more you are affected, but it does hurt everyone to some extent. Searching, for instance--which almost everyone uses--is impeded by the current system (consider the lawsuit against Google Print.)

There are other (better) ways to ensure money gets to authors and to ensure that works are created in an efficient manner, but not much thought is put into them. The linked document proposes a government entity to fund public-domain works. This is an obvious solution, in hindsight at least, and perhaps the only workable one, but there are obvious concerns to be had about how money is distributed. Whenever the government starts paying people for work, a great risk appears that the money will be used inefficiently.

Of key importance is preserving the benefits of capitalism in the new regime. The key benefit of capitalism is that it tends to create "efficient markets", as they are called--markets where resources are used efficiently. I believe the reason capitalism achieves this is that it leverages the knowledge and intelligence of all participants in the economy to determine what is produced, and how much. If this can be reproduced in another system, even in a government-overseen system, then that system should function well.

By the way, the system proposed by the author doesn't impress me that much, since it seems arbitrarily constructed without much justification for its funding structure. Something this important needs thorough economic analysis, and the author doesn't leave me with a good impression of economic expertise. I myself haven't figured out how an IPR-alternative system should work, though.

I should develop my thoughts further.

Modding And The Law (link)

2005-11-12T10:14:00.000-07:00

This guy thinks like me. He can't talk about "modding" without complaining about any and every distasteful IP law.

$100 Laptop

2005-11-12T03:05:00.000-07:00

My suggestions for this project.

Give own staff education about life in the third world
Ensure that "market forces" affect software (even hardware?) available for the machine
Invest large amounts in educational software
Provide ways for local people to create educational software and e-books
Address language barriers. Need efficient and effective localization infastructure; should promote an international language
Create "hi-res" (640x480, 800x600) version of the laptop
Develop theories about how the laptop could be used to improve economies and quality of life beyond simply having laptops. Use the "teach a man to fish" principle - but need short term benefits also.
Provide better development tools than LOGO for students
Develop a mono version of the .NET Compact Framework for the machine?

Note to self:

Get involved in the project somehow? I could...
Contact others who look smart and bring them in?
Help promote the project at companies & educational institutions, and solicit investment?

Prolog - Lecture 1

2005-10-20T14:58:00.000-06:00

Prolog:

Two types of statements:

Rules
Propositions

File extension: .pl (just like Perl)
Periods end statements.
Avoid using spaces in code with the "gprolog" interpreter/compiler (GNU Prolog 1.2.16).
This compiler is very user-unfriendly.
Capital letters are "variables".
At the interpreter prompt, type "[X]." to load and compile a file named X.pl. Do not type "[X.pl].".
Type "trace." to enable trace mode, which will display the steps done by the interpreter.
Type "notrace." to turn off trace mode.

With this file:

likes(jake,chocolate).
likes(jake,apricots).
likes(darcie,licorice).
likes(darcie,apricots).

Output of "likes(X,chocolate).":
 X = jake ? ; (it waits for command here:
   ; to show next solution, a for all solutions,  to stop)
 no

comma (",") is an "and" operator.
Output of "likes(darcie,X),likes(jake,X).":
 X = apricots
 yes

----
grandmother(X,Y):-mother(X,Z),mother(Z,Y).
grandmother(X,Y):-mother(X,Z),father(Z,Y).
mother(anna,peter).
mother(anna,clara).
mother(mary,anna).
father(joe,peter).
father(jim,clara).
father(tom,joe).

The "grandmother" statements are a propositions. ":-" means "implies".

grandmother(X,peter).
 X = mary ? ;
 no

Algebraic proof that 2=1

2005-10-19T13:29:00.000-06:00

x=y
x^2=xy
x^2-y^2=xy-y^2
(x+y)(x-y)=y(x-y)
x+y=y
2y=y
2=1

Lost in translation

2005-10-15T18:03:00.000-06:00

The software is not equipped for 10 consecutive translations of the same piece of text.
-> Which the software of the interior of 10 witnesses turned the similar partial continuation is not equipped.

I want a new car for Christmas
-> I demand loaded a new automobile for them

Time flows like a river. History repeats. Mind your own business.
-> The operations of the time have taste of a river. Retorts of history its material hardly of the guata of the transactions.

The early bird gets the worm. Time flies when you're having fun. The blind are leading the blind.
-> The bird receives the continuous screw soon. The time flies, if you he have the safeguard. The screen of the light bulb executes the screen of the light bulb.

Haskell - lecture 7

2005-10-13T15:14:00.000-06:00

-- isLower, isUpper etc. are not recognized in WinHugs if the prompt says "Main>" (but it is recognized on startup when the prompt is "Prelude>")
kindOfChar :: Char -> String
kindOfChar c =
 if (isLower c)
 then "lower"
 else if isUpper c
   then "upper"
   else if isDigit c
     then "digit"
     else "other"
-- Same function implemented with guards:
kindOfChar2 :: Char -> String
kindOfChar2 c    -- Notice that there is no "=" before the guards
 | isLower c = "lower"
 | isUpper c = "upper"
 | isDigit c = "digit"
 | otherwise = "other"

-- Acts like the prelude (built-in) function 'take'
myTake :: Int -> [a] -> [a]
myTake 0 list = []
myTake m [] = []
myTake m x:xs =
 x : (myTake (m-1) xs)
-- Implementation using "case" expression
-- Internally, this is how Haskell resolves multiple function declarations?
myTake2 :: Int -> [a] -> [a]
myTake2 n list = case (n,list) of
 (0, list) -> []
 (n, []) -> []
 (n, x:xs) -> c : myTake2 (n-1)

-- In Haskell
 -- Everything exists at the top level (mutually recursive (?))
 -- Basic libraries automatically exist in prelude
 -- Type synonym
 -- Type classes (Ord, Num, Fractional, ...)
 -- Read and Show
 -- Pattern findings

Haskell - lecture 6

2005-10-13T15:00:00.000-06:00

-- I can't figure out what's going on here.
test1 = (\y -> (-) y 1)
-- test2 = (\y -> (-) y (\x -> x))     -- won't compile
test2 z = (\y -> (-) y (\x -> x)) z
test3 z = \y -> (-) y (\x -> x) z
test2b a b  = (\y -> (-) y (\x -> x)) a b
test3b a b = \y -> (-) y (\x -> x) a b

-- Prof implied that Haskell has no random-access arrays;
-- e.g. efficient hashtables cannot be created.

-- Data types in Haskell
-- Lists
--   [l] ++ [3,4], a : b
-- Tuple
--   (0, "abc", 'd', 5.0)
-- Enumerated:
--   data Weekday = Sun | Mon | Tue | Wed | Thu | Fri | Sat
-- Recursively defined types
--   data Tree a = Leaf a | Node (Tree a) (Tree a)
-- Lambda abstractions
-- List comprehensions

-- Declaration order doesn't usually matter, but module imports
-- must come first?  Also, function signatures' patterns are
-- checked/matched in the order they appear, every time a
-- function is called.  For example, out of the four functions below,
-- the first one is always regardless of the arguments.  Even so,
-- note that the arguments must be lists, because in Haskell, all
-- functions with the same name share the same data type
-- signature.  Try changing the order to see what happens.
orderTest a b = "a b"
orderTest a [] = "a []"
orderTest [] [] = "[] []"
orderTest (x:xs) (y:ys) = "(x:xs) (y:ys)"

-- Control Constructs
-- Patterns: pattern matching on function signatures is implicit flow control
-- Guards
-- "Where" - creates temporary local variables; example below
-- List comprehensions

-- Finds the roots of ax^2 + bx + c
-- Example: roots 1 5 6 -> (-2.0,-3.0)
roots a b c =
 if d < 0 then error "imaginary" else (x1, x2)
   where
     x1 = (-b + (sqrt d)) / twoa
     x2 = (-b - (sqrt d)) / twoa
     d = b*b - 4*a*c
     twoa = 2*a

Movie Piracy -- oOoOoOo

2005-10-08T15:15:00.000-06:00

Maybe I could make a main blog entry on this sort of thing... although to be honest I don't know very much about how the music & film industries screw real artists. All I know is that a lot of people aren't too happy with how bug business runs things.

What's a hoe

2005-10-08T15:07:00.000-06:00

I must have laughed for five minutes. But what is a rake?

Simplified XML?

2005-10-06T13:04:00.000-06:00

?sxml version=1.0?
root-element

-- this is a single-line comment.  Single-line comments
an-element attribute1="1.0" attribute2=2.0
child-element attribute3=<=>?!"'&sp;&        |             attribute4="<=>?!"' &"
another-one attribute5="bla" > example text
  > this text is part of the "another one" element
> this text is part of an-element
an-element/ -- closing tag is optional.
          -- if present, the XML reader would use it for error-checking

Possible useful & unusual morphemes

2005-10-06T12:29:00.000-06:00

"standard", "predefined idea" - e.g. "standard second month" = febuary, "standard first day" = Sunday. e.g. infix "o" - owundey (sunday), omunth (a month of the year), owik (a week that begins Sunday); not used with 'the'
"generalization" or "scope widening" affix - e.g. je
"specialization" or "specific" affix - spe
"unit distance or step away" affix - ste
"the path toward something" affix - e.g. "homtoo"=the path leading home
...which is distinct from "a path or manner", "wey"
"direction along a path or axis" affix
"movement along a path or axis" affix - rd

Haskell - lecture 5

2005-10-04T15:06:00.000-06:00


-- Lambda functions are specified with a backslash.
-- (\x -> x*(x-1)) 4   =   12
-- (\x -> (\y -> ((+) y 1))) 2 3   =   4
-- (\x -> (\y -> ((/) x y))) 10 2   =   5.0
-- (\y -> ((+) y x)) 5   =   ERROR - Undefined variable "x"
-- (\x -> (\z -> ((/) z 2)) x) 3   =   1.5
-- (\x -> (\z -> ((*) x z)) x) 3   =   9

Haskell - lecture 4

2005-09-29T15:12:00.000-06:00

--
-- What's this?
interleave x [] = [[x]]
interleave x (y:ys)
 = [x:y:ys] ++ map (y:)(interleave x ys)

perms [] = [[]]
perms (x:xs)
 = [ zs | ys <- perms xs, zs <- interleave x ys ]

-- Back to prime calculation.  Note: /= means "not equal to"
crossOut :: Int -> [Int] -> [Int]
crossOut m ns = [ n | n <- ns, (n `mod` m) /= 0]   -- Could also use "mod n m"

-- Excludes non-prime numbers from a list.  Must be [2..] or a list of the form [2..n]
seive :: [Int] -> [Int]
seive [] = []
seive (x:xs)
 = x : seive (crossOut x xs)

-- output of seive [2..50]
-- -> [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47]

-- Finds a bunch of integers satisfying a^2 + b^2 == c^2
-- What's interesting about this example is that it is slow: n^3
-- 50x50x50 = 125,000 iterations; takes about 20 seconds @ 1.6GHz
-- Other languages would do it faster.
triads = [(a,b,c) | a <- [1..50], b <- [1..50], c <- [1..50], a^2 + b^2 == c^2]
-- type:  [(Integer,Integer,Integer)]
-- output: [(3,4,5),(4,3,5),(5,12,13),(6,8,10),(7,24,25),(8,6,10),(8,15,17),(9,12,15),(9,40,41),(10,24,26),(12,5,13),(12,9,15),(12,16,20),(12,35,37),(14,48,50),(15,8,17),(15,20,25),(15,36,39),(16,12,20),(16,30,34),(18,24,30),(20,15,25),(20,21,29),(21,20,29),(21,28,35),(24,7,25),(24,10,26),(24,18,30),(24,32,40),(27,36,45),(28,21,35),(30,16,34),(30,40,50),(32,24,40),(35,12,37),(36,15,39),(36,27,45),(40,9,41),(40,30,50),(48,14,50)]

-- The quicksort (using first-element pivot)
-- Here are two implementations.
quicksort :: Ord a => [a] -> [a]
quicksort [] = []
quicksort (x:xs)
   = quicksort [y | y <- xs, y <>= x]
--  = quicksort (filter (=x) xs)
-- You can sort numbers but also pairs:
-- quicksort [(1,3),(6,3),(2,4),(2,0),(6,1)] -> [(1,3),(2,0),(2,4),(6,1),(6,3)]

-- All operators can be expressed in prefix form.
-- (+) 1 2:  3
-- :t (+):  (+) :: Num a => a -> a -> a
-- :t (^): (^) :: (Num a, Integral b) => a -> b -> a
-- This is interesting:
-- :t (^2): flip (^) 2 :: (Integral a, Num b) => b -> b
-- ((flip (^)) 2) 3: 9

-- This function performs an operation on a collection of elements like so:
--   myfoldr (+) 1 [2,3,4] == 1 + (2 + (3 + 4))
-- Note the right-first evaluation.
myfoldr :: (a -> b -> b) -> b -> [a] -> b
myfoldr fn b []
 = b
myfoldr fn b (x:xs)
 = fn x (myfoldr fn b xs)

myfoldr1 :: (a -> a -> a) -> [a] -> a
-- myfoldr1 is meaningless on an empty list: show error message
myfoldr1 fn [] = error "applied to empty list"
myfoldr1 fn [x] = x
myfoldr1 fn (x:y:xs) -- x:y:xs guarantees it matches only lists with at least 2 items
 = fn x (myfoldr1 fn (y:xs))
--

Haskell - lecture 3

2005-09-27T15:10:00.000-06:00

-- Here's the filter again, this time with "guards".  Guards are like
-- case statements in other languages.  The guards are
-- evaluated in order; "otherwise" must come last.
otherFilter :: (a -> Bool) -> [a] -> [a]
otherFilter functionName [] = []
otherFilter functionName (x:xs)
 | functionName x = x : otherFilter functionName xs
 | otherwise = otherFilter functionName xs

-- This function is intended for use as a filter. It takes one pair
-- as an argument, and returns true if y == 2*x.
-- example use: myFilter doubleSecond [(1,2),(3,4),(5,10)] -> [(1,2),(5,10)]
doubleSecond :: (Int, Int) -> Bool
doubleSecond (x,y)
 = y==2 *x

-- Here's another kind of "filter" function: a mapper.  It takes a
-- mapping function as an argument, along with a list.  It passes
-- each element of the list to the supplied function, and puts the
-- return values in a new list.  Example use:
-- myMap (^2) [1,2,3,4] -> [1,4,9,16]
myMap :: (a -> b) -> [a] -> [b]
myMap fn []
 = []
myMap fn (x:xs)
 = fn x : myMap fn xs

-- The inRange function determines whether a number is
-- in a certain range.
--    The type declaration introduces "Ord".  "Ord a" means
-- "any type 'a' that is ordered", i.e. that supports magnitude
-- operators such as > and <.  Also notice the new arrow, "=>".
-- It looks like the arrow separates the "interface constraint"
-- on the left with the normal data type declaration on the right.
inRange :: Ord a => a -> a -> a -> Bool
inRange beginning end element
 = element >= beginning && element <= end

-- inRange can't be used as a filter directly because it takes 3
-- arguments instead of 1:
-- * myFilter inRange 2 4 [1,2,3,4,5,6] -- wrong
-- However, we can bind the first two arguments, to produce
-- a "new" function that takes only one argument:
--   myFilter (inRange 2 4) [1,2,3,4,5,6] -> [1,5,6]

-- BTW: "zip" takes two lists and makes a list of pairs:
-- zip [1,2,3] ['a','b','c'] -> [(1,'a'),(2,'b'),(3,'c')]
-- zip [1,2,3] "abc"        -> [(1,'a'),(2,'b'),(3,'c')]
-- zip [1,2,3,4,5,6] (map (^3) (filter (inRange 2 4) [1,2,3,4,5,6]))
--   -> [(1,8),(2,27),(3,64)]

-- "List comprehensions": a way to generate a finite or infinite
-- list from 1 to 3 parameters.  Best explained by example:
--   [1..4] -> [1,2,3,4]
--   [5,4..1] -> [5,4,3,2,1]

--   [5,3.. -5] -> [5,3,1,-1,-3,-5]
--   [2,3.5..7] -> [2.0,3.5,5.0,6.5]
--   [2,3.5..7.5] -> [2.0,3.5,5.0,6.5,8.0] -- strange, eh?
--   [0,10..29] -> [0,10,20]
--   [-2..] -> [-2,-1,0,1,2,...]
--   [2,4..] -> [2,4,6,8,10,12, ...]

-- Here's a list-generating loop construct in Haskell.
ex1 = [x *2 +4 | x <- [1,3..10]]
-- ex1 -> [6,10,14,18,22]
ex2 = [(x,y) | x <- [1..4], y <- [1..4]]
-- ex2 -> [(1,1),(1,2),(1,3),(1,4),(2,1),(2,2),(2,3),(2,4),(3,1),(3,2),(3,3),(3,4),(4,1),(4,2),(4,3),(4,4)]
ex3 = [(x, x*2+y) | x <- [1,2,3], y <- [4,5,6]]
-- ex3 -> [(1,6),(1,7),(1,8),(2,8),(2,9),(2,10),(3,10),(3,11),(3,12)]
tri m = [(i,j) | i <- [0..m], j <- [0..i]]
--  tri 3 -> [(0,0),(1,0),(1,1),(2,0),(2,1),(2,2),(3,0),(3,1),(3,2),(3,3)]
--  :t tri
--    tri :: (Num a, Enum a) => a -> [(a,a)]

-- Tomorrow: computing prime numbers

ACLU's twisted ideas

2005-09-26T12:42:00.000-06:00

Wow.

I am writing to let you know about a vitally important ACLU case that will begin in a few days.

Once again, the ACLU will be defending religious freedom against those who want to force creationism into our public schools. The underlying conflict has been going on at least since the Scopes trial, a famous ACLU case from an earlier era.

At the core, the conflict is between those who believe science should be taught in science classes and those who want to use our public schools to promote one set of religious beliefs over another.

But, this time, the creationists have a new ploy. It's called "intelligent design" -- an "alternative" to the scientific theory of evolution that religious extremists have cooked up as a way to sneak religious proselytizing into our public schools.

...

It is all too clear that powerful political forces are not just tinkering around the edges of our religious freedom -- they have set their sights on transforming our country from a constitutional democracy to a thinly veiled theocracy. They want to turn America into a country governed by their interpretation of the Bible, serviced by faith-based, taxpayer-funded institutions and guided by religious doctrine against which neither citizens nor judges should dare to speak up.

- Anthony D. Romero
Executive Director, ACLU

hmm.

"The consent judgment is repeatedly violated by these individuals because they do not believe anything will happen to them," the ACLU said in its Wednesday court filing. "Their refusal to comply with the consent decree should and must result in their removal from society." (emphasis added)

CPSC 349: Haskell: 2nd lecture

2005-09-22T14:11:00.000-06:00

-- To use Haskell on Windows, download WinHugs from here:
-- http://cvs.haskell.org/Hugs/pages/downloading-Nov2003.htm
-- Commands in the Haskell environment start with a colon:
-- If this code is in test.hs, use command ":l test.hs" to load
-- :t gives the type of something
-- :? gives a list of commands

-- Computes a factorial
fact :: Integer -> Integer
-- Int is 32 bits; Integer is unlimited.
fact 0 = 1
fact (n+1) = (n+1) * fact n

-- Gets the sum of the diagonal of a 3x3 list
-- e.g. diagonal [[1,2,3],[4,5,6],[7,8,9]] = 1+5+9 = 15
diagonal :: [[Int]] -> Int
diagonal [a,b,c] -- type decl. implies a, b, and c are lists of Int
= head a + head (tail b) + head (reverse c)

-- Tuples: complex ordered data type with unnamed elements
-- e.g. (1, 1.0, "1.0", '1', [1])
-- e.g. ("my age in years", 25)

-- 'points' compute the coordinates of a series of integer points
-- along a line, where each point is 1 unit apart horizontally
-- points 8 0 2 4
-- -> [(0,4),(1,6),(2,8),(3,10),(4,12),(5,14),(6,16),(7,18)]
points :: Int -> Int -> Int -> Int -> [(Int, Int)]
points 1 x slope intercept
= (x, x * slope + intercept) : []
points (n+1) x slope intercept
= (x, x * slope + intercept) : points n (x+1) slope intercept

-- "++": Concatenation operator: [1,2] ++ [3,4] -> [1,2,3,4]
-- ":": I don't know what it's called: [1,2] : [3,4] -> [[1,2],[3,4]]

-- You can produce functions from the built-in operators.
-- Examples:
-- (2/) is a function that divides 2 by something, so (2/) 4 -> 0.5
-- (/2) is a function that divides something by 2, so (/2) 4 -> 2.0
-- (/) is the division function: (/) 21 3 -> 7.0
-- Another example: ([1,2]++) [3,4] -> [1,2,3,4]

-- This function uses the output of another function as a "filter".
-- The filter determines whether to keep an element of the list.
myFilter :: (a -> Bool) -> [a] -> [a]
myFilter functionName [] = []
myFilter functionName (x:xs) =
if functionName x then
x : myFilter functionName xs -- Keep 'x' in the output list
else myFilter functionName xs -- Discard 'x'
-- Example:
-- myFilter (>4) [1,8,2,7,3,6,4,5] -> [8,7,6,5]
-- myFilter

Haskell sample

2005-09-20T14:59:00.000-06:00

About haskell haskell.org
-----------------
len :: [a] -> Int
len []
= 0
len (a : rest)
= 1 + len rest
-----------------
everyThird :: [Char] -> Int
everyThird [] = []
everyThird (x:y:z:xs) = x : everyThird xs
everyThird (x:y:xs) = []
everyThird (x:xs) = []
-- Um, whouldn't these be ambiguous? [1,2,3] ought to match x:xs and x:y:xs and x:y:z:xs, cxu ne?
-- Result of everyThird "classroom" : "arm"
-----------------
To load a file: :l filename.hs
To get the type of something: :t 123
output: 123.0 :: Int