Bryan Ray’s recent posting on a drag and drop mentality of developers gave the kick start to this here posting. You might want to read his first.
 

It’s cruical for a employer/customer to get stuff done as quickly as possible. Therefore it’s tempting to demand the developer to reuse foreign code, drop in plugins instead of developing from scratch, get a whole idea of the project and make that happen. Instead, they often demand: ‘Just dump every almost usefully looking plugin into the app, and our users will love it.’

Despite that’s often not true, adding foreign code to your project often is really the opposite of a time saver: If you want to get to the save side, you’d review that foreign code. Which’d cost you time. As the foreign developer might had have other issues in mind, the foreign code might not exactly fulfill what you’re after. So you need to make that code do what you want. If you’ve got the source code and allowed to patch it, then by going into that matter — and figuring out foreign code is not always that funny — or, if you’ve got no source code at all, you need to develop some wrappers or workarounds. Chances, that you’d be quicker if you’d developed everything from scratch here. Even more the chance that that patching need rips your whole project schedule apart.

Second thing is, code always implies the chance of glitches. That’s true for code you write yourself as for code you get from foreign sources. Customers often believe foreign code would be save to use per se, simply because either they paid for it or that it’s assumedly community-backed.

It’s a venerable assumption that more eyes spot glitches quicker than only two of them. Anyways, that venerable assumption might miss an important point: Not every GPLed project has a community. Often GPLed projects consist only of a mere two or three developers and no community at all. They of course might not spot and fix issues as quickly as you might assume. And same so for commercial developers: If their team consists of that few developers as well, you’re in no better luck. — For that reason, although foreign code is available, you’re nontheless in the duty to test it, at least review it. Saves you time over developing the same functionality yourself? — I have my doubts.
 

Update:
WordPress.com automatically added a link to an early 2007 post by Tom Harris on code review. As that post read reasonable and his blog even features a whole category on the code review, I suggest to give his posts a try.

As my yesterday posting on how to do many-to-many relationships in Rails turned out to be popular, today I give an example for how to add tags to a Rails model in the same stripped down style.

Just like yesterday, as the thing that shall get tags attached we want an item model. And we want to make use of the tagging tool.

To achieve the little today goal, we need a scaffold for the item model first, then install a plug-in for the tagging, do some modification to the model, views, and the plug-in itself. To the plug-in only because this little project aims for quick results — to get the matter clear —, not for comfort.

To prevent possible side-effects with whatever project we might be working on already, let’s start a completely new project:

$ rails tag_me && cd tag_me
… [output] …

Then the let’s apply scaffold to get the model set up:

$ ./script/generate scaffold item name:string && rake db:migrate
… [output] …

Now we install the plug-in for the tagging:

$ ruby script/plugin install http://svn.viney.net.nz/things/rails/plugins/acts_as_taggable_on_steroids
… [output] …

(I used acts_as_taggable_on_steroids because the plug-in it’s based upon, acts_as_taggable, looks outdatedly.)

$ ruby script/generate acts_as_taggable_migration && rake db:migrate
… [output] …

Once done with that, we have everything in place to perform the necessary modifications on both, the plug-in and the scaffolded application. Since everything depends on the plug-in, we start our modifications there:

file: vendor/plugins/acts_as_taggable_on_steroids/lib/acts_as_taggable.rb:
At the end of the module body (currently line 200) we insert two additional methods:

def tags_as_text
  tag_list
end

def tags_as_text= text
  self.tag_list = text
end

Next, we make the item taggable, by inserting a acts_as_taggable into the class body:

file: app/models/item.rb:

class Item < ActiveRecord::Base
  acts_as_taggable
end

(Bold code lines like the one above are those you need to insert.)
 

That’s it, mainly. What’s left is to update the views so that tags get displayed and can get entered:

file: app/views/items/index.html.erb:

<h1>Listing items</h1>

