Seems we're missing an element of cache busting.

There are a number of things we're going to want to check before the v2 site goes live. There are notes below that flesh out all the checklist items.

• The track has a page on the v2 site: https://v2.exercism.io/tracks/purescript
• The track page has a short description under the name (not starting with TODO)
• The "About" section is a friendly, colloquial, compelling introduction
• The "About" section follows the formatting guidelines
• The code example gives a good taste of the language and fits within the boundaries of the background image
• There are exercises marked as core
• Exercises have rough estimates of difficulty
• Exercises have topics associated with them
• The first exercise is auto_approve: true

Track landing page

The v2 site has a landing page for each track, which should make people want to join it. If the track page is missing, ping @kytrinyx to get it added.

Blurb

If the header of the page starts with TODO, then submit a pull request to https://github.com/exercism/purescript/blob/master/config.json with a blurb key. Remember to get configlet and run configlet fmt . from the root of the track before submitting.

About section

If the "About" section feels a bit dry, then submit a pull request to https://github.com/exercism/purescript/blob/master/docs/ABOUT.md with suggested tweaks.

Formatting guidelines

In order to work well with the design of the new site, we're restricting the formatting of the ABOUT.md. It can use:

• Bold
• Italics
• Links
• Bullet lists
• Number lists

Additionally:

• Each sentence should be on its own line
• Paragraphs should be separated by an empty line
• Explicit <br/> can be used to split a paragraph into lines without spacing between them, however this is discouraged.

Code example

If the code example is too short or too wide or too long or too uninteresting, submit a pull request to https://github.com/exercism/ocaml/blob/master/docs/SNIPPET.txt with a suggested replacement.

Exercise metadata

Where the v1 site has a long, linear list of exercises, the v2 site has organized exercises into a small set of required exercises ("core").

If you update the track config, remember to get configlet and run configlet fmt . from the root of the track before submitting.

Topic and difficulty

Core exercises unlock optional additional exercises, which can be filtered by topic an difficulty, however that will only work if we add topics and difficulties to the exercises in the track config, which is in https://github.com/exercism/purescript/blob/master/config.json

Auto-approval

We've currently made any hello-world exercises auto-approved in the backend of v2. This means that you don't need mentor approval in order to move forward when you've completed that exercise.

Not all tracks have a hello-world, and some tracks might want to auto approve other (or additional) exercises.

Track mentors

There are no bullet points for this one :)

As we move towards the launch of the new version of Exercism we are going to be ramping up on actively recruiting people to help provide feedback. Our goal is to get to 100%: everyone who submits a solution and wants feedback should get feedback. Good feedback.

If you're interested in helping mentor the track, check out http://mentoring.exercism.io/

When all of the boxes are ticked off, please close the issue.

Tracking progress in exercism/meta#104

