RookieOne

    public class NamedCommand : ICommand
    {
        public NamedCommand(ICommand decoratedCommand, string name)
        {
            _DecoratedCommand = decoratedCommand;
            Name = name;
        }

        readonly ICommand _DecoratedCommand;
        public string Name { get; set; }

RookieOne

        /// <summary>
        /// Returns true if the object is the type of T
        /// </summary>
        public static bool IsTypeOf<T>(this object o)
        {
            return o.GetType() == typeof (T);
        }

RookieOne

    public interface ITranslator
    {
    }

    public class ClientATranslator : ITranslator
    {
    }

    public class ClientBTranslator : ITranslator
    {

RookieOne

        [TestMethod]
        public void should_set_parameter()
        {
            var message = new Message() as dynamic;

            message.Foo = "foo";

            var foo = message.Foo as string;
            foo.ShouldBe("foo");
        }

RookieOne

            string showAs = _defaultShowAs;

            if (route.Contains(KnownParameters.ShowAs))
            {
                showAs = route[KnownParameters.ShowAs].ToString();
            }

/// AND

        public override bool CanProcessFilter(IRoute route)

RookieOne

d3.select("#make-table")
    .append("tr")
    .selectAll("td")
    .data(data)
    .enter()
    .append("td")
    .text(function(d) {
        return d.value;
    });

RookieOne

SurvivorContest.where("finalized = false and cancelled = false").each do |contest|
      # do nothing
        round = contest.active_round
        if round.present?
          if round.syncable?
            round.match_ups.where(syncable: true).find_each do |match_up|
              # do nothing
            end
            # round.match_ups.syncable.each do |match_up|
            #   SyncMatchUpWorker.queue(match_up.id, @options)

RookieOne

class Trading::CalculatePosition

  def self.execute(user, contender, options={})
    position = user.positions.where(contender_id: contender.id).first    

    contracts = user.contracts
                    .select{|c| c.contender_id == contender.id}
                    .sort{|x,y| x.created_at <=> y.created_at }

    if contracts.empty? 

RookieOne

# Submit the homework by pasting the code in a gist and emailing JB the url to the gist

# Assign "Hello World" to a variable message

# Assign a different string to a different variable

# Assign a number to a variable

# Use string interpolation to display the number in a string
# string interpolation = #{}

RookieOne

Too many opinions. Too many white papers.

GET /things
returns collection of things

POST /things
adds an item to things

GET /things/100
returns a thing with id 100