<table>
  <tr>
    <th>Name</th>
    <th>Tags</th>
  </tr>

  <% for item in @items %>
    <tr>
      <td><%=h item.name %></td>
      <td><%=h item.tags_as_text %></td>
      <td><%= link_to ‘Show’, item %></td>
      <td><%= link_to ‘Edit’, edit_item_path(item) %></td>
      <td><%= link_to ‘Destroy’, item, :confirm => ‘Are you sure?’, :method => :delete %></td>
    </tr>
  <% end %>
</table>

<br />

<%= link_to ‘New item’, new_item_path %>

file: app/views/items/new.html.erb:

<h1>New item</h1>

<%= error_messages_for :item %>

<% form_for(@item) do |f| %>
  <p>
    <b>Name</b><br />
    <%= f.text_field :name %>
  </p>

  <p>
    <b>Tags</b><br />
    <%= f.text_area(’tags_as_text’) %>
  </p>

  <p>
    <%= f.submit “Create” %>
  </p>
<% end %>

<%= link_to ‘Back’, items_path %>

file: app/views/items/show.html.erb:

<p>
  <b>Name:</b>
  <%=h @item.name %>
</p>

<p>
  <b>Tags</b><br />
  <%= @item.tags_as_text %>
</p>

<%= link_to ‘Edit’, edit_item_path(@item) %> |
<%= link_to ‘Back’, items_path %>

file: app/views/items/edit.html.erb:

<h1>Editing item</h1>

<%= error_messages_for :item %>

<% form_for(@item) do |f| %>
  <p>
    <b>Name</b><br />
    <%= f.text_field :name %>
  </p>

  <p>
    <b>Tags</b><br />
    <%= f.text_area(’tags_as_text’) %>
  </p>

  <p>
    <%= f.submit “Update” %>
  </p>
<% end %>

<%= link_to ‘Show’, @item %> |
<%= link_to ‘Back’, items_path %>

Now you can launch the server by the common

$ ./script/server

and direct your browser to

http://localhost:3000/items/

There you can enter some dummy data (using the ‘new item’ link).
 

Notes:

• Despite single quotes in this posting get displayed as oblique ‘…’, in the source code you need real single quotes. — If you just copypaste the source and keep the wry single quotes, things might go wrong.
• To separate several tags from each other you can utilize te comma (,) character. Multiple identical tags get treated as a single one.
• To develop the above intro, I made use of the acts_as_taggable_on_steroids page and Simple Tag IO with acts_as_taggable_on_steroids.
• While aiming at getting a clue of how to deal with tags in Rails at all, I also found these sources useful: Installing the acts_as_taggable Rails Plugin and growing up your acts_as_taggable.
• In the neighbourhood of my search for/on how to deal with acts_as_taggable.*, I found some promising drill-ups related to acts_as_taggable.* such as auto-completion for acts_as_taggable_on_steroids by Ariejan de Vroom, acts_as_taggable per user tagging by Ben Smith (and some hiccup fixing on that by Micah Wedemeyer/Ryan Felton), Creating a TagApplicator for acts_as_taggable by Bryan Ray and Extending acts_as_taggable to take scope into account (by unknown, found on DZone).
  Update: I got aware of some more act_as_taggable* resources, e.g. acts_as_taggable_on by intridea or those found on github (via Bryan Ray).
• Last not least, I stumbled upon a tutorial on writing plug-ins for Rails. Might be useful, but I didn’t try it yet.

There are lots of tutorials out on Rails, and many people may need to work through them to get a grasp of Rails. but once you’re experienced in programming you might feel delayed by all the stuff the tutorial brings up but which you already know. Most of the tutorials I’ve seen so far also prevent you from skipping over to go straightly to the interesting parts because they do stuff in between that affects the interesting parts, so you need to go backwards through the tutorial to figure out what’s affect only and what actually needs to be there so that what you intend will work.

