Skip to content
Application Development II
GitLabGitHub

Topics to Review

Core topics covered in previous courses that are worth brushing your knowledge on, given their relevance in this course.
PreviousPDFSlidesNext
Overview

This document covers topics you have seen in previous courses that will be important to understand new concepts in our course.

It will be updated throughout the semester as we cover new ground — that is, as we go through the course and I learn more about what you know! I encourage you to be proactive when it comes to this: let me know if there is something I say in class that is confusing, I will be happy to add more material explaining what I mean.

  • Primitive types: You should be familiar with the basic set of primitive types in statically-typed languages like Java (int, byte, short, long, float, double, boolean, char). See here for reference. Crucially, primitive types do not have interfaces, fields, or methods that can be referenced.
  • Arrays: A special kind of primitive type, arrays are container objects that hold a fixed number of values of a single type stored sequentially in memory.
  • Derived types: More complicated types built from the primitive types in statically-typed languages like Java. Derived types have defined interfaces, allowing you to reference public fields or methods of that interface. List and String are examples of built-in derived types in Java.

In previous courses, you have gone beyond primitive and derived types to define your own classes and objects. You should be familiar with the following concepts:

  • Classes and instances: You should understand the big picture of and be comfortable implementing class definitions and objects instantiations of those classes in object oriented programming.
  • Inheritance: You should understand how to extend the behavior of class definitions by defining sub-classes of that type through inheritance.
  • Encapsulation: You should understand how and why to keep the state of an object instantiation private through encapsulation.
  • Static fields/methods/properties: what is the effect of declaring static on a given class property? You can find a short summary here

Some of the links above are Javascript examples, but the big picture is similar in Java/Kotlin.

In this course, we will be writing software in groups, as well as using software written by others. The most common way to share and distribute source code is in a repository. You have used git and GitHub in the past for this purpose — we will continue to do so in this course.

The sections below cover some of the main repository knowledge and techniques you should be familiar with to get started in this course.

A nice resource that covers the big picture of git and GitHub (they are different things), I recommend this article from the Odin Project.

Whether on the lab computers (OS X) or on your personal machines, you should be able to:

  • create git credentials: username/password/email/SSH key
  • use CLI or GUI to manage repository changes

There are many resources available on these topics, so you are not limited to my suggestions, but Getting started with git is a decent resource that covers all of them. Setting up Git is also a resourse I recommend.

You should be able to:

  • Pull a remote repository on to your working machine
  • Make and commit changes to the repository locally
  • Create/manage/merge local branches
  • Create pull requests to push branch commits to a remote repository

There are many resources available on these topics, so you are not limited to my suggestions, but Using git is a decent resource that covers all of them.