Expectations

version 1.1

Course Description

This fast-paced 17-week evening course offers a solid foundation in Javascript programming and a sample of experience developing every layer of a web application.

Not a contract

For definitive contractual agreements, see the "Portland Code School Student Enrollment Agreement" that you signed. Nothing in this syllabus is intended to supersede or replace terms agreed to in that document. Where a conflict exists, that document will apply.

Meeting hours:

Monday & Wednesday evenings (6:00 PM - 9:00 PM) and one Saturday each month (9:00 AM - 4:00 PM).

Location:

PCS Classroom, 735 SW 20th Place, Suite 230

Instructors:

Dan Bauer - Email: dbauer@portlandcodeschool.com - Office Hours: Sundays 3:00 - 6:00PM, or as needed.

Prerequisites

Before starting this course, you should be:

• comfortable building simple, static web pages by writing raw HTML and CSS in a text editor;
• familiar with the LINUX/OSX command line and able to navigate and manipulate your file system strictly through the terminal;
• acquainted with the basics of version-control through git and github.

You don't need prior programming experience, but it helps. This course is oriented to beginning programmers, but the less experience you come in with, the more time you'll need to commit to keep up. It's possible to succeed with either limited availability or limited experience, but not both.

Learning Objectives and Core Outcomes

Code Elements

• Core Javascript

  • Control structures: functions, operators, loops, conditionals;
  • Data structures: arrays, objects, JSON, and custom structures;
  • Core functions and class methods;
  • Use of nested functions, callbacks, and closures;
  • Modular design, interfaces, and implementation privacy;
  • Constructors, factories, and other object patterns;
  • Classes, prototypes, and inheritance;

• DOM manipulation

  • Dynamic manipulation of document structure and HTML elements;
  • Dynamic manipulation of appearance through CSS
  • Event handling
  • Jquery

• Front-end (client) frameworks and application design

  • MVC patterns and modularity
  • Backbone

• Back-end (server and database) frameworks and services

  • NodeJS
  • REST/HTTP
  • Orchestrate
  • APIs

Workflow Practices

• git, github, and repository management
• npm
• jsHint
• Unit testing (with Mocha and Chai)

Problem Solving Skills

• Pre-coding with diagrams, examples, and pseudo-code
• Choosing control structures appropriate to the logic of a solution
• Decomposing complex problems into simpler ones
• Designing data structures appropriate to a problem
• Discovering algorithms for novel problems without re-inventing established solutions
• Partitioning an application into modules with well-defined responsibilities
• Generalizing functions and modules to afford effective reuse
• Articulating assertions about the pre- and post-conditions of code units
• Anticipating sources of code failure and including reasonable safeguards
• Generating example cases and outliers for testing code

Communication Skills

• Expressing your reasoning and assumptions while solving problems in real time;
• Expressing partial understanding and paths of approach to unsolved problems;
• Delivering effective presentations on prepared topics to an appropriate degree of detail;
• Documenting code with an appropriate level of commentary;
• Coding clearly and efficently so that your code is accessible even without comments;
• Expressing design ideas though mock-ups, wireframes, storyboards, or other representations;
• Collaborating with team members about unresolved issues and articulate the space of visible solutions;
• Partitioning responsibilities between team members.

Career Skills

Educational Expectations

Time Commitment

In addition to the 7-8 (averaged) hours of class time each week, you should expect to spend at least 20 hours/week outside of class in a combination of self-study and peer collaboration.

Using your time effectively

There is a wide gulf between passively absorbing information, even actual code, and actively generating it. Generation, of both code and intermediate products, is far more difficult and more important.

Up to 20% of your time could reasonably be spent in a largely passive mode, absorbing information: reading about Javascript and related tools, watching tutorials, listening to someone else's explanations.

But least 80% of your time should be in production mode, in active generation of intellectual work. This could include:

• Actually typing code;
• Testing code fragments and expressions in a JS console, making and verifying predictions;
• Articulating pseudo-code, verbal descriptions of data structures and processes needed to manipulate them;
• Sketching diagrams on paper to represent data or processes or to trace the execution of code samples;
• Participating actively in conversation about specific problems;
• Articulating and writing down questions when you discover gaps in your understanding;
• Searching online for the answers to specific questions, and revising your inquiry as you proceed;
• Explaining a concept or algorithm to a classmate.

As a general rule, within every hour of work you should generate some kind of physical or digital trail: a few lines of code, a diagram, a list of vocabulary, some written sentences describing what you've learned.

If you're not regularly generating artifacts, and relentlessly exposing confusion by making errors, you're fooling yourself about how much you understand.

Homework

