Author: stewart

How to stop itching

Hot water stops itching.
This is not well known, but here are some links:
http://www.associatedcontent.com/article/394710/how_to_stop_the_itch_of_poison_ivy.html
http://www.peoplespharmacy.com/2005/10/18/hot-water-for-itches/
Scratching really doesn’t work.  After a few minutes, you want to scratch again, but hot water really does work, for hours.
Evidently, itching is caused by release of histamines from the skin.  Hot water causes the skin to release the whole reservoir at once.  This causes a truly weird sensation for a few seconds, but after that, the area won’t itch for quite a while – hours – until the histamines build up again.
The water has to be rather hot – not full on hot (140 at my house) but hotter than feels comfortable.  Experiment.  You will be a happy and itch free person.
I use this technique with poison ivy or mosquito bites.

iPhone tweaks

Overall I am very pleased with the iPhone 3G after a year.  Like everyone else, I detest ATT.
There are things that could be improved.
UNDO! In the mail application, I sometimes accidentally delete a message.  I notice right away, but it is a pain to recover.  My several mail apps use different naming schemes for deleted messages. I sure I could fix that, but right now I have to check each of the Trash/Deleted Messages folders  to locate the one the iPhone uses.  Then I have to scan down the list of deleted messages because the table of contents is kept sorted.  I delete so much spam that there can easily be dozens of spams ahead of the message I want.  Once I find it, I have to refile it back to the inbox.  All thus could be fixed with one undo button.
MARKING – It is a common event that I scan arriving mail while on the go.  The iPhone keyboard is not so wonderful that I respond that way.  Instead, I’d like to mark the messages I want to deal with later.  I could refile them to a todo folder, but I’d rather mark or flag them in the inbox.  I’m not much for sorting email into folders.  I just create a sequentially numbered archive folder with a few thousand old messages every few months.  I’ve been doing this since 1978, so it is kind of set.
The iPhone could use the edit dialog for this.  All it does is let you mark mail for deletion right now.  Instead, you could flag messages with the edit dialog.  To flag a single message, you might swipe it to the left.
Other iPhone apps.  I use Google reader on the iPhone.  Whevener my daughter borrows the phone, she logs into her account on Google reader.  When I get the phone back I have to retype my own login data.  The Google reader app could make it easier to select from multiple sets of credentials.  Or maybe the whole phone could have a switcher so multiple people could easily share it.
The iPhone needs a way to turn off all phone functionality while leaving WiFi running. This is for airplanes with WiFi.
UPDATE Sept 12.
I forgot the most important improvement to Google Reader.  “Mark all items as read” should also return to the feeds view, rather than staying on the particular feed looking at an empty screen.  My feed reading style is to scan the entries, reading the ones that look interesting, then “Mark all as read” and move on.  I always have to click again to return to the feed list.

SiCortex closing

I now have time to work on the chicken coop.
SiCortex wasn’t able to find financing in the current climate, and is shut down pending an asset sale.  See, for example, http://www.nytimes.com/external/gigaom/2009/05/28/28gigaom-on-the-block-sicortexs-delorean-style-green-super-23152.html
I haven’t written much here about the company or the technology, but I will do some more of that, because in the five years I spent working at SiCortex I learned a lot, and some of those things will be valuable to others somewhere down the line.
I follow the news of web 2.0 incubators, and the ease and low overhead of software startups, and you know, I am not impressed. SiCortex didn’t fail for lack of technology, or vision, or customers, but from the poor timing of having to raise money during a recession. I loved what we were doing. It wasn’t easy but we did it. We started with a pile of sand, and some ones and zeros, and built the most energy efficient high performance computers ever.
I know it is trite, but JFK pretty well nailed the concept of working on things that are worth doing.

We choose to go to the moon in this decade and do the other things, not because they are easy, but because they are hard, because that goal will serve to organize and measure the best of our energies and skills, because that challenge is one that we are willing to accept, one we are unwilling to postpone, and one which we intend to win, and the others, too. 

Best wishes to all my colleagues.

More bad design of hotel wifi

