
var LECTURES_PROBLEMS =
    { 'problems' :
      [                
          {      
              'module'         : 'BSL',
              'lecture'        : 'exprs',
              'kind'           : 'Practice',
              'setNumber'      : 1,
              'name'           : 'More Arithmetic Expression',
              'codeFiles'      : ['more-arithmetic-expression-starter.rkt',
                                  'more-arithmetic-expression-solution.rkt'],
              'description'    : 'Write more arithmetic expressions.',
              'duration'       : 5,
              'difficulty'     : 'Green'
          },
          {
              'module'        : 'BSL',
              'lecture'       : 'eval',
              'kind'          : 'Practice',
              'setNumber'     : 2,
              'name'          : 'Primitives Evaluation',
              'codeFiles'     : ['evaluation-prims-starter.rkt',
                                 'evaluation-prims-solution.rkt'],
              'description'   : 'Write out the step-by-step evaluation of expressions involving calls to primitives.',
              'duration'      : 8,
              'difficulty'    : 'Blue'
          },
          {      
              'module'        : 'BSL',
              'lecture'       : 'strs-imgs',
              'kind'          : 'Practice',
              'setNumber'     : 3,
              'name'          : 'Tile',
              'codeFiles'     : ['tile-starter.rkt',
                                 'tile-solution.rkt'],
              'description'   : 'Create an image using image composition primitives.',
              'duration'      : 5,
              'difficulty'    : 'Green'
          },
          {      
              'module'        : 'BSL',
              'lecture'       : 'strs-imgs',
              'kind'          : 'Practice',
              'setNumber'     : 4,
              'name'          : 'Glue',
              'codeFiles'     : ['glue-starter.rkt',
                                 'glue-solution.rkt'],
              'description'   : 'Write expressions to operate on strings using primitives.',
              'duration'      : 8,
              'difficulty'    : 'Blue'
          },
          {      
              'module'         : 'BSL',
              'lecture'        : 'bools-if-exprs',
              'kind'           : 'Practice',
              'setNumber'      : 5,
              'name'           : 'Compare Images',
              'codeFiles'      : ['compare-images-starter.rkt',
				  'compare-images-solution.rkt'],
              'description'    : 'Write expressions to operate on booleans using primitives.',
              'duration'       : 7,
              'difficulty'     : 'Green'
          },
          {      
              'module'         : 'BSL',
              'lecture'        : 'stepper',
              'kind'           : 'Practice',
              'setNumber'      : 6,
              'name'           : 'More Foo Evaluation',
              'codeFiles'      : ['more-foo-evaluation-starter.rkt',
				  'more-foo-evaluation-solution.rkt'],
              'description'    : 'Step by step evaluation of a call to a function that calls a number primitive in its body.',
              'duration'       : 7,
              'difficulty'     : 'Green'
          },
          {      
              'module'         : 'BSL',
              'lecture'        : 'stepper',
              'kind'           : 'Practice',
              'setNumber'      : 7,
              'name'           : 'Even More Foo Evaluation',
              'codeFiles'      : ['even-more-foo-evaluation-starter.rkt',
				  'even-more-foo-evaluation-solution.rkt'],
              'description'    : 'Step by step evaluation of a call to a function that calls a string primitive in its body.',
              'duration'       : 7,
              'difficulty'     : 'Green'
          },
          {      
              'module'         : 'BSL',
              'lecture'        : 'strs-imgs',
              'kind'           : 'Practice',
              'setNumber'      : 8,
              'name'           : 'Canadian Flag Background',
              'codeFiles'      : ['cflag-starter.rkt',
				  'cflag-solution.rkt'],
              'description'    : 'Write expression to produce background image of Canadian flag.',
              'duration'       : 5,
              'difficulty'     : 'Green'
          },
          {      
              'module'         : 'BSL',
              'lecture'        : 'exprs',
              'kind'           : 'Practice',
              'setNumber'      : 9,
              'name'           : 'Even More Arithmetic Expression',
              'codeFiles'      : ['even-more-arithmetic-expression-starter.rkt',
				  'even-more-arithmetic-expression-solution.rkt'],
              'description'    : 'Write even more arithmetic expressions.',
              'duration'       : 5,
              'difficulty'     : 'Green'
          },
          {      
              'module'         : 'BSL',
              'lecture'        : 'strs-imgs',
              'kind'           : 'Practice',
              'setNumber'      : 10,
              'name'           : 'Triangles',
              'codeFiles'      : ['triangle-starter.rkt',
				  'triangle-solution.rkt'],
              'description'    : 'Write an expression that operates on images using image primitives.',
              'duration'       : 5,
              'difficulty'     : 'Green'
          },
          {      
              'module'         : 'BSL',
              'lecture'        : 'stepper',
              'kind'           : 'Practice',
              'setNumber'      : 11,
              'name'           : 'Bobble Evaluation',
              'codeFiles'      : ['bobble-evaluation-starter.rkt',
				  'bobble-evaluation-solution.rkt'],
              'description'    : 'Step by step evaluation of a call to a function that has an if expression in its body.',
              'duration'       : 7,
              'difficulty'     : 'Green'
          },
          {      
              'module'         : 'BSL',
              'lecture'        : 'strs-imgs',
              'kind'           : 'Practice',
              'setNumber'      : 12,
              'name'           : 'Debug Expression',
              'codeFiles'      : ['debug-rectangle-starter.rkt',
				  'debug-rectangle-solution.rkt'],
              'description'    : 'Fix the error(s) in a call to an image primitive.',
              'duration'       : 5,
              'difficulty'     : 'Green'
          },
          {      
              'module'         : 'BSL',
              'lecture'        : 'exprs',
              'kind'           : 'Practice',
              'setNumber'      : 13,
              'name'           : 'Arithmetic Expression',
              'codeFiles'      : ['arithmetic-expression-starter.rkt',
				  'arithmetic-expression-solution.rkt'],
              'description'    : 'Write an arithmetic expression.',
              'duration'       : 5,
              'difficulty'     : 'Green'
          },
          {
              'module'         : 'BSL',
              'lecture'        : 'strs-imgs',
              'kind'           : 'Practice',
              'setNumber'      : 14,
              'name'           : 'Overlay',
              'codeFiles'      : ['overlay-starter.rkt',
				  'overlay-solution.rkt'],
              'description'    : 'Write an expression that operates on images using image primitives.',
              'duration'       : 10,
              'difficulty'     : 'Green'
          },
          {
              'module'         : 'BSL',
              'lecture'        : 'fun-def',
              'kind'           : 'Practice',
              'setNumber'      : 15,
              'name'           : 'Function Writing',
              'codeFiles'      : ['function-writing-starter.rkt',
          'function-writing-solution.rkt'],
              'description'    : 'Write a function that produces the larger of two given numbers.',
              'duration'       : 5,
              'difficulty'     : 'Green'
          },
          {      
              'module'         : 'BSL',
              'lecture'        : 'stepper',
              'kind'           : 'Practice',
              'setNumber'      : 16,
              'name'           : 'Foo Evaluation',
              'codeFiles'      : ['foo-evaluation-starter.rkt',
				  'foo-evaluation-solution.rkt'],
              'description'    : 'Step by step evaluation of a call to a function that has an if expression in its body.',
              'duration'       : 15,
              'difficulty'     : 'Blue'
          },

          
          {      
              'module'         : 'HtDF',
              'lecture'        : 'yell',
              'kind'           : 'Lecture',
              'setNumber'      : 1,
              'name'           : 'Yell',
              'codeFiles'      : ['yell-starter.rkt',
				  'yell-solution.rkt'],
              'description'    : 'Design a function to yell!',
              'recipe'         : 'HtDF(Atomic)',
              'duration'       : 7,
              'difficulty'     : 'Green'
          },

          {      
              'module'         : 'HtDF',
              'lecture'        : 'area',
              'kind'           : 'Lecture',
              'setNumber'      : 2,
              'name'           : 'Area',
              'codeFiles'      : ['area-starter.rkt',
				  'area-solution.rkt'],
              'description'    : 'Design a function to calculate the area of a square.',
              'recipe'         : 'HtDF(Atomic)',
              'duration'       : 8,
              'difficulty'     : 'Green'
          },
          {      
              'module'         : 'HtDF',
              'lecture'        : 'img-area',
              'kind'           : 'Lecture',
              'setNumber'      : 3,
              'name'           : 'Image Area',
              'codeFiles'      : ['image-area-starter.rkt',
				  'image-area-solution.rkt'],
              'description'    : 'Design a function to calculate the area of an image.',
              'recipe'         : 'HtDF(Atomic)',
              'duration'       : 8,
              'difficulty'     : 'Green'
          },
          {      
              'module'         : 'HtDF',
              'lecture'        : 'tall',
              'kind'           : 'Lecture',
              'setNumber'      : 4,
              'name'           : 'Tall',
              'codeFiles'      : ['tall-starter.rkt',
				  'tall-solution.rkt'],
              'description'    : 'Design a function to determine if an image is tall.',
              'recipe'         : 'HtDF(Atomic)',
              'duration'       : 10,
              'difficulty'     : 'Green'
          },                   {      
              'module'         : 'HtDF',
              'lecture'        : 'full',
              'kind'           : 'Practice',
              'setNumber'      : 1,
              'name'           : 'Summon',
              'codeFiles'      : ['summon-starter.rkt',
				  'summon-solution.rkt'],
              'description'    : 'Design a function to summon items.',
              'recipe'         : 'HtDF(Atomic)',
              'duration'       : 10,
              'difficulty'     : 'Green'
          },
          {      
              'module'         : 'HtDF',
              'lecture'        : 'full',
              'kind'           : 'Practice',
              'setNumber'      : 2,
              'name'           : 'Less Than 5',
              'codeFiles'      : ['less-than-five-starter.rkt',
				  'less-than-five-solution.rkt'],
              'description'    : 'Design a function to check if length of a string is less than 5.',
              'recipe'         : 'HtDF(Atomic)',
              'duration'       : 10,
              'difficulty'     : 'Green'
          },
          {      
              'module'         : 'HtDF',
              'lecture'        : 'full',
              'kind'           : 'Practice',
              'setNumber'      : 3,
              'name'           : 'Boxify',
              'codeFiles'      : ['boxify-starter.rkt',
				  'boxify-solution.rkt'],
              'description'    : 'Design a function to put a box around a given image.',
              'recipe'         : 'HtDF(Atomic)',
              'duration'       : 15,
              'difficulty'     : 'Blue'
          },
          {      
              'module'         : 'HtDF',
              'lecture'        : 'full',
              'kind'           : 'Practice',
              'setNumber'      : 4,
              'name'           : 'Pluralize Stubs',
              'codeFiles'      : ['pluralize-stubs-starter.rkt',
				  'pluralize-stubs-solution.rkt'],
              'description'    : 'Write more than one stub for a function given its signature and purpose.',
              'recipe'         : 'HtDF(Atomic)',
              'duration'       : 5,
              'difficulty'     : 'Green'
          },
          {      
              'module'         : 'HtDF',
              'lecture'        : 'full',
              'kind'           : 'Practice',
              'setNumber'      : 5,
              'name'           : 'Blue Triangle',
              'codeFiles'      : ['blue-triangle-starter.rkt',
				  'blue-triangle-solution.rkt'],
              'description'    : 'Design a function to produce a blue solid triangle of a given size.',
              'recipe'         : 'HtDF(Atomic)',
              'duration'       : 10,
              'difficulty'     : 'Green'
          },
          {      
              'module'         : 'HtDF',
              'lecture'        : 'full',
              'kind'           : 'Practice',
              'setNumber'      : 6,
              'name'           : 'Double Error',
              'codeFiles'      : ['double-error-starter.rkt',
				  'double-error-solution.rkt'],
              'description'    : 'Fix the error(s) in a function that doubles a given number.',
              'recipe'         : 'HtDF(Atomic)',
              'duration'       : 7,
              'difficulty'     : 'Green'
          },
          
          {      
              'module'         : 'HtDF',
              'lecture'        : 'full',
              'kind'           : 'Practice',
              'setNumber'      : 7,
              'name'           : 'Make Box',
              'codeFiles'      : ['make-box-starter.rkt',
				  'make-box-solution.rkt'],
              'description'    : 'Design a function to create a square based on the given colour.',
              'recipe'         : 'HtDF(Atomic)',
              'duration'       : 10,
              'difficulty'     : 'Green'
          },
          {      
              'module'         : 'HtDF',
              'lecture'        : 'full',
              'kind'           : 'Practice',
              'setNumber'      : 8,
              'name'           : 'Ensure Question',
              'codeFiles'      : ['ensure-question-starter.rkt',
				  'ensure-question-solution.rkt'],
              'description'    : 'Design a function to produce a question by adding "?" to the end of a given string.',
              'recipe'         : 'HtDF(Atomic)',
              'duration'       : 10,
              'difficulty'     : 'Blue'
          },
          {      
              'module'         : 'HtDF',
              'lecture'        : 'full',
              'kind'           : 'Practice',
              'setNumber'      : 9,
              'name'           : 'Cartesian',
              'codeFiles'      : ['cartesian-starter.rkt',
				  'cartesian-solution.rkt'],
              'description'    : 'Design a function to calculate the distance between two points.',
              'recipe'         : 'HtDF(Atomic)',
              'duration'       : 20,
              'difficulty'     : 'Black'
          },
          
          
          
          
          
          {      
              'module'         : 'HtDD',
              'lecture'        : 'atomic',
              'kind'           : 'Lecture',
              'setNumber'      : 1,
              'name'           : 'City name',
              'codeFiles'      : ['city-name-starter.rkt',
				  'city-name-solution.rkt'],
              'description'    : 'Design a data definition for all the citys in the world.',
              'recipe'         : 'HtDD',
              'duration'       : 8,
              'difficulty'     : 'Green'
          },
          {      
              'module'         : 'HtDD',
              'lecture'        : 'atomic-htdf',
              'kind'           : 'Lecture',
              'setNumber'      : 2,
              'name'           : 'Best',
              'codeFiles'      : ['best-starter.rkt',
				  'best-solution.rkt'],
              'description'    : 'Given the data definition for City, design a function that checks if a given city is the best city in the world.',
              'recipe'         : 'HtDF',
              'duration'       : 8,
              'difficulty'     : 'Green'
          },
          {      
              'module'         : 'HtDD',
              'lecture'        : 'interv',
              'kind'           : 'Lecture',
              'setNumber'      : 3,
              'name'           : 'Seat number',
              'codeFiles'      : ['seat-num-starter.rkt',
				  'seat-num-solution.rkt'],
              'description'    : 'Design a data definition for seat numbers in a theatre.',
              'recipe'         : 'HtDD',
              'duration'       : 8,
              'difficulty'     : 'Green'
          },
          {      
              'module'         : 'HtDD',
              'lecture'        : 'enum',
              'kind'           : 'Lecture',
              'setNumber'      : 4,
              'name'           : 'Letter grade',
              'codeFiles'      : ['letter-grade-starter.rkt',
				  'letter-grade-solution.rkt'],
              'description'    : 'Design a data definition to represent a student\'s grade.',
              'recipe'         : 'HtDD',
              'duration'       : 10,
              'difficulty'     : 'Green'
          },
          {      
              'module'         : 'HtDD',
              'lecture'        : 'itemz',
              'kind'           : 'Lecture',
              'setNumber'      : 5,
              'name'           : 'Countdown',
              'codeFiles'      : ['countdown-starter.rkt',
				  'countdown-solution.rkt'],
              'description'    : 'Design a data definition to represent the current state of a New Year\'s Eve countdown.',
              'recipe'         : 'HtDD',
              'duration'       : 18,
              'difficulty'     : 'Blue'
          },
          {      
              'module'         : 'HtDD',
              'lecture'        : 'interv-htdf',
              'kind'           : 'Lecture',
              'setNumber'      : 6,
              'name'           : 'Aisle',
              'codeFiles'      : ['aisle-starter.rkt',
				  'aisle-solution.rkt'],
              'description'    : 'Given the data definition for SeatNum, design a function that determines if the seat number is on the aisle.',
              'recipe'         : 'HtDF',
              'duration'       : 10,
              'difficulty'     : 'Green'
          },
          {      
              'module'         : 'HtDD',
              'lecture'        : 'enum-htdf',
              'kind'           : 'Lecture',
              'setNumber'      : 7,
              'name'           : 'Bump up',
              'codeFiles'      : ['bump-up-starter.rkt',
				  'bump-up-solution.rkt'],
              'description'    : 'Given the data definition for LetterGrade, design a function that produces the next highest grade.',
              'recipe'         : 'HtDF',
              'duration'       : 10,
              'difficulty'     : 'Green'
          },
          {      
              'module'         : 'HtDD',
              'lecture'        : 'itemz-htdf',
              'kind'           : 'Lecture',
              'setNumber'      : 8,
              'name'           : 'Countdown to display',
              'codeFiles'      : ['countdown-to-display-starter.rkt',
				  'countdown-to-display-solution.rkt'],
              'description'    : 'Given the data definition for Countdown, design a function that produces an image of the current state.',
              'recipe'         : 'HtDF',
              'duration'       : 15,
              'difficulty'     : 'Blue'
          },
          {      
              'module'         : 'HtDD',
              'lecture'        : 'interv-htdf',
              'kind'           : 'Practice',
              'setNumber'      : 1,
              'name'           : 'Employees',
              'codeFiles'      : ['employees-starter.rkt',
				  'employees-solution.rkt'],
              'description'    : 'Design a data definition and a function for a program to track a ski lodge\'s payroll.',
              'recipe'         : ['HtDD', 'HtDF'],
              'duration'       : 15,
              'difficulty'     : 'Green'
          },
          {      
              'module'         : 'HtDD',
              'lecture'        : 'enum-htdf',
              'kind'           : 'Practice',
              'setNumber'      : 2,
              'name'           : 'Demolish',
              'codeFiles'      : ['demolish-starter.rkt',
				  'demolish-solution.rkt'],
              'description'    : 'Design a data definition and a function for a program to classify buildings in downtown Vancouver.',
              'recipe'         : ['HtDD', 'HtDF'],
              'duration'       : 20,
              'difficulty'     : 'Blue'
          },
          {      
              'module'         : 'HtDD',
              'lecture'        : 'itemz-htdf',
              'kind'           : 'Practice',
              'setNumber'      : 3,
              'name'           : 'Rocket',
              'codeFiles'      : ['rocket-starter.rkt',
				  'rocket-solution.rkt'],
              'description'    : 'Design a data definition and a function for a program to track a rocket\'s return to Earth.',
              'recipe'         : ['HtDD', 'HtDF'],
              'duration'       : 25,
              'difficulty'     : 'Black'
          },
          {      
              'module'         : 'HtDD',
              'lecture'        : 'enum',
              'kind'           : 'Practice',
              'setNumber'      : 4,
              'name'           : 'LetterGrade Error',
              'codeFiles'      : ['letter-grade-error-starter.rkt',
				  'letter-grade-error-solution.rkt'],
              'description'    : 'Fix error(s) in the revised data definition for LetterGrade.',
              'recipe'         : 'HtDD',
              'duration'       : 8,
              'difficulty'     : 'Green'
          },
          {      
              'module'         : 'HtDD',
              'lecture'        : 'interv',
              'kind'           : 'Practice',
              'setNumber'      : 5,
              'name'           : 'Style Rules',
              'codeFiles'      : ['style-rules-starter.rkt',
				  'style-rules-solution.rkt'],
              'description'    : 'Discuss the importance of following style rules and fix a given data definition to follow them.',
              'recipe'         : 'HtDD',
              'duration'       : 8,
              'difficulty'     : 'Green'
          },
          {      
              'module'         : 'HtDD',
              'lecture'        : 'enum-htdf',
              'kind'           : 'Practice',
              'setNumber'      : 6,
              'name'           : 'Bike Route',
              'codeFiles'      : ['bike-route-starter.rkt',
				  'bike-route-solution.rkt'],
              'description'    : 'Design a data definition and a function to determine whether a bike route is exclusively designated for bicycles.',
              'recipe'         : ['HtDD', 'HtDF'],
              'duration'       : 20,
              'difficulty'     : 'Blue'
          },
      //     {      
      //         'module'         : 'HtDD',
      //         'lecture'        : 'enum-htdf, interv-htdf',
      //         'kind'           : 'Practice',
      //         'setNumber'      : 7,
      //         'name'           : 'Steepness',
      //         'codeFiles'      : ['steepness-starter.rkt',
				  // 'steepness-solution.rkt'],
      //         'description'    : 'Design two data definitions and a function to determine the steepness rating of a hill grade.',
      //         'recipe'         : ['HtDD', 'HtDF'],
      //         'duration'       : 35,
      //         'difficulty'     : 'Black'
      //     },
          {      
              'module'         : 'HtDD',
              'lecture'        : 'itemz-htdf',
              'kind'           : 'Practice',
              'setNumber'      : 7,
              'name'           : 'Rocket Error',
              'codeFiles'      : ['rocket-error-starter.rkt',
				  'rocket-error-solution.rkt'],
              'description'    : 'Fix the error(s) in a function we have developed for the Rocket program.',
              'recipe'         : ['HtDD', 'HtDF'],
              'duration'       : 7,
              'difficulty'     : 'Green'
          },
      //     {      
      //         'module'         : 'HtDD',
      //         'lecture'        : 'itemz',
      //         'kind'           : 'Practice',
      //         'setNumber'      : 9,
      //         'name'           : 'Breakfast',
      //         'codeFiles'      : ['breakfast-starter.rkt',
				  // 'breakfast-solution.rkt'],
      //         'description'    : 'Design two data definitions and a function for a program to perfectly heat oatmeal.',
      //         'recipe'         : ['HtDD', 'HtDF'],
      //         'duration'       : 35,
      //         'difficulty'     : 'Black'
      //     },           
          {      
              'module'         : 'HtDD',
              'lecture'        : 'enum-htdf',
              'kind'           : 'Practice',
              'setNumber'      : 8,
              'name'           : 'Direction',
              'codeFiles'      : ['direction-starter.rkt',
				  'direction-solution.rkt'],
              'description'    : 'Design a function based on a given data definition for compass directions.',
              'recipe'         : 'HtDD',
              'duration'       : 8,
              'difficulty'     : 'Green'
          },
          {      
              'module'         : 'HtDD',
              'lecture'        : 'enum-htdf',
              'kind'           : 'Practice',
              'setNumber'      : 9,
              'name'           : 'Dinner',
              'codeFiles'      : ['dinner-starter.rkt',
				  'dinner-solution.rkt'],
              'description'    : 'Design a data definition to represent airline dinners, and a function to let flight attendants know a passenger\'s choice.',
              'recipe'         : ['HtDD', 'HtDF'],
              'duration'       : 18,
              'difficulty'     : 'Blue'
          },
          
          
          
          
          
          {      
              'module'         : 'HtDW',
              'lecture'        : 'da, main, wish-list',
              'kind'           : 'Lecture',
              'setNumber'      : 1,
              'name'           : 'Cat',
              'codeFiles'      : ['cat-starter.rkt',
				  'cat-v3.rkt'],
              'description'    : 'A cat that moves across the screen.',
              'recipe'         : 'HtDW(Atomic)',
              'duration'       : 40,
              'difficulty'     : 'Blue'
          },
          {      
              'module'         : 'HtDW',
              'lecture'        : 'add-key',
              'kind'           : 'Lecture',
              'setNumber'      : 2,
              'name'           : 'Add mouse-handler to cat',
              'codeFiles'      : ['add-mouse-handler-starter.rkt',
				  'cat-v4.rkt'],
              'description'    : 'Given an existing world program, add a mouse handler to reset the position of the moving cat.',
              'recipe'         : 'HtDW(Atomic)',
              'duration'       : 25,
              'difficulty'     : 'Blue'
          },
          {      
              'module'         : 'HtDW',
              'lecture'        : 'da, main, wish-list',
              'kind'           : 'Practice',
              'setNumber'      : 1,
              'name'           : 'Countdown Animation',
              'codeFiles'      : ['countdown-animation-starter.rkt',
          'countdown-animation-solution.rkt'],
              'description'    : 'Design an animation of a countdown.',
              'recipe'         : 'HtDW(Interval)',
              'duration'       : 30,
              'difficulty'     : 'Green'
          },
          {      
              'module'         : 'HtDW',
              'lecture'        : 'da, main, wish-list',
              'kind'           : 'Practice',
              'setNumber'      : 2,
              'name'           : 'Traffic Light Animation',
              'codeFiles'      : ['traffic-light-starter.rkt',
				  'traffic-light-solution.rkt'],
              'description'    : 'Design an animation of a traffic light.',
              'recipe'         : 'HtDW(Enumeration)',
              'duration'       : 50,
              'difficulty'     : 'Blue'
          },
          {      
              'module'         : 'Compound',
              'lecture'        : 'htdw',
              'kind'           : 'Lecture',
              'setNumber'      : 3,
              'name'           : 'Cowabunga',
              'codeFiles'      : ['cowabunga-starter.rkt',
				  'cowabunga-v0.rkt', 'cowabunga-v1.rkt', 'cowabunga-v2.rkt', 'cowabunga-v3.rkt', 'cowabunga-v4.rkt', 'cowabunga-v5.rkt', 'cowabunga-v6.rkt'],
              'description'    : 'A cow that wanders back and forth across the screen.',
              'recipe'         : 'HtDW(Compound)',
              'duration'       : 120,
              'difficulty'     : 'Blue'
          },
          {      
              'module'         : 'Compound',
              'lecture'        : 'dd',
              'kind'           : 'Practice',
              'setNumber'      : 1,
              'name'           : 'Movie',
              'codeFiles'      : ['movie-starter.rkt',
				  'movie-solution.rkt'],
              'description'    : 'Design a compound data definition to represent movies, and a function to compare their release dates.',
              'recipe'         : ['HtDD(Compound)', 'HtDF'],
              'duration'       : 25,
              'difficulty'     : 'Blue'
          },
          {      
              'module'         : 'Compound',
              'lecture'        : 'htdw',
              'kind'           : 'Practice',
              'setNumber'      : 2,
              'name'           : 'Spinning',
              'codeFiles'      : ['spinning-starter.rkt',
				  'spinning-solution.rkt'],
              'description'    : 'Design a world to represent a growing and rotating red box.',
              'recipe'         : 'HtDW(Compound)',
              'duration'       : 80,
              'difficulty'     : 'Black'
          },
          {      
              'module'         : 'Compound',
              'lecture'        : 'dd',
              'kind'           : 'Practice',
              'setNumber'      : 3,
              'name'           : 'Student',
              'codeFiles'      : ['student-starter.rkt',
				  'student-solution.rkt'],
              'description'    : 'Design a compound data definition to represent students, and a function to monitor their allergies.',
              'recipe'         : ['HtDD(Compound)', 'HtDF'],
              'duration'       : 25,
              'difficulty'     : 'Blue'
          },
          {      
              'module'         : 'Compound',
              'lecture'        : 'dd',
              'kind'           : 'Practice',
              'setNumber'      : 4,
              'name'           : 'Trip',
              'codeFiles'      : ['trip-starter.rkt',
				  'trip-solution.rkt'],
              'description'    : 'Design a compound data definition to represent trips, and a function to compare their lengths.',
              'recipe'         : ['HtDD(Compound)', 'HtDF'],
              'duration'       : 25,
              'difficulty'     : 'Blue'
          },
          {      
              'module'         : 'Compound',
              'lecture'        : 'htdw',
              'kind'           : 'Practice',
              'setNumber'      : 5,
              'name'           : 'Growing Grass',
              'codeFiles'      : ['growing-grass-starter.rkt',
				  'growing-grass-solution.rkt'],
              'description'    : 'Design a world to represent grass that grows and is replanted.',
              'recipe'         : 'HtDW(Compound)',
              'duration'       : 80,
              'difficulty'     : 'Black'
          },
          {      
              'module'         : 'Compound',
              'lecture'        : 'htdw',
              'kind'           : 'Practice',
              'setNumber'      : 6,
              'name'           : 'Mouse Tracker',
              'codeFiles'      : ['tracker-starter.rkt',
				  'tracker-solution.rkt'],
              'description'    : 'Design a world where the mouse position is displayed at the mouse cursor.',
              'recipe'         : 'HtDW(Compound)',
              'duration'       : 50,
              'difficulty'     : 'Blue'
          },
          {      
              'module'         : 'Compound',
              'lecture'        : 'htdw',
              'kind'           : 'Practice',
              'setNumber'      : 7,
              'name'           : 'Rolling Lambda',
              'codeFiles'      : ['rolling-lambda-starter.rkt',
				  'rolling-lambda-solution.rkt'],
              'description'    : 'Design a world where a lambda rolls back and forth across the screen.',
              'recipe'         : 'HtDW(Compound)',
              'duration'       : 100,
              'difficulty'     : 'Black'
          },        
          {      
              'module'         : 'Compound',
              'lecture'        : 'dd',
              'kind'           : 'Practice',
              'setNumber'      : 8,
              'name'           : 'Compound Evaluation Starter',
              'codeFiles'      : ['compound-evaluation-starter.rkt',
				  'compound-evaluation-solution.rkt'],
              'description'    : 'Write down the evaluation steps for an expression that has compound data.',
              'recipe'         : 'HtD(Compound)',
              'duration'       : 5,
              'difficulty'     : 'Green'
          },
          {      
              'module'         : 'Compound',
              'lecture'        : 'htdw',
              'kind'           : 'Practice',
              'setNumber'      : 9,
              'name'           : 'Water Balloon',
              'codeFiles'      : ['water-balloon-starter.rkt',
				  'water-balloon-solution.rkt'],
              'description'    : 'Design an animation of throwing a water balloon.',
              'recipe'         : 'HtDW(Compound)',
              'duration'       : 90,
              'difficulty'     : 'Black'
          }, 

	  
          // {      
          //     'module'         : 'Compound',
          //     'lecture'        : 'htdw',
          //     'kind'           : 'Practice',
          //     'setNumber'      : 10,
          //     'name'           : 'Simple Text Editor',
          //     'codeFiles'      : ['simple-text-editor-starter.rkt',
          // 'simple-text-editor-solution.rkt'],
          //     'description'    : 'Design a simple one-line text editor.',
          //     'recipe'         : 'HtDW(Compound)',
          //     'duration'       : 90,
          //     'difficulty'     : 'Black'
          // },

          {      
              'module'         : 'Self-Ref',
              'lecture'        : 'list-fun',
              'kind'           : 'Practice',
              'setNumber'      : 1,
              'name'           : 'Total String Length',
              'codeFiles'      : ['total-string-length-starter.rkt',
				  'total-string-length-solution.rkt'],
              'description'    : 'Design a function to calculate the total number of individual characters in a list of strings.',
              'recipe'         : 'HtDF',
              'duration'       : 18,
              'difficulty'     : 'Green'
          },
          {      
              'module'         : 'Self-Ref',
              'lecture'        : 'des-w-list',
              'kind'           : 'Practice',
              'setNumber'      : 2,
              'name'           : 'Double All',
              'codeFiles'      : ['double-all-starter.rkt',
				  'double-all-solution.rkt'],
              'description'    : 'Design a function to double every number in a list.',
              'recipe'         : 'HtDF',
              'duration'       : 18,
              'difficulty'     : 'Green'
          },
          {      
              'module'         : 'Self-Ref',
              'lecture'        : 'des-w-list',
              'kind'           : 'Practice',
              'setNumber'      : 3,
              'name'           : 'Boolean List',
              'codeFiles'      : ['boolean-list-starter.rkt',
				  'boolean-list-solution.rkt'],
              'description'    : 'Design a data definition to represent a list of booleans, and a function to determine if all values in a given list are true.',
              'recipe'         : ['HtDD', 'HtDF'],
              'duration'       : 35,
              'difficulty'     : 'Blue'
          },
          {      
              'module'         : 'Self-Ref',
              'lecture'        : 'list-fun',
              'kind'           : 'Practice',
              'setNumber'      : 4,
              'name'           : 'Yell All',
              'codeFiles'      : ['yell-all-starter.rkt',
				  'yell-all-solution.rkt'],
              'description'    : 'Design a function to add \'!\' to each string in a list of strings.',
              'recipe'         : 'HtDF',
              'duration'       : 18,
              'difficulty'     : 'Green'
          },
          {      
              'module'         : 'Self-Ref',
              'lecture'        : 'des-w-list',
              'kind'           : 'Practice',
              'setNumber'      : 5,
              'name'           : 'Largest',
              'codeFiles'      : ['largest-starter.rkt',
				  'largest-solution.rkt'],
              'description'    : 'Design a function to find the largest number in a list of numbers.',
              'recipe'         : 'HtDF',
              'duration'       : 18,
              'difficulty'     : 'Green'
          },
          {      
              'module'         : 'Self-Ref',
              'lecture'        : 'des-w-list',
              'kind'           : 'Practice',
              'setNumber'      : 6,
              'name'           : 'Image List',
              'codeFiles'      : ['image-list-starter.rkt',
				  'image-list-solution.rkt'],
              'description'    : 'Design a data definition to represent a list of images, and a function to find the sum of areas from a list of images.',
              'recipe'         : 'HtDF',
              'duration'       : 35,
              'difficulty'     : 'Blue'
          },

          {      
              'module'         : 'Ref',
              'lecture'        : 'part-1-2-3',
              'kind'           : 'Lecture',
              'setNumber'      : 1,
              'name'           : 'Tuition',
              'codeFiles'      : ['tuition-graph-starter.rkt','tuition-graph-v1.rkt','tuition-graph-v2.rkt','tuition-graph-v3.rkt','tuition-graph-v4.rkt','tuition-graph-v5.rkt','tuition-graph-v6.rkt'],
              'description'    : 'A tuition graphing program and intermediate solutions.',
              'recipe'         : 'HtDF',
              'duration'       : 60,
              'difficulty'     : 'Black'
          },
          {      
              'module'         : 'Ref',
              'lecture'        : 'part-3',
              'kind'           : 'Practice',
              'setNumber'      : 1,
              'name'           : 'Alternative Tuition Graph',
              'codeFiles'      : ['alternative-tuition-graph-starter.rkt',
				  'alternative-tuition-graph-solution.rkt'],
              'description'    : 'Design the tuition graph bar chart function based on an alternative data definition for School.',
              'recipe'         : ['HtDD', 'HtDF'],
              'duration'       : 50,
              'difficulty'     : 'Black'
          },
          {      
              'module'         : 'Ref',
              'lecture'        : 'part-3',
              'kind'           : 'Practice',
              'setNumber'      : 2,
              'name'           : 'Spinning Bears',
              'codeFiles'      : ['spinning-bears-starter.rkt',
				  'spinning-bears-solution.rkt'],
              'description'    : 'Design a world program that has an arbitrary number of spinning bears.',
              'recipe'         : ['HtDD', 'HtDF', 'HtDW'],
              'duration'       : 100,
              'difficulty'     : 'Black'
          },
          {      
              'module'         : 'Ref',
              'lecture'        : 'part-3',
              'kind'           : 'Practice',
              'setNumber'      : 3,
              'name'           : 'Tuition Graph',
              'codeFiles'      : ['tuition-graph-c-starter.rkt',
				  'tuition-graph-c-solution.rkt'],
              'description'    : 'Design a function to find the lowest tuition, and a function to produce a list of school names.',
              'recipe'         : 'HtDF',
              'duration'       : 45,
              'difficulty'     : 'Black'
          },
          {      
              'module'         : 'Naturals',
              'lecture'        : 'nat nums',
              'kind'           : 'Lecture',
              'setNumber'      : 1,
              'name'           : 'Naturals',
              'codeFiles'      : ['naturals-starter.rkt',
				  'naturals-solution.rkt'],
              'description'    : 'Design functions that operate on the Natural data definition.',
              'recipe'         : 'HtDF',
              'duration'       : 25,
              'difficulty'     : 'Green'
          },
          {      
              'module'         : 'Naturals',
              'lecture'        : 'parlor',
              'kind'           : 'Lecture',
              'setNumber'      : 2,
              'name'           : 'New numerals',
              'codeFiles'      : ['new-numerals-starter.rkt',
				  'new-numerals-solution.rkt'],
              'description'    : 'Design functions that does arithmetic operations on the NATURAL data definition.',
              'recipe'         : 'HtDF',
              'duration'       : 50,
              'difficulty'     : 'Blue'
          },
          

          {      
               'module'         : 'Naturals',
               'lecture'        : 'nat nums',
               'kind'           : 'Practice',
               'setNumber'      : 1,
               'name'           : 'Sum to n',
               'codeFiles'      : ['sum-to-n-starter.rkt',
            'sum-to-n-solution.rkt'],
               'description'    : 'Design a function that computes the sum of all natural numbers from zero to n.',
               'recipe'         : 'HtDF',
               'duration'       : 10,
               'difficulty'     : 'Green'
            },
                 
                 {      
                         'module'         : 'Naturals',
                         'lecture'        : 'nat nums',
                         'kind'           : 'Practice',
                         'setNumber'      : 2,
                         'name'           : 'Decreasing Image',
                         'codeFiles'      : ['decreasing-image-starter.rkt',
                         'decreasing-image-solution.rkt'],
                         'description'    : 'Design a function that produces an image of the numbers from n to zero, side by side.',
                         'recipe'         : 'HtDF',
                         'duration'       : 15,
                         'difficulty'     : 'Blue'
                 },

                 {      
                         'module'         : 'Naturals',
                         'lecture'        : 'nat nums',
                         'kind'           : 'Practice',
                         'setNumber'      : 3,
                         'name'           : 'Odd from n',
                         'codeFiles'      : ['odd-from-n-starter.rkt',
                         'odd-from-n-solution.rkt'],
                         'description'    : 'Design a function that produces a list of all the odd numbers from n to zero.',
                         'recipe'         : 'HtDF',
                         'duration'       : 15,
                         'difficulty'     : 'Blue'
                 },
                 
                 {      
                         'module'         : 'Naturals',
                         'lecture'        : 'nat nums',
                         'kind'           : 'Practice',
                         'setNumber'      : 4,
                         'name'           : 'Concentric Circles',
                         'codeFiles'      : ['concentric-circles-starter.rkt',
                         'concentric-circles-solution.rkt'],
                         'description'    : 'Design a function that produces an image of n concentric circles of a given colour.',
                         'recipe'         : 'HtDF',
                         'duration'       : 15,
                         'difficulty'     : 'Blue'
                 },
          
          {      
              'module'         : 'Helpers',
              'lecture'        : 'all',
              'kind'           : 'Lecture',
              'setNumber'      : 1,
              'name'           : 'Arrange Images',
              'codeFiles'      : ['arrange-images-starter.rkt',
				  'arrange-images-v1.rkt','arrange-images-v2.rkt','arrange-images-v3.rkt', 'arrange-images-v4.rkt','arrange-images-v5.rkt','arrange-images-v6.rkt'],
              'description'    : 'Creating a program to sort a list of images and lay them out next to each other, as demonstrated in lecture, with all intermediate solutions.',
              'recipe'         : ['HtDF'],
              'duration'       : 60,
              'difficulty'     : 'Blue'
          },   
          {      
              'module'         : 'Helpers',
              'lecture'        : 'all',
              'kind'           : 'Practice',
              'setNumber'      : 1,
              'name'           : 'Render Roster',
              'codeFiles'      : ['render-roster-starter.rkt',
				  'render-roster-solution.rkt'],
              'description'    : 'Design a program to render a dodgeball game roster.',
              'recipe'         : ['HtDF'],
              'duration'       : 100,
              'difficulty'     : 'Blue'
          },              
          {      
              'module'         : 'Helpers',
              'lecture'        : 'all',
              'kind'           : 'Practice',
              'setNumber'      : 2,
              'name'           : 'Making Rain Filtered',
              'codeFiles'      : ['making-rain-filtered-starter.rkt',
				  'making-rain-filtered-solution.rkt'],
              'description'    : 'Design a world program to make it rain where you want it to. In this version of the program you should remove drops that have already fallen off the screen from the world state. Be sure to use all appropriate helper function rules. There are a total of 9 functions in our solution, so this problem takes some time.',
              'recipe'         : ['HtDW'],
              'duration'       : 120,
              'difficulty'     : 'Blue'
          },

          //BSTs
          {      
              'module'         : 'BSTs',
              'lecture'        : 'loa',
              'kind'           : 'Lecture',
              'setNumber'      : 1,
              'name'           : 'Lookup in List',
              'codeFiles'      : ['lookup-in-list-starter.rkt',
				  'lookup-in-list-solution.rkt'],
              'description'    : 'Creating a program to find an account in a list of account given its account number.',
              'recipe'         : ['HtDF'],
              'duration'       : 15,
              'difficulty'     : 'Green'
          }, 

          {      
              'module'         : 'BSTs',
              'lecture'        : 'dd',
              'kind'           : 'Lecture',
              'setNumber'      : 2,
              'name'           : 'BST Data Definition',
              'codeFiles'      : ['bst-dd-starter.rkt',
				  'bst-dd-solution.rkt'],
              'description'    : 'Creating a data definition for a Binary Search Tree.',
              'recipe'         : ['HtDD'],
              'duration'       : 25,
              'difficulty'     : 'Blue'
          }, 

          {      
              'module'         : 'BSTs',
              'lecture'        : 'lookup',
              'kind'           : 'Lecture',
              'setNumber'      : 3,
              'name'           : 'Lookup in BST',
              'codeFiles'      : ['lookup-in-bst-starter.rkt',
				  'lookup-in-bst-solution.rkt'],
              'description'    : 'Creating a function that searches through a BST.',
              'recipe'         : ['HtDF'],
              'duration'       : 25,
              'difficulty'     : 'Blue'
          },

          {      
              'module'         : 'BSTs',
              'lecture'        : 'render',
              'kind'           : 'Lecture',
              'setNumber'      : 4,
              'name'           : 'Render BST',
              'codeFiles'      : ['render-bst-starter.rkt',
				  'render-bst-solution.rkt'],
              'description'    : 'Creating a function that renders a BST',
              'recipe'         : ['HtDF'],
              'duration'       : 30,
              'difficulty'     : 'Blue'
          },
          
          {      
              'module'         : 'BSTs',
              'lecture'        : 'lookup',
              'kind'           : 'Practice',
              'setNumber'      : 1,
              'name'           : 'Count Nodes',
              'codeFiles'      : ['count-nodes-starter.rkt',
				  'count-nodes-solution.rkt'],
              'description'    : 'Design a function to count the number of nodes in a BST.',
              'recipe'         : ['HtDF'],
              'duration'       : 7,
              'difficulty'     : 'Green'
          },
          {      
              'module'         : 'BSTs',
              'lecture'        : 'lookup',
              'kind'           : 'Practice',
              'setNumber'      : 2,
              'name'           : 'Sum Keys',
              'codeFiles'      : ['sum-keys-starter.rkt',
				  'sum-keys-solution.rkt'],
              'description'    : 'Design a function that sums the keys in a BST.',
              'recipe'         : ['HtDF'],
              'duration'       : 7,
              'difficulty'     : 'Green'
          },
          {      
              'module'         : 'BSTs',
              'lecture'        : 'lookup',
              'kind'           : 'Practice',
              'setNumber'      : 3,
              'name'           : 'Height',
              'codeFiles'      : ['height-starter.rkt',
				  'height-solution.rkt'],
              'description'    : 'Design a function to determine the height of a BST.',
              'recipe'         : ['HtDF'],
              'duration'       : 20,
              'difficulty'     : 'Blue'
          },
          {      
              'module'         : 'BSTs',
              'lecture'        : 'lookup',
              'kind'           : 'Practice',
              'setNumber'      : 4,
              'name'           : 'Insert',
              'codeFiles'      : ['insert-starter.rkt',
				  'insert-solution.rkt'],
              'description'    : 'Design a function that inserts a node in the proper place in a BST.',
              'recipe'         : ['HtDF'],
              'duration'       : 30,
              'difficulty'     : 'Blue'
          },
          {      
              'module'         : 'BSTs',
              'lecture'        : 'lookup',
              'kind'           : 'Practice',
              'setNumber'      : 5,
              'name'           : 'Balance Factor ',
              'codeFiles'      : ['balance-factor-starter.rkt',
				  'balance-factor-solution.rkt'],
              'description'    : 'Design functions to determine whether a BST is balanced. ',
              'recipe'         : ['HtDF'],
              'duration'       : 30,
              'difficulty'     : 'Blue'
          },
          {      
              'module'         : 'BSTs',
              'lecture'        : 'render',
              'kind'           : 'Practice',
              'setNumber'      : 6,
              'name'           : 'Render BST with Lines',
              'codeFiles'      : ['render-bst-w-lines-starter.rkt',
				  'render-bst-w-lines-solution.rkt'],
              'description'    : 'Design a function that renders a BST with lines.',
              'recipe'         : ['HtDF'],
              'duration'       : 45,
              'difficulty'     : 'Black'
          },
          
          {      
              'module'         : 'Mutual-Ref',
              'lecture'        : 'all',
              'kind'           : 'Lecture',
              'setNumber'      : 1,
              'name'           : 'File System',
              'codeFiles'      : ['fs-starter.rkt',
				  'fs-v1.rkt','fs-v2.rkt','fs-v3.rkt','fs-v4.rkt'],
              'description'    : 'An implementation of a file system, as demonstrated in lecture, with all intermediate solutions.',
              'recipe'         : ['HtDF'],
              'duration'       : 60,
              'difficulty'     : 'Black'
          },

          
          {      
              'module'         : 'Mutual-Ref',
              'lecture'        : 'fun-part-2',
              'kind'           : 'Practice',
              'setNumber'      : 1,
              'name'           : 'Image Organizer',
              'codeFiles'      : ['image-organizer-starter.rkt',
				  'image-organizer-solution.rkt'],
              'description'    : 'Several function design problems for arbitrary-arity trees.',
              'recipe'         : ['HtDF'],
              'duration'       : 90,
              'difficulty'     : 'Blue'
          },

          {      
              'module'         : 'Mutual-Ref',
              'lecture'        : 'fun-part-2',
              'kind'           : 'Practice',
              'setNumber'      : 2,
              'name'           : 'Find Person',
              'codeFiles'      : ['find-person-starter.rkt',
				  'find-person-solution.rkt'],
              'description'    : 'Design a function to find a person in a person tree.',
              'recipe'         : ['HtDF'],
              'duration'       : 30,
              'difficulty'     : 'Blue'
          },
          {      
              'module'         : 'Mutual-Ref',
              'lecture'        : 'fun-part-2',
              'kind'           : 'Practice',
              'setNumber'      : 3,
              'name'           : 'Harry Potter Family Tree',
              'codeFiles'      : ['hp-family-tree-starter.rkt',
				  'hp-family-tree-solution.rkt'],
              'description'    : 'Represent information about descendant family trees from Harry Potter and design functions that operate on them.',
              'recipe'         : ['HtDF'],
              'duration'       : 90,
              'difficulty'     : 'Blue'
          },
          
          // 2-One-Of
          {      
              'module'         : '2-One-Of',
              'lecture'        : 'code',
              'kind'           : 'Practice',
              'setNumber'      : 1,
              'name'           : 'Concat',
              'codeFiles'      : ['concat-starter.rkt',
				  'concat-solution.rkt'],
              'description'    : 'Design a function that concatenates two lists.',
              'recipe'         : ['HtDF'],
              'duration'       : 25,
              'difficulty'     : 'Blue'
          },
          {      
              'module'         : '2-One-Of',
              'lecture'        : 'code',
              'kind'           : 'Practice',
              'setNumber'      : 2,
              'name'           : 'Merge',
              'codeFiles'      : ['merge-starter.rkt',
				  'merge-solution.rkt'],
              'description'    : 'Design a function that merges two sorted lists into a single sorted list.',
              'recipe'         : ['HtDF'],
              'duration'       : 35,
              'difficulty'     : 'Blue'
          },
          {      
              'module'         : '2-One-Of',
              'lecture'        : 'code',
              'kind'           : 'Practice',
              'setNumber'      : 3,
              'name'           : 'Zip',
              'codeFiles'      : ['zip-starter.rkt',
				  'zip-solution.rkt'],
              'description'    : 'Design a function that produces a list of the corresponding elements of the given two lists.',
              'recipe'         : ['HtDF'],
              'duration'       : 30,
              'difficulty'     : 'Blue'
          },
          {      
              'module'         : '2-One-Of',
              'lecture'        : 'code',
              'kind'           : 'Practice',
              'setNumber'      : 4,
              'name'           : 'Pattern Match',
              'codeFiles'      : ['pattern-match-starter.rkt',
				  'pattern-match-solution.rkt'],
              'description'    : 'Design a function that determines if a sequence of characters matches a given pattern.',
              'recipe'         : ['HtDF'],
              'duration'       : 40,
              'difficulty'     : 'Blue'
          },   
          {      
              'module'         : '2-One-Of',
              'lecture'        : 'code',
              'kind'           : 'Practice',
              'setNumber'      : 5,
              'name'           : 'Championship Bracket',
              'codeFiles'      : ['championship-bracket-starter.rkt',
				  'championship-bracket-solution.rkt'],
              'description'    : 'Represent and operate on information about USA Ultimate championship bracket.',
              'recipe'         : ['HtDF'],
              'duration'       : 40,
              'difficulty'     : 'Blue'
          },
          
          {      
              'module'         : 'Local',
              'lecture'        : 'encap, recomp',
              'kind'           : 'Lecture',
              'setNumber'      : 1,
              'name'           : 'File System 2',
              'codeFiles'      : ['fs-v4.rkt','fs-v5.rkt',
				  'fs-v6.rkt','fs-v7.rkt'],
              'description'    : 'Refactoring of file system developed in Mutual-Ref.',
              'recipe'         : 'HtDF',
              'duration'       : 25,
              'difficulty'     : 'Blue'
          },
          {      
              'module'         : 'Local',
              'lecture'        : 'eval',
              'kind'           : 'Practice',
              'setNumber'      : 1,
              'name'           : 'Evaluate boo',
              'codeFiles'      : ['evaluate-boo-starter.rkt',
				  'evaluate-boo-solution.rkt'],
              'description'    : 'Step by step evaluation of a call to a function that involves local.',
              'duration'       : 15,
              'difficulty'     : 'Green'
          },
          {      
              'module'         : 'Local',
              'lecture'        : 'avoid-recomp',
              'kind'           : 'Practice',
              'setNumber'      : 2,
              'name'           : 'Faster Render BST with Lines',
              'codeFiles'      : ['render-bst-w-lines-faster-starter.rkt',
				  'render-bst-w-lines-faster-solution.rkt'],
              'description'    : 'Improve the performance of a function that produces a simple rendering of a bst with lines.',
              'recipe'         : ['HtDF'],
              'duration'       : 30,
              'difficulty'     : 'Blue'
          },
          
	  {      
              'module'         : 'Local',
              'lecture'        : 'eval',
              'kind'           : 'Practice',
              'setNumber'      : 3,
              'name'           : 'Evaluate foo',
              'codeFiles'      : ['evaluate-foo-starter.rkt',
				  'evaluate-foo-solution.rkt'],
              'description'    : 'Step by step evaluation of a call to a function that involves local.',
              'duration'       : 30,
              'difficulty'     : 'Blue'
          },
          {      
              'module'         : 'Local',
              'lecture'        : 'encap',
              'kind'           : 'Practice',
              'setNumber'      : 4,
              'name'           : 'Encapsulate total area',
              'codeFiles'      : ['encapsulate-total-area-starter.rkt',
				  'encapsulate-total-area-solution.rkt'],
              'description'    : 'Encapsulate the total-area function into local.',
              'recipe'         : ['HtDF'],
              'duration'       : 25,
              'difficulty'     : 'Green'
          },
          {      
              'module'         : 'Local',
              'lecture'        : 'encap, avoid-recomp',
              'kind'           : 'Practice',
              'setNumber'      : 5,
              'name'           : 'Championship Bracket Improved',
              'codeFiles'      : ['championship-bracket-improved-starter.rkt',
				  'championship-bracket-improved-solution.rkt'],
              'description'    : 'Improve a function that determines which team knocked a given team out of the tournament.',
              'recipe'         : ['HtDF'],
              'duration'       : 30,
              'difficulty'     : 'Blue'
          },




          {      
              'module'         : 'Abstraction',
              'lecture'        : 'from-ex',
              'kind'           : 'Lecture',
              'setNumber'      : 1,
              'name'           : 'Parameterization',
              'codeFiles'      : ['parameterization-starter.rkt',
				  'parameterization-v2.rkt','parameterization-v3.rkt','parameterization-solution.rkt'],
              'description'    : 'Introduction to abstracting functions, as demonstrated in lecture, with intermediate solutions.',
              'recipe'         : 'HtDF',
              'duration'       : 45,
              'difficulty'     : 'Blue'
          },
          
          {      
              'module'         : 'Abstraction',
              'lecture'        : 'built-in',
              'kind'           : 'Lecture',
              'setNumber'      : 2,
              'name'           : 'Using built ins',
              'codeFiles'      : ['using-built-ins-starter.rkt',
				  'using-built-ins-solution.rkt'],
              'description'    : 'Design functions that use built-in abstract list functions.',
              'recipe'         : 'HtDF',
              'duration'       : 25,
              'difficulty'     : 'Green'
          },
          {      
              'module'         : 'Abstraction',
              'lecture'        : 'closures',
              'kind'           : 'Lecture',
              'setNumber'      : 3,
              'name'           : 'Closures',
              'codeFiles'      : ['closures-starter.rkt',
				  'closures-solution.rkt'],
              'description'    : 'Design functions that use built-in abstract list functions with closure.',
              'recipe'         : 'HtDF',
              'duration'       : 35,
              'difficulty'     : 'Blue'
          },

          {      
              'module'         : 'Abstraction',
              'lecture'        : 'built-in',
              'kind'           : 'Practice',
              'setNumber'      : 1,
              'name'           : 'Wide only',
              'codeFiles'      : ['wide-only-starter.rkt',
				  'wide-only-solution.rkt'],
              'description'    : 'Design a function to produce only wide images from a list of images.',
              'recipe'         : ['HtDF'],
              'duration'       : 15,
              'difficulty'     : 'Green'
          },
          {      
              'module'         : 'Abstraction',
              'lecture'        : 'built-in',
              'kind'           : 'Practice',
              'setNumber'      : 2,
              'name'           : 'Photos',
              'codeFiles'      : ['photos-starter.rkt',
				  'photos-solution.rkt'],
              'description'    : 'Design a function to produce all the favourited photos in the given album.',
              'recipe'         : ['HtDF'],
              'duration'       : 25,
              'difficulty'     : 'Blue'
          },

          {      
              'module'         : 'Abstraction',
              'lecture'        : 'from-ex-3',
              'kind'           : 'Practice',
              'setNumber'      : 3,
              'name'           : 'Abstract sum',
              'codeFiles'      : ['abstract-sum-starter.rkt',
				  'abstract-sum-solution.rkt'],
              'description'    : 'Design an abstract function to simplify the sum-of functions.',
              'recipe'         : ['HtDF'],
              'duration'       : 30,
              'difficulty'     : 'Green'
          },
          {      
              'module'         : 'Abstraction',
              'lecture'        : 'from-ex-3',
              'kind'           : 'Practice',
              'setNumber'      : 4,
              'name'           : 'Abstract some',
              'codeFiles'      : ['abstract-some-starter.rkt',
				  'abstract-some-solution.rkt'],
              'description'    : 'Design an abstract function to simplify the some functions.',
              'recipe'         : ['HtDF'],
              'duration'       : 40,
              'difficulty'     : 'Blue'
          },
          {      
              'module'         : 'Abstraction',
              'lecture'        : 'built-in',
              'kind'           : 'Practice',
              'setNumber'      : 5,
              'name'           : 'Ellipses',
              'codeFiles'      : ['ellipses-starter.rkt',
				  'ellipses-solution.rkt'],
              'description'    : 'Write expressions that uses abstract functions to produce a list of ellipses and images of ellipses.',
              'duration'       : 25,
              'difficulty'     : 'Blue'
          },
          {      
              'module'         : 'Abstraction',
              'lecture'        : 'built-in',
              'kind'           : 'Practice',
              'setNumber'      : 6,
              'name'           : 'Bag',
              'codeFiles'      : ['bag-starter.rkt',
				  'bag-solution.rkt'],
              'description'    : 'Design a function to produce the linear lengths of a list of bags.',
              'recipe'         : ['HtDF'],
              'duration'       : 25,
              'difficulty'     : 'Green'
          },
          {      
              'module'         : 'Abstraction',
              'lecture'        : 'built-in',
              'kind'           : 'Practice',
              'setNumber'      : 7,
              'name'           : 'Sum n',
              'codeFiles'      : ['sum-n-starter.rkt',
				  'sum-n-solution.rkt'],
              'description'    : 'Design a function to produce the sum of the first n odd numbers.',
              'recipe'         : ['HtDF'],
              'duration'       : 25,
              'difficulty'     : 'Blue'
          },
          {      
              'module'         : 'Abstraction',
              'lecture'        : 'fold',
              'kind'           : 'Practice',
              'setNumber'      : 8,
              'name'           : 'Fold dir',
              'codeFiles'      : ['fold-dir-starter.rkt',
				  'fold-dir-solution.rkt'],
              'description'    : 'Design an abstract fold function for Dir and some functions that uses this abstract function.',
              'recipe'         : ['HtDF'],
              'duration'       : 60,
              'difficulty'     : 'Black'
          },
          {      
              'module'         : 'Abstraction',
              'lecture'        : 'from-ex-3',
              'kind'           : 'Practice',
              'setNumber'      : 9,
              'name'           : 'Accounts',
              'codeFiles'      : ['accounts-starter.rkt',
				  'accounts-solution.rkt'],
              'description'    : 'Design abstract functions to simplify given functions.',
              'recipe'         : ['HtDF'],
              'duration'       : 45,
              'difficulty'     : 'Blue'
          },
          {      
              'module'         : 'Abstraction',
              'lecture'        : 'built-in',
              'kind'           : 'Practice',
              'setNumber'      : 10,
              'name'           : 'Weather',
              'codeFiles'      : ['weather-starter.rkt','weather.ss',
				  'weather-solution.rkt'],
              'description'    : 'Use built-in abstract functions to design a function that produces the sum total of rainfall on warm days.',
              'recipe'         : ['HtDF'],
              'duration'       : 30,
              'difficulty'     : 'Blue'
          },
          
          
          
          
          {      
              'module'         : 'Genrec',
              'lecture'        : 'fractals',
              'kind'           : 'Lecture',
              'setNumber'      : 1,
              'name'           : 'Fractals',
              'codeFiles'      : ['fractals-starter.rkt',
				  'fractals-v1.rkt','fractals-v2.rkt'],
              'description'    : 'Design of a few basic fractals, as demonstrated in lecture, with intermediate solutions.',
              'recipe'         : ['HtDF'],
              'duration'       : 30,
              'difficulty'     : 'Green'
          },
          {      
              'module'         : 'Genrec',
              'lecture'        : 'term-arg',
              'kind'           : 'Lecture',
              'setNumber'      : 2,
              'name'           : 'Termination',
              'codeFiles'      : ['termination-starter.rkt',
				  'termination-solution.rkt'],
              'description'    : 'Design three part termination argument for generative recursions.',
              'recipe'         : ['HtDF'],
              'duration'       : 45,
              'difficulty'     : 'Blue'
          },
          {      
              'module'         : 'Genrec',
              'lecture'        : 'term-arg',
              'kind'           : 'Practice',
              'setNumber'      : 1,
              'name'           : 'Circle Fractal',
              'codeFiles'      : ['circle-fractal-starter.rkt',
				  'circle-fractal-solution.rkt'],
              'description'    : 'Design a function to draw a circle fractal.',
              'recipe'         : ['HtDF'],
              'duration'       : 90,
              'difficulty'     : 'Black'
          },
          {      
              'module'         : 'Genrec',
              'lecture'        : 'term-arg',
              'kind'           : 'Practice',
              'setNumber'      : 2,
              'name'           : 'Van Koch',
              'codeFiles'      : ['van-koch-starter.rkt',
				  'van-koch-solution.rkt'],
              'description'    : 'Design a function to draw a Van Koch fractal line. The GEOMETRY of this problem is much more difficult than the triangle and the carpet. If you feel confident with cartesian geometry then this function may not be too difficult. If you feel less confident then you may find this problem to be too difficult.',
              'recipe'         : ['HtDF'],
              'duration'       : 110,
              'difficulty'     : 'Black'
          },
          {      
              'module'         : 'Genrec',
              'lecture'        : 'term-arg',
              'kind'           : 'Practice',
              'setNumber'      : 3,
              'name'           : 'Cantor',
              'codeFiles'      : ['cantor-starter.rkt',
				  'cantor-solution.rkt'],
              'description'    : 'Design a world program to create the cantor set.',
              'recipe'         : ['HtDW'],
              'duration'       : 90,
              'difficulty'     : 'Blue'
          },

          {      
              'module'         : 'Search',
              'lecture'        : 'sudoku',
              'kind'           : 'Lecture',
              'setNumber'      : 1,
              'name'           : 'Sudoku',
              'codeFiles'      : ['sudoku-starter.rkt','sudoku-v1.rkt','sudoku-v2.rkt','sudoku-v3.rkt', 'sudoku-v4.rkt','sudoku-solution.rkt','sudoku-constraints.rkt'],
              'description'    : 'Design a program that solves a sudoku board, as demonstrated in lecture, with intermediate solutions.',
              'recipe'         : ['HtDF'],
              'duration'       : 180,
              'difficulty'     : 'Black'
          },

	  {      
              'module'         : 'Search',
              'lecture'        : 'sudoku',
              'kind'           : 'Practice',
              'setNumber'      : 1,
              'name'           : '2 Way Maze',
              'codeFiles'      : ['maze-2w-starter.rkt','maze-2w-v1.rkt', 'maze-2w-solution.rkt'],
              'description'    : 'Design a program that tries to find the path through a maze.',
              'recipe'         : ['HtDF'],
              'duration'       : 120,
              'difficulty'     : 'Black'
          },

	  {      
              'module'         : 'Search',
              'lecture'        : 'sudoku',
              'kind'           : 'Practice',
              'setNumber'      : 2,
              'name'           : 'Triangle Solitaire',
              'codeFiles'      : ['triangle-solitaire-starter.rkt','triangle-solitaire-v2.rkt','triangle-solitaire-v3.rkt','triangle-solitaire-v4.rkt'],
              'description'    : 'Design a program that solves triangle solitaire puzzles.',
              'recipe'         : ['HtDF'],
              'duration'       : 120,
              'difficulty'     : 'Black'
          },

	  {      
              'module'         : 'Search',
              'lecture'        : 'sudoku',
              'kind'           : 'Practice',
              'setNumber'      : 3,
              'name'           : 'N Queens',
              'codeFiles'      : ['nqueens-starter.rkt','nqueens-v1.rkt','nqueens-v2.rkt','nqueens-solution.rkt'],
              'description'    : 'Design a program that solves the n queens problem.',
              'recipe'         : ['HtDF'],
              'duration'       : 360,
              'difficulty'     : 'Black'
          },

	  {      
              'module'         : 'Search',
              'lecture'        : 'sudoku',
              'kind'           : 'Practice',
              'setNumber'      : 4,
              'name'           : 'Programming Contest',
              'codeFiles'      : ['programming-contest-starter.rkt','programming-contest-v1.rkt','programming-contest-solution.rkt'],
              'description'    : 'Design a program to help your team plan what problems to solve in a programming contest.',
              'recipe'         : ['HtDF'],
              'duration'       : 180,
              'difficulty'     : 'Black'
          },
          
          // Accumulators
          {      
              'module'         : 'Accumulators',
              'lecture'        : 'context-preserv-acc',
              'kind'           : 'Practice',
              'setNumber'      : 1,
              'name'           : 'Drop N',
              'codeFiles'      : ['dropn-starter.rkt',
				  'dropn-solution.rkt'],
              'description'    : 'Design a function that drops every nth element from a list.',
              'recipe'         : ['HtDF'],
              'duration'       : 15,
              'difficulty'     : 'Green'
          },
          {      
              'module'         : 'Accumulators',
              'lecture'        : 'context-preserv-acc',
              'kind'           : 'Practice',
              'setNumber'      : 2,
              'name'           : 'Replicate Element',
              'codeFiles'      : ['replicate-elm-starter.rkt',
				  'replicate-elm-solution.rkt'],
              'description'    : 'Design a function that replicates elements in a list.',
              'recipe'         : ['HtDF'],
              'duration'       : 15,
              'difficulty'     : 'Green'
          },
          {      
              'module'         : 'Accumulators',
              'lecture'        : 'context-preserv-acc',
              'kind'           : 'Practice',
              'setNumber'      : 3,
              'name'           : 'Strictly Decreasing',
              'codeFiles'      : ['strictly-decreasing-starter.rkt',
				  'strictly-decreasing-solution.rkt'],
              'description'    : 'Design a function that produces true if numbers in a list are strictly decreasing.',
              'recipe'         : ['HtDF'],
              'duration'       : 20,
              'difficulty'     : 'Green'
          },                 
          {      
              'module'         : 'Accumulators',
              'lecture'        : 'tail-rec',
              'kind'           : 'Practice',
              'setNumber'      : 4,
              'name'           : 'Average',
              'codeFiles'      : ['average-tr-starter.rkt',
				  'average-tr-solution.rkt'],
              'description'    : 'Design a tail-recursive function that produces the average of numbers in a list.',
              'recipe'         : ['HtDF'],
              'duration'       : 15,
              'difficulty'     : 'Green'
          },
          {      
              'module'         : 'Accumulators',
              'lecture'        : 'tail-rec',
              'kind'           : 'Practice',
              'setNumber'      : 5,
              'name'           : 'Product',
              'codeFiles'      : ['product-tr-starter.rkt',
				  'product-tr-solution.rkt'],
              'description'    : 'Design a tail-recursive version of a function that produces the product of numbers in a list.',
              'recipe'         : ['HtDF'],
              'duration'       : 15,
              'difficulty'     : 'Green'
          },
          {      
              'module'         : 'Accumulators',
              'lecture'        : 'tail-rec',
              'kind'           : 'Practice',
              'setNumber'      : 6,
              'name'           : 'Sum N',
              'codeFiles'      : ['sum-n-tr-starter.rkt',
				  'sum-n-tr-solution.rkt'],
              'description'    : 'Design a tail-recursive version of a function that produces the sum of naturals in [0, n].',
              'recipe'         : ['HtDF'],
              'duration'       : 15,
              'difficulty'     : 'Green'
          },
          {      
              'module'         : 'Accumulators',
              'lecture'        : 'tail-rec',
              'kind'           : 'Practice',
              'setNumber'      : 7,
              'name'           : 'Sum Odds',
              'codeFiles'      : ['sum-odds-tr-starter.rkt',
				  'sum-odds-tr-solution.rkt'],
              'description'    : 'Design a tail-recursive version of a function that produces the sum of odd numbers in a list.',
              'recipe'         : ['HtDF'],
              'duration'       : 15,
              'difficulty'     : 'Green'
          },
          {      
              'module'         : 'Accumulators',
              'lecture'        : 'tail-rec',
              'kind'           : 'Practice',
              'setNumber'      : 8,
              'name'           : 'To list',
              'codeFiles'      : ['to-list-tr-starter.rkt',
				  'to-list-tr-solution.rkt'],
              'description'    : 'Design a tail-recursive version of a function that produces a list of naturals from 1 to n.',
              'recipe'         : ['HtDF'],
              'duration'       : 15,
              'difficulty'     : 'Green'
          },
          {      
              'module'         : 'Accumulators',
              'lecture'        : 'tail-rec',
              'kind'           : 'Practice',
              'setNumber'      : 9,
              'name'           : 'Count Evens and Odds',
              'codeFiles'      : ['count-odd-even-tr-starter.rkt',
				  'count-odd-even-tr-solution.rkt'],
              'description'    : 'Design a tail-recursive function that produces separate counts of odd and even numbers in a list.',
              'recipe'         : ['HtDF'],
              'duration'       : 20,
              'difficulty'     : 'Blue'
          },
          {      
              'module'         : 'Accumulators',
              'lecture'        : 'tail-rec',
              'kind'           : 'Practice',
              'setNumber'      : 10,
              'name'           : 'Reverse',
              'codeFiles'      : ['rev-tr-starter.rkt',
				  'rev-tr-solution.rkt'],
              'description'    : 'Design a tail-recursive function that produces a list of the same elements in the opposite order.',
              'recipe'         : ['HtDF'],
              'duration'       : 20,
              'difficulty'     : 'Blue'
          },
          {      
              'module'         : 'Accumulators',
              'lecture'        : 'worklist-acc',
              'kind'           : 'Practice',
              'setNumber'      : 11,
              'name'           : 'House Path',
              'codeFiles'      : ['house-path-starter.rkt',
				  'house-path-solution.rkt'],
              'description'    : 'Design functions that operate on house paths.',
              'recipe'         : ['HtDF'],
              'duration'       : 45,
              'difficulty'     : 'Blue'
          },
          {      
              'module'         : 'Accumulators',
              'lecture'        : 'worklist-acc',
              'kind'           : 'Practice',
              'setNumber'      : 12,
              'name'           : 'Contains Key',
              'codeFiles'      : ['contains-key-tr-starter.rkt',
				  'contains-key-tr-solution.rkt'],
              'description'    : 'Design a tail-recursive function that determines whether a binary tree contains a given key.',
              'recipe'         : ['HtDF'],
              'duration'       : 40,
              'difficulty'     : 'Blue'
          },
          
          {      
              'module'         : 'Accumulators',
              'lecture'        : 'context-preserv-acc',
              'kind'           : 'Lecture',
              'setNumber'      : 1,
              'name'           : 'Context Preserving Accumulators',
              'codeFiles'      : ['skip1-starter.rkt','skip1-solution.rkt','skip1-v1.rkt','skipn-starter.rkt','skipn-solution.rkt','skipn-v1.rkt'],
              'description'    : 'Problems where an accumulator is needed to preserve information lost in the structural recursion template.',
              'recipe'         : ['HtDF'],
              'duration'       : 60,
              'difficulty'     : 'Blue'
          },
          {      
              'module'         : 'Accumulators',
              'lecture'        : 'tail-rec',
              'kind'           : 'Lecture',
              'setNumber'      : 2,
              'name'           : 'Tail Recursion',
              'codeFiles'      : ['sum-tr-starter.rkt','sum-tr-solution.rkt'],
              'description'    : 'Using accumulators to make functions tail recursive.',
              'recipe'         : ['HtDF'],
              'duration'       : 50,
              'difficulty'     : 'Blue'
          },
          {      
              'module'         : 'Accumulators',
              'lecture'        : 'worklist-acc',
              'kind'           : 'Lecture',
              'setNumber'      : 3,
              'name'           : 'Worklist Accumulators',
              'codeFiles'      : ['same-house-as-parent-v1.rkt','same-house-as-parent-v2.rkt','same-house-as-parent-v3.rkt','same-house-as-parent-v4.rkt','same-house-as-parent-v5.rkt','same-house-as-parent-v6.rkt','same-house-as-parent-v7.rkt','same-house-as-parent-solution.rkt'],
              'description'    : 'Making functions operating on an arbitrary-arity tree tail recursive using context preserving and worklist accumulators.',
              'recipe'         : ['HtDF'],
              'duration'       : 120,
              'difficulty'     : 'Black'
          },
          
          // Graphs
          {      
              'module'         : 'Graphs',
              'lecture'        : 'graphs-reachable',
              'kind'           : 'Practice',
              'setNumber'      : 1,
              'name'           : 'All Reachable',
              'codeFiles'      : ['all-reachable-starter.rkt', 'all-reachable-solution.rkt'],                         
	      'description'    : 'Design a function that produces rooms reachable from a given room.',
              'recipe'         : ['HtDF'],
              'duration'       : 20,
              'difficulty'     : 'Green'
          },
          {      
              'module'         : 'Graphs',
              'lecture'        : 'graphs-reachable',
              'kind'           : 'Practice',
              'setNumber'      : 2,
              'name'           : 'Count Rooms',
              'codeFiles'      : ['count-rooms-starter.rkt', 'count-rooms-solution.rkt'],                         
	      'description'    : 'Design a function that produces the number of rooms reachable from a given room.',
              'recipe'         : ['HtDF'],
              'duration'       : 20,
              'difficulty'     : 'Green'
          },
          {      
              'module'         : 'Graphs',
              'lecture'        : 'graphs-reachable',
              'kind'           : 'Practice',
              'setNumber'      : 3,
              'name'           : 'Lookup Room',
              'codeFiles'      : ['lookup-room-starter.rkt', 'lookup-room-solution.rkt'],                         
	      'description'    : 'Design a function that produces a room with the given name.',
              'recipe'         : ['HtDF'],
              'duration'       : 20,
              'difficulty'     : 'Green'
          },
          {      
              'module'         : 'Graphs',
              'lecture'        : 'graphs-reachable',
              'kind'           : 'Practice',
              'setNumber'      : 4,
              'name'           : 'Max Exits From',
              'codeFiles'      : ['max-exits-from-starter.rkt', 'max-exits-from-solution.rkt'],                         
	      'description'    : 'Design a function that produces the room with the most exits.',
              'recipe'         : ['HtDF'],
              'duration'       : 40,
              'difficulty'     : 'Blue'
          },
          {      
              'module'         : 'Graphs',
              'lecture'        : 'graphs-reachable',
              'kind'           : 'Practice',
              'setNumber'      : 5,
              'name'           : 'Max Exits to',
              'codeFiles'      : ['max-exits-to-starter.rkt', 'max-exits-to-solution.rkt'],                         
	      'description'    : 'Design a function that produces a room to which the greatest number of other rooms have exits.',
              'recipe'         : ['HtDF'],
              'duration'       : 60,
              'difficulty'     : 'Black'
          },
          {      
              'module'         : 'Graphs',
              'lecture'        : 'cyclic-data, templating, reachable',
              'kind'           : 'Lecture',
              'setNumber'      : 1,
              'name'           : 'Graphs',
              'codeFiles'      : ['graphs-v1.rkt','graphs-v2.rkt','graphs-v3.rkt','graphs-v4.rkt','graphs-v5.rkt'],
              'description'    : 'Walking through the design of a data definition for representing graphs, and a simple function that operates on those graphs.',
              'recipe'         : ['HtDF'],
              'duration'       : 120,
              'difficulty'     : 'Black'
          }

          

      ]};
