Coffee on the Keyboard

Google Loves Competition

2009-07-08T20:12:08Z

Google has announced a new Chrome-based operating system. Of course, if you read blogs like mine, there’s no way you didn’t already know that.

It amazes me how many people assume Google wants to drive Microsoft out of business. From a ZDNet article: “The Chrome OS is a direct attack against Microsoft’s lucrative – albeit vulnerable – Windows operating system.”

“Lucrative?” Isn’t Google’s OS free? “Vulerable?” Most people don’t know enough to change browsers, let alone operating systems. Most of them want it to “just work,” not to be forced to learn new things.

Maybe, deep inside Google, in the minds of some of its most hardcore decision makers, Microsoft is the evil empire, to be vanquished heroically. But on a more realistic level, I think Google is happier when there’s more competition, not less. If you listen to many of the comments surrounding the release of Chrome and its source code, there is a distinct sense that Google itself is better off if there are a dozens major browsers, all competing and driving standards adoption and development.

So too, I think, with operating systems. Google is designing an open-source system that will, hopefully, lead to the creation of additional platforms and push others to make their user experiences better.

Google isn’t trying to take Microsoft down, but encouraging a more competitive marketplace, in the hope that competition will keep everyone innovative and honest.

New Information Processes

2009-07-08T19:31:56Z

Robert Pondiscio started a great discussion on Twitter in the classroom over on The Core Knowledge Blog. In particular, I’m interested in one of his comments:

If someone invented a 21st century hammer it wouldn’t dramatically change the training and experience a contractor would need to build a house. Nor would anyone suggest that “tool fluency” is now the soul of carpentry. And so it is with information literacy. It dramatically expands access to information. It doesn’t change how we process it.

The emphasis is mine. Now, whether tools like Twitter or Today’s Meet are useful in classrooms is a broader discussion than I want to deal with right now*, but here’s a more specific question: does the way we access information alter the ways we process it?

Let’s look at the history of writing in general: Socrates was against it. He felt that writing diminished the ability of the reader/listener to question and interact with the author/speaker, and, in an eerily familiar concern, that the written word destroy our memories. Socrates worked by his eponymous method, a rhetorical strategy of questioning to ferret out truth and expose falsehood and fallacy. When he was presented with a written argument, he was not able to evaluate its author, nor to directly question the author’s deductions.

Here we have a physiological shift in how we process information: from listening with our ears to reading with our eyes. I’m not a neurologist, but I’m sure those processes involve different areas of the brain—though surely with much overlap.

But more crucially, the reader typically processes much larger chunks of content than the listener. The listener is able to interrupt, clarify, disagree with any particular point. The listener can be persuaded by discussion while the reader must accept what is written, or not. Readers who wish to respond often do so en masse, with equal-length writings, rather than specific questions.

The technology of writing changed how we access information, how we process it, and how we respond to it.

For all the downfalls, and all of Socrates concerns, writing spread throughout the civilized world, because it has several key advantages over the oral/aural tradition. Writing can be stored for later, copied, distributed. A performance of The Iliad requires the audience to come together at a time and place; the book can be read by individuals at their leisure, passed around and carried to new places—though it loses the meter, rhythm and excitement imparted by the performer.

From our historical point of view, writing enables us to create more “complete” works, uninterrupted by the audience, with more time to contemplate, and forces us to form arguments on a larger scale than when speaking. From Socrates point of view, those were not advantages.

So, when Stuart comments

Many things that are really worth knowing — whether world history or human anatomy or advanced physics — will demand that a student be able to pay attention to dense texts for long periods of time, along with memorizing quite a bit of what is printed there.

remember that the books he’s praising would not, could not, exist without writing, a technology that altered our way of storing and accessing information. (And without the printing press, we wouldn’t have homework, either, and kids would not be expected to read those books.)

Let’s stick with writing and jump ahead, way past the typewriter to the word processor. Why the word processor?

If you are writing by hand, chiseling in rock, painting on papyrus, or even using a typewriter, writing and editing are essentially linear processes. You write in order. Changing the order is a cumbersome process, and nearly any edit requires a complete re-type.

With the advent of the word processor, non-linear editing is possible. The way we approach, and critique, writing is so significantly different, thanks only to cut, copy, and paste, that I doubt many of us can truly appreciate the shift. Ask someone about the difference between linear and non-linear video editing and I think you may start to catch a glimpse of that shift.

