Module 3 Success

Completion Requirements

In order to graduate from Module 3, students must complete each of the following:

Final Assessment

Students must earn a score of 3 or greater in each category of the final assessment rubric.

Independent Work

Expected: During M3 students will be required to complete API Curious as an independent project. Full requirements for that project can be found here.

Group Work

Expected: Students, as a pair, document the results of their Rales Engine project.

Expected: Students, as a group, document the results of both sprints of their Cloney Island project.

Professional Skills

The professional skills curriculum is available here. Students will be required to submit their deliverables as a pull request to the Career Development Curriculum Repository

Meg Stewart will review these deilverables, provide feedback, and alert the M3 instructional team of any deficiencies prior to portfolio reviews. Please provide a brief description of the career development work that you completed in your portfolios.

Feedback & Community

As stewards of the larger Turing community, Module 3 students are expected to complete at least one of the following:

  • lead or co-lead a Friday Spike session (submit through Turing Fridays App)
  • give a lightning talk (Sign up form)
  • open source contribution
  • write a blog post

Skill Proficiencies

Academic success in B3 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

Professional Skills

Project Management

  • Students communicate with product owners with regard to missing deadlines (functional)
  • Students understand the process by which business requirements are turned into acceptance requirements (familiar)
  • Students introduce how acceptance requirements are turned into stories and feature requirements (functional)
  • Students use pull requests to organize discussion about features (mastery)
  • Students utilize project management tools to communicate across technical teams and stakeholders/clients (familiarity)

Interpersonal Skills

  • Students collaborate with teammates with tools that could be used by remote teams (functional)
  • Students communicate around code, explaining what it does and why (functional)
  • 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 (familiarity)
  • Students provide feedback in the form of a code review to improve quality and share knowledge (familiarity)

Self-Directed Learning

  • Students find resources online or in print to help them learn new technologies (mastery)
  • Students read documentation and implement strategies described (mastery)
  • Students utilize mentors and other community members to identify and discuss the merits of various implementations (functional)
  • Students ask meaningful questions (mastery)
    • Example: Don’t ask “How do I get this to work?” Instead, mention what has been tried, what happened, what was expected with a goal of understanding where you have made a wrong assumption.

Agile Processes

  • Students use an agile process to turn acceptance requirements into deployed software (funcitonal)
  • Students translate acceptance requirements into user stories that are ready for work (functional)
  • Students verify acceptance requirements using automated testing (mastery)

Technical Skills

Advanced Rails

  • Students are able to interpret a business need and develop a solid product using agile processes (functional)
  • Students are able to contrast the different approaches between working on greenfield and brownfield projects (familiarity)
  • Students are able to describe how multitenancy changes design in Rails (functional)
  • Students are able to construct a Rails app using multitenancy authorization (functional)
  • Students are able to develop and test secure internal APIs using Rails (mastery)
  • Students are able to consume external APIs and test the consumption (mastery)
  • Students are able to critique previous projects for fundamental security flaws and understand how to prevent them (famliarity)
  • Students are able to describe what happens when an email is sent (familiarity)
  • Students compose advanced ActiveRecord queries to analyze information stored in SQL databases (functional)
  • Students utilize and debug the Rails asset pipeline locally and in production (functional)
  • Students understand the advantages of background workers and can identify potential use cases (famliarity)

App Performance

  • Students are able to explain when to use caching strategies to improve performance in Rails (familiarity)
  • Students are able to explain the scenarios that would benefit from using background workers in Rails (familiarity)

JavaScript in the Browser

  • Students are able to use jQuery to traverse and manipulate the DOM (functional)
  • Students are able to modify elements of the DOM using AJAX calls within a Rails app (familiarity)

PostgreSQL & SQL

  • Students write basic SQL statements without the assistance of an ORM (functional)
  • Students intelligently structure/normalize data so as to maintain reasonable performance as the data size increases (familiarity)
  • Students use the CLI to understand the structure and data of their database (ex: list databases, tables, table structure) (familiarity)
  • Students implement indexes to address slow queries (familiarity)