D project management for better growth and longevity

[js.mdnq]

This is an idea I have that I believe can help D become in time 
one of the most popular, if not the, programming language.

The D language, excluding some of known issues, has many great 
language constructs that set it above the mainstream programming 
languages today. While there are many competitors to D, D seems 
to have stronger fundamentals and IMO a better language syntax 
steaming from it's relation to C/C++.

There are several problems with D as it stands but the main one 
is the userbase. For proper development there must be users or 
are willing to invest the time and energy to create the tools to 
make more users want to use D(which will result in a cycle (or 
rather a spiral)).

D needs a lot of work, more importantly, D development needs a 
structured approach to hardness it's development. I feel D's 
development is sporadic and many user created tools and resources 
are localized, hard to use, etc...

So, what I propose is that D use a sort of integrated project 
development application(web based) that allows users to easily 
help in D's development. It is difficult to explain exactly what 
I'm talking about because I do not know the terms to use or have 
a really clear idea myself.

Therefor, it would be better for me to explain what a user my 
experience:

Suppose I am interested in D. I download the compiler play around 
with it and find some bug. For argument sake, suppose I want to 
improve upon the GC and I have also written a tool that parses D 
code and changes UDA's.

But suppose I could log into to D's web site and access a web 
page that gave an overview of all the develop that D is going 
through. I could see a graphical chart, click on each graphic 
that will take me further into the development of D(more specific 
areas) which allow me to see who is working on what, what has 
been done, and communicate with others on the specifics of that 
topic.

e.g., I want to write a better GC. So I go to the development 
chart find where the GC development area is, and click on it. I 
log in, sign up, and discuss or download what others have done in 
this area. I can sign up to help others in this area, etc...

Hopefully you guys get the picture. The idea is to make it really 
easy to develop for D and the development chart would be massive. 
IDE's, VM's, D lang specifics, tools, documentation, modules, 
etc...

One could also integrate it with GIT so pull's could be 
"visualized" and it would be easier for the project leaders to 
get and send pulls. (for example, there could be several GC 
projects on the GC area)

The goal is to facilitate users to develop D quickly and 
efficiently. It makes it easier to find other users to develop 
"projects", get information(a sort of wiki for each "node" in the 
tree), and pull in the projects into D's main repository.


D
   Language
     Specification
       ...
     Documentation
       ...
     2.x
       ...
     3.x
       ...
   IDE
       ...
   VM
       ...
   Tools
       ...
   Modules
       ...
   etc...

I envision one day when D could be used across many 
platforms(common and not so common) very easily. Say a single 
unified IDE that can be used to develop across multiple platform, 
a great debugger, many integrated tools, build in gui 
development, etc... (basically a one stop shop)

(a script would be used that would do something which also runs a 
script on each child. This allows one to "compile" the hierarchy 
quite easily which would also include builds of the D language, 
modules, and tools. When one installs D a similar hierarchy would 
be presented above allowing them to "install" the modules node(or 
select specifics in the sub node), etc)




Each node in the above tree is backed by a git repository, a wiki 
like helps system, a forum(and each super node's forum includes 
all child forums), and project management stuff.

The owner of D, can, for example, pull in any changes to all it's 
subnodes, and each parent can pull in the immediate children. 
Essentially any modifications work there way up from the leafs to 
the branches but must be verified by allowed by the parent.

Anyways, it's just an idea I came up with. The point is not so 
much that it's new but about combining all the stuff out there in 
a very good way to deal with the extremely large project 
development cycle needed for D to be big(or any project).

It's number one goal is to make it easy for users to contribute 
and to give users to contribute something. Example: someone could 
put in a request for some tool at some node(say you are looking 
for some tool and can't find it then you can make a request) 
which give the ability for someone else to write one and it will 
be added as a node/leaf(which someone could fork).