Today I am at the Marriott Courtyard near BWI. They have free wifi.  Actually it isn’t bad. Go Marriott. Unfortunately it is still screwed up in three ways:

  • iPhone access is entirely broken. When you try to use the web browser you get an infinite series of “click here to continue”
  • https access doesn’t work.  I have configured google so that it always connects with TLS.  No intercept screen or advice, just fail.
  • When you finally think to try http, you get the incredibly busy ibahn login screens, with the free option, but then you get this acceptance screen:

ibahn
May I rant?  Showing customers the stack trace of your broken application is Not Good.  And Microsoft! Thank you for advertising that your “.net” is so helpful.  I’ll be sure to not select .net for my next web project.

Ice!

Important safety tip!  Do not try to bicycle on ice.  It doesn’t annoy the ice, but it doesn’t work, either.
Another tip!  If the road is wet on a North facing slope, and it is 39 degrees, there’s a good chance there is ice underneath.
And another! If you notice ice on the puddles in the gutters, there might be more ahead.
I had my first wipeout this morning, on the hill from Sudbury north into Maynard, on 27.  I think I scared the driver behind me.  One second everything is fine and the next, with no apparent transition, the bike and I are sliding sideways down the road.  No harm done, but I will be more vigilant!

Microsoft EULAgy

As I was planning this post, I thought I would check the fine print in the End User License Agreement for Microsoft Office Home and Student 2004 for the Mac.
I can’t find it.
The Microsoft website does have the license for the Windows version of Home and Student 2007, but only as a self-extracting EXE file.  (A) I don’t have a way to read that, since my XP won’t run under VMware and (B) Office on the Mac says to load the original CD to see the license.  Well the CD is at home.
For such a lawyer-crazed company as Microsoft, they sure make it hard to find out what their rules are.  I guess that is deliberate.
Anyway, AFAIK, I can’t use Home and Student for work related things.  Consequently, last week when I gave a talk at Microsoft Research Silicon Valley, I used Keynote.

Evidently I am a Windows Pirate

May I rant?
I have a Macbook Pro, which I like, well, quite a lot.  When I first got it, I gave it to my wife to run Windows XP, using Boot Camp.  Why? Because I love her more than the Mac.
It turned out that she doesn’t like the trackpad having only one button, so I got it back, and I happily run MacOS.
The copy of Windows XP on the Mac is an OEM copy for computer builders, which I think is fine, since I replaced the hard drive.
Last night I had to run Windows in order to run Turbotax Business, which unaccountably is only available for Windows.  I fired up Vmware Fusion and had it boot the boot camp partition… and Windows refused to run because it had been installed on a different computer.
Um, no, Microsoft, this is NOT a different computer. I added a layer of emulation, but every transistor and wire is identical to before.  I am not sure how this behavior is supposed to benefit Microsoft shareholders.
And yes, by rebooting directly into Windows, it works fine.

Unclear on the concept

I am so mad at myself for forgetting to take a photograph of this.
Earlier this week I spent a few days at the famed Claremont Resort and Spa in Berkeley, California.  I was there for the Hot Topics in Parallelism workshop, but that isn’t the point.
It used to be that in bathrooms, one had a “heat lamp.” This was a dull red PAR type bulb in a ceiling fixture, typically with a twist knob timer.  You turn it on and it runs for 10 minutes or whatever while you take a shower and dry off.
Now I know that California is Eco-Groovy, and Berkeley is about the epicenter of Eco Groovyness, but at the Claremont, they have replaced the bathroom heat lamps with, … wait for it… compact fluorescent bulbs.
They still have the 10 minute twist knob timers and everything.

Fun with the C Preprocessor

Recently I’ve been writing an implementation of OpenSHMEM for the SiCortex platform. OpenSHMEM is a communications API that lets you write PGAS programs in C or FORTRAN.  PGAS stands for “partitioned global address space.”  A PGAS program is a parallel program that can run on a lot of cores or cluster nodes simultaneously. Each processing element (PE) can read and write the address spaces of the other PEs, but the program “knows” that the global address space is partitioned into a bunch of local address spaces. This is either taken care of by the language, like in UPC (unified parallel C) or by the programmer explicitly using something like OpenSHMEM.
All this is just introduction.  OpenSHMEM derives from the Cray/SGI SHMEM API, and one of the things it has are a lot of API calls that differ only in the datatypes of their arguments.
For example, OpenSHMEM has

