-
Notifications
You must be signed in to change notification settings - Fork 1
Anatomy of a Good Learning Goal
This document outlines what makes a good goal. It specifies qualities of a goal, and provides example cases to help in reviewing/authoring good goals.
As learners who are authoring and reviewing goals, we consider the following qualities to be essential:
| Quality | Criteria |
|---|---|
| Complete | There are no missing components. Every section (i.e. "Description", "Specifications") is complete. |
| Clear | The language used is concise and readable, without unnecessary jargon. The expectations for the artifact are obvious. |
| Relevant | The goal will help learners develop important and relevant web development skills. |
| Focused | There is little room for distraction. Non-relevant tasks are minimized. |
| Deterministic | Based on the specifications and description, it is straight-forward to evaluate completeness. No vague specs. |
| Well-Sized | Completing the goal will easily fill a week of a challenging work for a learner in their ZPD. |
| Resourced | Useful and relevant third-party resources are referenced and utilized whenever possible. Leverage the Internet! |
A quick note on the subtlety of relevancy: just because a task is interesting does not mean that it is not a distraction. A goal that requires learners to do a lot of UI design, or project management, or content creation is irrelevant because it centers attention on skills that are non-critical for the craft of JS web development, even if those tasks may be interesting or fun.
For real examples of goal reviews, take a look at the following pull requests (both commits and conversations/comments):
- "Question and answer web app" -> terse, obviously relevant
- "Web UI for shared resource library" -> focused on one component
- "Chat command-line tool with Node.js" -> clear, specific
- "Social media site" -> too ambiguous
- "Figure out how to use WebGL" -> describes the process, not the product
- "Enterprise-level accounting software for Windows 98 using Java and C# and Prolog" -> not super relevant to the craft of web development
Set is a wonderfully simple and yet challenging pattern-matching card game. If you haven't played the real-life version, go find it and play it! It's a lot of fun.
In this goal, you will build a playable version of Set as a static web site (i.e. no server-side logic). You'll have to implement the game logic using JavaScript and the React.js [link] library.
The official rules of the game are described in full in this document [link]. Use it as your reference for both the game logic and the card design.
This description is clear (it states exactly what will be produced), relevant (identifies web tech to be used), and resourced (it makes use of an existing game and its predefined rules).
The goal is to create the same web application using three different language/framework combinations: Ruby on Rails, Node.js/Express and Python/Django.
This description is not clear (it doesn't say anything specific about what the product actually is) and it is (arguably) not critically relevant or focused for a JavaScript web dev.
- Artifact produced is a fork of the core-algorithms repo.
- Can run all tests with
npm test. - All tests are passing.
- For each algorithm in the algorithms list, there exists:
- a test file with at least 2 unit tests using valid inputs, and at least 1 unit test using invalid inputs.
- an implementation file with a correct implementation of the algorithm.
These specs are deterministic (there is no room for ambiguity) and well-sized (learners in their ZPD will be challenged to complete the goal in 1 week).
- All logic in the client-side code
- No database (just raw JSON files loaded into the browser)
- Tools used:
- Node.js
- Webpack
- React
- d3.js
- Bootstrap
These are not deterministic (what does it mean to "use" a tool?) or well-sized (it's very hard to say exactly what is being asked here).
Functional programming patterns are becoming increasingly popular in the web development community. Using these patterns results in code that is more adaptable and flexible, less buggy, and more scalable.
The article The Two Pillars of JavaScript : Pt 2: Functional Programming How to Stop Micromanaging Everything goes into many of the reasons why you might want to consider learning how to write JavaScript as a functional programmer would.
This context answers the question "why is this relevant to my learning?" and references a useful external resource.
Solidify your knowledge of the JavaScript language
It's too broad to be useful. Not very clear or focused.