I find that rather annoying. I’d like to have a simple overview of what files need to get modified to get a many-to-many relationship between two tables. For starters, it’s rather useless to know all the details, gimmicks and features you might want to use once you’re a bit more experienced: If you come from a different development language, you probably don’t want anything as simple as a single-table application to get a first impression of Rails for yourself. I want to know how I can implement a many-to-many, and how to make that visible. Nothing more, nothing less.
 

For the example, I use tags and items: Each tag may be related to multiple items; each item may have multiple tags. (For example, the tags {sunset, sun, water} may be related to a sunset picture. Thus, there are multiple tags related to a single picture yet. And another picture might have the tags {tap, water, damp, dishes}. Thus ‘water’ would be a tag that’s related to more but a single item.)

We’ve got three scaffolds to do, one for the items, one for the tags and one for the many-to-many relationship. The three scaffolds create three model files. For simplicity, we start with a whole new project, so there won’t be any side effects of whatever project we might be working on already:

$ rails many_to_many && cd many_to_many
… [output] …

Next, we do the scaffolds:

$ ./script/generate scaffold item name:string && rake db:migrate
… [output] …

$ ./script/generate scaffold tag label:string && rake db:migrate
… [output] …

$ ./script/generate scaffold item_tag item_id:integer tag_id:integer && rake db:migrate
… [output] …

Once done with that, we have everything in place to set up the many-to-many relationship. We modify the models first, then the output for a single item to make it show the tags for that item also:

file: app/models/item.rb:

class Item < ActiveRecord::Base
  has_many :item_tags
  has_many :tags, :through => :item_tags 
end

(The bold code lines are those you need to insert into the model. Same for the two others below.)
 

file: app/models/tag.rb:

class Tag < ActiveRecord::Base
  has_many :item_tags
  has_many :items, :through => :item_tags 
end

file: app/models/item_tag.rb:

class ItemTag < ActiveRecord::Base
  belongs_to :item
  belongs_to :tag 
end

And now the output. To meet the needs of the Model View Controller pattern, to get the appropriate output, we need to modify the controller and view of the item(s). First we modify the controller, then the view; in the controller we modify the show() method:

file: app/controllers/items_controller.rb:
show method before:

def show
  @item = Item.find(params[:id])

  respond_to do |format|
    format.html # show.html.erb
    format.xml  { render :xml => @item }
  end
end

show method after:

def show
  @item = Item.find(params[:id])

  @tagline = @item.tags.collect { |t| t.label }.join(’, ‘)
  respond_to do |format|
    format.html # show.html.erb
    format.xml  { render :xml => @item }
  end
end

In the view, we simply add a paragraph that outputs the tagline gotten by the controller:

file: app/views/items/show.html.erb:

<p>
  <b>Tags:</b>
  <%=h @tagline %>
</p>

That mostly is it.

Now you can launch the server by the common

$ ./script/server

and direct your browser to

http://localhost:3000/

You can access items, tags and relationships between both by going to their respective views, like

http://localhost:3000/items
http://localhost:3000/tags
http://localhost:3000/item_tags

There you can enter some dummy data (using the ‘new’ link); to see the effect, I’d start by defining some items, then some tags, then some item_tag relationships, then view the individual item I related some tags to.
 

Notes:

• If you want to do something serious with tags, you might want to use the acts_as_taggable or the acts_as_taggable_on_steroids Rails plug-in. — Update: Here’s my quick reference on how to apply the latter.
• Some background info on many-to-many relationships in Rails (which I used  to come up with the step-by-step intro above): Many-to-many Dance-off of 2006 by Josh Susser; a brand-new post on the same matter of June 2008 by Prashant Raju and Andrew Cetinick; a Railscast of June 2007 on still the same matter and, for reference, the Rails wiki on :through associations, date may vary.
• Furthermore, not only items:tags are common many-to-many relationships — contact lists are too. Here are two contact list maintaining tools in Rails I found along the way when I was after grasping the many-to-many issue: acts_as_network and Fischy Friends. — Contact lists resemble a social network, though a rather low-level one.

