As many people are posting, and studies are finding, most gnutella users are freeloaders. I have to admit, I am one too. (Hey, I'm an economist, they taught me to do it in college...) It shouldn't be a surprise to anyone since there are no personal incentives for sharing but there is the penalty of bandwidth and computer resources. This is the externality that is killing the gnutella network.

The current ways of promoting sharing such as requiring one shared file or limiting download bandwidth as a percent of upload bandwidth are not working and were not very well thought out ideas to begin with. We need to unleash some economics on gnutella.


I have a proposal to the gnutella standard to promote and maintain efficient sharing.


Make it a “build up” game and set a price:

Think of it like those that sit and play “Everquest” for unbelievable amounts of time, people want to “build up” their resources. We can use this to gnutella’s advantage. By using good files like points, players can win by sharing the most useful files.

The price to download is to upload. Simple enough. This requires the client to keep track of the uploads and “useful files”. For every item that was sought to be uploaded, the user will obtain rights to download. This does not means that the file had to be uploaded or even completed from your computer (perhaps it was busy at the time with other uploads) but if you had the exact same file as someone else but it was being uploaded from their computer and not yours at the time, you should also get credit for sharing a useful file. That file should be marked by the client software as “useful” or with a cute star or a smiley face…. You get the idea. Also, the useful rating of the file should have a time limit of 1 month which will cause users to continuously need to strive to provide other users with good files rather than sit on some old outdated files and just be a leech. This policy will also eliminate freeloading by people that put a useless file in their share folder and start sucking the life out of gnutella.

For every useful byte that you share, you are allowed 10x that in return in full speed without bandwidth limitations. That means if you shared a file that was 1,000 bytes. As long as someone wants that file, and as long as you share that wanted file, you are entitled to 10,000 bytes at full speed in return for you contribution to the network. The client software can keep track of that. Otherwise, your total download bandwidth should be limited to 10 kb/s. However, if the max speed does not exceed 10 kb/s anyway, sharers shall not have their points deducted until they can download in excess of 10 kb/s.


Special “Tenure” rating:

Since sharing a single 3 Mb song is hardly sharing, it would be a good idea to promote some arbitrary amount of sharing that promotes putting files on the board. I’m saying 1 GB is a reasonable size that says, “Hey! I’m actually contributing to this network”. To those that share in excess of 1 GB, I would give them a “Tenure” rating for their service. Since not every file is a useful file, having 1 GB of useful files safely implies that the actual shared amount exceeds 1 GB by far. Users will need to share as much as possible and fill the demand of their fellow users to obtain and maintain the 1 GB tenure.

A tenure user sharing more than 1 GB of useful files should have unlimited bandwidth use of gnutella and also should be favored when downloading against “non-tenure”(10 kb/s) users. However, people entitled to their limited bytes at full speed are also treated as tenure for their limited bytes. So if multiple people on one server, a non-tenure user’s downloads will be paused if the server has limited bandwidth while tenure users download happily. Also, once sharing exceeds 1 GB, the user’s screen should turn gold and say “Tenure” and have fireworks to acknowledge their contribution to the gnutella network. Pride is good and necessary especially in an invisible place like the internet. Pride is the thing that can make something like gnutella work since no one is getting paid.

There are many inherent benefits to these policies. Many people will treat this like a role playing game where they build up useful files and obtain rights to download and obtain “Tenure” status. This will promote quality file sharing naturally and end freeloading by intentionally sharing useless files. This will also automatically ensure continuous quality improvement of the files being shared. People will be willing adhere to standards of file naming as renaming an identical file some other name will not likely get that file a “useful” status as people choose files with the most users providing it and not the odd ball. The speed of transfers should dramatically improve as more and more people seek to provide popular files for upload.

I hope this encourages discussion on how to improve sharing in gnutella. It would really be great if this or a more refined version of this can be implemented in the next gnutella standard. Thanks for reading.



critic

A similar proposal to this has already been made. If I remember correctly, the method was called 'Generosity Indicator', or GI

Look at this thread:

How to stop Freeloaders

My idea about this is that, in contrast to what you are saying, the generosity of a user should not be measured by the popularity of the the files his node is sharing, but by the amount of bytes it actually did upload over the last 48 hours divided through amount of bytes download at the same time.
I see two advantages in this:

First, while your method measures the potential usefulness of a node to the network, this one measures its actual usefulness. Remember, users can still cut uploads manually or limit their upload rate to 0.5 kB/s or something like that! There are probably still more possibilities how to cheat out the measurement as it

Second, this method is easier to implemement. Your method would mean drastic alterations to the protocol, since the nodes would need to exchange information about which files are popular and which aren't. Using the other method however, nodes would just add their GI-number somewhere in their http download requests. If the sharing host doesn't know what a GI is, it'll just ignore it (hopefully).

-

Then there is the question about how such a rating should be applied. You propose that it should affect the users download rate. I believe it could be less problematic if the GI would be applied like in this scenario:

Node A wants wants download file x from Node B, so it sends a http request to B. The user of node B has set the number of maximum simultaneous uploads to n. If B is providing less than n uploads to the network at the time the request from A arrives, A will get the desired file regardless of its GI.
The interesting question is what happens if B's upload slots are already taken. In that case B will compare A's GI to the GIs of the other uploading nodes. If it finds that A's GI is too low, A will get a 503. If it finds that A's GI is 5 or more points higher than the lowest GI of the other uploading hosts, B will open up an additional upload slot for a good network citizen. If it finds that A's GI exceeds the minimum GI by more than 10 points, it will even cut off the upload with the lowest GI if necessary.

I hope we will soon find the best solution.

Guido

Hi,
the idea above sound interesting (it sounds like Mojo Nation [1]), but I guess Mojos can be faked. I have another idea to stop freeloading and improve download speed at once. My favourite is: Swarming.

Swarming means to distribute small parts of files all over the network and every servant takes part (even modem users). Please read more about advantages and technical details in the link above.

Also I think a philosophy of "healthy servant behaviour" is a very good idea (read more at Limewire [2]). For example a servant does allways share the download folder or _allways_ does allow 1-n upload slots (n depends on uplink bandwith) with a minimum bandwith, e.g. like Xolox does.
A Gnutella servant that does allow zero upload slots (most servants do this), does support freeloader and therefor is unhealthy to the network. Especially this behaviour must be stopped IMHO!

And finally the anonymous Gnutella network should be turned into a real community. Inside an anonymous network people intend to "take and go"... a community would encourage people to a much more cooperative behaviour. To achieve this goal there are various ideas: The users need a personal contact, a chat between clients. We should build structures which strengthen communities, e.g. more specialized horizons where people of a special interest (music taste, gamers, coders, etc) can find each other. People with similar interest intend to be more cooperative to each other. Or how about showing a "gnutella karma" which shows how much you have downloaded and how much you have given back. All this together could encourage users to be more cooperative, to be a part of the network. Let me say this again: Gnutella means sharing.

Some of my ideas. hope you like it, Moak.

[1] Mojo Nation http://www.mojonation.net/
[2] LimeWire article about Network Healt http://www.limewire.com/index.jsp/med_require

Anti-freeloading isnt a really good thing. I believe that users should share because they want too and not because others force them too.

Anti-freeloading plans rarely work if they work at all. Take Direct Connect for example they have an anti-freeloading feature by allowing users to set file/size amount shared and number of upload slots as restrictions. Go into anyone of those nodes and there will be probably 1-2 modem users the rest are all broadband. That is point number one it discourages modem or other narrowband users off the program and would discourage them off gnutella. Even with supernodes many modem users wouldnt be able to meet restrictions and the time to take to upload massive amounts or build up would be too long.

Antifreeloading features only help out broadband people and not all the users. Most places broadband isnt avaible, its too expensive, or in my case the backlog is so big you have to wait an extreemely long time to get it hooked up.

Number two it promotes the sharing of worthless files like copies of a group of files over and over, or corrupted/partial files and etc.

Lastly using DC as an example again it doesnt really improve download rates. Sure your search screen will be filled up with more crap but if downloads rarely go through or are slow then whats the use.

Also swarming was mentioned. Swarming isnt the holy grail. On the fasttrack network even though there is no way to get teh stats ill bet that more people freeload there than they do on gnutella. Swarming just makes freeloaders less noticeable it doesnt encourage users to share. Even though it uses less bandwidth to upload would it really be enough to convince someone who wasnt sharing in the first place to share? I doubt it.

Hmm, I still believe in "freeloaders are not bad" and swarming is a holly grail to integrate modem bandwith... do you personaly think there is a way out of the freeloader dilema?

Dilema? Its not really a dilema alot more people are sharing now on gnutella than a year ago when there were those funny news articles predicting gnutella death within a few months. I think people worry too much about freeloaders.

Information is the only thing really needed. I say let users see whos sharing and whos not and if freeloading bothers them then they can manually abort all they want.

Swarming wont intergrate modem users supernodes will. Using a supernode a modem user can download/upload the same as they would on a centralized program like napster was. Swarming just makes downloads a little faster thats it. It wont help modem users if just that is added because modem users will still use most of their bandwidth on host connections.

How did you come to this new conclusion, did I miss any article? All available statistics and articles [1] [2] point to the fact: most users on Gnutella are freeloaders.

Supernodes will not integrate modem users. Supernodes will together with search-caches: reduce backbone traffic + improve network topology + increase horizon (more available files).

I expect much more positive effects from swarming. I allready posted swarming ideas here, a short summary from that:
The bandwith of modem users is completely wasted right now and modem users are often "forced" to be freeloader. Actually this egoizm is contraproductive and means less files for all. While high bandwith users can share the traditional way, swarming is a key to make low bandwith users share with the network, without any significant negative effect or traffic-overhead. Swarming will: make low bandwith user become a valueable resource + spread often requested files + balance load + less "busy" servants (more available files + higher bandwith).

Greets, Moak

You didn't read my proposal very well.
What I proposed is quite well cheat proof AND not unfair for modem users.
Here's why I think so:

It is cheat proof because this 'GI' is not measured by how many or which files are in your shared folder, but how many bytes you actually _did_ upload during the last 48 hours, divided through the number of bytes you did download. Thus you can impossibly increase your GI without contributing to the network. (Okay, there's still the possibility of manipulating your node's source code - but I don't think a significant amount of users will do so.)

It is not unfair to modem users because of the way this GI is applied. If you read through my proposal carefully (and think a little further), you will see that the trick is to have a GI that is slightly higher than the GIs of those who want to download something from the same host. You do _not _ need a GI which is near to the maximum, it only shouldn't be too far below the average GI on the network.
As the majority of Gnutella users probably have asynchronous connections, this average GI will probably not be more than 30% or so, meaning in order to have a decent chance of getting your desired files, you'd have to upload 30 bytes for every 100 bytes you download. Don't tell me this is too much for modem users!

What I have to admit though, is that all this won't be of much use as long as the majority of clients don't support swarming.

This idea is similar to one posted by someone in another thread.

Either way it is discriminatory: I share 2GB of files, most of them obscure classic pieces by Ligeti, Tallis and Orff. Should my download speed be throttled simply because the files I share are not popular?

As far as I'm concerned, I share - usually 24/7. Although I receive very few upload requests, I know that I share files that the masses are not interested in. Does this however class me as a freeloader, or even a 2nd class citizen?

To say it's not cheat proof is incorrect. I can start two servants and download one from another with no great difficulty.

If such a mechanism were to be put in place, you can bet your life that people would massage the figures very quickly. They choose not to now because there is no reason to, give people a reason though and you'll see why the phrase 'necessity is the mother of invention' is so apt...

Rachel

__________________
But the fact that some geniuses were laughed at does not imply that all who are laughed at are geniuses. They laughed at Columbus, they laughed at Fulton, they laughed at the Wright brothers. But they also laughed at Bozo the Clown.

Carl Sagan

Hi, I like the idea of an indicator how generous/nice you are.... IF this is only an indicator without any restriction for downloading. Freeloaders are not evil, mode users are still not integrated and must not be punished.

I did call this generousity indicator "gnutella karma", which shows a ratio of how much you have downloaded and how much you have given back. Let's imagine there is a chat ability between future clients and you will see the generousity/karma (together with a title from 'A++ superpeer operator' to 'Big sharer' to 'whining milkdrinking freeloader') of your opponent... I guess such an indicator can encourage people to share and build a community.

guido i think your idea would be better off on a propierty network. To implement such an idea it has to be supported by every servent on gnutella which is impossible. Because people will use old servents and theres no guarentee that every developer would add it anyways.

Your idea would be biased towards what you share. What if a user was sharing 2 gigs of polka music and only uploaded 2 songs in a day. Even though they are sharing an enormus amount they wouldnt matter to their rating. On the contrary a user could share one small and popular file like an ebook thats about 800k big upload it a hundred times and get a high rating for sharing just one file.

This is no argument at all here. This is a developer forum where we discuss about gutella's future and ideas. New ideas must be developed and proofed, good ideas will be implemented in future clients.

That is not the mass, the mass are freeloaders. Some rare polka trader can still share famous files (swarming?) or offer a superpeer to help the network. Traders of rare files ar no problem for the network, non-stop downloader without sharing are.

That's perfect. If a trader shares less files but very famous, he is doing a good job to the network!

What ideas do you have to improve gnutella?

Btw. It's certainly been a while since I've seen a modem user connect to my host do download something. - I think most of the modem users would rather use fasttrack, as the traffic of two connection already takes up a considerable part of bandwidth. - I remember the days when I still was a modem user, and how rarely I used gnutella.

FREE LOADERS RULE!

Things that make Gnutella rock:
1) It's free
2) EVERYONE IS TREATED EQUALLY

