On Friday, 4 May 2018 at 11:35:22 UTC, Sjoerd Nijboer wrote:
So i'm a college student in and what bothers me is that there
seem to kind of assume programming languages don't evolve or
don't get replaced by better ones.
Right now if you go to college you'll most likely get tought
c++, c# or java for any comp sci degree. While these languages
are industrial standards, they all have their drawbacks. And
one drawback that looks important for teaching is flexibility
in expressiveness.
From my experience college students seem to have problems
translating their often declarative thought process into actual
semi compile-able code that runs in a given language.
Since D seems to be a language that supports a lot of
programming paradigms very well, wouldn't it be beneficial to
learn people declarative programming using D for a little and
from there expose them to other programming styles in thesame
language to lower the barrier of entry?
I think D could play a bigger role in education since its such
a "clean" language that is flexible but doesn't have any real
gotcha "features". Its also a language that could potentially
be used over someones entire college career as the primary
language. If this would be achieved there would be a higher
income flow into the industry of young D programmers which will
pollute other programmers with the D mind and featureset.
I thought it might help if I mentioned that I successfully used D
as one of three languages to teach the Programming Languages
course at Vassar College last Fall.
The main reason I ended up using three languages was this:
1. Most undergraduate CS courses that I sampled (at UW, for one
taught by Dan Grossman, among others) use a core functional
programming language such as (S)ML which really helps in
solidifying some of the principles of programming languages—the
concept of environment, scope, binding; functions as values;
curry, filter, map, etc. Plus it has a version that comes with a
REPL and really helps students explore it. That said, it is not a
"industrial strength" language, and since I also wanted to
empasize on the pragmatic aspects, it could not be the only one.
2. I briefly introduced the concept of logic programming using
Prolog, but I couldn't really spend too much time on it and so
cannot count it as another language
3. When I asked students what language they would like to
choose—given the choice, most of the class leaned towards Python.
That plus the likelihood of them actually using it at some
point, I decided to cover some programming language aspects using
it over two-three weeks. It also has some fascinating feature
sets (dunder methods, some meta programming niceties, etc.) and
being interpreted language, provides a nice complementary view.
4. The rest of the course used D. I used both Andrei
Alexandrescu's book and Ali's book to generate the course
content. I was fortunate to have a stack of slides from the
Andrei himself. And even more fortunate, as it happened to spend
a Boston D meetup dinner with the two and Steven Schv-guy.
I have been in love with D ever since I firsr started reading
Andrei's book in 2010, and it was really quite something that I
could use it in an undergraduate CS curriculum seven years later.
Originally, I was hoping to use D for the entire course, but then
given various aspects of the course, and the styles in which it
is being taught many places made me change things a bit. Oh, and
I should mention that I did get a few slides from Chuck Allison
who uses D to teach a small part of his course at UVU. If you
haven't seen his talk at, I believe the first/second DConf
at UVU, I would highly recommend it.
The icing on the cake was that Andrei was able to visit Vassar in
November and give a talk on his Fastware muse (if I may call it
that). He was an instant success!
I am scheduled to teach the course again next Spring, and I am
trying to figure out how/if I can use more D than I did the last
time without sacrificing some of the goodness that (S)ML brings
to the table. That way I can cover more programming paradigms
that D brings to life—built in unittests, contract programming,
delegates, and many many more—with a flair.
Any thoughts/pointers that this wonderful community can provide
would be very much appreciated.
--
Sameer