[t]

Dependent on where you are Twitter is slow, but how’d be Google web applications? — Globally quick because of distributed datacenters? But if so, how could you keep your business independent of Google?

Twitter has performance issues that very often, a probably local slow-down caused by local thunder-storm made me suspect Twitter was down, again. IsTwitterDown said No. I suspected IsTwitterDown was wrong.

Anyways, this little incident this morning made me aware of a possible side-effect of Google Web Apps — I mean those you can build yourself now by using the Google Web App Kit: As Google is global and they’ve placed their datacenters around the world so you can get Google search results in less than a second and the web apps built using the Google web application kit are going to be hosted on those very datacenters, this might be a side-effect, but maybe one being very significantly: Maybe, building your web apps upon the Google web application kit might make your apps as quickly available as Google search results. And that globally.

At least, that’s what I’d be glad to see if Twitter or a serious competitor would do.

On the other hand there is the issue that hosting your app on Google gets you dependent of them. Same for your your business.

I think, one way to deal with that could be to have two variants of your app at hand: One quickly available for your country..continent in your own data center, and one boosted for global audience, hosted on Google, globally speedy.

That solution would resemble what we had (and still have) for pages to be rendered on different web browsers. Obviously, that’s not a solution you’d long for. But — alternatives? Also: You developers already are used to do the work twice; it would not be that great difference, would it?

If you’d like to minimize the efforts of developing everything twice, to make the passages of the Google web application framework relevant (to you) available as free software (”open source”) would be obvious. Where a clone of the framework might originate from — which of course might be significantly slower at your individual web host but which would help to decrease the efforts to develop your app twice. And, that framework clone could be picked up by an alternative datacenters provider or anyone of the big ones, like Amazon.

I think, keeping your business and yourself independent of Google could get achieved this way.

thought it would be nice to share this
Besides of this, the top left corner of the card is free, so you could add a personal note or reminder there — or simply your actual e-mail address or phone number.

The green and the yellow square refer to the natural green environment and the sun and sky. Where the bird fits in well. The bar code should link to this blog.

Looking at some web services one might get the impression their creators assumes their audience to be fools. Once I even learned that from a manager’s side of view who stated that opinion clearly.

And why do managers may think so? Maybe for all the trolls out there and for the reports about those trolls. Maybe even for news media propagating such cliches.

True, trolls might be those folks who are loudest and most wide spread, therefore those folks who get recognized first, by number of postings and by number of places they post to. Not to forget, they get also noticed by outsiders first.

I wonder whether outsiders generally fail to dig in any deeper to recognize there are some more wise people there, so they simply don’t realize trolls in reality contribute very little. So they don’t really shape the places or communities or folks or attitudes of mind found there.

But there are more experienced and more ‘wise’ people there, even if there are trolls around. (But, rule of thumb, the more trolls the quicker the really contributing people leave.) And for all the other participants on whatever community you might look at — may it be a blog/comments ‘community’ or a fully fledged social network — the experienced folks count most.

So, in other words, trolls are like flies. Breathing the sweat of others. There and obvious. But not necessary. Those folks may be dumb. But to address your service at them gets you what? — A crap audience, I suppose.

Probably from the beginning on, computers suffered a common lack: latency on user action. Therefore a computer, some time old, will always feel slow regardless how quick it was regarded once.

I’ve got an old i286 PC/AT here. Currently it has a 40 MB disk in it (I guess). As I want to get id of it but not just throw it away, I pondered whether I should put a 400 MB disk into it and see what nice software I could put there too.

Then I realized, despite the smalliness of the software I’d put there and how quickly it would load and exec on a current machine, there — of course — it would be awfully slow. Which brought me to the original insight.

However, I wonder whether it’d be possible to speed up software in general, including current one on current machines, especially the situation of latency you’re encountering everywhere and always, until now and probably also in future — but let’s think this one through.

