A couple of weeks ago I met a a nice guy in a social picknick that told me about radio.blog.club (Thanks François!). The idea is great. They are building a pear to pear streaming network. Basically, they provide the software that allows you to stream music from your server to clients.

You can use radio.blog.search in two ways:

• You can create your own music server that will stream music to users. The software is provided by radio.blog.club but you need to look for it in the forums, I have not seen any other access to it.
• You can search in their website for songs that are stored in user servers, build your playlist and listen to it. The player they supply will automatically stream the music from the appropriate server to your client.

I guess the way it works is that when a user adds a music server, radio.blog.club is notified so they can tell their crawler to look and index all the songs stored on that server (well, there is a configuration file you can use to tell radio.blog.search not to index and share your songs). That way users can search for indexed songs through the website and play them directly from the servers where they are stored. Doesn’t sound great?

I have used it for a couple of days and I works pretty well. Some of the songs in my playlist cannot be accessed, I guess that’s because the servers are no longer there or because they don’t have enough bandwidth.

I think it is a good start but it could be optimized by factorizing songs. Currently, if you look for a song you will get one result per server with that song. I guess it will be better to show just one result and load balance requests across the different servers behind the scenes.

The site also needs some rework maybe to improve the process of building your playlist (I don’t know how to change the order of songs in the playlist for instance). In any case it looks like a very interesting product.

All that said, it looks to me that this might not be completely legal … Well, is like sharing your music with friends and it does not look that different from Kazaa or other p2p networks. But for the time being, just enjoy it!

This morning I saw an interesting article in Techcrunch about a possible Bebo acquisition offer which led to an interesting discussion about the real value of community websites.

All these community sites are usually obtaining money from advertising as their services are free, therefore it seems that the more users and the more pages per user viewed should lead to a bigger revenue and so to a bigger value. Well, as said in one of the comments, there are at least two reasons why this is not necessarily true.

On the one hand, the content is user driven, and thus you encounter a lot “indecent” information, photos, etc. Therefore, some advertisers may not want to appear in this context because it will go against their image.

On the other hand, as the design, layout and also the content is provided by users, adds will probably pass unperceived. You can try the exercise, when you go to a news site or a blog you are interested in, after having read all the information try to remember about the advertisers.

Anyways, we are talking about hundreds of millions of dollars. This looks like a lot to me but I guess, mainly because the unique real differentiator of these websites is usually the user database (technically they are not very complex and the content is provided by users), the barriers of entry are then low. You will of course need money to build your image and market your site. Obviously media companies don’t want to stay behind in the race and so they seem kind to invest big amounts of money.

I hope nobody has forgotten what happened 5 years ago …

Not really related to the kind of information I use to post in this blog, but I thought somebody might be interested in a script that I quickly wrote to take the freedb database files and store them in MySQL (you could use another RDBMS provided a driver is available for ActiveRecord). It also shows how an easy it is to interact with a database through Ruby and ActiveRecord.

FreeDB is an open and free alternative to CDDB built using the “solidary community intelligence” I’ve been talking about in my lasts posts.I used it as first test to build a catalog of CDs, but the quality of the data is not very good if you want to build a relational, consistent view of it. It is based on the FreeDB database specification available here. You may also want to try MusicBrainz. Is is a an interesting alternative, although less well known. They started building a relational (and therefore more consistent) database of music metadata, which includes CD albums but also digital tracks.

Anyways, below is the code. There is a lot of room for improvement (it does not check the arguments for instance), but it is a good start point.

(Note: I hope it still works as I wrote it sometime ago and I might have done some modifications for testing … )

#!/usr/bin/env ruby
require ‘rubygems’
require_gem ‘activerecord’#use UTF8
$KCODE = ‘u’
require ‘jcode’

#Define database connection (change host and database to your own)
ActiveRecord::Base.establish_connection(:adapter => ‘mysql’, :host => ”myhost”, :database => ‘mydatabase’)
ActiveRecord::Base.connection.execute ‘SET NAMES UTF8′