Weekly homework assignments are the backbone of this course; they will help you structure your efforts and ensure practice of the most important skills. The homework problems will often be difficult; they are meant to exercise you until it hurts. We don't expect you to solve them all, but make your best effort; your growth will be proportional to the number of problems you wrestle with.

Exploration

Although the homework problems are important and demanding, don't become fixated on solving them to the exclusion of making discoveries. Some of your time each week should be spent in active play:

• changing a problem in way you find interesting;
• discovering a new function or feature of JS and testing out how it works;
• forming a hypothesis about the behavior of some code, or unusual inputs to code, and doing experiments to test your prediction;
• finding a sample of code unrelated to class and figuring out how it works.

In short, explore: push all the buttons, turn all the knobs, take everything apart and poke the pieces, and put them back together in ridiculous ways.

Tracking your time

You should create a free account with Harvest or another time-tracking service and log all of the hours you spend related to the class. Try to describe your activity in sufficient detail that, when you review your log after a week or month, you can draw useful lessons about your time-management.

Assessment Methods

You will not receive a grade. Your trophy will be the skills you build, and it's your responsibility to keep focused on that goal. But an inevitable secondary product is the impression you leave on your instructors and peers.

At the end of each term, employers ask us for recommendations -- the names of particularly talented and hard-working students. We want you to do well, and want to recommend you. And we have greater confidence in making endorsements when a trail of evidence of your participation supports our subjective impression.

All of these sources contribute to our evaluation of your progress and readiness:

1. Homework: The code and work products you submit will be evaluated by at least two people: you yourself and at least one TA or instructor. Each problem section will receive a score from 0-4, following a rubric which will be shared openly and re-negotiated as needed. The weekly details of your scores will have little significance, except for two worrisome patterns:

   • consistent differences (in either direction) between your self-evaluations and your mentor's evaluation are a sign that you don't recognize what constitutes code quality;
   • low scores (0 or 1) are a sign that either you're not managing your time or you're not connecting with others to get yourself unstuck.

2. Weekly Invoices: Life is busy, and you can have some distracted weeks, but if you have consistently low hours per week (or consistently fail to submit data!), your confusions will be met with less sympathy. And if your reported time spent is higher than your apparent progress, we'll wonder how efficiently your using your time.

3. Midterm Conferences: In Week 9 or 10 you'll need to schedule a time for a 30 minute conversation with your instructor about your progress and concerns. It will not be a technical interview, but you will be expected to offer a realistic and candid summary of your progress and proposals to redress any trends of failure.

4. Participation in Class and Office Hours: The ability to formulate questions even in the fog of confusion is a critical skill. No one is counting the number of questions you ask in class or scoring your success on in-class exercises, but a pattern of passivity will raise concerns and stunt your growth.

5. Practice talks, whiteboarding, and mock interviews: In later weeks especially, these activites can be a chance to show some skill which other measures have missed.

6. Capstone Groups: Starting in week 12, your instructor will organize you (with your input) into groups of 3-4 for your Capstone projects. Most of your activity in weeks 12-16 will be with your group, and you will succeed or flail together. Each week, your group will have a "stand-up" meeting with the instructor to report on your progress, obstacles, and individual roles. In this phase, teamwork is as important as individual skill, and people who might have been struggling in isolation will be re-evaluated in regard to their collaborative skills.

7. Capstone Presentations: The last evening of the class will be a public open-house in which Capstone groups show off their work to visitors including potential employers. That event is a chance to impress peers and future colleagues without regard to any bumps in the road beforehand.

Mutual Respect

This class depends upon an atmosphere of mutual respect among students and staff. Together, we create a safe place to listen, learn, speak candidly, and fail safely. This is not a typical college class, it's a team effort producing a final product: jobs for everyone. You have the opportunity to make deep connections here that you will enjoy the rest of your career.

Students are expected to act at their highest capacity and with mutual respect for each other regardless of age, race, gender identity and expression, sexual orientation, or prior experience. Instructors are expected to lead in this regard by example.

In a related vein, this class requires work in close proximity to others as we code and debug in pairs and small groups. Good hygiene is mandatory and an additional sign of respect for your colleagues.

Grievances Procedure

Students who observe or experience any behavior on the part of instructors, staff, or students at Portland Code School that does not meet the school's Code of Conduct should take action. If you experience or perceive a problem, attempt to work it out on your own, if possible, but do not hesitate to bring it privately to the attention of your instructor. If this is unsatisfactory, bring it to the attention of the school Director (Cris Kelly) or Director of Curriculum (Al Zimmerman).

Curriculum Overview

General Schedule

• Weeks 1-6: Core Javascript
• Weeks 7-9: DOM and Client Apps
• Weeks 10-12: HTTP and Servers
• Weeks 13-17: Advanced Topics, Capstone Projects

Calendar

This term's calendar of topics and assignments (subject to minor revision) is here.