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!