When the computer and word processor were first introduced, there was not an immediate productivity increase over typewriters. It took time for users’ methods of processing the information to adapt and assimilate the new technology, even though they keyboard was essentially unchanged. The access to information (our own writing) in a new way altered the way we processed and created that information.

In the most modern era, critics of multitasking argue that accessing multiple sources of information simultaneous alters our method of processing that information (for the worse, or they wouldn’t be critics). They cite fMRIs and other scans indicating a physiological shift in information processing, stemming simply from a change in access.

It is difficult to accept the claim that new methods of accessing information have no effect on our processing of that information, regardless of your opinion of social media, social networking, and/or education. The dichotomy of content and delivery is hardly clear-cut. If it were, why should teachers mind students watching a movie in lieu of reading a book? This blurring is the very basis of “differentiated instruction,” an admission that all processing paths are not equal in all students.

* For the record, I agree with Mr. Pondiscio on many—if not most—points, especially with his concern that teachers spend too much time making any particular technology an end in and of itself. However, I think there is a very fine line to walk when a psychosocial moratorium is not possible. I’ll write more about modeling interactions with new tools, from e-mail to social media.

WP: Better Search Widget 1.1

2009-07-02T17:05:05Z

Better Search Widget 1.1 is a significant upgrade to Better Search Widget that adds new features and fixes an old bug with internationalization.

Features

(New features in bold.)

Optional default value.
Optional, custom widget title.
Optional onfocus and onblur listeners.
Optional, customizable focus and blur colors.
Custom button value.
Custom field size.

The built-in search widget has only one of these features, the optional, custom title.

Onfocus and Onblur

In order to use the blur and focus colors, you must enable the onfocus and onblur event listeners. In order to use the listeners, you must specify a default value (otherwise none of this makes sense). Here’s an example:

Bug Fixes

A pretty serious typo meant that none of the internationalization code worked correctly. This has been fixed, and en_US, en_GB, and fr_FR localizations are available. de_DE is coming. If you’d like to translate, there is a .pot file included in the languages directory.

License

Better Search Widget is released under the MIT License. If you use it, or have suggestions for new features or bug fixes, let me know!

Getting It

You can download Better Search Widget 1.1 now in a Zip file. Or, to save yourself some trouble, you can check it out of Subversion from

svn co svn://jamessocol.com/better-search-widget/tags/1.1.0 ./better-search-widget

(Run that in your wp-content/plugins directory.) Subversion will make it easiest to upgrade later.

Roadmap

Soon, though probably not today, I will be releasing Better Search Widget 2, which will take advantage of the new Widget API in WordPress 2.8. This will add support for multiple instances of the widget, but will require at least WordPress 2.8. You should upgrade, anyway.

Widget l10n

2009-07-02T04:36:43Z

I spent some of today working on bringing a couple of WordPress widgets up-to-date (Better Search and Most Comments) only to discover there is a new widget API. I guess I haven’t been paying attention.

I’ll probably start some 2.0 branches tomorrow to take advantage of the new API. I wish I didn’t know how many people don’t keep their WordPress installations up to date, so I wouldn’t care about backwards compatibility.

At least both widgets got nice new, and functional, internationalization (i18n) code and new localization (l10n) files.

And BSW got a good feature update, incorporating some suggestions from Marco Jung, who is also, kindly, doing a German localization, and a few of my own. The built-in search widget has stepped up it’s game, and fixed the thing BSW was originally designed to fix (no widget title) so I have a higher bar to clear to justify the name “Better Search Widget.”

I’ll write up the new features tomorrow.

A Personal Update

2009-06-19T04:23:15Z

Most of my blog visitors are people trickling in from Google with questions about rebuilding PHP on RHEL, connecting PHP, IIS6 and SQL Server, or, inexplicably, looking for info on the game Crysis.

I should warn, a lot of that stuff is out of date. And I never did end up buying Crysis. (Gaming at 640×480 just isn’t that fun anymore.)

Anyway, given that traffic profile, I doubt most visitors will care about this. But, in case I’m wrong, and I often am, I thought you deserved to know about some relatively large changes with me lately.