extern void shmem_short_wait(short *var, short value);
extern void shmem_int_wait(int *var, int value);
extern void shmem_long_wait(long *var, long value);
extern void shmem_longlong_wait(longlong *var, longlong value);
all of which wait for a local variable to be set by some remote PE.

I am a lazy programmer.  I should write the same routine four times?  Instead, I used some C preprocessor magic and wrote this:

#define EmitWait(type)
void shmem_##type##_wait(type *var, type value)
{
while (*((volatile type *) var) == value) shmem_progress();
}
EmitWait(short);
EmitWait(int);
EmitWait(long);
EmitWait(longlong);
This uses the “token pasting” feature of CPP to write the proper function names for the different versions of the routine.
A bit later, I learned of the Global Address Space Performance initiative, a project at the University of Florida. By putting the performance analyzer library in front of the OpenSHMEM library on your search path, you can instrument the communications functions in your program without recompilation. This works via dynamic linking. The program calls shmem_long_wait, which is intercepted by the performance library. The library does whatever it does, then passes the call to pshmem_long_wait, which is provided by the OpenSHMEM implementation.
You can do this by providing two OpenSHMEM implementations, one with the names like shmem_long_wait, which is used when not profiling, and one with names like pshmem_long_wait, which is used when you are.  Alternatively, you can use the “weak symbol” feature of the GNU runtime. A weak symbol defines something, but it doesn’t complain if an alternative definition is present in the address space.  To make this work, you write all the functions as pshmem_long_wait, then add a weak symbol definition for the standard versions, like this:

#pragma “weak shmem_long_wait=pshmem_long_wait”

Now everything is in one library, and there is no performance penalty when you aren’t using the instrumentation library.
Well the obvious way for the lazy programmer to do this is like this:

#define EmitWait(type)
#pragma “weak shmem_##type##_wait=pshmem_##type##_wait”
void shmem_##type##_wait(type *var, type value)
{
while (*((volatile type *) var) == value) shmem_progress();
}
but this fails because you can’t use the C preprocessor to write C preprocessor items like #pragma. No problem! C99 provides an alternate version of pragma exactly for this reason. The GNU info file says:

C99 introduces the `_Pragma’ operator.  This feature addresses a major problem with `#pragma’: being a directive, it cannot be produced as the result of macro expansion.  `_Pragma’ is an operator, much like `sizeof’ or `defined’, and can be embedded in a macro.

Now I can write my macro with

_Pragma(“weak shmem_##type##_wait=pshmem_##type##_wait”)

right? Well, no. token pasting doesn’t work inside strings!  You can’t build up string constants this way. No problem! GCC automatically concatenates adjacent string constants into a single longer string. This was originally done so you can avoid line wrapping, but whatever. I can write this

_Pragma(“weak shmem_” #type “_wait=pshmem_” #type “_wait”)

This is using a different preprocessor feature, called “stringification” in which #type is expanded and turned into a string constant.
Unfortunately, this doesn’t work either, because _Pragma is processed earlier in the compiler than other uses of string constants, and before the string concatenation happens.  _Pragma has to have exactly one string constant as an argument.
How much time have I spent on this?  How many cases of _Pragma do I have to write by hand?  I give up.  The final version is

#define EmitWait(type)
void pshmem_##type##_wait(type *var, type value)
{
while (*((volatile type *) var) == value) shmem_progress();
}
_Pragma(“weak shmem_short_wait=pshmem_short_wait”)
_Pragma(“weak shmem_int_wait=pshmem_int_wait”)
_Pragma(“weak shmem_long_wait=pshmem_long_wait”)
_Pragma(“weak shmem_longlong_wait=pshmem_longlong_wait”)
_Pragma(“weak shmem_wait=pshmem_wait”)
EmitWait(short);
EmitWait(int);
EmitWait(long);
EmitWait(longlong);

It has more typing than ought to be necessary, but I got over it.