As the latency becomes experiencable mostly and most easily in programs people interact with, yes, especially those programs I have in mind. Even more specifically, programs that have a graphical user interface (GUI), such as any GNOME programs. Of course, people do experience latency effects on text user interface (TUI) programs too, and even on service programs that don’t feature a immediate user interaction. — Once we’ll be got over start up latencies, of course, that should be tackled too. But for the moment, please let’s focus on programs with a graphical user interface.

I imagine, the process of loading and making a program ready to use, i.e. to interact with it, in general could be speed up by preloading every possible [GUI] program. On a averagely set up computer, that will probably a lot of programs to load, and even more probably that will eat up a huge share of memory — if it won’t make your machine swap immediately. Plus, you need to hide all those programs and make sure they’ll keep sitting in the background until the user actually wants to use any of them. So, if any such program might get bored for some reason (”No user interaction since xxx minutes. Shall I quit?”) you must make sure it does not fire up any distracting popup right in front of the user.
 

So far, now we’ve got two issues: #1, loading all possible programs would eat up a lot of memory, probably go to swap, thus slow the machine down in general (although that way lack in responsivity might slip through unnoticedly). #2, programs need to be enforced to sit invisible in the background — and stay there. I see chances to get rid of both, with a little help of either the maintainers of the respective programs or by figuring out and applying the necessary patches all ourselves.

So, what’d need to be done?

The user interacting with a program experiences something that probably is a bit different from what the average user might think they experience. At first glance, most people probably would assume they have — or at least demand — a linear user experience. That means, once you get into a program you’d have a steady (linear) stream of interaction. But that’s not the case: Today, we’ve got machines that are a million times faster but their cousins from twenty years ago, but still they lack — you guess — responsivity. Which exactly hints to what’s going on instead of linearity in interaction: a dialog.

The user does something, say, launch a program by clicking an icon. Then the user waits for the program’s upcoming next action. This clearly is the moment where lack in responsivity kicks in, you wait for some reaction. But the point is: Even if you’d speak with a real person, after saying something you’d expect a reaction from the other side. There you’d wait also. So, it’s a natural, thus familiar, habit to wait for a reaction once you initiated an action. Even below the level of human interaction this takes place in nature: If you release a bottle of water from your hand, you expect it to drop to the ground. Although there you probably won’t have to wait too long till that takes place.

The point I wanted to make clear by that was that there is a natural break in the flow of interaction of [at least] humans, and it’s so common, it’s fully integrated into our flow of habit’s we don’t even notice. But that implies, your flow of action/interaction simply is not linearly but stepped.

So, the user launches a program, waits until it’s loaded, then orient — another delay in interaction –, then decides, then perform another step of interaction, wait for another reaction, and so on. — By that, for the vast memory usage ignited by #1 — loading all available GUI programs at once –, to get rid of it by still loading all the programs at once, but not in complete.

Let’s look at that for a single program: As the user needs to orient themselves anyways, instead of loading the whole program at once it might suffice to load the GUI only, first. That even might reduce to some picture instead of a real program, then. Which would result in a “Whoa!” user experience since the programs would seem to load instantly, i.e. without any latency here. — Loading a picture only, of course, would cause the latency to take place the moment the user really wants to interact with the program, say make use of the sensitive areas of the user interface, menu, buttons, click fields, hovering interactions (”hint windows”).

So we’ve got two alternatives here: Either start with a small part of the program like indeed a picture of the user interface, then load the remainder in the background once the user starts interacting with a particular program (which would avoid to run out of memory). — Or: Load only a small share of the program, until the next predictable break in the users interaction. To get some notion for that, I’d call the user interaction between two (predictable) break in user interaction a ’stage’. This refers to the time the user needs to get from one user interaction break to the next one but also to the according part(s) of the program which enable the user to perform that move [from one interaction break to the next one]. Once the user makes a decision, they leave the interaction break and enter another stage.

