Syllabus: August update

[colinleach]

This is an update to issue #956. Two months on, there has been some progress (despite a subjective sense of wading through molasses!)

• Both dates-times and regular-expressions are now live.
• Three new concepts are now live(ish), but still need exercises:
  • multi-dimensional-arrays : no idea of what exercise to use.
  • comprehensions: PR Boutique Suggestions concept exercise [DRAFT] #992 is a draft which might fit with a bit more work.
  • higher-order-functions: no clear idea of an exercise, but might something inspired by Boutique Suggestions concept exercise [DRAFT] #992 also be developed to fit here?

At an earlier stage:

• linear-algebra has a part-written concept that is getting very long. I need to finish that before worrying about an exercise.
• dict-functions is at an early stage of doodling, to see how python/mecha-munch-management could be translated to Julia.

Interfaces

There was some discussion about this in the context of iterators.

• For an iterators exercise, we have two to play with. I'm currently at an early stage of thinking about them.
• python/plane-tickets
• julia/old-fibonacci iterator

The Julia docs list several other interfaces. Are any of these important enough for an Exercism syllabus?

• Indexing
• Abstract Arrays
• Strided Arrays
• Customizing broadcasting
• Instance Properties
• Rounding

Documents

Reports of typos have become rare recently. I suspect we wore students down, rather than making everything typo-free!

References needs improving:

• Cross-links to other syllabus Concepts (now that most of them exist).
• Add more links to relevant bits of Wikibooks.

Anything else?

[depial]

multi-dimensional-arrays : no idea of what exercise to use.

I was looking at exercism-matrix and was somewhat surprised to see that it's not in problem-specifications. For that reason, I was wondering if I should just try modifying the old one in place? I think it could use a significant rewrite since it focuses on things we weren't necessarily looking at (e.g. matrix rotations), but I'm thinking we could use the base matrix structure for something. Otherwise, we could just introduce it as a practice exercise as is and I'll come up with something fresh. I've been a bit lazy lately though...

There was some discussion about this in the context of iterators.

I'll take a closer look at the two exercises you suggest to see how they fit in with the iteration interface. My laziness again...

Are any of these important enough for an Exercism syllabus?

I think would (highly subjectively) classify Abstract Arrays as the most interesting, but I also feel Indexing and Customizing Broadcasting are potentially useful.

[colinleach]

I was looking at exercism-matrix

That was written by the previous Julia maintainers, so old-exercism-matrix is the only version.

I'll take a closer look at the various interfaces, starting with trying to get iterators done.

Also: YOU ARE AN UNPAID VOLUNTEER. "LAZINESS" WOULD BE FINE, EVEN IF IT WAS TRUE!

Unfortunately, Markdown doesn't let me put that in 28pt red.

[depial]

I'll take a closer look at the two exercises you suggest to see how they fit in with the iteration interface.

I've looked at these and I feel like:

• fibonacci iterator is purpose made for using the iterator interface (e.g. the current introduction.md is effectively just the manual section on this).
• plane-tickets appears to be aimed more at generators.

It seems Julia has these two aspects, generators and the iteration interface, which could differ from Python's idea of "iterators" in a more general sense. I found this fairly short article to be helpful in comparing the two languages.

In short, a generator (a Base.Generator type) can be created in Julia via the comprehension syntax, or Python-like generators can be created with Channels (which produces a Channel type, not a Base.Generator type).

From my current understanding, I can think of four things we could look at related to "iterators":

1. Generators from comprehensions: we've touched on in comprehensions, but this could be expanded on
2. Generators from Channels: could be part of a channel concept, or have the channel concept as a prereq.
3. Iteration interface: potentially could be part of, or related to, a broader interfaces concept.
4. Iteration utilities: things like Base.Iterators.Stateful (which provides similar behavior to a Channel).

I guess the question is what aspect of iteration are we interested in showing?

Base.Iterators has some interesting points, like lazy versions of normally eager functions (e.g. map, filter), as well as the Stateful wrapper, but I'm not sure whether that could make up a full concept or not.

The other aspects may be best left for their own concepts channels and interfaces?

With my current understanding of the landscape, I would probably recommend separate channel and interfaces concepts, where we could potentially put a generators concept after channels. There are some caveats for using Channels in the iterator interface too...

To sum up, at present, I'm not quite sure what we could put under a concept labeled iterators, with the exception of something I've suggested before: using fibonacci-iterator to guide students to using the interface without explicitly mentioning interfaces. Then, for the interfaces concept, describe interfaces explicitly, and then have the student implement a custom interface for a custom type system. I started looking into how hard it is to write a custom interface, but I got distracted shortly after starting. I feel this could be plausible though.

[colinleach]

Thank you for the analysis! I need to get back to doing more on the syllabus, after a lax few weeks. To the (limited) extent I've been doing anything, it's been messing about with Futhark, C and Kotlin. Well, I needed a temporary change of context...