Because of the emphasis on stability and quality code, people must be pre-approved before joining the NetGore development team to work on the official base engine releases. Though you may still edit the base engine code in any way you like for your own usage if you are not on the development team.

Requirements

There is no required amount of time or effort you must put into the engine to join the dev team. It is purely voluntary and you are free to work at your own pace. But it is important that you are able to write good code. While having "more" in the engine is nice, it does more harm than good if features in the engine are full of bugs or poorly designed.

Please do not apply unless you are decent with C# and OOP. We're not looking for anything exceptional, just people who are able to write basic C# without any help. You should know and have a lot of practice with OOP, along with understand and be able to use and utilize different components of C# such as generics, delegates, exception handling, etc. If you can understand and write code similar to what you see in most parts of NetGore without much hassle, and understand why it was written that way or better ways to write it, you should be fine.

Join Request

If you wish to join the NetGore development team, please send an email or private message to Spodi. This doesn't need to be anything more than "I want to join the NetGore dev team. My NetGore username is .... and my Google username/email is ....". I put my trust in those who want to join that they will be responsible with their commitments, only take on tasks they can handle, and only commit quality code.

Please note that the NetGore project is on Google Code. This means that you will have to have an account on Google. If you do not have one already, you can sign up for one for free.

Development Tasks

As part of the NetGore development team, you are free to work on any part of the engine. To give you some idea on what kind of tasks can be worked on, a broad list of categories is provided below. In each category, there is a listing of the approximate skill requirements required. These requirements are ranked on a scale of 1 (easiest) to 5 (hardest) and include:

OOP: Your ability to create well-designed and logical classes and inheritance chains, along with your ability to implement abstraction (such as using interfaces and abstract classes). This is a skill that simply comes with lots of practice.
Programming: Your ability to take a task and implement it in a way that performs well, has as few bugs as possible, and it is clear that the potential outcomes are all well-defined (even if the definition is "undefined", in which case you'd throw an exception).
NetGore Knowledge: This is how well you understand NetGore as a whole. A high ranking in this means that you need to know your way around the engine, how different parts of it work, why things were designed the way they were, and how to keep with the design style of the engine. Experience in this just comes with working with the engine, either as a programmer or as a developer making their own game.

Unit Tests

OOP: 1
Programming: 1
NetGore Knowledge: 1

Writing unit tests is probably the easiest way to contribute to NetGore with actual programming. Ideally, this is done hand-in-hand with the Programming category, but its not always easy to write tests while writing the objects (although those who love TDD will say otherwise). This is especially true when you are constantly refactoring your classes while writing them. Tests are simply something you cannot have too many of. The more parts of the code that are covered, the better. Not only do unit tests reveal when changes to the code end up breaking something, but they can also be a good way to find obscure bugs that already exist.

If you have never written unit tests before, it might be a slow start. Knowledge of NetGore will help you with figuring out what can be tested, experience with writing tests will help with thinking of how to write the tests, and your ability to program will help with writing tests that can cover a lot of different objects (such as every implementation of an interface or base class) all with the same code. But none of this is required. Seriously, writing unit tests is an incredibly easy way to contribute a lot to the engine.

Documentation

OOP: 1
Programming: 1
NetGore Knowledge: 1-5

Documentation is a vital part of the engine both for engine developers and users. Ideally, every class and class member would contain comments that perfectly describe what it does in as few words as possible. In reality, there are plenty of classes and class members that do not have any documentation, and even more that have quite poor documentation. No programming or OOP skills are required to write documentation, but you do need to understand what you are documenting as incorrect documentation is worse than no documentation. It is also important you are fluent in English and can write very clear sentences.

Refactoring

OOP: 3-5 (depends on what components you are working with)
Programming: 1-2
NetGore Knowledge: 2-4 (depends on what components you are working with)

Refactoring involves redesigning existing parts of the engine so that they perform the same task, but in a much more elegant way. For the most part, you do not change any of the logic of the code, but the design of where it is located and how it is utilized. This can include tasks such as creating interfaces and referencing the interfaces instead, turning static methods/classes into instanced ones or vise versa, renaming classes or class members, separating classes into multiple classes (or joining multiple classes together), etc.

Right now, this is one of the key parts of NetGore's development. Not only does the foundation of the engine need to be improved before more parts are added to it, but as much as possible needs to be removed from the DemoGame projects and put into the base engine.

Adding Features

OOP: 2
Programming: 2-5 (depends on what you are working on)
NetGore Knowledge: 2

Features are always nice to have, but they must be done properly. When adding features, you need to make sure that they work and are very stable. Being able to design a good interface to using the features is always nice, but not absolutely required, especially when it is a feature used by other parts of the base engine and not actual games on top of the engine.

Optimizations

OOP: 2
Programming: 4-5
NetGore Knowledge: 3

Optimizing different parts of the engine can be a tricky task. For the most part, the engine already performs great, but it is possible to improve it in many places. The first step in optimizing alone can be a bit difficult, as it requires finding something that is worth optimizing. For the most part, we are not interested in micro-optimizations, such as slight rewrites to code that result in a few less CPU instructions. The optimized version of the code also needs to be as easy to use as the unoptimized version. While we love high performance code, we will not scrafice usability and maintainability for it.