I have been doing this for years. At serveral points, I started with noting. Someone on the network hooked me up, and let me leech off of their server, and in return, I served back to the community.

As with anything social, there are going to be contributers, and non-contributers. I have broadband, so I'll contribute, but if I had precious little bandwith (dial up) I would not contribute... it already takes 20 min a song, and sometimes it quits in the middle of the download!

IMHO freeloaders are okay. If you don't like freeloaders, use the tools that are available to you now, but don't continue to add overhead to the network to a technology that is already top-heavy with ping data (I have ready 50% of the Gnutella overhead is in ping and pongs).

Let 'em freeload, the files you want are probably still available to you (by some courier that doesn't care if you give THEM anything), and remember... all of you started with nothing at some point. What if you were told "sorry... I won't give you any files... you download more than you upload"

Remember the thing that all the Gnutella brags about - everyone on the network is equally important... T3 - 2400 baud

__________________
If I were smart, I could have a profound quote here.

Are you serious? Free loading is contra productive for all of us... which means less files, less bandwith, less fun. Together with more multidownload clients this could finally KILL GNUTELLA, oops.

Please read this thread.

Q: What is the reason that FastTrack and eDonkey are that fast?
A: They do not allow pure freeloading, you allways share a small part of your bandwith. I'm sorry that Xolox is dead, the _only_ healthy gnutella client, because it does not provide pure freeloading! Did Xolox hurt any modem user... no... anti-freeloading means not punishing anyone, but improve speed/availabitlity and that is one of many reasons why FastTrack/eDonkey is more famous, more modern.

The main goal of Gnutella developer must be IMHO: Stop freeloading in a very fair manner (for example integrate modem users with swarming and a miminum upload bandwith, following the Xolox/eDonkey example) and decrease backbone traffic (e.g with superpeers, which will be a dramatic speed increase for modem users!).

1. Technical speaking there is no way arround stopping freeloading.
2. Speaking not technial, anti-freeloading will result in: modem users will download faster (yeah!), high bandwith user will download faster (yippie!).
Saying this, judge on your own now: Freeloading is cool, freeloading is bad?