Online D course on coursera/udacity/etc?

[Chris Cain]

The format that I found the most powerful to learn a new language 
or concept goes like this:

1. Gather a set of problems
2. Introduce a few new concepts while considering the effect of 
those concepts on your problems
3. Use new concepts to solve that set of problems
4. Iteratively improve the usage of those concepts in each 
problem until "perfection" is reached. Essentially, revisit a 
"sufficiently difficult" problem (trivial problems are boring to 
revisit) several times doing it better (by some metric) each time.

More recently for me, 1 seems less necessary as I've learned over 
time to make the connections needed for 2 without specific 
problems in mind. However, for someone learning this stuff for 
the first time, having a well chosen set of problems (1) is 
_exceptionally_ valuable.

Now, these steps might seem "obvious", but I've found that the 
majority of "bad" videos or classes that claim to teach something 
in Computer Science fail to follow them in some way. Often I find 
courses withhold the problems until after you've gone through the 
material OR give you too many problems to consider at once which 
doesn't allow you to really consider the impact of your approach 
to each of the problems. Generally ~3 non-trivial problems is the 
best number to consider at any one point in time.

If a D language course were created, I think the absolute BEST 
way to gain some viewership is to teach _problem solving_ (which 
is a major niche for beginner/intermediate students of 
programming and has immense value for even expert programmers) 
using D. Look up some of the many programming problems in various 
programming competitions and teach people how to solve them and 
how the thinking process goes for them, and teach them the best 
way to utilize D for the task.

This is how I learned most of the programming languages I know 
and it allows me to get up to speed on the various idioms of the 
languages and how everything helps (or hinders) in non-trivial 
situations. It'd be even better if the course taught you the 
meta-learning skills needed to replicate the experience of the 
course for other languages (though that might be exceptionally 
difficult to teach in a single course).

For the format of the course:

Provide an introduction to the course, how it will work, etc. 
Show the student how to set up the programming environment 
necessary to complete the course (including teaching a proper 
workflow for Programming in D which should show how to use the 
docs effectively). Personally, I love using Sublime Text 2 for 
programming, but Notepad++ is free and it treated me very well 
for a long time while learning D for the first time.

Build each section a course somewhat like this:

1. Provide 3 non-trivial problems up front and give input/output 
combinations (for D, you could use a unittest block that runs 
your solution on a few inputs and verifies they return correct 
information)
2. Give ~1-1.5 hours of short video segments (~10-15 minutes 
each) teaching problem solving skills necessary to solve the 
problems while showing off the syntax, semantics, idioms, and 
standard library of D. Encourage the student to either think 
through or work through the problem set themselves as they go 
through the videos, but do not provide the actual solution to the 
problems during the videos.
3. Have the students submit their homework problems and have them 
run on a variety of inputs that aren't necessarily known by the 
student.
4. Allow the student unlimited resubmissions of the homework 
problems that test the code for brevity (don't include short 
identifiers, though) and speed. Maybe put up a scoreboard that 
allows everyone to see how their code ranks. Maybe give a tiny 
bit of extra credit to the best 20%. It'd be really nice if, 
after the course ends, there was a way to download and view the 
best submissions for each problem.

For the final problem solving section, provide a series of 
challenging problems that use techniques learned in the previous 
sections. Amped up varations of previous problems might be 
acceptable, but something new and interesting would be better 
since many people might have redone the previous problems enough 
times to be bored by a simple "variation".

As a bonus, link to a few good tutorials on git and good git 
practices. Then show the workflow needed to contribute to DMD 
and/or Phobos. Maybe we can interest enough students to help fix 
more bugs and get even more pull requests this way!