I feel a little removed from what's going on during the submission process. A boilerplate message "received, will update the site in a moment" would be nice. I ended up submitting an assignment twice because it wasn't super apparent how a new submission differed from an update.

See #4 for the discussion about this.

Add websockets?

See #20.

It would be nice to see at a glance that something hasn't been nitpicked yet.

Right now this would require either adding a counter cache or doing a pretty gross query against MongoDB.

See #7 for discussion.

Rather than go through the code ourselves, create a process where nitpickers can nominate a snippet of code as the defacto answer to a code problem. Or perhaps as just one excellent answer to the problem.

This may be outside of the MVP and it may be easier to just do it manually for now so I'm leaving #7 open as well.

Make it easy to see where you need to jump into a discussion.

I don't know if this should be only discussions on nits that you made or any nits.

For admins, maybe all discussions are interesting/important, whereas for participants it's just their own.

I don't want to encourage pile-on discussions.

Right now I'm using smtp settings from one of my own domains. The deliverability of this is going to be absolutely dismal.

See https://github.com/kytrinyx/exercism.io/blob/master/lib/services/email.rb#L44

This is how I approach learning very new things:

https://github.com/theotherzach/ruby-crash

I try to memorize exact steps and reproduce them in order to capture some micro-lessons. I think it's a different, complimentary approach to solving puzzles and I wonder if there is room for something like this in Exercism.

I think it would be good to have them ordered in reverse chronological order (most recently submitted).

... so that people can argue or ask for clarification.

http://d.pr/i/hw0v

Looks like we may just need to indent code samples by 4 spaces on each line to make the markdown parser happy.

Right now people end up waiting a bit for feedback, and they're itching to get started on the next problem.

We could expose the next assignment in the trail (exercism sneak-peak?) and they could work on it but not submit it until the previous one is completed.

Heck. We could even let them download the entire trail and just allow them to submit one at a time.

From Blair: I visited http://exercism.io/user/ruby/word-count directly and it showed a 404 page because i was not logged in.

It would be really good to have a full-on step-by-step set of exercises for regexes.

I just wanted to kick this thing off by saying:

Thank you so much to everyone who has shown interest in this project and contributed ideas and time and code so far, and showing the willingness to contribute ideas and time and code in the future.

I intend to make this open source, but I want to have some idea of where it's going first. Right now the direction is a bit like "whatever we can think of that seems useful". Everything is a collection of hacks (a lot of it is tested, but I think the design pattern / architecture we've got going here is called "Mayhem" right now). So I figure in a few months or so we'll have an idea of how this is used and how we can structure things and how we can guide the project in a useful direction.

I'm adding anyone who shows any interest as collaborators on the project. Please feel free to create branches on the main repo, experiment, don't worry about picking up issues unless you feel like it's interesting or fun or whatever. If you have an idea, go for it!

Special thanks to @burtlo who has taken my complete butt-ugly prototype and added some color and usability to it. Thank you, also, to @vosechu who helped combine a number of warmups into single coherent exercises. Thank you to @theotherzach for experimenting with notifications, and for refactoring and improving things, and to @lalalainexd for exposing data to make the command-line client more usable. @theotherzach and @JoshCheek have been generous with their time and paired with me on it. @seeflanigan, @rubysolo, @vosechu, @JoshCheek and @burtlo have contributed warmup exercises, both originals and translations into other languages (clojure, javascript, elixir).

I've been having a ton of fun, I'm so excited that other people are excited about this, and I just wanted to say thanks and welcome.

Some users don't expose their email address in their github profile, and we end up with the gravatar for "".

Github kindly exposes the gravatar url for each user (avatar_url) in the data that comes in. We can use that instead.

maybe something like 'submitted 2 days ago' or '5 minutes ago' or 'just now'

Right now the nitpicks and their comments get all smooshed together.

I'm unsure of how best to decide the order for the assignments. With the current group of gSchool students, we've been making up warmups as we go, and sometimes we give them something that turns out to be difficult, which we then later break down into multiple assignments.

Any ideas on how to get feedback on the order that we have, or how to best determine what order assignments should be in?

We have a handful of javascript assignments, but it's a bit of a hodge-podge. It would be helpful to know which order we want to have them in (see #5) so that we can prioritise.

This is one task that I definitely need help with. I think Franklin and Cory around here are open to helping out with that. Would any of your advanced students be interested in this sort of thing, @vosechu?

This will make it easier to refer to specific lines in the feedback.

Go has their gopher, but I'm not sure what's appropriate for the others.