The first and biggest: I no longer work at Michigan State University. I worked there for a year and a half as an student, and when I graduated, they kept me on as a temporary employee and then offered me a year-long contract position. That contract expired at the end of May—literally: May 31st would’ve been my last day if it hadn’t been a Sunday.

My month-to-month lease renewed on June 3rd, so I had a choice of moving everything out very quickly or paying for an extra month. Since I was only bugging out about 100 miles to my father’s place, I decided to get out quickly. (Nice for the landlord: there were already people coming to see and apply for the place before I was done packing.)

And then the last week of May I needed to fly out to California.

So in the span of a week, I flew to California and back, ended my job, and moved. Quite a turbulent time. A lot of things, like Twitter and this blog, fell by the wayside. Don’t worry, though. I have a post about semantic form markup that’s almost ready to go.

The job thing: I was not particularly excited about staying in the Lansing area when it was offered, but I took it because, basically, everyone told me to. Really, I only ended up staying about 9 months longer than I’d planned, but I needed to get out of the area. In the future, I may write about my experiences as support staff in a university environment (hint: I didn’t love it) but for now, know that leaving was a very positive thing for me in a lot of ways.

When you start to feel like Matthew McConaughey in Dazed and Confused (”That’s what I love about these undergrads, man. I get older; they stay the same age…”) it’s time to move on.

And, while I’m not yet quite ready to talk about it, it looks like the job situation will work out very well, and very quickly. Of course, I’ll have to move again.

That’s the story. Or at least as much as I’ll tell right now. Now for some technical mumbo-jumbo.

I’ve been working on a little project—though not in the past three weeks—called Cocode. It’s an open-source pastebin app that runs on my PHP framework, Maveric. Well, not quite a pastebin. More accurately, it’s a tool to support internal code review. It supports user authentication, comments on code snippets, and, of course, revisions with diffs and syntax highlighting.

Working on Cocode has given me a good reason to do some development on Maveric, itself. I’ve added some neat ORM features and am working on a real database abstraction layer. I also want to improve routing and several other ugly bits, but, you know, one thing at a time. The changes to Maveric give me a good reason to go back and rework the application layer of Today’s Meet, as well, though I haven’t done it yet. What a good time to add some of the features people request!

You can check out Maveric and Cocode from Subversion, if you’re curious. And if you’re a PHP developer who wants to contribute, please let me know. I would certainly appreciate the help and a fresh perspective. I’ll post more about Cocode soon.

Finally, I’m working on a little WordPress plugin to help with the new rash of irrelevant comment spam I’m getting. (You know the kind: they just say “Great Psot!” and their URL is the important part.) I’ll post about that one, too.

There’s my life, lately, both the coding and non-coding aspects. I hope you’ve enjoyed this brief, personal interlude. Next up, you’re regularly scheduled geekery and social media name-calling—except on the West Coast, where you’re local news is up next.

JavaScript: Private Static Members, Part 2

2009-05-19T14:55:36Z

Finally, it’s time to finish up the lesson on private static members and methods in JavaScript.

Last time, I introduced the technique of creating and immediately executing a function, using parentheses. I talked a little about returning a function and storing it in a variable.

var myFunc = (function () {
return function () {
alert("Hello, World!");
}
})();

alert(myFunc); // "function () … "

myFunc(); // Hello, World!

There are a lot of things you can do with this trick, like create interesting bookmarklets. But let’s see how you can use it to protect information on the class level.

Here we’ll take advantage of JavaScript’s scope behavior. Remember that a function uses the variables where it is defined, not executed. Perhaps a better example…

var myFunc = (function () {
var message = "I’m hidden.";
return function () {
alert(message);
}
})();

var message = "I’m visible.";

myFunc(); // "I’m hidden."

We can see that the inner function (which is returned from the outer function and set to myFunc) uses the value of message from the block where it was defined, not executed.

Now you should be able to see where this is going. Let’s look at a more complex example, extended from the first part:

var Product = (function () {
var partNumRegex = /^\d{4}\-\d{2}$/;

return function ( num )
{
var partNum = null;

this.setPartNum = function ( n )
{
if (partNumRegex.test(n)) {
partNum = n;
return true;
} else {
return false;
}
}

this.getPartNum = function ()
{
return partNum;
}

if (num) this.setPartNum(num);

return this;
}
})();