#Define freedb objects
class Artist < ActiveRecord::Base
has_and_belongs_to_many :albums

def to_s
self.name
end
end

class Album < ActiveRecord::Base
has_many :tracks
has_and_belongs_to_many :artists
end

class Track < ActiveRecord::Base
belongs_to :album

def to_s
“#{self.number}. #{self.title} – #{self.duration} s”
end
end

#Process files in folder
def read_folder(directory)

if File.directory?(directory)
Dir.chdir(directory) do
puts “chdir to #{directory}”
Dir.foreach(‘.’) do |file|
next if file.eql?(“.”) or file.eql?(“..”)
if File.directory?(file)
read_folder(file)
elsif File.file?(file) and File.readable?(file)
read_freedb_item(file)
end
end
end
else
#Maybe should throw exception
read_freedb_item(directory)
end
end

#Populates mysql database with data from freedb item
def read_freedb_item(file)

puts “Read file #{file}”

=begin
FREEDB FILE FORMAT
# xmcd
#
# Track frame offsets:
# 150
[ ... 21 frame offsets omitted ]
# 210627
#
# Disc length: 2952 seconds
#
# Revision: 1
# Submitted via: xmcd 2.0
#
DISCID=270b8617
DTITLE=Franske Stemninger / Con Spirito
DYEAR=1981
DGENRE=Classical
TTITLE0=Mille regretz de vous abandonner
[ ... 21 TTITLEN keywords omitted ]
TTITLE22=L’arche de no
EXTD=Copyright (c) 1981 MCA Records Inc.\nManufactured f
EXTD=or MCA Records Inc.
EXTT0=Des Prez\nYez
[ ... 21 EXTTN keywords omitted ]
EXTT22=Schmitt: A contre-voix \n(excerpt)
PLAYORDER=

=end

lines = IO.readlines(file)
if lines[0] !~ /^# xmcd/
puts “ERROR: Wrong header: #{lines[0]}”
return
end

