Okay, I'm a dev-rookie and I'd like to build a gnutella client while learning a new language (my only experiences are with vb, php and javascript). I'm reading the protocol specs but..
I really cannot decide which language fits best for the job.

It should have strong XML support and easy network management. Main "candidates" are Java and C#... what do you think is the best for this kind of work?

Thanks in advance

Well, I'm coding a client in VB, the multithreading in VB is real creepy, if you want to go use hashing or other high cpu operations, forget it. Then you have to go use C++ed dlls.

But actually it is possible in VB too.
If you want to start learning a complete new language from the scratch just to code a client, well, its not bad but much work.

If you choose between Java and C#, I would use Java.
C# is just a kinda cheap (OK, the .CRAP framework wasnt that cheap) clone of Java although *they* say it is based on C++.

Java is kind free, so you dont get addicted to any greedy bigsized ultra-capitalistic corporations, so I would choose java

I don't know any programming languages well either. I decided to program in C, since there are many applications still written in C, and I can learn languages as they came about historically...C being an older one, then C++, then I will probably learn Java. That's a while off though, I still need to get a handle on C before I move onto C++. I'm also learning some assembler along the way, although I'm not planning to write any big programs in assembler.

If your choices are C# and Java, I would choose Java. Java runs on many platforms seamlessly, has a large user community, has had a lot of the bugs worked out, runs fast and so forth. C# is kind of Microsoft-centric. I'm making sure my client is cross-compatible from the beginning - currently it compiles on Windows, Linux, Solaris and OpenBSD.

I would not suggest a gnutella client as a teething exercise for a new language. Pick the language you want to learn, then code up a few simple projects first. Tackling something as complicated as a gnutella client as a first project with a new language is just asking for trouble.

There are many elements to a gnutella client: user interface, library management, TCP/IP communications. Do some smaller projects that will let you learn about these things in a less hostile environment (and where your experiments won't have the chance to bring down a huge portion of the network). Then, when you've tackled the basic skills, bring these pieces of knowledge together and start on your client.

I know this wasn't the answer you were looking for, but it's the smart approach.

Patchmaster:
There are many elements to a gnutella client: user interface, library management, TCP/IP communications.

I know. Indeed, the main reason for my decision is to "explore" a language having fun. I can build the client starting from small pieces (managing xml, establishing a connection...), and then put them together obtaining an application that works. I really hate coding only "proof of concept"

(and where your experiments won't have the chance to bring down a huge portion of the network)

well, I think I'm not so stupid
I wouldn't put anything in the network if I had the smallest suspect that something hasn't been fixed

Now I'm really scared for the network. A statement like this demonstrates a total lack of appreciation for what is required for something as complicated as a gnutella client. It's not a matter of putting your software online with known bugs not being fixed. It's a matter of not being able to tell you have bugs until you go online. You can't fix it if you don't know it's broken, and there's no way you can know it's broken unless you start linking up to other clients. This has nothing to do with your personal programming practices; it's in the very nature of the beast. I was simply suggesting you could reduce the chance of catastrophic failure by gaining experience with related projects.

Originally posted by Patchmaster
Now I'm really scared for the network.

Beware you all! The awesome monster from the black lagoon is coming!

It's a matter of not being able to tell you have bugs until you go online.

Well, I can assure you I'll test it on my lan for a VERY long time. Then, I'll go online and monitor what's happening every second, for another VERY long time.. Then, *maybe*, I'll release it...

But let's clear this: I won't create a LimeWire/Gnucleus/BearShare wannabe, nor I'll release anything until I am sure it can't hassle something or someone. Probably it won't be released at all. It's just for my fun.

hi, why not Delphi?
our project is open source, there you can find code, although not very well structured

http://sourceforge.net/projects/gpu

I don't necessarily agree. Building a Gnutella client is complex, but it is doable if you do it one step at a time. I started my program at the first step - I wrote a program that connected to another Gnutella server, sent "GNUTELLA CONNECT/0.4" and waited for a "GNUTELLA OK" response. With plenty of books and web pages on programming, sockets and so forth, not to mention GPL software to look at, Gnutella and otherwise, this is doable for a beginner. And I've been looking at C language for over 13 years although this is my first big C language programming project. Once I got that down, I had it send a ping after it got the OK and then had it wait to receive data (eg pongs and queries - although I also sometimes received queryhits and pushes even though I shouldn't have). So I got that down. All the data I got looked like junk so I started parsing and interpreting it into queries, pongs and so forth, the format of which I learned from the Gnutella protocol specification. After this, I gave it the ability to do a search, and then put in the functionality to interpret queryhits (which was not easy). Then I noticed some cross-compatibility problems between Windows, Solaris, BSD, Linux etc. so I started working on them. And so on and so forth, I just take it one step at a time.

As far as irresponsible developers possibly harming the network, this is true. I always try to be responsible - I have a little LAN at home and try things out there before going on the network. I also don't like overloading the pong servers like connect1.gnutellanet.com so I always use my cache before resorting to that in an effort to prevent overloading those servers.

I also don't always send queries out with a large TTL. As long as I'm testing, a few responses will usually suffice. I usually use words that give a large response rate like "live" or "love". Queries cost the network more than queryhits, as queryhits are routed while queries go everywhere.

The key thing I think is to be aware of what can harm the network. Bombarding the network with TTL=7 queries is one way. Bombarding the main pong servers is another, although gwebcache is making this less of an issue. Most of the popular well-developed clients filter out a lot of the type of the junk that can hurt the Gnutella network, making it more resilient. Usually what the developers of those big clients complain about is sending out queries/searches with a TTL of 7 too often. I usually get 10 or more responses with a search/query TTL of 4 when I search for common words like live or love, so lower your search TTL to 4 when testing and use common words...if you have a problem, increment it to 5 when you have a problem, although a TTL of 4 is fine for getting 10 or more queryhits for popular words.

As long as you're responsible like this I wouldn't worry too much about hurting the network due to being a beginner. I think the main problem is people who consciously try to hurt the network, either authors of popular Gnutella clients who have a low requery rate, or people who send bogus replies to queries with spam, and so forth. The main threat to the network as I see it is people consciously trying to hurt it, or who are at least indifferent to how much they hurt the network as long as their client gets a lot of replies, or as long as they can sell their spam, or as long as they satisfy their MPAA/RIAA paymasters. I think developers who are trying to be responsible, even if they sometimes make mistakes, almost always give more to Gnutella than they take. Hell, even the Limewire and Bearshare developers goof once in a while and harm the network in a new release until they or someone else notices the problem and they fix the bug they accidentally unleashed. But that's the exception, in my opinion Limewire and Bearshare have always done a good job, and even if you have an ax to grind with one or both of them, there are certainly less responsible clients floating around out there, which I won't name.

Well I think C++ is my favorite ones. But I think I like Java a bit too.