var car = new Product;
car.setPartNum(‘1234-56′);

var table = new Product;
table.setPartNum(‘345678′);

alert("Car: "+car.getPartNum()); // "Car: 1234-56"
alert("Table: "+table.getPartNum()); // "Table: null"

What’s the advantage here? The variable partNumRegex is not copied by the new operator. In a small example like this, there is not much benefit, but if you had hundreds of Product objects, you could save a significant amount of memory.

There are a few major drawbacks: a public static (class) method cannot access a private static method or variable. For example:

var Product = (function () {
var partNumRegex = /^\d{4}\-\d{2}$/;

return function () {
// snip
}
})();

Product.validPartNum = function (num) {
if (partNumRegex.test(num)) { // (1)
return true;
}
return false;
}

The class method validPartNum has no access to the private class variable partNumRegex, and so will throw an error at (1). Adding an accessor must be done on the instance, not the class, like so:

var Product = (function () {
var partNumRegex = /^\d{4}\-\d{2}$/;

return function () {
this.getPartNumRegex = function () {
return partNumRegex;
}

// snip
}
})();

But then you cannot access the private variable without first creating an instance of the class, and the accessor function is copied with the new operator. New methods added to the Product.prototype object are likewise unable to access the private static variables. This is a limitation of JavaScript.

Even with these limitations, the ability to hide implementation behind an agreed-upon interface is powerful. (JavaScript doesn’t actually have interfaces, but you can just write it down.) Behind the scenes, you could load new data via Ajax, without ever exposing your Ajax method to that new guy down the hall who likes to misuse everything he can:

var Product = (function () {
var partNumRegex = /^\d{4}\-\d{2}$/;

// private static function, not copied with "new"
function loadPartData(partNum) {
// load data via Ajax
}

return function () {

var partNum = null;

// snip

this.setPartNum(num) {
if(partNumRegex.test(num)) {
partNum = num;
var data = loadPartData(partNum);
this.productName = data.productName;
this.price = data.price;
return true;
} else {
return false;
}
}

// snip
}
})();

That’s it for now. I owe most of these three articles to the book Pro JavaScript Design Patterns, by Ross Harmes and Dustin Diaz. Those two are geniuses, and anyone who wants to be a better JavaScript programmer would do well to pick up their book.

Next up, I’ll argue why the <dl> tag is a good way to display forms semantically.

Social Media Marketing: This is your Chance

2009-04-30T16:49:50Z

If I could’ve sat down with Chris Brogan and Laura Fitton six months ago and asked them one thing, it would have been: “Who, exactly, are you marketing to?”

There has always been a small thorn in my paw about social media marketing. It’s the same thing that bothers me when people come on TV and promise to help make you rich. All you have to do is… sell a book that promises to make people rich! It’s the same feeling I get when I read Problogger and wonder: “Do I want to listen to advice from a blog about blogging? Would I do better to listen to someone like Jeff Atwood?”

For months—years—the “social media space” has been dominated by, well, social media users. There are lots of people, from Brogan and Pistachio on down, promising to help you leverage tools like Twitter. But who was the audience on Twitter? Early-adopters. Geeks. Other “social media marketers.”

Of course Chris Brogan can sell himself on Twitter: it was his ideal audience. But when it comes to marketing the end product, who’s listening?

Twitter use has skyrocketed over the last 9 or 10 months. Once the morning shows started talking about Twitter (unfortunately, giving very false impressions) the cascade was probably inevitable. And the people who are joining now are not the same people who joined a year and a half ago.

The time for social media marketers—the real ones, dealing with consumers, not meta-marketers selling advice on selling—to prove themselves is right now.

This is your chance.

Prove to me that this can work; that what you do is worth it.

I don’t mean to pick on Chris Brogan. I’m sure his company, CrossTech Media, has a portfolio of successful campaigns. What doesn’t impress me is convincing the early adopters of the potential of the space. If there’s a more apt example of “preaching to the choir,” I don’t know it.

There has been a reinforcement loop in this field. “We should follow Chris Brogan, he knows what he’s talking about!” “Chris Brogan has 18,000 followers, he must know what he’s talking about!”

“I’ll subscribe to Problogger because they’ll help me get more subscribers. They must be good, look how many subscribers they have!”

