diff --git a/README.md b/README.md index 51e58500..1e782e30 100644 --- a/README.md +++ b/README.md @@ -9,13 +9,22 @@ Lesson plans, activities and assignments for Unit 1 will be posted here! 0 | Apr 21 | 0 | [Android Prework](lessons/0_Android-Prework.md) 1 | Apr 23 | 0 | [Android Studio & Structure of an Android Project](lessons/1_Android-Studio-Structure-of-Android-Project.md) 2 | Apr 25 | 0 | [Inheritance and Interfaces](lessons/2_Interfaces-And-Inheritance) - 3 | Apr 26 | 0 | [Generics and Abstract Classes](/lessons/3_Generics-and-Abstract-Classes.md) + 3 | Apr 26 | 1 | [Generics and Abstract Classes](/lessons/3_Generics-and-Abstract-Classes.md) 4 | Apr 28 | 1 | [Anatomy of the Android Manifest](/lessons/4_Anatomy_Manifest.md) - 5 | May 02 | 1 | [Android Resources] (lessons/6_Android-Resources.md) - 6 | May 03 | 1 | [Activity Lifecycle](lessons/7_Android-Lifecycle.md) + 5 | Apr 30 | 1 | [OOP and Intents](exercises/5_OOP-and-Intents) + 6 | May 02 | 1 | [Android Resources] (lessons/6_Android-Resources.md) + 7 | May 03 | 2 | [Activity Lifecycle](lessons/7_Android-Lifecycle.md) + 8 | May 05 | 2 | [Intro to Final Project](lessons/8_Intro-Final-Project.md) + 9 | May 07 | 2 | [Android Exercises](https://github.com/shurane/unit-1-exercises) + 10 | May 09 | 2 | [Github and Debugging](lessons/10_Github-Debugging.md) + 11 | May 10 | 3 | [UI Basics](lessons/11_Android-UI-Basics.md) + 12 | May 12 | 3 | [Layouts](lessons/12_Layouts.md) ### Homework | Due Date | Homework| |---|---| | Apr 25 | -| May 1 | +| May 1 | +| May 8 | +| May 15 | + diff --git a/exercises/10_Github-Debugging/src/BuggyClass.java b/exercises/10_Github-Debugging/src/BuggyClass.java new file mode 100644 index 00000000..9ea7c1e9 --- /dev/null +++ b/exercises/10_Github-Debugging/src/BuggyClass.java @@ -0,0 +1,62 @@ +public class BuggyClass { + static int N = 1000*1000; + static int TRIES = 100; + static int TOLERANCE = 10; + + static int used_loop = 0; + static int used_recursive = 0; + static int used_divide_and_conquer = 0; + + public static void main(String[] args) { + int[] A = new int[N]; + int BIG = 1000*1000*1000; + long correct_sum = 0; + for(int i=0; i p; + } + + public static int sum_loop(int[] A){ + int sum = 0; + for(int i=0; i<=A.length; i++) { + sum += A[i]; + } + return sum; + } + + public static int sum_recursive(int i, int[] A){ + if(i==A.length - 1) { + return 0; } + return A[i+1] + sum_recursive(i+1, A); + } + + public static int sum_divide_and_conquer(int lo, int hi, int[] A) { + int mid = A.length/2; + if(lo==hi) { + return A[0]; } + return sum_divide_and_conquer(lo, mid, A) + sum_divide_and_conquer(mid, hi, A); + } + +} \ No newline at end of file diff --git a/exercises/assessment_prep.md b/exercises/assessment_prep.md new file mode 100644 index 00000000..48da1c93 --- /dev/null +++ b/exercises/assessment_prep.md @@ -0,0 +1,22 @@ +### Assessment Prep + +In order to be prepared for the assessment, make sure you know how to do the following things. If you don't know, +don't just look up how to do it. Practice doing it in an application, several times. + +1. Start a new Android project. + +1. Create a new Activity. + +1. Move between two Activities using Explicit intents. + +1. Open up a new app using Implicit Intents. + +1. Know the order of Activity lifecycle methods for common cases. + +1. Be able to reason about the Activity lifecycle diagram. + +1. Know how to use the resources directory. + +1. Know how to add a widget to a layout and set properties on it. + +1. Know how to use a linear layout, including weight, gravity and layout_gravity. diff --git a/homework/week-2.md b/homework/week-2.md new file mode 100644 index 00000000..2a94fa16 --- /dev/null +++ b/homework/week-2.md @@ -0,0 +1,53 @@ +##Homework + +##### Exercise 1: Code Review + +Find your name in the first column; code review the developer in the second column. + +| Reviewer | Reviewee | +|----------|----------| +| Abass Bayo-Awoyemi | Jaellys Bales +| Allison Bojarski | Madelyn Tavarez +| Alvin Kuang | Kadeem Maragh +| Anthony Fermin | Rosmary Fermin +| Anthony McBride | Joshelyn Vivas +| Charlyn Buchanan | John Gomez +| Dison Ruan | Sufei Zhao +| Elvis Boves | George Syrimis +| George Syrimis | Alvin Kuang +| Hanbi Choi | Pooja Pasawala +| Hoshiko Oki | Jose Garcia +| Jaellys Bales | Jorge Reina +| Janneisy Vidals | Reinard Cox +| John Gomez | Anthony Fermin +| Jorge Reina | Anthony McBride +| Jose Garcia | Luke Lee +| Joshelyn Vivas | Vanice Yee +| Kadeem Maragh | Na Li +| Madelyn Tavarez | Allison Bojarski +| Marbella Vidals | Tasha Smith +| Na Li | Elvis Boves +| Ramona Harrison | Charlyn Buchanan +| Raynaldie Acevedi | Dison Ruan +| Reinard Cox | Ramona Harrison +| Rosmary Fermin | Yuliya Kaleda +| Sarah Kim | Raynaldie Acevedi +| Sufei Zhao | Hanbi Choi +| Tasha Smith | Marbella Vidals +| Vanice Yee | Sarah Kim +| Yuliya Kaleda | Abass Bayo-Awoyemi +| Pooja Pasawala | Hoshiko Oki +| Luke Lee | Janneisy Vidals + +It is on you to have communication with your reviewer/reviewee in order to complete this assignment. + +##### Exercise 2: Revenge of the Horoscope App +* Resolve all comments your reviewer leaves on your app. +* Change the layout of at least two of your existing features. +* Create consistent UI styling across your app. +* Test your app on at least two devices of different screen sizes. + +The main purpose of this week's assignment is to play around with the visual elements - have fun with it and iterate with your peers. + +##### Bonus +* Create your own [Theme](http://developer.android.com/guide/topics/ui/themes.html). diff --git a/lessons/10_Github-Debugging.md b/lessons/10_Github-Debugging.md new file mode 100644 index 00000000..077765d0 --- /dev/null +++ b/lessons/10_Github-Debugging.md @@ -0,0 +1,273 @@ +### Github and Debugging + +#### Objective +Students will learn general software engineering practices and will be able +to navigate Git, have more available debugging tools at their disposal, +and learn the basics of exception handling. + +#### Pre-Work + +[Github & Git Foundations](https://www.youtube.com/playlist?list=PLg7s6cbtAD15G8lNyoaYDuKZSKyJrgwB-) + +#### Do Now (Morning) + +Create a new Java class to do the following string operations: +* Reverse - "Quispe" -> "epsiuQ" +* Uppercase words - "i love java" -> "I Love Java" +* Reverse words - "Java Love I" -> "I Love Java" +* Parse Addition Expression - "3 + (4 + 2)" -> "9". Assume that the only operations are "+" and parentheses. + +#### Git and Github + +*Git* is a version control system. *Github* is a very popular website for storing git repositories and collaborating. + +Some basic git commands: + +| Command | Description | +|---------|-------------| +| git init | Creates a new git repository | +| git clone [path] | Creates a local copy of a repository | +| git add | Adds a file or directory to staging | +| git rm | Adds the removal of a file or directory to staging | +| git commit | Commits staged changes to head | +| git push origin [branch] | Push changes to [branch] at remote | +| git status | Lists staged changes and changes that have not get been staged | +| git fetch | Get remote changes | +| git pull | Get remote changes and merge | +| git branch | List branches and indicate current branch | +| git branch [branchname] | Create new branch called [branchname] | +| git checkout [branchname] | Switch to branch called [branchname] | +| git checkout -b [branchname] | Create a new branch called [branchname] and switch to it | +| git blame | Revision and author of a line of the file | +| git log | Show commit logs | +| git diff | Show changes between commits | + +Other vocabulary: +* Fork: A copy of a repository. +* Master: The main branch. +* Origin: The remote repository. +* Upstream: The repository that origin copied. +* Branch: A series of changes starting at a particular commit. + +## Git log --graph +[git log graph](https://github.com/davisRoman/git_dag/blob/master/intro_to_the_dag.md) + +----- + +> Exercise: Partner with the other person at your table. + +> Part I: Fork and Pull + +> 1. Create a repository on Github. + +> 1. Clone the repository locally, add the Do Now, and push the change to Github. + +> 1. Fork your partner's repository. + +> 1. Clone the fork of your partner's repository locally. + +> 1. Set the upstream to your partner's repository. + +> 1. Create a new branch and make changes to the file in your partner's repository. + +> 1. Commit and push this change to Github. + +> 1. Open a pull request to your partner's repository master. + +> 1. Code review the pull request from your partner. + +> 1. Respond to all the changes requested on your pull request (either make the change or push back), and push your changes. + +> 1. Accept your partner's pull request. + +> Part II: Merge Conflict + +> 1. Make your partner a collaborator on your repository. + +> 1. Sync your local clone of your repository to origin master. + +> 1. Clone your partner's repository locally. + +> 1. Make changes to the file in your partner's repository and push. + +> 1. Make changes to the file in your own repository and commit. + +> 1. Before pushing, sync to origin master. + +> 1. Resolve any merge conflicts. + +> 1. Push your changes to your repository. + +> Part III: Shared repository + +> 1. Sync your local clone of your partner's repository to origin master. + +> 1. Create a new branch on your partner's repository. + +> 1. Push this branch to Github. + +> 1. Make changes to the file on this branch and push. + +> 1. Open a pull request from this branch to master. + +> 1. Code review your partner's pull request on your repository. + +> 1. Respond to all comments on your partner's code review on your pull request (either make changes or push back) and push your changes. + +> 1. Go back and forth code reviewing and responding to comments until all comments are resolved. + +> 1. If comments can't be resolved, ask a third party to weigh in on your pull requst. + +> 1. Once all comments are resolved, accept your partner's pull request. + +> 1. Sync your local clones of your repositories to origin master, and delete all resolved branches. + +#### Do Now (Afternoon) + +Find the pull request for your reviewee from this week's code review. Download and run their horoscope app. If there are any problems with the pull request, please work with your reviewee to fix this pull request. + +#### Debugging Basics + +##### Variable Scope + +A few rules about variable scope: +* Anything declared between {} belongs only to that block. This also goes for the signature of a loop. +* Anything declared in a method only exists for the scope of that method. +* Reference class variables using the `this` keyword. + +##### Reading Stack Traces + +Stack traces explain the series of method calls that have led to the current state. For example: + +``` +Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 1000000 + at BuggyClass.sum_loop(BuggyClass.java:44) + at BuggyClass.find_sum(BuggyClass.java:29) + at BuggyClass.main(BuggyClass.java:19) <5 internal calls> +``` + +Means that `main` called `find_sum` on line 19, `find_sum` called `sum_loop` on line 29, and `sum_loop` received an `ArrayIndexOutOfBoundsException` on line 44. On the other hand: + +``` +Exception in thread "main" java.lang.StackOverflowError + at BuggyClass.sum_recursive(BuggyClass.java:50) + at BuggyClass.sum_recursive(BuggyClass.java:52) + at BuggyClass.sum_recursive(BuggyClass.java:52) + at BuggyClass.sum_recursive(BuggyClass.java:52) + at BuggyClass.sum_recursive(BuggyClass.java:52) + at BuggyClass.sum_recursive(BuggyClass.java:52) + at BuggyClass.sum_recursive(BuggyClass.java:52) + at BuggyClass.sum_recursive(BuggyClass.java:52) + at BuggyClass.sum_recursive(BuggyClass.java:52) + at BuggyClass.sum_recursive(BuggyClass.java:52) + at BuggyClass.sum_recursive(BuggyClass.java:52) + . + . + . +``` + +means that `sum_recursive` infinitely calls itself and eventually crashes. + +### Example: +- Division by zero + +```java +public class Main { + + public static void m1(){ + System.out.println("Method one - m1"); + m2(); + } + + public static void m2(){ + System.out.println("Method two - m2"); + + int x= 10; + int y = 0; + + double z = x/y; + + System.out.println(z); + } + + public static void main(String[] args) { + System.out.println("Starting Main method"); + m1(); + System.out.println("End main method"); + } +} +``` +Output: +``` +Exception in thread "main" java.lang.ArithmeticException: / by zero +Starting Main method +Method one - m1 +Method two - m2 + at com.company.Main.m2(Main.java:16) + at com.company.Main.m1(Main.java:7) + at com.company.Main.main(Main.java:25) + at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) + at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57) + at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) + at java.lang.reflect.Method.invoke(Method.java:606) + at com.intellij.rt.execution.application.AppMain.main(AppMain.java:134) +``` + +##### Using the Debugger + +The debugger allows you to set breakpoints in your code. When you run your code, the execution stops when it reaches a breakpoint. At this point, you can inspect the current state of the program as well as step through the code line by line. + +> Exercise: Debug [BuggyClass](../exercises/10_Github-Debugging/src/BuggyClass.java). BuggyClass attemps to compare several different array addition algorithms, but it's fraught with bugs. Remember, bugs are problems with functionality, not just crashing. It may be tricky to infer what someone *meant* to do with the code - in the future you may have to deal with (and fix!) poorly-documented code written by someone who is no longer at the company, or is otherwise not contactable. + +#### Exception Handling + +Exceptions are errors generated by your program. These errors normally crash your program, but you can write code to `catch` them and recover. + +First, let's see how to raise an exception. For example, let's say you had a `myDivide` method. Since dividing by zero isn't defined arithmetically, we should raise an exception. + +``` +public static double myDivide(int dividend, int divisor) { + if(divisor == 0){ + throw new IllegalArgumentException("Dividing By Zero"); + } + // implement division here + . + . + . +} +``` + +Once an exception is raised, calling code may handle it. For example, let's say you are using the `myDivide` API for a calculator application. + +``` +public static void myCalculator(String userInput) { + . + . // parse userInput + . + . + try { + myDivide(num1, num2); + } + catch (IllegalArgumentException e) { + alert_user(e.getMessage()); + } + . + . + . + . +} +``` + +Here, we use the exception to alert the user as to what went wrong. Exceptions propogate up the call stack, so the method that called `myCalculator` can also handle the exception. If the exception gets to the top of the call stack, then the program crashes. + +##### Printing and Logging ( time permitting ) + +Printing is a very useful debugging method that you've probably already touched. Printing is useful because it can help display intermediate program state. Logging is essentially the same method (i.e. writing state to external output). + +#### Bonus + +[Project Euler Problem 20](https://projecteuler.net/problem=20) + +#### Assessment + +What does the first line in the call stack indicate? ([Exit Ticket](https://docs.google.com/forms/d/1a-gfjjsn35N-C6wrQU9y02vHoYLFaEfjUgD7J91n3rM/viewform?usp=send_form)) diff --git a/lessons/11_Android-UI-Basics.md b/lessons/11_Android-UI-Basics.md new file mode 100644 index 00000000..77135c09 --- /dev/null +++ b/lessons/11_Android-UI-Basics.md @@ -0,0 +1,68 @@ +### Android UI Basics + +#### Objective + +Students will learn about the properties of widgets and containers and be more comfortable editing widget properties in the XML. + +#### Code Review + +Code Review a lucky developer's app! + +#### Lesson (Morning) + +Widgets are UI components meant to serve a particular interaction with the user. Containers determine the structure of how widgets are arranged. Here are a few key things to know about widgets: +* Parent/Child: If a widget A is structured within another widget or container B, then A is a child of B, and B is a parent of A. +* Padding vs. Margin: Padding is internal spacing, margin is external spacing. +* match_parent: Fills the space of the parent element. +* wrap_content: Takes up the minimum amount of space needed for the content. +* Structure vs Function: XML displays the structure of the user interface. Function should be definied in Java. When structure needs to be defined in Java, it should be disconnected from function as much as possible. +* Structure vs Style: Structure defines the hierchy in which elements are laid out, while style dictates things such as font color and size. Although both can be defined in XML, these different pieces should also be separated from each other when possible. +* Callbacks: A callback is a piece of code passed to another piece of code, which controls the execution. We will start to see code that asynchronously executes some action. This may be different from the "linear" programs you may have been writing before. Reasoning about synchronous/asynchronous items will become important in the future. + + +> Exercise: Without using the designer, do the following: + +> 1. Create an Android app with a blank Activity. + +> 1. In the main layout, add a button. + +> 1. Add another button positioned underneath the first button. + +> 1. Add another button positioned undernead the second button. + +> 1. Have your buttons display the text 1, 2, and 3 based on their position. + +> 1. Add a button to the right of each button displaying R1, R2, and R3 respectively. + +> 1. Add a TextView under each button. + +> 1. Create an OnClickListener in a new class. + +> 1. Implement a method that increments a class variable OnClick i.e. this variable should count the number of times something has been clicked. + +> 1. Add a constructor to the OnClickListener that takes in a TextView and change OnClick such that it updates the TextView with the # of times the button has been clicked. + +> 1. For each button, add an instance of the OnClickListener and pass in the corresponding TextView. + +> 1. Create a new TextView that displays all the times all of the Buttons have been clicked in total. + +> 1. Exchange code review with the person at your table and resolve all comments. + +#### Do Now (Afternoon) + +Add TODOs into your horoscope app based on what we learned this morning. + +#### Github + +Work on yesterdays' [Github exercises](10_Github-Debugging.md) + +#### Group Project + +Spend the rest of the day working on your group project with your team. + +#### Assessment + +[Exit Ticket](https://docs.google.com/forms/d/1a-gfjjsn35N-C6wrQU9y02vHoYLFaEfjUgD7J91n3rM/viewform?usp=send_form) + +#### Resources +* Textbook: The Theory of Widgets, The Android User Interface, Basic Widgets diff --git a/lessons/12_Layouts.md b/lessons/12_Layouts.md new file mode 100644 index 00000000..2de12d51 --- /dev/null +++ b/lessons/12_Layouts.md @@ -0,0 +1,48 @@ +## Layouts + +### Lesson: Layouts + +#### Views and View Groups + +A View is the building block of a basic UI element. Views are bounded by a rectangle and are in charge of event +handling and drawing. A Widget is a type of View. A ViewGroup is also a type of View. + +A ViewGroup is a container class that contains other Views, including ViewGroups. Layouts are a type of ViewGroup. + +#### Layout Basics + +Layouts define the structure of a user interface, typically in the XML, although you can dynamically create +the UI in Java. + +When loading a layout, call `setContentView`. You have probably seen this in your `onCreate`, but take note that +you can change the layout at any time. Activities are not implicitly associated with layouts. + +A Layout is a rectangle - the boundaries of the a Layout are defined by `getLeft()`, `getRight()`, `getTop()`, and +`getBottom()`. You can also use `getHeight()` and `getWidth()` to get the actual size of the Layout box. + +#### Linear Layout + +In a Linear Layout, all the children are aligned either horizontally or vertically, depending on the +`android:orientation`. That is, all the children are placed one after another linearly. + +* Orientation: Vertical for rows, horizontal for columns. +* Gravity: [Gravity and layout_gravity](http://sandipchitale.blogspot.com/2010/05/linearlayout-gravity-and-layoutgravity.html) +* Weight: Weight describes the relative importance of the Views, which allows these views to expand to fit the +parent proportionally. For example, two views with a weight of 1 will fill the layout at a 1:1 ratio (or, the same +amount), and two views with weights of 1 and 2 will fill the layout with a 1:2 ratio (so, 1/3 and 2/3 of the screen). + +#### Relative Layout + +In a Relative Layout, the children can define their position relative to the parent or the other children available. + +### Exercises + +> 1. Create a form using a Linear Layout that asks a user for first and last name, username, DOB, etc. + +> 1. Create a calculator layout using a Linear Layout. Use this opportunity to figure out how to nest layouts. + +### [Quiz](https://docs.google.com/forms/d/1AZO4SyYgglEzroJqMbEuTTRp3D7TnEBiI--LHcfNTSo/viewform?usp=send_form) + +### Assessment + +[Exit ticket](https://docs.google.com/forms/d/1a-gfjjsn35N-C6wrQU9y02vHoYLFaEfjUgD7J91n3rM/viewform?usp=send_form) diff --git a/lessons/8_Intro-Final-Project.md b/lessons/8_Intro-Final-Project.md index b840b80f..092e43d7 100644 --- a/lessons/8_Intro-Final-Project.md +++ b/lessons/8_Intro-Final-Project.md @@ -16,6 +16,16 @@ for the Unit 1 final project. > Exercise: Work with your team to design the project and figure out division of labor. +> 1. Make a git repo for work & make sure both partners can push. + +> 2. Create design for app. + +> 3. Put together a schedule for group work. + +> 4. Figure out who is taking what parts. + +> 5. Create your skeleton project & push to github. + #### Assessment diff --git a/project/requirements.md b/project/requirements.md index 146156bf..4361850d 100644 --- a/project/requirements.md +++ b/project/requirements.md @@ -1,7 +1,7 @@ ### Final Project: Scientific Calculator #### Due Date -A pull request with your code must be issued to the unit-1 `calculator` branch by 18:59 on 5/21 (that is, before class). Presentations will be in class that day. +A pull request with your code must be issued to the [calculator](https://github.com/accesscode-2-1/calculator) repository by 18:59 on 5/21 (that is, before class). Presentations will be in class that day. #### Groups You will work in assigned [groups of two](groups.md).