Engineering Foundations [EF]

Introduction

A key component of our Tech Mastery is building a foundation of engineering thinking and best practices. We believe the Engineering Foundations standards emcompass important practices that are necessary for any developer to know and utilize regardless of stack. These span a wide variety of topics from metacognitive skills to writing maintainable code.

Critical Thinking and Problem Solving ₁

EF.1 Identify a problem or challenge, conceptualize a way (or multiple ways) to approach it, consider potential effects of additional factors, and test different solutions until they find one that works. Break down complex problems into their component parts, form hypotheses to test them, consider the effects of additional factors, and eliminate potential problems one by one.

EF.1.a Know how to find a plausible answer independently: Identify essential requirements that define the answer that needs to be solved, based on users, stakeholders, and constraints, single out missing information and determine the best way to find it, whether through existing resources, an online search, available libraries, etc., sort through varied information to determine what’s useful and reliable, and use those resources to learn something new, figure out a problem, and/ or locate additional helpful resources.

EF.1.b Deal effectively with dead ends, frustration: Demonstrate ability to overcome frustration effectively. When one approach doesn’t work, rather than becoming despondent or giving up, able to take a step back, regroup, and try a different way.

EF.1.c Know when, and how, to ask for help from peers/instructor once independent resources are exhausted.

EF.1.d Strong desire and ability to learn: Demonstrate the desire and ability to find and learn new material. Must be able to conduct effective research (find and sort through various resources to find useful, reliable information) and teach themselves new material in an ever-evolving field. This includes learning and being able to apply new languages to solve business problems.

EF.1.e Understand dense technical material: Ability to read dense technical material and documentation with attention and rigor and accurately pick out and apply important information.

EF.1.f Curiosity: Demonstrate an inherent curiosity to want to uncover and overcome new frontiers through tech-related personal/side projects, non-tech extracurriculars, and exploration of topics through a reading list.

The Command Line

EF.2 Know all important terms and concepts related to the basic implementation and usage of the bash terminal.

EF.2.a Explain the difference between a CLI and a GUI.

EF.2.b Know and use basic file system navigation and manipulation (at least: 'ls', 'cd', 'touch', 'mkdir', 'rm'). Able to navigate to any folder/file in the terminal when asked. Create a file/folder anywhere they have permission to in their filesystem.

EF.2.c Know and use basic bash commands (e.g. 'sudo', 'which') and shorthand (at least: '-v', '-u', '-a', '--help'). Install any software with command line support and be able to utilize it with documentation. Discern what software they have installed globally, what version it is, and how to update/uninstall/reinstall as necessary.

EF.2.d Understand system-level environment variables - what they are and how to manipulate them (more on this in the Node section).

Local Development

EF.3 Know how to set up and maintain their local development environments and independently set up and operate a development environment on a new computer.

Web

• Install, configure, update, and use text editors, including themes, fonts, and linters.
• Install, configure, update, and use technologies important to the local implementation of full-stack web apps (for example, NPM, Express, Postgres, React, Postman, testing frameworks, deployment tools, mock data generators).

iOS

• Set up Xcode
• Familiar with the Xcode environment
• Navigate Xcode and know Project Navigator, Debug area, Assistant editor, and Version editor

Version control

EF.4 Know all foundational Git commands, best practices, and terminology.

EF.4.a Create GitHub accounts and link them to their Git installations in the command line.

EF.4.b Utilize basic Git commands (at least: 'init', 'add', 'commit', 'diff', 'push', 'status', 'history', 'pull', 'log', 'branch', 'checkout', 'clone', 'remote'). Create, clone, and remove Git repositories anywhere they have permission to on their systems. See changes, commits, and commit history in the command line and revert to previous commits if necessary. Pull updates from a remote repository.

EF.4.c Understand basic Git/GitHub terminology and underlying concepts (at least: 'repository', 'clone', 'fork', 'branch', 'staged', 'commit', 'merge', 'merge conflict', '.git', '.gitignore', 'pull request').

EF.4.d Conceptual understanding of GitHub collaboration and best practices (at least: the difference between Git and GitHub, QA/feature branches versus master branch, the importance of readme files, the pull request/review/approval cycle, how to avoid merge conflicts). Create, update, checkout, and push branches. Submit, annotate, comment on, and approve pull requests on GitHub.

