10 Learning Objectives
Software Ecosystem and Development
- Program in Haskell using stack
- Setup a project
- Depend on external code (e.g., hackage libraries and other local projects)
- Version control projects with git
- Interact with other students and the instructors using GitHub features (e.g., pull requests and git issues)
- Write idiomatical functional programs expanding on skills required previously in COMP 105
- Elegantly handle common problems in functional code using design patterns (e.g. functors, applicatives, and monads)
- Encode and solve real world problems from a domain using functional programs
Abstractions and Representations
Recognize, analyze, and revise software designs with respect to abstractions (interfaces presented to external users), and representations (implementations depended upon for internal algorithms).
Technical Reading Comprehension
- Summarize the main points of technical papers
- Understand the benefits and tradeoffs of the approach described in a paper
- Compare works in the same field of study (e.g., compare DSL papers in similar domains, but solving different problems)
Technical Writing and Rhetoric
Present your designs and implementations for a like-minded audience such that:
- the problem you are solving is well-defined,
- your methods can be reproduced by an expert, and
- your product can be compared to other works under the same field of study with minimal effort.
Documentation and Usability
- Document your code such that it can be used by non-technical (non-PL-designer) users
- Design tests that cover your use cases
- Clearly delineate the scope of your project (what it can and cannot do)
This is practicing industry attractive soft-skills.
CodeGen and Metaprogramming
- Identify the supports required for metaprogramming (eg. boilerplate, libraries, and runtime system supports)
- Find candidates for metaprogramming by: (1) analysing redundant, boilerplate code from a set of programs, (2) abstracting away a pattern of common or generic code, and (3) reifying that pattern as a metaprogram.
- Do this for both templates (concrete to concrete metaprogramming) and CodeGen (AST to AST metaprogramming).
Language FrontEnd Design
- Define an abstract syntax that represents a small, composable core of a programming domain's operations
- Describe the idiomatic use of those operations as a concrete syntax
- Reify the relationship between the syntaxes as a grammar and a parser using parser combinators.
Composing Feedback and Evaluation
Provide meaningful, actionable feedback that:
- takes into account the skill level of those getting the feedback, and
- focuses primarily on the artifact as it is presented
Metacognition, Reflection, and Personal Growth
- Parse through feedback and evaluation to improve your designs, projects, and approaches to all areas in this course.
- Justify accepting or rejecting feedback, questions, or comments and show either growth or investment in the interaction.
5 Levels of Detail
Required level of skill to begin any of this work.
- Follow rote instructions and match given outcomes
- Confirm existing knowledge from other sources, e.g. COMP105
- Follow setup instructions
- Build muscle memory for routine tasks in the course.
Recreate solutions in the same context as that in which the material was taught (literally recall), but without hints.
In a "toy example" setting, follow rote instructions in cases where the exact outcome may not be given. Instead, evaluate your work against abstract acceptance criteria. E.g.: You may be given algebraic laws that a function definition must fulfill, as opposed to a finite set of test cases.
Fill in the blank
Solve a problem by recognizing that it is similar to one you have seen before.
Solve problems with a known solution when given the acceptance criteria, but not necessarily the rote instructions. This scaffolding acts as a sandbox to solidify your skills, since you need to re-use a known technique. E.g.: Use a design pattern practiced before on a new data type.
Think about something big and abstract in the context provided by this course -- in order words, reason about a specific domain.
Simplify real world problems into toy models that fit into the scope of the class. This process may not immediately have a solution, so you will have to make decisions on what to simplify in order to fit the problem domain to skills acquired in the course. E.g. design a mock model of a transit system that models its functions as an abstract data type.
Bring (or radiate) the knowledge and skills acquired in the course to "real world" contexts. From pedagogy theory, this is called far-transfer learning and answers the: "Will I use this n years from now?" question.
Show how the work you are doing can apply (or expand; grow out) to real world problems in the scope outside of this class. Speculate or provide artifacts that have potential for work beyond the class, such as proposals, papers, user documentation, and videos.
There isn't a clear analogy of assessment for radiant knowledge. Classrooms typically cannot assess how students have applied the concepts outside of the classroom because students aren't observed outside of the classroom. However, you are preparing artifacts for real world use and and we are simulating how experts in the field or end users would accept these artifacts, so, we can get pretty close to assessing your radiant knowledge.