I have run into a few cases where I am approving a submission, and want to comment on some choices they've made.

Let's make it so that the comment box in the nitpick page has two buttons:

1. comment & approve
2. nitpick

I noticed this earlier in the day. No issues locally with the test users on my local system.

Internal Server Error

The exercism gem uses a custom user-agent header, exercism-CLI-v0.0.11 (or whatever the version happens to be). This has been the case since the earliest releases, so we could detect that someone is using an outdated version of the gem and tell them to install the newest version.

Right now most of the example files example.rb are just whatever solution first popped into mind. It would be nice to refactor these so that they are actually good solutions.

• you have nitpicks (not approved yet)
• it's been approved. See the example, and fetch the next assignment.

Should we be pulling the multi-days back together again? Thinking about say-{1-4} and wordy-calculator for instance.

Add tests to the test suite for the l33t? implementation that was an extension in the earlier bob warmup.

@burtlo Do you have any idea what might cause this?

Logged in you can see it in action here: http://exercism.io/submissions/51c3d633c09973aa5200000c

Go does not recognize test.go as being a test. The file needs to be named something_test.go.

Apparently we can name files things like word-count_test.go and it doesn't blow up. So for the moment I'm suggesting that we use the slug as a prefix for the test file name.

Would it be interesting to have an exercism nits ruby command to get the current nits just outputted to your terminal?

Right now it just breaks. That's not very nice.

What should the experience for the user be?

What should happen if we make new assignments available after you've finished a trail?
What should happen if we make new assignments available earlier in the trail than where you are currently at?

The nitpick, current submission and completed submission views are complex and have many similarities. Let's see if we can improve this when we know a bit more about what the UX is going to be.

I want to update each of the current admin page entries needing review and you can't stop me.

Change it from this per entry:

To be something like this:

I originally thought this would be a very document-oriented system, but it's turning out to be ridiculously relational.

I don't think MongoDB is a good choice for this anymore.

We talked a bit about possible ways of assessing difficulty of the assignments (presumably in order to sequence them better) in this issue.

Here's a comment from @seeflanigan on the same topic

Also I wonder if there's a way to crowdsource difficulty ratings, and for a
user to correlate a self-assessment of skill level with their rating, ie.
I am a [grasshopper, novice, intermediate, advanced, one with the
shellcode] and found XYZ exercise [adorable, a cakewalk, average, daunting,
ARE YOU INSANE?].

Thoughts?

Crash on login.

http://exercism.io/github/callback?code=85b79fde785d01a1fa5e

Steps to Reproduce

1. Visit http://exercism.io/
2. Click "login with github"
3. View Internal Server Error

@1337807 is a good friend of mine and I would love to give him access but I lack the settings button on this project. Pretty please add him? :)

Several students have asked about seeing the history of submissions and nits/discussion for an assignment.

We have the data, it's just a matter of exposing links to the older submissions.

In particular, once a submission has passed, it might be interesting to show the first + last (before/after) to highlight how much they improved. That is to say, if they submitted more than once on the assignment.

Would it be possible to display the results of the tests in the nitpick screen? This might also encourage people to do their tests correctly.

The whole default path vs absolute path vs relative path is screwing people up pretty badly. They don't understand the default *nix behavior, and we need to help them understand it. Maybe there should be a tour page that tells about all these things in detail.

Example Nit Input

The secondWord is the input and you split it each time in the match function. I think you only need to do it once.

wordSplitter is not the best name in my mind as it seems as though it is splitting words but really what it is doing is getting an sorted character array.

Also shorten it up a bit.

var wordSplitter = function(word){ 
  return word.split("").sort().join();
};

Right now if we have their email address, they'll be getting emails.

Could we add a feature to favorite particular students so we see them float to the top? Thinking about my students (and I'm sure you have the same thing) but I'm also wondering if this goes against any philosophies; maybe we want everyone who's qualified to nitpick everyone else?

For example

md(code, language).

This would simplify what we're currently doing:

Markdown.render("```#{submission.language}\n#{submission.code}\n```")

Explain that nitpicking is nudging in the direction they're already taking.

Look at examples as just that -- examples. They may be exemplary, but other people's code doesn't have to look like it to be approved.

Here are a number of typical things that we might nitpick.

I know it's hard to remember all the dev setup tasks after you've done them so I'm documenting the problems I run into as I go and as I figure them out:

• Getting mongoid running √
• How to set ENV vars to use ENV.fetch. Where to put these when we don't have config/initializers √
• Getting API key for Github √
• Seed data for default admin user to activate 'Be Admin' button.