In order to graduate from Module 4, students must successfully complete each of the following:
Students must pass each part of the final assessment. The final assessment is composed of three sections:
Assessment requirements will be provided during the first week of the module.
Expected: Students will build their Capstone project.
Expected: Students will complete and submit weekly Checks for Understanding questions (weeks 1-4).
Expected: Students, as a pair, complete the Quantified Self project.
Expected: Students, as a project team, are responsible for passing their Open Source project and submitting an individual blog post summarizing the experience.
The Career Development segment is made up of several pieces:
- The 30-day post-grad job search action plan (submitted in B4 portfolio)
- Share a summarized version of your professional story with your instructors during the portfolio review. This is a 1-2 minute sharing highlighting who you are, why you are in software, and what’s next in your career
- Prepare a lightning talk of their Turing story to present during the final week of the module (see the Turing Story Presentation section below)
Feedback & Community
As stewards of the larger Turing community, Module 4 students are expected to facilitate a Gear-up session that they’ve designed with other Mod 4 students.
When documenting your community contribution, say a few words about the facilitation experience.
To document all of the work you’ve done this module, follow the guidelines stated in the B4 portfolio template here. A Pull Requested submitting your portfolio is due Wednesday of Week 6.
Turing Story Presentation
On Thursday of Week 6, you’ll present the story of your journey at Turing to your classmates and staff.
- should be about 4 minutes
- should include the time leading up to Turing
- should include your time at Turing
- should include the trajectory you’re on as you start your new career
- should include thoughtful reflection and describe how you’ve grown and changed
- can include a slide deck, or any other visual aids you’d like
After you present, instructors will ask you a couple questions, mostly to dig into things we found interesting about your story. There’s not specific answers we’ll be looking for.
If you’re unsure how to cover your time at Turing, a common pattern is to simply talk about each module. Talk about your favorite project, or what the biggest takeaway was for you, or just a fun story from that module.
You’re required to present, but there’s no grade. As long as you get up and speak, you’ve met the requirement.
Academic success in B4 means that students demonstrate proficiency and comfort with the concepts below. The expected mastery level can be understood with the following scale:
- Mastery: student is able to explain and implement the concept independently or with light reference
- Functional: student recognizes when to use the concept and can implement it with the support of documentation and/or a collaborator
- Familiarity: student can recognize and describe the concept when needed/appropriate, but is not able to implement the technology/technique
Each of the following skills is covered in the curriculum, and most are covered by an assessment or project rubric.
- Students use an agile process to turn acceptance requirements into deployed software (mastery)
- Students estimate complexity of user stories (functional)
- Students translate acceptance requirements into user stories that are ready for work (mastery)
- Students verify acceptance requirements using automated testing (mastery)
- Students formulate questions by synthesizing what was expected vs what was observed (mastery)
- Students explain intent and execution of their code (mastery)
- Students document intent and usage of their code for effective collaboration (functional)
- Students use pull requests to organize discussion about features (functional)
- Students implement feedback from a code review to improve quality (functional)
- Students provide feedback in the form of a code review to improve quality and share knowledge (familiarity)
Core Technical Skills
Architecting for Scalability
- Students divide applications into components and domains of responsibilities to facilitate multi-developer teams (functional)
- Students abstract external dependencies and services to provide flexibility (familiarity)
- Students integrate outside data sources (Files, APIs, databases) (functional)
- Students coordinate data and events across applications (functional)
- Students build applications that execute in development, test, CI and production environments (functional)
- Students securely apply authentication and authorization patterns (functional)
- Students apply cacheing patterns to improve application performance (familiarity)
- Students create and use functions with parameters (mastery)
- Students organize functions into classes and objects (functional)
- Students make effective use of
thisin multiple contexts (functional)
- Students use event listeners to attach code to event-element combinations including document-ready and element-click (functional)
- Students write precise CSS-style selectors in multiple contexts like DOM manipulation and integration testing (functional)
- Students integrate outside data sources in the browser (AJAX, local storage) (functional)
- Students implement a stand-alone web service with Node and Express (functional)
- Students use the Node Package Manager to manage dependencies (functional)
- Students use WebPack as a build tool for organizing their code into modules (functional)
PostgreSQL & SQL
- Students write basic SQL statements without the assistance of an ORM (functional)
- Students use the CLI to understand the structure and data of their database (ex: list databases, tables, table structure) (familiarity)