The Employer’s Cheat Sheet

“See challenges as opportunities to learn”

-Senior iOS Developer for Nike


That’s the best advice I’ve received. It has nothing to do with computers, but it’ll endure pressure. The same senior dev told my friends and I his value for potential. He said when he’s interviewing someone he basically plops a crash report in front of the applicant and asks them to try and symbolicate it and just watches what they do. Ya that’s hard. He also said his app has around 5 million active daily users. Ok now I get it. The hidden potential his applicants must have, in order to avoid catastrophe in a situation where he might lose users because of a bug, must be significant. However, interviewers are challenged to gauge this potential in such a confined interview environment. There are so many things to know in programming and so many different scenarios to know them in. Not to mention the unknown unknowns, those things like that next biggest prime number. I’d like to make this process a little easier for my future employer by describing my understanding of some essentials of programming. This is not going to be an exhaustive list and I’ll certainly learn more in the future. This list represents the tip of the iceberg for not only my knowledge, but my potential as well.


  • OOP- Object Oriented Programming: Objects have properties and methods that can be declared and defined with arguments and values.
    • JSON: Javascript object notation. It’s an easy for humans to read and computers to parse.
    • Class: A template used to create instances. Classes don’t have properties.
    • Instance: An object that has methods and properties that store and manipulate data.
    • Property: Can be primitives (ex. integers or strings) or objects (functions or JSON) that hold values.
    • Methods: Also known as functions, used to compute new values that can be held in properties.
    • Inheritance/Subclassing: When a class or object is built on another object or class, so it inherits its properties and methods.
  • Closure: A function inside a function, where the inner function has access to the outer functions methods and properties.
  • Extensibility: Software’s ability to extend to future circumstances with limited change. For instance, how easily can this software be implemented on new platforms like the various browsers.
  • Maintainability: How quickly software can be restored after failure. For instance, defining values in a single module and using the module’s properties in operations.
  • Encapsulation: restricting access to an objects components, such as properties and methods by the use of scope. For instance, the use of ‘var’ instead of ‘this’ in javascript or defining properties in the implementation instead of the interface in Objective-C.
  • APIs
    • REST: representational state transfer. A remote resource that can be used by a project.
      • GET, POST, PUT, DELETE: Basic methods for working with some APIs.
  • CRUD: Create, Read, Update and Delete are the basic functions of data management.
  • Latency: the time it takes for a package to go from source to destination.
    • Lean programming method: extract value
  • Persistence: How data is stored to disk, as opposed to being held in memory.
  • Task runners: Grunt can run multiple tasks under one command.
  • Frameworks: Documented boiler plate code the performs common tasks.
  • Collisions: When the same variable names are declared in the same scope and override each other. It’s bad.
  • Refactoring: Rewrite code for brevity without changing behavior.
  • Parsing: Transforming code so that it can be transmitted or used in a new way. 
  • Data modeling: How objects are created and stored so you don’t replicate code and can manage it as well as extend it. 
    • Relationships: When stored, objects can relate to each other as one-to-one, one-to-many, or many-to-many. Important considerations include what are object requirements and how should objects manage object deletion.
  • Content Delivery Network: multiple servers dispersed to be closer to the user and reduce latency.
  • UX: User Experience: The discipline of fulfilling user expectations over all else.


  • Runtime 
    • Javascript is single threaded, meaning it performs one task at a time, however the browser can use APIs that return asynchronously.
    • Call Stack: always performs tasks one at a time.
    • Task Queue: collects responses from remote APIs to execute when Call Stack is clear.
    • Event Loop: pushes tasks from the task queue onto the call stack when the Call Stack is clear.
  • AJAX: User can work with server data without reloading the page
  • Node.js: Javascript runtime environment 
    • package.json: save for development or distribution
  • Modules: Separate related code into files that make it easier to understand by providing more context.
  • this: it depends on the context
    • In the global scope it’s the global object
    • In a function’s scope it can be
      • whatever is calling the function
      • value of enclosing context
  • call() vs. apply() vs. bind(): call and apply execute a function in the scope of the first argument and are very similar. For apply, the second argument would be an array. Use them to explicitly set ‘this’ in different ways.
  • Hoisting: Bring variables to the top of the scope so they are available for use.
  • Angular: Two way data binding is underlying process to update data when scope is updated.

Design Patterns

  • MVC: Model, View, Controller.
    • Model is where app logic lives
    • View is how the app is displayed
    • Controller handles how the model and view interact with each other including user interaction.
  • Singleton: Where there should be one and only one object for the life of the app. Used for things like user defaults.
  • Delegation: Where a class can sign up to perform a task that originated in another class.
  • Deterministic vs. Nondeterministic: If the result of a program is predetermined or a result of fluctuating variables. 


  • Deploying
    • Test Flight: used to beta test apps using internal or external testers prior to distribution. 
    • iTunesConnect: Main hub to gain access to App Store. It’s where you set up your bundle ids, profiles and developer certificates. 
    • Bundle Identifiers: An id that one or a set of apps will be categorized by.
    • Keep binaries for builds so you can symbolicate crash logs later.
  • Concurrency
    • Grand Central Dispatch: A library for setting up multi-threaded processing. 
    • Atomic/NonAtomic: Atomic prevents concurrent access to properties, meaning the property is locked while changes are made from other threads. 
    • Threads: Apps can run processes on a single thread synchronously or asynchronously by using multiple threads. You would use multiple threads if you had to perform some background tasks, like fetching data from an API, without slowing the user’s experience. 
  • Memory Management
    • Automatic Reference counting: beginning in XCode 4.2, basically eliminates memory management concerns. 
  • Core Data: iPhone’s way of persisting data 
    • Managed Object Context: Where managed objects can be manipulated so they can be persisted to or fetched from the store. 
    • Managed Object Model: Class that defines managed objects 
    • Persistent store: Phones built in non-relational database 
  • Protocols: You can conform to protocols to inherit their methods.
  • KVO vs. Notification center: Key Value Observing (KVO) is for registering for notifications using a key rather than receiving a notification that has be broadcast at large.

Version Control

  • Pull from a repository to manage conflicts before you push.
  • Never work on the master branch, always work on feature branches and merge into master.


  • Breakpoints: Set these to pause your app at runtime to inspect the context. 
  • Watchpoints: You can watch the values of properties change at runtime. 
  • Logging: Find the value of properties at runtime. 


  • TDD- Test Driven Development: Write tests that represent desired behavior first, then make them pass. 
    • Make the thing right
    • Make tests that fail first
    • Make tests that pass/fail for the right reasons
  • BDD- Behavior Driven Development: Write what you want to happen as simply as you can first, then program tests that match. 
    • Make the right thing
  • Unit testing-  Focusing on small parts 
  • Older browsers vs. newer browsers:
    • Polyfills : making tests that run on all browsers
  • Assertions: Chai, node assert, etc. 
  • Frameworks: Mocha, Cucumber, etc. 
  • Hooks: Setup or breakdown operations that can be executed before or after a cycle to maintain test accuracy between iterations. 
  • Adapters and Ports: The ways we disseminate our domain world. Domain world testing is much faster for authenticating app logic.
  • Promises: How an app sequences asynchronous events. 
    • Blocking: Execution won’t move to the next line until a promise if fulfilled. 
  • Automation- Use webdrivers to run through website UIs to perform tests as close to user interaction as possible.

This is not an exhaustive list, but it’s a baseline. I hope this lists helps you get to know me better as a programmer and please feel free to reach out to me on LinkedIn if you have any work recommendations or general suggestions. Thank you.

Leave a Reply

Your email address will not be published. Required fields are marked *