As a stage may allow several interactions to get initiated (such as drawing a line, flipping a picture, selecting a new drawing tool in a painting program) a stage, by the users part of view end by a single interaction break — but not by the program’s part of view: For the program the stage may end by diverse set of interaction breaks. So, despite you’ve got a single entry point for a stage, most times you’ll have a multitude of exit points (thus, if you imagine it, you get some kind of triangular shape for a stage, not a line-wise or rectangular one).

Loading the program only in stages probably can get extended to the whole program. I imagine even the old machines could handle that, therefore get rid of interaction latencies. At least with a little help of the program loader.
 

Let me utter one more word about the interaction breaks: You might imagine that every time a user needs to make a decision an interaction break takes place. That’s true for inexperienced users since encountering the menu (or any other initial choosing alternative) might enforce them to get oriented first before making a decision. But obviously that does not happen for experienced users: They already have a picture of the choosing alternative in mind and therefore pre-plan their interactions beforehand. For such users it’s most likely they outrun the machine/program, simply because the machine insists on drawing the menu instead of taking up the user’s approach of ignoring the accomplishment of menu drawing. — Because of that you’d need to choose interaction breaks for your program carefully: Probably the best chances to get a match [between presumed and real interaction break] is for every situation where the user needs to orient themselves before they can make the decision. — This probably can get optimized even more. However, I think this approach might find a good use on multi-core or other parallelized machines.

Back to the issue #2, programs to sit invisible in the background: Well, I hope it’d simply vanish once developers get used to the idea their program might get loaded [partitially] without being used ever.

However, to make this approach work, we’d either need to apply this for programs or we’d need to get some help from the program loader/operating system/desktop environment. Also because they might help on determining where stages might end.

What about a discussion, below, in the comments?

Unknowingly, Robert Scoble reminded me about something I thought about the last 24 hours: Yesterday, I attended Web Monday in Cologne, Germany. Although her entry to the presentation was not tech but fashion, Sandra of armedangels.de gave a great presentation on a shirt fashion label that noticed a community gathering around them and aims at binding that community to the label by doing just that: add common community functionality to their site. Sandra ignited the discussion of what a community site needs by means of features; one annoyed question of some attender there was “Why do people need one another community site?”

Today, pondering the idea to extend the focus of this blog to w0rk and on/offline society, and noticing what I have in mind might be better doable as a community, the “why one another community?” question from yesterday evening came back to my mind. Open Social and Open ID without particularly mentioned floated around.

As far as I know (and if I remember correctly), there still is no consensus on how to make the personal social graph portable. One issue in this is privacy: Data that I own is my own data. But my social graph defines by some more data: data that belongs to me, but I am clearly not the owner of it. That’s relationship data, i.e. my contact list. Though it does belong to me but I don’t own it, that’s exactly that part of data I am interested to take with me, over to the next social site I join. Simply because I’m yet fed up adding the very same friends at every new platform I join, ever and ever again.
 

On the other hand, on most social platforms I am aware of people I add to my contact list need to confirm the contact — or to reject my request if they don’t like me. That’s a common need, people are familiar to it and — most important — they accept that bit of manual work, the demand to explicitly confirm or refuse whatever contact request comes in.

So, if that’s so simple, so common and people are used to do it that way, then why not just to add a second checkbox that says: “allow contact to port me”? In other words: If the contacter wants to port their social graph to just another social platform, me gives the permission to be ported there too, i.e. this one arc of the requester’s social graph. That would ease to reuse once established social graphs on every new social platform I join — without violating the other ends’ (of my social arcs) privacy.

That checkbox would refer to the relationship between contacter and self only, not to personal data of self (i.e. the contactee).

I quit programming as a hobby in about 1996. That was when finally I noticed repetitions in my programming work — situations you ran into before, but for sure not ever since you learned this particular language. Today, you most likely would call them patterns. Patterns are quite popular today, but those days I was not aware of neither the term nor the science behind. It just got me frustrated.