EF.4.e Add files and commit with descriptive messages to a remote repository. Use present tense verbs in commit messages. Use frequent, small commits.

Debugging

EF.5 Understand the process by which to use debugging tools in fixing bugs in your app including running code frequently and reading error messages.

Web

Utilize:

• Use debugger
• Use console.log()
• Set breakpoints
• Utilize developer tools (e.g. Chrome's developer tools, Postman, online code formatters) to test functionalities in full stack web projects
• Utilize online resources (e.g. the curriculum, Stack Overflow, MDN, Google) to ameliorate gaps in understanding and address bugs in code

iOS

• Use breakpoints
• Symbolicated crash reports vs Unsymbolicated crash reports
• Find and use crash reports
• Manage performance and memory

Testing

EF.6 Unit Testing and General TDD: Understand the philosophy and practice behind testing.

EF.6.a Explain what Test Driven Development is and why it's important. Discuss the pros and cons of TDD in an interview environment effectively.

EF.6.b Know the difference between unit, integration, and end-to-end testing.

EF.6.c How to use testing frameworks to create unit tests for applications including test cases and test methods, test assertions and asynchronous tests.

Web

• Utilize Jest to design and implement unit tests for projects, keeping in mind common inputs and edge cases.

iOS

• Familiar with XCTest.
• Know how to test an iOS app's user interface for expected behavior using UI Element Queries, UI Elements, Application lifecycle, Screenshots, and Device simulation.

Programming Paradigms

EF.7 Know that programming paradigms refers to the way that code is organized by grouping code into units and the two common paradigms Functional Programming and Object Oriented Programming.

EF.7.a Understand the principles of Object Oriented Programming including encapsulation, polymorphism, and inheritance and implement them.

EF.7.b Have a beginning level understanding of the SOLID principles of OOP: S - Single-responsibility, principle, O - Open-closed principle, L - Liskov substitution principle, I - Interface segregation principle, D - Dependency Inversion Principle. Able to speak to and reason about these principles.

EF.7.c Understand the principles of Functional Programming including immutability and pure functions.

Application Architecture

EF.8 Know that architectural patterns are standardized methods of structuring code to address common issues such as separation of concerns. Able to discuss and compare some common architectural patterns including MVC, MVP, and MVVM.

EF.8.a Understand how to use the MVC pattern to design an application. Know Model: the data needed by the app, View: visual aspects of the user interface, and Controller: the messenger (glue) between the views and the models.

EF.8.b Have an introductory understanding of MVP and how it differs from other patterns.

EF.8.c Have an introductory understanding of MVVM and how it differs from other patterns.

How the Internet Works

EF.9 Understand the physical and conceptual structure of the Internet. Explain, in detail, what happens when you type 'www.google.com' into a browser and press enter.

EF.9.a An awareness of physical infrastructure, including servers and cables.

EF.9.b Understand DNS routing, servers, HTTP, and the request-response cycle.

EF.9.c Understand and handle various errors based on specific HTTP error codes.

REST-ful APIs and JSON

EF.10 Knowledge of and familiarity with REST-ful APIs. Build a frontend application that queries remote APIs to render information to the user.

EF.10.a Know HTTP and the request-response cycle.

EF.10.b Utilize GET, POST, PATCH, and DELETE requests and the difference between them. Utilize CRUD requests to create, update, or delete information from an API.

EF.10.c Make requests to APIs.

Web

Utilize various libraries/services to make AJAX requests to APIs (including fetch, axios, XMLHttpRequest).

iOS

Use URLRequest and URLSession to make a POST request to a Web API.

EF.10.d Understand API routing, wildcards, and formatting appropriate requests in order to query an API in Postman or the browser to get a desired response.

EF.10.e Able to navigate new API documentation to discern how an API might be useful in a project.

EF.10.f Know how to handle, parse, and represent data received in JSON format.

iOS

iOS Use JSONDecoder / JSONEncoder along with Codable to parse JSON data

EF.10.g Know how to manage API keys and keeping them safe.

_{1 From NYC Tech Talent Pipeline, NYC Industry Insights: Key Skills and Competancies Needed for In-Demand, Entry-Level Tech Jobs in New York City}