WDI 34 Learning Objectives
Developers will be able to...
- Navigate the file system from the command line.
- Create, move, copy, and delete files or directories from the command line.
- Research unfamiliar bash commands and options with
man, and/or online resources.
- Describe the uses of the
###HTML & CSS Review
- Recognize common HTML tags and attributes.
- Describe the structure of an HTML document.
- Apply CSS styles to HTML elements based on tag, class, or id.
- Distinguish among block, inline, and inline-block elements.
- Draw the CSS box model.
- Explain the uses of Git and GitHub for tracking changes and collaborating on projects.
- Draw a model of local, remote, and working copies of their repositories.
- Write some code to improve their work, commit the changes, and write a strong commit message.
- Deploy their first live website using gh-pages.
- Declare variables in the Chrome developer tools console.
- Get and set the values of variables.
- Use built-in methods to manipulate strings and arrays.
- Predict the output of boolean expressions, including "truthy" and "falsey" values.
- Write syntactically correct conditional statements.
- Compare & contrast
- Identify the differences between defining a function and calling (invoking) a function (casting the spell).
- Create a simple function that prints a value (for the user/developer to see a result) and a simple function that returns a value (for the rest of the code to use a result). Distinguish between the impact of these different results.
- Draw a model of a function that includes arguments as input, side effects, and return values as output.
- Explain the scope of a function.
###Chrome Dev Tools and Debugging
- Use the console tab to gather diagnostic information about code (read various error messages and logs of their own creation).
- Use the elements tab to view an manipulate the DOM and styling.
- View sites in mobile mode with the device mode.
- Describe and draw the document object model (DOM) of a simple HTML document.
- Use the elements tab to view and manipulate the DOM and styling.
- Select elements from the page using CSS selectors and use jQuery to dynamically change the DOM.
- Explain what DOM events are and how they are triggered.
- Attach event listeners to DOM elements.
- Target the source of an event.
- Respond to events with a callback.
- Explain event propagation.
- Implement class-based CSS.
- Use a CDN to import Bootstrap into projects.
- Effectively use a grid system to space elements across the page.
- Improve the design of HTML pages with the aid of Bootstrap & mockups
###Iterator Methods & Callbacks
- Use appropriate iterator methods to declaratively loop through collections
- Follow the order of execution in a program that uses callbacks
- Write a higher-order function that calls a custom callback
- Create an object that contains a variety of data types
- Access attributes of an object using
- Articulate the usefulness of JSON
- Explain the basics of the client/server model
- Compare and contrast the available input options for HTML forms
- Use a method and an action to submit form data
- Generate query parameters using a form
- Articulate why AJAX is useful and how it works
- Create an AJAX request that fetches data
- Describe the meaning of
onSuccess:keys for jQuery's
Data Templating w/ Handlebars
- Articulate the usefulness of data templating in the browser
- Create and compile a Handlebars template
- Use Handlebars templating to display JSON data
- Create shared methods amongst instances with prototypes
- Draw a diagram of the request-response cycle with Node.js and Express included and labeled
- Describe the roles that Node.js and Express play in building a server
npmto initialize a Node.js project
- Write a local web server to serve JSON and static assets with Express
###Express Routes & Parameters
- Create flexible, dynamic routes with parameterized route urls
- Process data sent to a server through query strings
- Process data sent from named form fields (as with POST requests)
- Identify Express routing patterns that can be used for PUT, PATCH, and DELETE requests
- Explain how MongoDB and Mongoose are related
- Describe the relationship between schemas and models in Mongoose
- Create Mongoose model instances
- Using Mongoose, integrate a MongoDB database with an Express project
- Describe one-to-one, one-to-many, and many-to-many data relationships
- Write mongoose schemas that can reference and embed data
- Reflect model relationships in server routes
###Personal API & Heroku
- Deploy server side code to Heroku to make an API publically accessible
- Write an API documentation endpoint at the
- Build an API from scratch
- Articulate a set of steps to determine Big O complexity.
- List the Big O complexities of some commonly-used patterns and algorithms.
- Estimate the time or space efficiency of an algorithm using Big O notation.
- Describe the binary search algorithm and identify its advantages and disadvantages.
- Determine the runtime (in big-O notation) for binary search.
- Explain the benefits of using Angular and describe the problems Angular aims to solve.
- Initialize Angular in an HTML view, and use expressions and templates to impact the DOM.
- Organize the code into controllers and connect the View & Controller using
- Implement 2-way data binding.
- Inject a service into a controller.
- Read data with
- Create data with
- Update data with
- Delete data with
- Update the view to reflect a successful state change.
###Angular Client-side Routing
- Compare and contrast client-side and server-side routing.
- Add a module to an Angular project.
- Implement client-side routing with the
- Display view template files with the
- Explain the justifications for using custom directives.
- Describe the directive definition object and implement it in creating a directive.
- Integrate a third party directive into your code.
- Explain the purpose of promises.
- Draw the lifecycle of a promise.
- Manipulate promises using Angular’s
- Explain motivations for using services.
- Create a custom service.
- Use promises in a custom service.
- List Ruby data types.
- Articulate strategies to learn new programming languages and frameworks.
- Run Ruby code in an interactive Command Line Interface or from a file.
- Write conditionals, loops, and methods in Ruby.
- Apply methods in ruby to solve problems.
- Define the OOP terms “class,” “instance,” and “inheritance.”
- Create your own classes and instances.
- Define attributes and methods for instances or for the class as a whole.
- Explain and implement the class-based inheritance pattern.
- Justify writing unit tests.
- Explain important testing concepts: edge cases and test coverage.
- Read and explain Rspec tests.
- Write DRY and effective test code using RSpec.
- Articulate the Rails philosophy and the MVC pattern.
- Start a Rails project with no database and create routes that render dynamic templates.
- Distinguish between Express and Rails.
- Create a model that inherits from ActiveRecord class
- CRUD data in the database using our model
- Write a migration to define a database schema
- Update our database schema with another migration
- Describe how layouts, view templates, and partial templates work together.
- Recognize rails url helpers and path helpers.
- Explain benefits of using Rails form helpers and link helpers.
- Find and determine correct syntax for Rails form helpers and link helpers.
- Add and remove columns from the database.
- Alter an existing column.
- Explain when it is okay to edit a migration and when it is okay to edit the schema.
###Error Handling and Validations
- Use built-in ActiveRecord validation methods to validate database entries.
- Display errors in the view using Rails flash messages.
- Set breakpoints to check your assumptions.
- Describe how relational databases can be used to create associations between resources.
- Create one to-many-model relationships in Rails.
- Create many to-many-model relationships in Rails.
###Cookies and Sessions
- Describe the request and response cycle's relationship to the stateless web.
- Discuss and use an HTTP Cookie in a web application.
- Differentiate between an HTTP Cookie and a Session.
- Build routes, controllers, and views for user sign up, log in, and logout.
- Implement a
Usermodel that securely stores hashed passwords with
- Compare and contrast authentication and authorization.
- Explain benefits of using the Rails asset pipeline.
- Require custom and third-party assets in Rails.
###Rspec with Rails
- Identify aspects of Rails apps that we might want to test.
- Differentiate between integration testing and unit testing.
- List tools that are used to test Rails applications.
- Test model methods using rspec-rails.
- Test controller actions using rspec-rails.
- Describe bubble sort algorithm and identify its advantages and disadvantages.
- Write a pseudocode version of bubble sort and a ruby version of bubble sort.
- Determine the runtime (in big-O() notation) for bubble sort.
- Pseudocode an algorithm to merge two sorted arrays, and implement the algorihtm in ruby.
###Recursion & Merge Sort
- Explain three steps to create a recursive algorithm.
- Describe the merge sort algorithm.
- Write a pseudocode version of merge sort and a ruby version of merge sort.
- Determine the runtime (in big-O() notation) for merge sort.
- Describe the low-level structure of arrays and linked lists.
- Manipulate linked lists.
- Describe a stack by its methods and last in, first out (LIFO) behavior.
- Build stack methods using linked list methods.
- Describe a queue by its methods and first in, first out (FIFO) behavior.
- Build queue methods using linked list methods.
- Compare and contrast stacks and queues and appropriately choose which is better for a given situation.
- Describe and draw the structure of a hashmap.
- Explain properties of a good hash function.
- Perform runtime analysis on the hashmap data structure.
- Explain the relationship between graphs, trees, and binary search trees.
- Draw a balanced binary search tree from some given data.
- Use binary search trees in answering interview style challenge questions.
###Breadth First Search
- Describe and draw breadth-first tree traversal.
- Pseudocode breadth-first search.
- Identify use cases for breadth-first search.
###Depth First Search
- Describe and draw depth-first tree traversal.
- Compare and contrast depth-first and breadth-first.
- Pseudocode depth-first search.
- Identify use cases for depth-first search.
###Rails JSON API
- Use Rails and jbuilder to build a JSON API without a front end.
###Angular and Rails
- Build an Angular front end for a Rails JSON API back end.
###MEAN stack review
- Explain the role of each technology within the MEN/MEAN stack.
- Give detailed account of the purpose of the different files and folders that make up a MEN/MEAN app.
- Explain basic Angular setup and write examples of important built-in directives.
- Identify key Angular concepts: directives, controllers, templates, services, client-side routing.
- Authenticate users in Express.
- Restrict access to data based on whether a user is authenticated.
- Describe various authentication or authorization strategies.
- Explain block scope and when to use var, let, and const.
- Interpolate strings with template literals.
- Write shorter function declarations with arrow functions.
Gulp & Webpack (Build Tools)
- Explain roles of build tools: minification, compilation, concatenation/bundling, compression, file watching, etc.
- Compare build tools: Rake, Gulp, Webpack.
- Use build tools to automate workflow.
- Explain what ReactJS is and where it fits in our applications' stack.
- Explain the component model of web development.
- Create and render React components in the browser.
Interview Prep - Strategies
- Follow a planned series of steps when answering in-person technical interview questions.
- Explain technical thinking to another person while coding or whiteboarding.
- Follow a planned series of steps when working on take-home technical challenges.
- Identify interviewing areas of strength and areas to focus on and improve.
Interview Prep - Topics
- Apply good coding syntax habits even on whiteboard:
===; correct syntax for loops; correct syntax for if/else; semantic variable naming.