However, I just reordered the categories of my blog and noticed the long list of sub-categories to “core social framework functionality”: buddy/contact list, contact list management, social graph, user management, user account management, emergency login, lost-password recovery, user profile, basic user model, handle for a user, e-mail address, username. By looking at that list, Jonathan Weiss’ presentation on patterns in Rails came back to my memory.

Yesterday, I had another look into my Java patterns book. The O’Reilly people here put emphasis on the task to memorize the different patterns. That’s a bit in contradiction to developing algorithms. (Anyway, I wondered what might be the difference between a pattern and a simple algorithm.) When you develop an algorithm you look at the problem, then determine which steps to take, how to granularize the task — until you get to the point that you can express your demands immediately by the commands a programming language provides you with.

If you need to sort things and your language does not provide you with a sort routine you usually are aware that there are several alternatives you could apply — quick sort, bubble sort, or others. Is that a pattern yet? That you are aware of alternatives and the chance to select one. — At least, similarly to knowing about alternative algorithms to apply, in you might need to be aware of available patterns and select the one best suited for the case.

Patterns apparently get developed once and from that onwardly nothing but propagated/memorized. The task for the developer reduces to recognize whether or not the situation demands applying a pattern. Because of that background, I wonder whether it’d be correct to say patterns were meta-algorithms?

I’ve been a bit shy — maybe too shy — to go on with my series of posts of prerequisites needed to launch a social network because my previous posting ended with a cliff hanger on “now we finally approach social networks”. Point is, my original notes on different kinds of communities were not as extended as one might expect. On the other hand, recently, some net prominent propagated charging for web services was a good idea, and I’d like to add a word or two on crowdsourcing. — After a second look, I noticed you actually need to know about crowdsourcing before you can go into the matters of discerning different kinds of communities. But commenting on David Heinemeier-Hansson’s presentation I leave out for now.

crowdsourcing

The previous post of this series, on crowdsourcing I stated: “Using that by-product of your users effectively is nothing but crowdsourcing. It uses the crowds to get some task done. Such as tagging all the items known to your service.” Or to collect those items first place. Crowdsourcing simply is to use a crowd — the collective of all users of your service — to get some task done. Such as gathering a excessively mostly complete collection of all things in a particular field of interest — such as the things which are/were in Wikipedia — or to apply some rule on all such things gathered once; some rule that requires mind, decision-making or knoowledge — such as tagging of music tracks on Last.FM or typewriting music track titles on CDDB/FreeDB.

Despite it might look like a win:loose situation at first sight, crowdsourcing in fact is a win:win situation: If the alternative is no chance for tagging at all, people love to get the chance to tag items — since that way they gain the valuable and real chance to re-find things they once decided to be useful for them. On the other hand, tagging performed by a crowd piles up, effectively creating a resource for the service. Which in turn can be re-used for extended services, such as determining similar music tracks (as Last.FM does and offers as an additional service). But also, such a resource can be traded. Which makes crowdsourcing a win for you — the service provider — too.

social platforms

But let’s take one step back. Previous to social networks, there are social platforms, such as Last.FM or Wikipedia. They do not even offer the most basic level of social networks, a contact list. Here I count Last.FM in, because its use mostly takes place off-site.

I see two core kinds of social platforms. Both of them have two things in common: They are after to tackle a problem and they apply crowdsourcing. As I am going to flipside that very sentence in a minute, let me make clear: By the problem that’s getting tackled by the users, I refer to a problem the users notice and want to get solved. Such as quitting to smoke (self-help forums) or loosing the need to enter the track titles whenever you rip a CD (FreeDB) or form a new software application (free software projects). And crowdsourcing does take place simply because lots of individual users contribute to get over that problem.

But this very note — the core commonalities of social platforms were tackling a problem and using a crowd to get over it — also can be seen from the opposite point of view, that one of a company that applies crowdsourcing to gather a resource: In their view, the problem might be to gather the resource, and crowdsourcing would be nothing but a tool for the company to get that task done. — Worthwhile to note, that there is a series of open/free software projects struggling, probably because of the dominance of such a company in the background (Asterisk, Asterisk front-end Asterisk@Home, Mambo). Anyways, that’s going to be off-topic, therefore let’s concentrate on social platforms again:

