Please share your opinion on a Crystal syllabus

Yes a learning mode for crystal has started to be planned. I started planning for about a month ago and after a first-round a feedback from the crystal community. I am now requesting feedback from the exercism community.

Here is what currently every category covers:


  • Create variabels and constants
  • How to define a method and how to call a method
  • Default parameters


  • Cover basic “math” methods (+, -, *, **, /, %)
  • How to round a number
  • Floats, Uint, int and all the forms of them e.g int16 etc
  • How to convert between different number types
  • Prioritization in math methods

Binary & octal & hexadecimal

  • How to create Binary & octal & hexadecimal
  • TBD


  • True/False
  • &&, ||
  • !


  • General oop
  • Initialize
  • Instance variables
  • Class variables


  • Getter
  • Property


  • What a string is and how to create them
  • Interpolation
  • Empty?
  • Size
  • Indexing
  • Convert a string to a number and the other way around

String methods

  • Escaping
  • gsub
  • TBD


  • If/elsif/else
  • Comparisons operators(==, <= etc)
  • Unless

Case (switch)

  • How to create a case
  • When to use a case


  • How to create a module
  • Difference between a class and a module
  • Extend & include

Ternary operator

  • How to create a ternary operator


  • Basics of what a char is and how to use them
  • TBD

While & Until

  • How to create a while loop
  • Next
  • Break
  • Until
  • Difference between until and while


  • Range with numbers, chars, and strings
  • Range with .. and ...
  • How to slice a String


  • Introduction to nil
  • Explain that [x]? returns the item if it exists otherwise nil.

Union types

  • Explain how to create a union type
  • Explain that assigning for example Int32? means (Int32 | Nil)
  • Explain typeof vs .class

Rasing errors

  • Explain how to raise errors
  • Explain errors in crystal


  • How to create an array
  • Declaring an empty array
  • Declaring a nested array
  • Indexing and slicing arrays
  • Join and split
  • Explain that arrays are mutable
  • Explain append(<<)
  • Delete/pop

Array methods

  • Sort
  • uniq
  • shift
  • fil
  • concat
  • Compact
  • First
  • Last
  • Flatten
  • Reverse
  • Rotate
  • Shuffle
  • Index
  • TBD


This category is a little bit TBD.
It is suppose to give you enough knowledge for a student to be able to use methods like each. But perhaps not know how to use yield. So the block part may be taken away for a later concept so we only cover proc.


  • each
  • all?
  • any?
  • count
  • each_with_index
  • find
  • none?
  • map
  • map_with_index
  • one?
  • products
  • reduce
  • sum
  • Sort_by

More enumeration

Comment: Some of this will there not be any deep dive on, just a mention

  • chunks
  • cycles
  • each cons
  • each cons pair
  • each slice
  • group_by
  • in_groups_of
  • max_by
  • max_of
  • min_by
  • min_of
  • reject
  • Select
  • skip_while
  • skip
  • take_while


  • What a symbol is
  • Comparison between symbols and strings
  • Convert a symbol to a string


  • How to create a tuple
  • Difference between array and tuple
  • When to use a tuple and when to use an array
  • Explain that tuples are immutable


  • Explain how to create a hash
  • Explain how to create a hash with symbols
  • Explain how to create an empty hash
  • Explain hash methods TBD

Named tuple

  • How to create a named tuple and the difference between a hash.

Decompositon & multiple assignment

  • How to do multiple assignments
  • How to use the splat operator

All feedback is welcome.

Great work, that looks pretty well constructed.

I have no idea how Crystal works and which paradigms it is based on. I guess functional and object-oriented, from the syllabus. As I am doing the same thing with the C++ track, there are many good things here that I am going to build on. Thank you, for the inspiration!

1 Like

Looks great. Thanks for sharing!

One comment really and that’s that the scope of each exercise needs to be pretty small, which it turn means that means that for OOP things like instance mhhtods, class methods, initializer etc probably need to be 3 separate exercises. For the arrays section - that’s again likely a few exercises etc.

You can see a lot of this fine-grained nature in the different stories at Exercise stories | Exercism's Docs

Often it’s enough to teach the concept of something in the Concept exercise (e.g. arrays have methods - try this one or two) and then let the student discover a wider selection of methods themselves in the practice exercises.

I’d also say the tracks that have suceeded in building out syllabuses the best tend to have chosen a few core concepts to start with and then built from there rather than doing too much up front planning. Many have discovered that Mike Tyson’s famous quote (“Everyone has a plan until they get punched in the mouth”) can often apply to building out the exercises! :slight_smile:

Hmm, yeah I mean I will see, at the same time it is hard to do initializer without instance mehtods. As with everything, how I work is that I look how other people have done it. And Crystal and Ruby is quite alike so I can look at that track for what I like and what I dont.

At the same time I rellay also on coming to a concept and seeing whats fits and doesnt. I can reveal that the developemnt (writting) of the crystal syllabus has been in active development for a week. But I can still take feedback for later parts.

It seems that the collection datatypes are not early enough. Wouldn’t you want arrays and hashes just after strings?

It is a hard question, there is a lot of data types and which to put first is a hard decision. I can tell you in an earlier version array was actually placed further down in the tree, but I decided to move it up. But to make an exercise for arrays, it could be good to know basic loops and I personally think that knowing union types before arrays are really helpful.

I am up for suggestions on moving concepts, but I have a pretty hard lock on that symbols have to come before hashes, but other than that feel free to suggest more specific changes.

Most concepts of the tree are data types, strings, numbers, char, range, nil, arrays, tuples, hashes, symbols, named tuples, and block. All of these are just data types and union types are another concept that is important to be able to utilize types to the fullest.

I have for a while thinking about how to approach numbers, should I do a single big concept? splitting floats and int? I have come to the conclusion that it may be best to separate it in such a way to first introduce numbers as a quite “dynamic” thing. Not talking too much about the type more or less saying that there are int and floats and here are methods to work with.

Then adding a concept right after named number types, which explains all forms of int, a short introduction to the uint and all types of floats. And explaining why there are multiple types and how to work with them. Then when I get the time or feel like it there will be another concept branching of the tree that explains Bignumber types (bigint, bigfloat etc).

How do you folks feel about such an approach?

My advice is to first figure out the exercise early when planning a concept. What classes and methods will be highlighted by a “generic numbers” concept?

I am a bit unsure of the number types concept, but for the generic number concept I am thinking temperature exercises, where you are supposed to among other thinks convert celsius to kelvin and farenhiet