[v3] Roadmap to Launch

This issue is to track the [Dart v3][root] roadmap. If you intend to _help_ with this track, please read this entire document, and find the section about **"How can you help"**.

@exercism/dart Please update and revise this as I pulled much of it from a template.

---

I have been working on the Dart v3 track by compiling a list of Dart specific concepts, transition documents from various languages and starting writing exercises. The [concepts][readme] can be found [here][readme].

## Folder structure

Specifics for Dart concepts can be found in the [`/info`][info] folder. There are other special folders such as [`/keywords`][keywords], which take the keyword, and explain what they do, as they are language-specific (mostly), and the [`/types`][types] folder in many other languages: it lists the global objects available.

## Concept exercises

The concept exercises in the Dart track are a work-in-progress and can be found in [`/concept-exercises`][concept-exercises]. Important _types_ of concepts to target are things that only exist in object-oriented programming (for people coming from non-oop languages), functions as a first class citizen (for people coming from non-functional languages), and Dart specifics.

It is important to understand we _never_ explain a specific type or syntax as a concept, but teach the more "abstract" concept around it, using the type(s) or syntax(is).

A list of exercises that we _must_ have is compiled below, and is not at all a complete list:

- [ ] [`/numbers`][concept-numbers]: `"basic-numbers"`, `"type-conversion"`
- [ ] [`/strings`][concept-strings]: `"basic-strings"`
- [ ] [`/futures`][concept-futures]: `"futures"`
- [ ] `"basic-iterables"`
- [ ] `"basic-errors"`
- [ ] `"recursion"`

**⚠ Note ⚠**: The idea here is to use a `concept` name for the folder, but perhaps use some sort of "progression", so they will naturally become a sort of path to traverse. In this example, the `numbers` exercise only teaches basic number usage, and doesn't look into more advanced subjects. I would expect to see

- `numbers-advanced` for mathy usage that is non-basic,
- `numbers-irrational` showing how to do irrational / complex / whatever numbers,
- `numbers-precision` which would explore binary representation and floating points,
- `numbers-arbitrary-precision` which would explore `bigints` and/or how to do that with decimals.

It's only important that it's reasonably easy to _find_ the exercise. It's okay if the name isn't perfect. We **will** iterate on this.

## Concept interpretation

Here is how I've interpreted the following concept-keywords. This should be synced across tracks.

| concept | interpretation |
|----------|----------------|
| `basic-numbers` | Know of the existence of the `number` type and (for this language) see that it's whole numbers, and floating points. Know of basic operators such as multiplication. Know where it's documented, or at least how to search for it. |
| `basic-strings` | Know of the existence of the `string` type. Know of some basic functions (like looking up a character at a position, or slicing the string). Know where it's documented, or at least how to search for it. |
| `futures` | Know of the `future` construct (`promise` or `observable` type in some other languages), chain-ability, and `.then`. Know where it's documented/how to search. |
| `basic-iterables` | Know of the `Iterable` construct (`array` type in some other languages). Know of some basic functions. |
| `basic-errors` | Know how to create an error, how throw it and how to catch it |
| `callbacks` | Know how to use a function as a first-class citizen, that is, pass it into a function as a value, and call it somewhere inside that function. Know that you can pass in values and retrieve out return values. |
| `recursion` | Know how to call a function from itself |
| `type-conversion` | Know that there exist functions that can convert between "objects" (instances of classes) and types (primitives). |

This also indicates that for example `basic-strings` does **not** include knowing that Dart strings aren't strings in the compsci sense as in, they are made up of UTF-16 codepoints, and therefore there are a lot of catches with this.

## How can you help?

### This track

- [x] Create a dart folder in the v3 repo.
- [ ] Files in the [`/info`][info], [`/keywords`][keywords] and [`/types`][types] folders. They need to be written. You can use the examples from other tracks to see what we're looking for.

### Globally

There are concepts missing.

### Exercises

We need two types of exercises. The concept ones, as explained above -- you can chose to pick one from the list above or suggest, in this issue, one that's not listed. The other ones are the practice ones, which are like the v2 exercises.

### Analyzers

TBD

[root]: https://github.com/exercism/v3/tree/master/languages/dart
[readme]: https://github.com/exercism/v3/tree/master/languages/dart
[info]: https://github.com/exercism/v3/tree/master/languages/dart/info
[keywords]: https://github.com/exercism/v3/tree/master/languages/dart/keywords
[types]: https://github.com/exercism/v3/tree/master/languages/dart/types
[concept-exercises]: https://github.com/exercism/v3/tree/master/languages/dart/concept-exercises
[concept-numbers]: https://github.com/exercism/v3/tree/master/languages/dart/concept-exercises/numbers
[concept-strings]: https://github.com/exercism/v3/tree/master/languages/dart/concept-exercises/strings
[concept-futures]: https://github.com/exercism/v3/tree/master/languages/dart/concept-exercises/futures