I think, you can discern two core kinds of social platforms — whereby some examples of both groups blur into the territory of social networks, as they feature something comparable to a contact list — the core of anything that deserves to be called a social network:

1. The one kind has some dedicated functionality — such as Last.FM or Twitter, which integrates cell phones simply but [in that] excellently as a user front-end, or 43 Things which in its functionality rewires the features of a blog to serve best to their users, so these get their goals done most easy.
2. The other kind of social platform has only basic common functionality but are targeted to one general common direction, by rules. Examples for this
   can be found in usual free culture projects, such as Wikipedia or free software projects, and in probably any network which builds upon white label (i.e. generic) social network platforms such as Ning or Mixxt: Those simply do not provide any special functionality despite contact list, about me, forum, event calendar, and a way to PR news (blog or newsletter). Often you (as a administrator-user) don’t even get news groups management.

Also, I see a tight relation between the two kinds of social platforms to as well only two different core types of communities. But I don’t see whether if a platform is of type one or two necessarily determines the community that will gather there (if at all, depending on previously analyzed factors such as usability or how you (as a platform provider) treat your users).

The one type of community I see in users whose participation in the ’social’ thing is only an effect, not an intend: The people work everyone for oneself, with the only intend to get benefit for everyone oneself. Contribution here is only a by-product. This can be seen on remote users of Last.FM: They send in the data of a track listened, and Last.FM can do anything with the data, but what they do about the data essentially is unimportant for the user — at least as long Last.FM guarantees for the users’ privacy, especially against man hunts for ‘robbery of intellectual properly’.

So, this kind of community as a by-product already can take place when someone manages to smartly set up crowdsourcing. An other case where being community is a by-product may be seen in self-help forums where people essentially go to to get help for themselves, to chitchat or to make new contacs. All these of course are social activities, but they do not imply that a community constitutes. That’s why I mention them here, and why I discern those social activities from actively forming a community.

The other type of users I see in folks who go after a particular, determined problem, to tackle, solve and get over it. This kind of users you find probably in mostly all free culture projects, such as free software projects and in Wikipedias (plural, because Wikipedias get developed in different languages by different teams). Clearly, you see a tight match between this kind of community and the kind of social platform that offers only basic common functionality but is driven by rules predetermined by the platform/service provider.

business expectations

So, as a service provider you might tend to provide a social platform that provides basic common functionality, select an arbitrary problem and hope the users to come. However, in my opinion that approach goes wrong, simply because for people affected by the problem, the problem is a real problem — other than for you — and they of course mind which tools to use to effectively and in the end get over that hassle that limits their lives. Note, although you’re after to form a community, you still do interact with an individual. Probably with millions of them, but nevertheless with each of them individually — by platform and, important to realize, by customer care.

I see the point that there remains a discrepancy between the company’s intend with the platform and the [individual] user’s intend to use that particular platform: The goal of the company might be to gather as many users as possible (to become able to take profit of The Long Tail approach to business) and to keep these users as long as possible — most hopefully even forever. On the other hand, for a user to take part on a community might immediately originate from a hassle the user wants to get rid of — and therefore the user’s goal is to get rid of that hassle and once to be done with that. — After that point in time there should be no more reason for the user to stay with that particular community, so they might want to leave. — I presume, in current business plans, this issue may be not regarded, and companies might assume they were after just gathering a ‘big enough’ share of global society to become their user base. I think, it’d be important for businesses to realize their platform, for the user, is not an end in itself but nothing but a vehicle — tool — to get over some issue. Therefore it’s part of their business model that they’re going to loose long-term users at some point in time; the only lesson for the companies too be learned is that this is the case, that this is part of their business model, even if they don’t do plan that.