Now there is finally an opportunity to put all this theory into practice. Can you use Chris Brogan’s advice to build relationships on Twitter with people who aren’t already excited about building relationships on Twitter? Can you use Darren Rowse’s advice to build an audience of people who aren’t other bloggers?

If I could sit down with Chris Brogan and Laura Fitton and Darren Rowse now, I wouldn’t be asking “who is the audience.” I would just say “Ok, the audience is here. Now show me.”

JavaScript: Private Static Members, Part 1

2009-06-18T17:23:54Z

A little while ago I talked about creating private variables and methods in JavaScript. This works, but is not necessarily efficient: each instance of the class creates new copies of the members. While that may be exactly what you want for instance variables (think of partNum in the old examples) it is not always ideal.

The complexity jumps significantly, though. So I’m dividing this half into two parts.

To get started, we need to forget about all this Object-Oriented Programming for a minute and look at some of the neat tricks you can do with functions in JavaScript.

Update: Part 2 is now available.

First, let’s take a look at a few ways to define a function in JavaScript:

function oneFunction ()
{
// function body goes here
}

var anotherFunction = function ()
{
// function body goes here
};

The first example, oneFunction should be familiar to programmers from most languages. The second one is completely equivalent, but works slightly differently. In this case, the right-hand side, a function, is being assigned to the left-hand side, the var anotherFunction.

Remember that in JavaScript, functions are first-class objects, just like everything else, so can be declared with the var keyword. They can also be passed to other functions as arguments, or returned from functions.

Now let’s take a brief look at parentheses. What do parentheses really do? Essentially, they evaluate and return whatever expression is inside them. For example:

var five = (5);
// the expression is "5"

var nine = (2 * 4) + 1;
// "2 * 4" is evaluated and returned as "8"

var nottrue = (true || false) && false;
// "true || false" evalutes to "true"

var thirty = ((5*5)-10)*2;
// "5*5" is evaluated, then returned as 25 to 25-10,
// which evaluates to 15, which is returned and doubled

So parentheses are slightly more powerful than the simple grouping operation we associate with them. Sometimes we see examples like this, which may be more illustrative:

function checkName (name)
{
return (name==‘admin’);
}

So what happens if we combine parentheses’ ability to evaluate and return code with our ability to define functions as an expression?

var aFunc = (function () { /*…*/ });

Of course, this is just the same as anotherFunction above, but you can see that the right-hand side “returns” a function. Let’s do something a little different now:

(function (name) {
alert("Hello, "+name+"!");
})("World");

What’s going on here? The first set of parentheses [(function ... )] evaluate and return the code inside, creating a function. The last set [("World")] are then calling the function created by the first set. Immediately.

This is a powerful technique, but has certain limits. The interior function is executed immediately on creation, which means the DOM will probably not be loaded yet. Once the function is executed, it is lost. Trying to save it in the left-hand side of an equation will only save the return value of the function, not the function itself. For example:

var aFunc = (function () {
return "I’m not a function!";
})();
alert(aFunc); // Alerts "I’m not a function!"

But, remember what I said about functions as first-class objects? It means we can use one function as a return value from another function:

var bFunc = (function () { // 1
return function () { // 2
alert("Hello, World!");
};
})(); // 3

The outer function (1) is executed immediately (3), and the var bFunc stores its return value, which is the inner function (2). So now, bFunc is a function, and calling bFunc() will alert “Hello, World!”.

We’ll stop for now. If this technique is new to you, play with it for a while. If not, just hang tight and I’ll get to Part 2 soon enough.

Communities within Communities

2009-04-24T16:38:39Z

There is an op-ed floating around Twitter today: As a social network, Twitter is a dud. Is it ironic that an article deriding Twitter is being spread on Twitter? Irony is so ill-defined.

Twitter is not for everyone, and I respect that, but the author, Alex Groves, seems to be basing his entire point of view on Ashton Kutcher. Alex claims (and this may well be true; I don’t know since I’m never on Facebook) that “[t]he only problem with all this twittering by celebrities and politicians is that they are on Facebook much more often.”

Based on this, Alex argues that Twitter is an “unnecessary” alternative to Facebook walls and warns that “[b]y spending more time on social networks and the Internet than we need to, we enable ourselves to become reclusive, sheltered from family and friends.”