start_offsets = (1..lines.length).find {|index| lines[index] =~ /^# Track frame offsets:/}
end_offsets = (1..lines.length).find {|index| lines[index] =~ /^# Disc length: (\d+)/}

if not (start_offsets and end_offsets)
puts “ERROR: No track offset section!”
return
end

offsets = []
lines.slice(start_offsets+1..end_offsets-1).each do |line|
if line =~ /^#\s+(\d+)\s+/
offsets << $1.to_i
end
end

total_duration = lines[end_offsets].scan(/^# Disc length: (\d+)/)
total_duration = total_duration[0][0].to_i

puts total_duration

#Read Key values into a hash
freedb_metadata = {}
lines.slice(end_offsets+1..lines.length).each do |line|
if line =~ /^([A-Z]+\d*)\s*=\s*(.*?)\s*\n/
if freedb_metadata[$1] #If the key is already defined -> concatenate values
freedb_metadata[$1].concat($2)
else
freedb_metadata[$1] = $2
end
end
end

#Check the mandatory attributes are set
if not freedb_metadata["DTITLE"]
puts “ERROR: Album does not have a title”
return
end

#Build Album and add tracks to it
album = Album.new
artists, album.title = freedb_metadata["DTITLE"].split(/\s+\/\s*|\s*\/\s+/)
if not album.title
album.title = artists
end
album.title.strip!

if album.title.length == 0
puts “ERROR: invalid title (probably wrong encoding)”
return
end

album.discid = freedb_metadata["DISCID"]
album.year = freedb_metadata["DYEAR"]
album.genre = freedb_metadata["DGENRE"]
album.extd = freedb_metadata["EXTD"]

(0..offsets.length-1).each do |index|
track = Track.new
track.title = freedb_metadata["TTITLE#{index}"]
track.title.strip! if track.title
if track.title == nil or track.title.length == 0
puts “ERROR: problem with track title (probably bad encoding)”
return
end
track.number = index + 1
track.extt = freedb_metadata["EXTT#{index}"]
if (index == offsets.length-1)
track.duration = total_duration – offsets[index]/75
else
track.duration = (offsets[index+1] – offsets[index]) / 75
end
album.tracks << track
end

puts album.tracks

puts “Artist: #{artists}, Title: #{album.title}”

#It looks like when several artists are related to a cd they are separated by ‘ – ‘
artists.split(/ – /).each do |artist_name|
name = artist_name.strip

if name.length == 0
puts “ERROR: problem with artist name (probably bad encoding)”
return
end

artist = Artist.find_by_name(artist_name)
if artist == nil
artist = Artist.new
artist.name = artist_name.strip
end
album.artists << artist
end

puts album.title

if not album.save
puts “ERROR saving album!”
return
end

puts “Album saved”

end

puts “Reading #{ARGV[0]}”
read_folder(ARGV[0])

DROP TABLE if exists artists;

CREATE TABLE artists (
id int not null auto_increment,
name varchar(100) not null,
primary key (id)
) character set utf8;

DROP TABLE if exists albums;

CREATE TABLE albums (
id int not null auto_increment,
discid char(8) not null,
title varchar(100) not null,
year smallint unsigned,
genre varchar(40),
extd varchar(255) default null,
asin varchar(20) default null,
primary key (id)
) character set utf8;

DROP TABLE if exists albums_artists;

CREATE TABLE albums_artists (
album_id int not null,
artist_id int not null,
constraint fk_aa_album foreign key (album_id) references albums(id),
constraint fk_aa_artists foreign key (artist_id) references artists(id),
primary key (album_id, artist_id)
) character set utf8;

DROP TABLE if exists tracks;

CREATE TABLE tracks (
id int not null auto_increment,
album_id int not null,
title varchar(100) not null,
number tinyint not null,
duration smallint unsigned,
extt varchar(255) default null,
constraint fk_tracks_album foreign key (album_id) references albums(id),
primary key (id)
) character set utf8;

With the proliferation of the read/write web, the Internet has become an enormous space holding too much information. In my previous post I talked about the concept of solidary community intelligence raising the issue of interaction and how information should be organized.

A possible solution to the problem is the combination of a “Content Hub” and a “Personalized Content Dispatcher”.

The main function of the “Content Hub” is to scan sources of information supplied by users and to extract new content as it appears. That way all the content can be queried and accessed through a single query. That’s something search engines. Thanks God we have them!

The “Personalized Content Dispatcher” goes one step forward, delivering to users the information they are interested in. And I say deliver, push rather than pull. Of course, you can always go to a search engine and search for the information you are interested in, but user profiles are quite complicated and so they involve too many different queries. Moreover, users do not usually have time to go and search that information, let alone go again and again through the same results to find a new relevant result. That’s why we need an intelligent way to look for that information in the “Content Hub” and personalize the delivery on a user’s basis with a “Personalized Content Dispatcher”.

There will still be a master piece missing that will enrich the system: “Intelligent Content Discovery”. What the hell does that mean you may ask. The answer is pretty simple, the system MUST suggest new sources of content to users based on their profile. That way, the system takes care of everything, users just need to define their profile, that is, what kind of information they are interested in (well, we could build profiles through a more complex process based on other information provided by users). The “Intelligent Content Discovery” could also use profile matching algorithms to group people in communities sharing the same interests and propose new content to users, by investigating the different sources defined by all the community users and that are not shared by all of them. This is something that I think we will start to see more and more in the near future as users contribute with more information to the community.

That’s the sort of problems we are trying to solve at 2or3things and for which we plan to provide solutions before the end of the year.

I’ll keep you posted.

It is amazing to see the maturity that free and open source software has acquired over the last years. I’ll use the term solidary community software, because that’s the foundation that makes this software successful: the coordinated effort of many different individuals that want to share with others tools that can make life easier. And I must say they achieve their goal in a very efficient manner.

Take a simple example: this blog. It runs on solidary community software: GNU Linux, Apache, MySQL, PHP and WordPress. New features are added continuously to the core product and new extensions are developed by individuals or groups of individuals that do not necessary belong to the WordPress developers community. Now, this is a very interesting point, people that do not necessary belong to the project are able to work and provide extensions for it, or even build their own modified version of the software.

I think the solidary community software model requires all our attention. We should analyze and see whether it could be used in other environments and how it could be applied.

One interesting application could be solidary community intelligence. Wikipedia is a very simple example. I am thinking about something much more reactive, like blogging and forums but in a more structured way.

What about solidary community help and health-care. Although many associations exist, it looks like developers are more kind to help providing tools to the community, than doctors and nurses are to provide assistance to people that do not have the necessary resources. Important to note than in the solidary community software world everybody can get the software for free, regardless of their financial situation. If doctors can get software for free, shouldn’t they provide their services for free as well?

I don’t want to make apology of communism, but rather stress the importance to study the solidary community model to understand how it could be adapted and applied to other domains.

Pros:

1. Motivation
   What can be more motivating that working on something you like for your own benefit?
2. Flexibility.
   You manage your time, you decide what, when and how. I love it. I probably appreciate it less than other people because my previous work was already very flexible.
3. Estimulates creativity
   Going trough the process of finding and building an idea requires a lot of creativity.
4. Estimulates concentration
   It is easy to waste a lot of time reading all sorts of stuff on the internet (Following the buzz)
5. Helps you meet other people with similar interests
   It is easy to get in touch with other entrepreneurs and have very interesting conversations about ways to find solutions for user problems.
6. Practical BA course
   You learn many different things about running a company. This is never going to be like an MBA (I guess) but I guess learning from the field also has its advantages.

Cons:

1. Too much work.
   This is not per say a con if you like what you are doing. However it limits the time you can spend doing other things, mainly take care of your family and friends.
2. Always on
   It is difficult to stop thinking about your business. I'll say I spend around 90% of my time thinking about it. I even dream about it! This is indeed very tiring.
3. Money
   Not that I care too much, but not only do you invest some money but you are also paid much less than you would earn working for someone else's company.

I don't know whether someone knows of a site that tracks each and every site that is showing off. Everybody following the web 2.0 wave is probably reading techchrunch, o'reilly radar, web 2.0 explorer, etc, etc. There are also web 2.0 applications to propagate and follow the buzz like buzzshout.

There is actually a site that tries to track all emerging web 2.0 start-ups: NEO Binaries. As a brand new entrepreneur, I sometimes find all this information overwhelming. If you run a search on the domain of your future product, there is a high probability you will find some competitors already. Maybe many of them.

I am not an expert in business strategy, nor do I have a related degree, but it seems to me that in traditional markets having some competition is not necessary a bad thing, because if some companies are already there, there is actually a market for your product. If you need to find and educate the market on your own you will have to invest a lot of money and effort.

In the world of web 2.0 this doesn't need to be true. Why? Well, creating a new internet application does not necessarily need a very important investment upfront, therefore anybody with some knowledge of programming and an idea can build an application in a very short time and make it available. This person has not probably made any (extensive) analysis of the market because it is expensive, so it is cheaper to build the application and see what happens.

What I am trying to point out is that following the buzz is very time consuming (it's is easy to expend half of the day reading blogs about new exciting websites) and not necessarily very productive because it is difficult to come out with good conclusions.

My advice is read one or two blogs at most so you stay tuned, but don't spend a lot of time on it, it is not worth it.

Although I am a high volume consumer of internet information, I haven't contributed much yet. I think I could (and who doesn't?) and that's why I decided to start this blog. I am not saying that it is going to be of any interest to anybody, but I guess some people might find some of the posts useful.

This blog is not aimed to let everybody know about my life. I'll keep it for me if you don't mind. I will just write about things that I am interested in, problems I have encountered and how I have solved them . And don't expect it to be poetic, English is not my first language. If it is written in a way that everybody can understand, I'll be more than happy.

I have recently founded a new company with my ex boss (and now partner). The company's main goal is to build Web2.0 services. So expect to find a lot of information related to that activity.

And that's it for my second post. I hope I'll be in the mood in the next days to add more interesting information.

Deeper Inside first post!