Extract the list of concepts required to solve the v2 purescript exercise: collatz-conjecture. For each concept, describe why it is required to solve the exercise. Keep in mind that an exercise can have multiple approaches (you can find community solutions here: https://exercism.io/tracks/purescript/exercises/collatz-conjecture/solutions). The goal of this task is to help determine the total list of concepts that make up collatz-conjecture.

The list of concepts should be stored in the following document: languages/purescript/reference/exercise-concepts/collatz-conjecture.md. Use this link to create a PR to add this document.

Running bin/configlet lint . results in errors for all of the UUIDs such as this:

-> The following UUID was found in multiple Exercism tracks. Each exercise UUID must be unique across tracks.
83b533f1-a712-4d6a-bc97-505c6e7c9161

Not sure how accurate it is, I searched GitHub and only this repository came up as a hit. I've also noticed that the UUIDs I've been generating using bin/configlet uuid are longer than the ones that were already in config.json

Relates to #92

Where the v1 site has a long, linear list of exercises, the v2 site has organized exercises into a small set of required exercises ("core").

If you update the track config, remember to get configlet and run configlet fmt . from the root of the track before submitting.

This morning I was like "I know, we've had all sorts of new languages on Exercism in the past few months. Let's talk about that".

And I completely missed PureScript in the list!

I'm so sorry, and I am going to make it the star of next week's newsletter 🌷

If, in the meantime, you want to write a 2-sentence blurb to entice people to try the language, or if you have any particular things you want me to highlight about contributions you need, then please let me know.

Extract the list of concepts required to solve the v2 purescript exercise: raindrops. For each concept, describe why it is required to solve the exercise. Keep in mind that an exercise can have multiple approaches (you can find community solutions here: https://exercism.io/tracks/purescript/exercises/raindrops/solutions). The goal of this task is to help determine the total list of concepts that make up raindrops.

The list of concepts should be stored in the following document: languages/purescript/reference/exercise-concepts/raindrops.md. Use this link to create a PR to add this document.

Extract the list of concepts required to solve the v2 PureScript exercise: pangram. For each concept, describe why it is required to solve the exercise. Keep in mind that an exercise can have multiple approaches (you can find community solutions here: https://exercism.io/tracks/purescript/exercises/pangram/solutions). The goal of this task is to help determine the total list of concepts that make up pangram.

The list of concepts should be stored in the following document: languages/purescript/reference/exercise-concepts/pangram.md. Use this link to create a PR to add this document.

Launch Checklist

Step 0: Prep the Repo (@kytrinyx)

• Create the repository
• Create starter issues
• Turn on Travis CI for the track

Step 1: Implement Exercises

• Implement at least 10 problems

See the contributing guide for the details about the format of an exercise.

The short version is:

• a test suite
• an example solution, named with example (case-insensitive) in the filename
• a section in the "exercises" key of the config.json file with the slug, topics, and difficulty level.

The topics can be an empty list, and the difficulty level is from 1 to 10, and can default to 1 until we know more about the exercises.

"exercises": [
  {
    "slug": "hello-world" ,
    "difficulty": 1,
    "topics": []
  }
]

Step 2: Add the Track to Exercism (@kytrinyx)

• Add PureScript as a submodule in trackler
• Update x-api and deploy

This means that it will show up on http://exercism.io/languages and http://exercism.io/languages/purescript

Step 3: Make the Track Ready for Launch

• Define test_pattern in config.json
• Add a language icon or logo + attribution
• Write documentation
• Find track mentors
• Add track mentors on the site (@kytrinyx)

test_pattern

The exercism.io website links to the exercise implementations, so it needs to know how to recognize the filename(s) for the test suite.

The "test_pattern" value in the config.json file should be a string that can be compiled as a regular expression, and which will match on the file or files that comprise the test suite of an exercise.

If the test filenames contain the word "test" (case insensitive) then the "test_pattern" key can be deleted.

Language Icon and Attribution

We try to create a language icon that has the exercism colors, and is recognizably similar to the language icon. Sometimes this isn't possible due to copyright issues.

The Exercism colors are:

• #D81D4E (pink)
• #212121 (charcoal)

The icon is used throughout the site in order to identify the language track, and to identify code that has been submitted to that track.

See http://exercism.io/languages for all the existing icons.

Icon

If image assets are not your strong suit, just find a reasonable image to start from, along with the information about the licensing, and we'll figure out the colorization thing (I've written some scripts to help me do this part).

The logo should be named icon.png and live under img/ in this repository. If you know how, go ahead and make an SVG as well.

Attribution

The attribution goes in the README.md file.

If the icon we have based this on is not in the public domain, we need to provide information about license and provenance. If we require permission to use and/or change the icon, then we need to obtain that permission before we can use it.

Documentation

The documentation is used in the http://exercism.io/languages/purescript section to help people get started with the track.

The files live in the docs/ directory here in this repository, and gets served to the site via the x-api. It should contain at minimum:

• INSTALLATION.md - about how to get the language set up locally.
• TESTS.md - about how to run the tests for the exercises.

Some nice to haves:

• ABOUT.md - a short, friendly blurb about the language. What types of problems does it solve really well? What is it typically used for?
• LEARNING.md - a few notes about where people might want to go to learn the language from scratch.
• RESOURCES.md - references and other useful resources.

Find Track Mentors

Usually in order to see someone's solution you have to have submitted the exercise yourself. Track mentors can access all of the solutions in a given language. Track mentors can therefore help review solutions that people submit on the website in the beginning when few people have submitted solutions to exercises.

Ideally we should have a handful of people who are willing to check Exercism regularly to give people feedback, in order to start the track off on the right note.

The first track mentor needs to be added manually by @kytrinyx, but after that there's a section in the account where existing track mentors can invite new ones.

The most successful tracks are where each submission receives feedback quickly, preferably within the first 24 hours.

In addition, the most interesting and useful conversations start when reviewers do not direct users to do specific things, but rather ask questions challenging people to think about different aspects of their solution, or explore aspects of the language.

Referencing existing blog posts and style guides seems to work well when making specific recommendations.

Prepare for Open Source Contributions

Once the track is live and active, it will often get new contributions.

• Read the maintainer documentation
• "Watch" the xpurescript repository
• Find a second maintainer

We've got a few years of experience maintaining language tracks on Exercism. Here's what we have learned:

• Maintaining a Track
• Reviewing a Pull Request

There's more stuff in the contributing guide, as well. We're working on turning that into better, more focused maintainer documentation.

Launch!

• Toggle "active" to true in config.json
• Mention it in the next "Behind the Scenes" newsletter (@kytrinyx)

In exercism/problem-specifications#1501, bracket-push was renamed to matching-brackets in problem-specifications, therefore it is recommended that this track (which has the bracket-push exercise) also renames it.

The reasons for this recommendation:

• to name the exercise by its story, not by what it potentially teaches
• to avoid unnecessarily biasing the solution space

If this track decides to follow this recommendation, here are some things that may need a change:

• config.json (change the slug of the exercise; no need to change its uuid)
• name of the directory
• README (contains the name of the exercise)
• code

If you're not sure what needs to change, feel free to examine PRs to other tracks by looking at any PRs linked to exercism/problem-specifications#1501.

When the rename is complete, the person who did the rename should close this issue; you don't need to ask for confirmation from the person who filed this issue (the person who filed this issue might not check back regularly).

If this track instead decides that accepting this recommendation is a bad idea for the track, then this issue should be closed upon making that decision, and none of the above steps should be taken.

Extract the list of concepts required to solve the v2 PureScript exercise: leap. For each concept, describe why it is required to solve the exercise. Keep in mind that an exercise can have multiple approaches (you can find community solutions here: https://exercism.io/tracks/purescript/exercises/leap/solutions). The goal of this task is to help determine the total list of concepts that make up leap.

The list of concepts should be stored in the following document: languages/purescript/reference/exercise-concepts/leap.md. Use this link to create a PR to add this document.

Related to #113

We have not configured yet by which other exercise the side exercises get unlocked. So the student can do all side exercises immediately and has no guidance on which core exercises he should do first.

We’ve recently started a project to find the best way to design our tracks, in order to optimize the learning experience of students.

As a first step, we’ll be examining the ways in which languages are unique and the ways in which they are similar. For this, we’d really like to use the knowledge of everyone involved in the Exercism community (students, mentors, maintainers) to answer the following questions:

1. How was your experience learning PureScript? What was helpful while learning PureScript? What did you struggle with? How did you tackle problems?
2. In what ways did PureScript differ from other languages you knew at the time? What was hard to learn? What did you have to unlearn? What syntax did you have to remap? What concepts carried over nicely?

Could you spare 5 minutes to help us by answering these questions? It would greatly help us improve the experience students have learning PureScript :)

Note: this issue is not meant as a discussion, just as a place for people to post their own, personal experiences.

Want to keep your thoughts private but still help? Feel free to email me at [email protected]

Thank you!

We're about to start a big push towards version 3 (v3) of Exercism. This is going to be a really exciting step forward for Exercism, with in-browser coding, new Concept Exercises with automated feedback, improved mentoring and much more.

This to be a big community effort, with the work spread out among hundreds of volunteers across Exercism. One key thing is going to be each track having enough maintainers who have the time to manage that community effort. We are therefore putting out a call for new maintainers to bolster our numbers. We're hoping that our existing maintainers will be able to act as mentors to the newer maintainers we add, and take on a parental role in the tracks.

If you are an existing maintainer, could you please reply to this letting us know that you think you'll have time (2-3hrs/week) to help with this over the next 6 months. If you won't have that time, but still want to be a maintainer and just help where you can instead, please tell us that too. If you have come to the end of the road as a maintainer, then we totally understand that and appreciate all your effort, so just let us know.

For anyone new who's interested in becoming a maintainer, thanks for your interest! Being an Exercism maintainer is also a great opportunity to work with some other smart people, learn more about your language of choice, and gain useful skills and experience that are useful for growing your career in the technical leadership direction. Please write a comment below introducing yourself along with your Exercism handle, and telling us why you're interested in becoming a maintainer, and any relevant experience. We will then evaluate every application and contact you using your exercism email address once we have finished the evaluation process.

Thank you!

See also exercism/exercism#5161

Extract the list of concepts required to solve the v2 purescript exercise: triangle. For each concept, describe why it is required to solve the exercise. Keep in mind that an exercise can have multiple approaches (you can find community solutions here: https://exercism.io/tracks/purescript/exercises/triangle/solutions). The goal of this task is to help determine the total list of concepts that make up triangle.

The list of concepts should be stored in the following document: languages/purescript/reference/exercise-concepts/triangle.md. Use this link to create a PR to add this document.

Extract the list of concepts required to solve the v2 purescript exercise: rna-transcription. For each concept, describe why it is required to solve the exercise. Keep in mind that an exercise can have multiple approaches (you can find community solutions here: https://exercism.io/tracks/purescript/exercises/rna-transcription/solutions). The goal of this task is to help determine the total list of concepts that make up rna-transcription.

The list of concepts should be stored in the following document: languages/purescript/reference/exercise-concepts/rna-transcription.md. Use this link to create a PR to add this document.

As we move towards the launch of the new version of Exercism we are going to be ramping up on actively recruiting people to help provide feedback.

Our goal is to get to 100%: everyone who submits a solution and wants feedback should get feedback. Good feedback. You can read more about this aspect of the new site here: http://mentoring.exercism.io/

To do this, we're going to need a lot more information about where we can find language enthusiasts.

• Is PureScript supported by one or more large organizations?
• Does PureScript have an official community manager?
• Do you know of specific communities (online or offline) that are enthusiastic about PureScript? (Chat communities, forums, meetups, student clubs, etc)
• Are there popular conferences for PureScript? (If so, what are some examples?)
• Are there any organizations who are targeted specifically at getting certain subgroups or demographics interested in PureScript? (e.g. kids, teenagers, career changers, people belonging to various groups that are typically underrepresented in tech?)
• Are there specific groups or programs dedicated to mentoring people in PureScript?
• Are there popular newsletters for PureScript?
• Is PureScript taught at programming bootcamps? (If so, what are some examples?)
• Is PureScript taught at universities? (If so, what are some examples?)

In other words: where do people care a lot and/or know a lot about PureScript?

This is part of the project being tracked in exercism/meta#103

Downloading them all like this makes the the tests quite slow. Perhaps we could use a cache through some bower-fu.

This relates to #92

Formatting guidelines

In order to work well with the design of the new site, we're restricting the formatting of the ABOUT.md. It can use:

• Bold
• Italics
• Links
• Bullet lists
• Number lists

Additionally:

• Each sentence should be on its own line
• Paragraphs should be separated by an empty line
• Explicit <br/> can be used to split a paragraph into lines without spacing between them, however this is discouraged.

The sentences in our ABOUT.md are not on their own lines. We should add line breaks between sentences. I guess the reason for this is to better track changes in the text.

TL;DR: the problem specification for the Bob exercise has been updated. Consider updating the test suite for Bob to match. If you decide not to update the exercise, consider overriding description.md.

Details

The problem description for the Bob exercise lists four conditions:

• asking a question
• shouting
• remaining silent
• anything else

There's an ambiguity, however, for shouted questions: should they receive the "asking" response or the "shouting" response?

In exercism/problem-specifications#1025 this ambiguity was resolved by adding an additional rule for shouted questions.

If this track uses exercise generators to update test suites based on the canonical-data.json file from problem-specifications, then now would be a good time to regenerate 'bob'. If not, then it will require a manual update to the test case with input "WHAT THE HELL WERE YOU THINKING?".

See the most recent canonical-data.json file for the exact changes.

Remember to regenerate the exercise README after updating the test suite:

configlet generate . --only=bob --spec-path=<path to your local copy of the problem-specifications repository>

You can download the most recent configlet at https://github.com/exercism/configlet/releases/latest if you don't have it.

If, as track maintainers, you decide that you don't want to change the exercise, then please consider copying problem-specifications/exercises/bob/description.md into this track, putting it in exercises/bob/.meta/description.md and updating the description to match the current implementation. This will let us run the configlet README generation without having to worry about the bob README drifting from the implementation.

• Is there a style guide the language itself?
• Are these styles encouraged or enforced?
• Are there any conventions that we should adopt on this language track for the sake of consistency?
• Can we enforce these?
• Is there a linter? Are there many? Should we use one?
• Is there a common convention for filenames? If not, what should our convention be?

Note that this is about the exercises (the test suites and code examples), not people's solutions.

Extract the list of concepts required to solve the v2 purescript exercise: difference-of-squares. For each concept, describe why it is required to solve the exercise. Keep in mind that an exercise can have multiple approaches (you can find community solutions here: https://exercism.io/tracks/purescript/exercises/difference-of-squares/solutions). The goal of this task is to help determine the total list of concepts that make up difference-of-squares.

The list of concepts should be stored in the following document: languages/purescript/reference/exercise-concepts/difference-of-squares.md. Use this link to create a PR to add this document.

Some exercise README templates contain links to pages which no longer exist in v2 Exercism.

For example, C++'s README template had a link to /languages/cpp for instructions on running tests. The correct URLs to use can be found in the 'Still stuck?' sidebar of exercise pages on the live site. You'll need to join the track and go to the first exercise to see them.

Please update any broken links in the 'config/exercise_readme.go.tmpl' file, and run 'configlet generate .' to generate new exercise READMEs with the fixes.

Instructions for generating READMEs with configlet can be found at:
https://github.com/exercism/docs/blob/master/language-tracks/exercises/anatomy/readmes.md#generating-a-readme

Instructions for installing configlet can be found at:
https://github.com/exercism/docs/blob/bc29a1884da6c401de6f3f211d03aabe53894318/language-tracks/launch/first-exercise.md#the-configlet-tool

Tracking exercism/exercism#4102

The track page is showing the "TODO" text underneath the track title because no introduction has been added.

I'll add the Hamming exercise as a PR.

Extract the list of concepts required to solve the v2 purescript exercise: accumulate. For each concept, describe why it is required to solve the exercise. Keep in mind that an exercise can have multiple approaches (you can find community solutions here: https://exercism.io/tracks/purescript/exercises/accumulate/solutions). The goal of this task is to help determine the total list of concepts that make up accumulate.

The list of concepts should be stored in the following document: languages/purescript/reference/exercise-concepts/accumulate.md. Use this link to create a PR to add this document.

Per the discussion in exercism/discussions#128 we
will be installing the probot/stale integration on the Exercism organization on
April 10th, 2017.

By default, probot will comment on issues that are older than 60 days, warning
that they are stale. If there is no movement in 7 days, the bot will close the issue.
By default, anything with the labels security or pinned will not be closed by
probot.

If you wish to override these settings, create a .github/stale.yml file as described
in https://github.com/probot/stale#usage, and make sure that it is merged
before April 10th.

If the defaults are fine for this repository, then there is nothing further to do.
You may close this issue.

Some tracks have added assertions to the exercise test suites that ensure that the solution has a hard-coded version in it.
In the old version of the site, this was useful, as it let commenters see what version of the test suite the code had been written against, and they wouldn't accidentally tell people that their code was wrong, when really the world had just moved on since it was submitted.

If this track does not have any assertions that track versions in the exercise tests, please close this issue.

If this track does have this bookkeeping code, then please remove it from all the exercises.

See exercism/exercism#4266 for the full explanation of this change.

We updated dependencies for the track in #107 – we should also reflect that in our CI build by using PureScript 0.13.*

Extract the list of concepts required to solve the v2 purescript exercise: bob. For each concept, describe why it is required to solve the exercise. Keep in mind that an exercise can have multiple approaches (you can find community solutions here: https://exercism.io/tracks/purescript/exercises/bob/solutions). The goal of this task is to help determine the total list of concepts that make up bob.

The list of concepts should be stored in the following document: languages/purescript/reference/exercise-concepts/bob.md. Use this link to create a PR to add this document.

npm wont let me install bower

I am on Arch Linux with npm version: 6.12.0
It says that bower is deprecated.

Is there any way around this?
I tried to learn elm, but it is too painful coming from Haskell, so I really want to try purescript

Travis builds are failing due to build timeouts:

https://travis-ci.org/exercism/xpurescript/builds/209606731.

The message is:

The job exceeded the maximum time limit for jobs, and has been terminated.

The above build took ~50m.

Chatted on gitter:

https://gitter.im/exercism/support?at=58c22a41872fc8ce62e00614

The recommendation is to start caching builds to shorten the build time, since pulp is recompiling everything every time.

This track has not yet specified the file format mapping
for syntax highlighting in exercism/meta#90

Please provide a mapping of file formats used by your track
in exercism/meta#90 (e.g. md = markdown)

This issue can be closed after this is completed. (Apologies
if you've already done this - this issue was generated
automatically).

Extract the list of concepts required to solve the v2 purescript exercise: hamming. For each concept, describe why it is required to solve the exercise. Keep in mind that an exercise can have multiple approaches (you can find community solutions here: https://exercism.io/tracks/purescript/exercises/hamming/solutions). The goal of this task is to help determine the total list of concepts that make up hamming.

The list of concepts should be stored in the following document: languages/purescript/reference/exercise-concepts/hamming.md. Use this link to create a PR to add this document.

Related to #92

If the code example is too short or too wide or too long or too uninteresting, submit a pull request to https://github.com/exercism/ocaml/blob/master/docs/SNIPPET.txt with a suggested replacement.

@jackhughesweb:

The code example is too long for the box (see https://v2.exercism.io/tracks/purescript) - lines should be less than 42 characters

Extract the list of concepts required to solve the v2 purescript exercise: all-your-base. For each concept, describe why it is required to solve the exercise. Keep in mind that an exercise can have multiple approaches (you can find community solutions here: https://exercism.io/tracks/purescript/exercises/all-your-base/solutions). The goal of this task is to help determine the total list of concepts that make up all-your-base.

The list of concepts should be stored in the following document: languages/purescript/reference/exercise-concepts/all-your-base.md. Use this link to create a PR to add this document.

Extract the list of concepts required to solve the v2 purescript exercise: sum-of-multiples. For each concept, describe why it is required to solve the exercise. Keep in mind that an exercise can have multiple approaches (you can find community solutions here: https://exercism.io/tracks/purescript/exercises/sum-of-multiples/solutions). The goal of this task is to help determine the total list of concepts that make up sum-of-multiples.

The list of concepts should be stored in the following document: languages/purescript/reference/exercise-concepts/sum-of-multiples.md. Use this link to create a PR to add this document.

Error found:
in module Type.Row
at bower_components/purescript-typelevel-prelude/src/Type/Row.purs:4:5 - 4:24 (line 4, column 5 - line 4, column 24)

  Export for type Prim.RowList.Cons conflicts with type class Prim.Row.Cons


See https://github.com/purescript/documentation/blob/master/errors/ExportConflict.md for more information,
or to contribute content related to this error.


* ERROR: Subcommand terminated with exit code 1

This gets fixed with an update of purescript-prelude to version 4.1.1.

See also:

• purescript/purescript#3502
• purescript/purescript-typelevel-prelude#43

We have decided to require all file-based tracks to provide stubs for their exercises.

The lack of stub file generates an unnecessary pain point within Exercism, contributing a significant proportion of support requests, making things more complex for our students, and hindering our ability to automatically run test-suites and provide automated analysis of solutions.

We believe that it’s essential to understand error messages, know how to use an IDE, and create files. However, getting this right as you’re just getting used to a language can be a frustrating distraction, as it can often require a lot of knowledge that tends to seep in over time. At the start, it can be challenging to google for all of these details: what file extension to use, what needs to be included, etc. Getting people up to speed with these things are not Exercism’s focus, and we’ve decided that we are better served by removing this source of confusion, letting people get on with actually solving the exercises.

The original discussion for this is at exercism/discussions#238.

Therefore, we’d like this track to provide a stub file for each exercise.

• If this track already provides stub files for all exercises, please close this issue.
• If this track already has an open issue for creating stubs, then my apologies. Please close one as a duplicate.
• Otherwise, please respond to this issue with useful details about what needs to be done to complete this task in this track so that people who are not familiar with the track may easily contribute.

Each language track has documentation in the docs/ directory, which gets included on the site
on each track-specific set of pages under /languages.

We've added some general guidelines about how we'd like the track to be documented in exercism/exercism#3315
which can be found at https://github.com/exercism/exercism.io/blob/master/docs/writing-track-documentation.md

Please take a moment to look through the documentation about documentation, and make sure that
the track is following these guidelines. Pay particularly close attention to how to use images
in the markdown files.

Lastly, if you find that the guidelines are confusing or missing important details, then a pull request
would be greatly appreciated.

Implement a test suite that can run both locally and on Travis CI, that verifies that the example code passes the test suite for each exercise..

Things to consider:

If some tests are marked as skipped or pending in some way, then CI should remove these annotations so that all the tests run against the example, not just the first test.

If we need to rewrite the files in any way, we should copy the exercise to a tmp directory first, so that we don't accidentally end up committing changes that are just for continuous integration or testing purposes.

We should make it possible to test just one exercise at a time, because testing everything can take a while.

This is created out of #92

We probably might improve in that, so I feel I shouldn't close that checkpoint in the parent issue. But I'm no good writer.

Suggestions for improvements in the text highly appreciated!

I was confused about what exactly to put as my bower.json in my exercise directory. The README mentions the master bower.json file but I wasn't sure if I was to just copy it into my directory or if I should tailor my dependencies specifically for the exercise. One particular problem is that the version of readlink on macOS doesn't have a -f flag and the check-bower.sh and update-bower.sh scripts fail to run.

One thing that might be worth adding is writing out a full step-by-step for creating a new exercise by first showing a file system tree ASCII diagram of what an exercise looks like and some general instructions (not specific terminal commands if possible) for creating that structure. Something like

1. Create the directory for the exercise in exercises with the name of the exercise
2. Create directories examples src test in your exercise directory
3. Use bin/fetch-configlet && bin/configlet generate . --only exercise-name to generate the README.md
4. Use bin/update-bower.sh to generate the bower.json
5. Use bin/configlet uuid to generate a new UUID for the exercise
6. Add details to config.json
   etc.

Extract the list of concepts required to solve the v2 purescript exercise: scrabble-score. For each concept, describe why it is required to solve the exercise. Keep in mind that an exercise can have multiple approaches (you can find community solutions here: https://exercism.io/tracks/purescript/exercises/scrabble-score/solutions). The goal of this task is to help determine the total list of concepts that make up scrabble-score.

The list of concepts should be stored in the following document: languages/purescript/reference/exercise-concepts/scrabble-score.md. Use this link to create a PR to add this document.

Related to #92

Topic and difficulty

Core exercises unlock optional additional exercises, which can be filtered by topic an difficulty, however that will only work if we add topics and difficulties to the exercises in the track config, which is in https://github.com/exercism/purescript/blob/master/config.json

For the past three years, the ordering of exercises has been done based on gut feelings and wild guesses. As a result, the progression of the exercises has been somewhat haphazard.

In the past few months maintainers of several tracks have invested a great deal of time in analyzing what concepts various exercises require, and then reordering the tracks as a result of that analysis.

It would be useful to bake this data into the track configuration so that we can adjust it over time as we learn more about each exercise.

To this end, we've decided to add a new key exercises in the config.json file, and deprecate the problems key.

See exercism/discussions#60 for details about this decision.

Note that we will not be removing the problems key at this time, as this would break the website and a number of tools.

The process for deprecating the old problems array will be:

• Update all of the track configs to contain the new exercises key, with whatever data we have.
• Simultaneously change the website and tools to support both formats.
• Once all of the tracks have added the exercises key, remove support for the old key in the site and tools.
• Remove the old key from all of the track configs.

In the new format, each exercise is a JSON object with three properties:

• slug: the identifier of the exercise
• difficulty: a number from 1 to 10 where 1 is the easiest and 10 is the most difficult
• topics: an array of strings describing topics relevant to the exercise. We maintain
  a list of common topics at https://github.com/exercism/x-common/blob/master/TOPICS.txt. Do not feel like you need to restrict yourself to this list;
  it's only there so that we don't end up with 20 variations on the same topic. Each
  language is different, and there will likely be topics specific to each language that will
  not make it onto the list.

The difficulty rating can be a very rough estimate.

The topics array can be empty if this analysis has not yet been done.

Example:

"exercises": [
  {
    "slug": "hello-world" ,
    "difficulty": 1,
    "topics": [
        "control-flow (if-statements)",
        "optional values",
        "text formatting"
    ]
  },
  {
    "difficulty": 3,
    "slug": "anagram",
    "topics": [
        "strings",
        "filtering"
    ]
  },
  {
    "difficulty": 10,
    "slug": "forth",
    "topics": [
        "parsing",
        "transforming",
        "stacks"
    ]
  }
]

It may be worth making the change in several passes:

1. Add the exercises key with the array of objects, where difficulty is 1 and topics is empty.
2. Update the difficulty settings to reflect a more accurate guess.
3. Add topics (perhaps one-by-one, in separate pull requests, in order to have useful discussions about each exercise).

I've used Sarah Sharp's FOSS Heartbeat project to generate stats for each of the language track repositories, as well as the x-common repository.

The Exercism heartbeat data is published here: https://exercism.github.io/heartbeat/

When looking at the data, please disregard any activity from me (kytrinyx), as I would like to get the language tracks to a point where they are entirely maintained by the community.

Please take a look at the heartbeat data for this track, and answer the following questions:

• To what degree is the track maintained?
• Who (if anyone) is merging pull requests?
• Who (if anyone) is reviewing pull requests?
• Is there someone who is not merging pull requests, but who comments on issues and pull requests, has thoughtful feedback, and is generally helpful? If so, maybe we can invite them to be a maintainer on the track.

I've made up the following scale:

• ORPHANED - Nobody (other than me) has merged anything in the past year.
• ENDANGERED - Somewhere between ORPHANED and AT RISK.
• AT RISK - Two people (other than me) are actively discussing issues and reviewing and merging pull requests.
• MAINTAINED - Three or more people (other than me) are actively discussing issues and reviewing and merging pull requests.

It would also be useful to know if there a lot of activity on the track, or just the occasional issue or comment.

Please report the current status of the track, including your best guess on the above scale, back to the top-level issue in the discussions repository: exercism/discussions#97

The instructions are misleading in claiming that "Input will not contain non-ASCII symbols"!

https://exercism.io/mentor/solutions/79d17dc77b484554b18fb1c6c5c5f015

The readme says The alphabet used is ASCII, and case insensitive, from 'a' to 'z' inclusively.
but there is a test

    test "pangram with non ascii characters" do
      Assert.equal true $
        isPangram "Victor jagt zwölf Boxkämpfer quer über den großen Sylter Deich."

If I understand the task this test is invalid.