What Alex is ignoring is that most people are not (just) following celebrities. If we look at the number of “following” relationships—even relatively inactive people often follow 30 or 40 others—the 1 million “follows” of Mr. Kutcher seems much, much less impressive.

What occurs to me, the more I see Twitter on newspaper websites and on the Today show, is that there are multiple communities within a larger community like Twitter.

On the very smallest scale, you may have a “community” of family and friends that are mostly following each other. You may have a TweetDeck group set up for them. That kind of mutual relationship leads to what Clive Thompson of the Times called “ambient awareness“. I would encourage Alex to read Mr. Thompson’s article, it might answer his question: “How does one know if his friends are OK?”

Now, Alex is absolutely right that spending too much time on the internet can take time away from other meaningful activities, like “enjoy[ing] a crisp, clean-smelling spring morning.” (With my allergies, I don’t think I have ever “enjoy[ed]” that.)

But the same could be said about almost any aspect of life. Too much time at work causes you to lose time with the family. Too much time away from work can make you lose your job. Too much time using computers can give you carpal tunnel.

On the large end of communities, I think you could classify several, such as “people interested in social networking,” “people interested in marketing,” “people interested in programming” (I’m in all three of these communities) “people interested in celebrities,” “people interested in news,” “people interested in <insert your special topic here>.”

I would argue that these communities reflect real-life relationships the same way the small communities do. A person who is more likely to read Us Weekly is probably more likely to follow more celebrities. A person who enjoys Britney Spears’ music is more likely to follow her. Just as I am more likely to make a joke about the word “const” on a construction sign, I am more likely to follow John Resig.

Alex asks, “[w]ith all the good we can do online, including disseminating information and spreading knowledge, why do we become obsessed with Britney Spears tweeting about playing with the boys on tour?”

I contend that the people Alex is really criticizing (surely many of the newest users) are the same people snapping up People at the checkout lane and watching TMZ in the mornings. Furthermore, he fails to recognize the rather large community of users that uses Twitter to share information and resources, follow the lives of people who may be emotionally, but not physically close, or generate other types of value.

The complaints he levies could—arguably should—be equally directed at Facebook, MySpace, several websites, magazines and TV shows. Alex is confusing “Twitter” with a culture of “celebrity worship.”

I argue that the people creating value off Twitter (and Facebook) are the same people creating it on Twitter. If all you follow on Twitter are celebrities, you obviously aren’t contributing much to that community’s conversation. On the other hand, if your community is broad, and includes peers, friends, family, then you have a unique opportunity to both benefit from, and provide benefit to, that community.

Fortunately, the way Twitter works, I don’t need to follow those celebrities. And neither do you, Alex.

Firefox: Open in Blank Tab

2009-04-22T18:17:49Z

If you don’t use Firefox 3, go get it. Then finish this article. (Safari and Opera users are excused, but there’s no promise this will work for them.)

One of my (few) gripes with Firefox is that bookmarks on the toolbar have no “open in blank tab” option. They have an “open in sidebar” option, but those uses are rare and esoteric at best. Personally, I never use the sidebar.

“Open in blank tab” should basically do this: if there is a blank tab, use it; if not, create a new tab. Frankly, it could just open in a new tab regardless, but it seems like such an easy thing to add.

But? It can’t be done directly in Firefox. Hence, I present this small script:

javascript:
(function(){var u=‘http://mail.google.com/mail’;
if(window.location==‘about:blank’){
window.location=u;
}else{
window.open(u,”);
}
)();

That’s it. Try dragging this link to GMail to your bookmark toolbar. Then click the link on your toolbar. Now, open a new tab, and click the link again.

This isn’t exactly what I asked for. It has no way of knowing if any blank tab exists, only if the current tab is blank. And, of course, it lacks the nice favicon support.

But it does the job. If you change the variable u to something other than ‘http://mail.google.com/mail’, you can make the link open any other page.

I love anonymous functions.

Update: If you want a bookmark for something besides GMail, you can create your own. Or you can drag this link to your toolbar, to make new ones whenever you want: Open in Blank Tab.

Update 2: Oops, fixed the “create your own” link. Tested it, then accidentally pasted in the results, instead of the actual script.