Technology Tales

A case of cross-fertilisation

Having two blogs allows me to stream my content; I doubt that many visitors to my hillwalking blog would appreciate seeing posts on, for example, the minutiae of UNIX shell scripting. However, as disparate as these worlds are, there is something shared between them, and it has started to cause some cross-fertilisation between them: blogging itself. Rather than being too self-referential on my hillwalking blog and preaching to the choir, I have taken the decision to muse about blogging and its progress right here. There is also some escape in the opposite direction too: technology does get used on the hill too. Examples include GPS receivers and digital mapping, and my hillwalking blog is definitely the place for them. It is all very much audience-driven; this consideration of content is the sort of thing on which a posting on The Blog Herald has been musing.

What are we like?

Do we surf the web less at the weekend?

Using Korn shell commands in scripts running under the bash shell

This is actually a fairly simple one: just prefix the relevant command with ksh like below (in the example below, bash won't know what to do with the print command otherwise):

ksh print "Hello, world!"

It's also useful for running Korn shell scripts under the bash shell as well.

Recalling previous commands in the Korn shell

The default shell on Solaris boxes seems to be Korn and the version that I have encountered doesn't appear to allow obvious access to the command history. In the bash shell, the up and down cursor keys scroll through your command history for you, but Korn doesn't seem to allow this. Thankfully, there is another way: you can set up the editor vi as the default method for gaining access to the command history by adding the following line to the .profile file in your home directory:

set -o vi

Then, you can use the Vi (it's pronounced vee-eye, apparently) commands ESC+h and ESC+j to move up and down the list of previous commands. That, or, assuming that you have access to it, just use the bash shell anyway...

WordPress 2.2

WordPress 2.2 made its debut yesterday and, after a spot of cautious testing, I upgraded my hillwalking blog to use it. The reason for the testing was that self-hosted WordPress blogs can now have what WordPress.com blogs have had for a while: built-in widget capability. It was this that upped my level of caution, but the changes weren't as drastic as I had feared: you need to amend your theme for widgets to be supported, and not having done this causes no untoward effects. Making themes widget compatible is something that Automattic describe in a helpful article on their website. Other than this, WordPress 2.2 doesn't cause much upheaval and, apart from pieces of JavaScript snagging on occasions in Firefox, all seems well. I am still sitting on the fence as regards those widgets, though...

Finding the number of observations in a SAS dataset

There are a number of ways of finding out the number of observations (also known as records or rows) in a SAS data set and, while they are documented in a number of different places, I have decided to collect them together in one place. At the very least, it means that I can find them again.

First up is the most basic and least efficient method: read the whole data set and increment a counter to pick up its last value. The END option allows you to find the last value of count without recourse to FIRST.x/LAST.x logic.

data _null_;
    set test end=eof;
    count+1;
    if eof then call symput(”nobs”,count);
run;

The next option is a more succinct SQL variation on the same idea. The colon prefix denotes a macro variable whose value is to be assigned in the SELECT statement; there should be no surprise as to what the COUNT(*) does…

proc sql noprint;
    select count(*) into :nobs from test;
quit;

Continuing the SQL theme, accessing the dictionary tables is another route to the same end and has the advantage of needing to access the actual data set in question. You may have an efficiency saving when you are testing large datasets, but you are still reading some data here.

proc sql noprint;
    select nobs into :nobs from dictionary.tables where libname=”WORK” and memname=”TEST”;
quit;

The most efficient way to do the trick is just to access the data set header. Here’s the data step way to do it:

data _null_;
    if 0 then set test nobs=nobs;
    call symputx(”nobs”,nobs);
    stop;
run;

The IF/STOP logic stops the data set read in its tracks so that only the header is accessed, saving the time otherwise used to read the data from the data set. Using the SYMPUTX routine avoids the need to explicitly code a numeric to character transformation; it’s a SAS 9 feature, though.

To finish, here is the most succinct and efficient way of all: the use of macro and SCL functions. It’s my preferred option, and you don’t need a SAS/AF licence to do it, either.

%let dsid=%sysfunc(open(work.test,in));
%let nobs=%sysfunc(attrn(&dsid,nobs));
%if &dsid > 0 %then %let rc=%sysfunc(close(&dsid));

The first line opens the data set, and the last one closes it; this is needed because you are not using data step or SCL and could leave a data set open, causing problems later. The second line is what captures the number of observations from the header of the data set using the SCL ATTRN function called by %SYSFUNC.

Using blog widgets

Are developers and designers overcomplicating their CSS?

When I have been tweaking the widgets in this blog, the thought crossed my mind that purveyors of open source blogging and CMS's may be overcomplicating matters with the CSS that they are writing. Using inheritance without much thought as to others having to pick it up is one irritation, but bunching styles together can confuse too. For instance, you can draw from two different styles for the same HTML element (it's what's going when you see class="class1 class2" in a tag definition), which is OK if done simply but can confuse matters when customisation is attempted later. Drupal particularly suffers from this bugbear, but it's there on WordPress too, though not to the same extent. Using a hierarchy to define and attach your styles (#id1 .class2 tag1 {style definition...} is the kind of thing that I have in mind), can also confound, even if I admit to finding the approach very useful for myself. I think that I know what's driving this: the need to cut down the bulk of CSS files but using the advanced features that I mentioned above without clear commenting and other documentation hampers later efforts. It would be nice if every developer of a theme to use in blogging or CMS software was forced to document their work extensively and share that documentation with interested users. After all, sharing is the whole purpose of their endeavours...

Outdoors enthuasiasts blogging in the U.K.