About this course

A course taught by Phill Conrad in the Dept. of Computer Science at UC Santa Barbara

Older materials can be found at the 56wiki site.

This site is maintained in this github repo: https://github.com/UCSB-CS56-pconrad/UCSB-CS56-pconrad.github.io

Previous Offerings of CS56

Textbooks

Articles on individual chapters can be found on the pages for each textbook

• Head First Java, 2nd Edition—Main textbook for learning Java
• Head First Design Patterns—Main textbook for learning Object-Oriented Programming

Tutorials

• Parsing—The basis of compilers, interpreters, evaluators, etc.
• Parsing: (00) Some sample code to refer to—Some code you can run, compile, and consult as go through the tutorial
• Parsing: (01) Background—What is this parsing stuff all about?
• Parsing: (02) Formal Language Specifications—How do we write the rules of a language? (FSAs, CFGs, etc.)
• Parsing: (03) What is parsing?—The general and specific sense of the word, and explanation of three phases: tokenization, parsing, evaluation
• Parsing: (04) Tokenization—Context Free Grammars, EBNF, and Abstract Syntax Trees
• Parsing: (05) Parsing, Grammars and ASTs—Context Free Grammars, EBNF, and Abstract Syntax Trees
• Parsing: (06) Evaluation Phase—The specific phase where we apply grammar productions and construct an AST
• Parsing: (07) Syntax vs. Semantic Errors—The formal definition of the difference
• Rational—A class for rational numbers, and starting point for learning Java, and the Java toolchain
• Rational: ex01—private data members, public constructors, integers from command line arguments, main methods, built in toString method, simple compilation/execution with javac/java
• Rational: ex02—toString method, public getters, simple build.xml file for Ant, mutiple classes with main() in a single project
• Rational: ex03—creating a jar file, automatic testing with junit, creating and publishing javadoc
• Rational: ex04—move source to /src and .class files to /build, adjustments to Ant build.xml, discuss immutable objects
• Rational: ex05—Addressing bugs with test-driven development (expose bug with test first, then make test pass to squash bug)
• Rational: ex06—understanding inheritance (from java.lang.Object), linking from our javadoc to Java standard libraries, negative rational numbers, multiplying rational numbers
• Rational: ex07—Exceptions, testing for Exceptions with JUnit
• Rational: ex08—functions (methods) to multiply two rational numbers
• Rational: ex09—== vs. .equals, hashCode()
• Rational: ex10—packages: edu.ucsb.cs56.pconrad.rational
• Rational: ex11—Using java arrays and java.util.ArrayList with Rational; running main() programs from a jar file; reading from file, constructing from string
• Rational: ex12—Converting from Ant to Maven, adding jacoco test case coverage
• Rational: ex13—Improved test case coverage
• Rational: ex14—Java Lambdas
• Rational: ex15—Sorting: Comparable, Comparators
• SparkJava—Creating webapps with the Spark framework for java
• SparkJava: 01—Getting Started, Hello World
• SparkJava: 02—Deploying the Library Tutorial App on Heroku

Topics

• Agile—A Software Development Methodology
• Agile: Standups—A timeboxed standing meeting, with no
• Agile: Team Norms—Groundrules set by a team that promote effective and harmonious teamwork and productivty
• Agile: User Stories—As a (who?) I can (what?) so that (why?)
• Android—Building Android Apps in the context of CS56
• Ant—Apache Ant, a build tool for Java (similar to Make/Makefiles)
• Ant: Comparing files—Doing something like a unix 'diff -q' via Ant
• Ant: Properties—The variable like things in Ant files (but they aren't really variables)
• antipatterns—Things to avoid in your code
• Antipatterns: inheritance—When NOT to use inheritance
• Code Smells—Common problems that arise in code
• Code Style—formatting, indenting, names, and much more
• Code Style: astyle—automatic code indenting tool available on CSIL
• Course Policies—Explanations of why certain instructors do things they way they do them.
• Course Policies: Answer Keys—Why do you not provide answer keys for all your old exams?
• CSIL—Computer Science Instructional Lab machines
• CSIL: browser from command line—How to open a browser from the command line
• CSIL: disk quota and file quota issues—How to diagnose and fix
• CSIL: git configuration—Configuring your CSIL account to use git
• CSIL: Remote Host Id Changed—The scary REMOTE HOST ID CHANGED message with mention of SOMETHING NASTY
• CSIL: Via MacOS—Accessing CSIL from your MacOS system
• CSIL: via ssh from Windows—Connecting via PuTTY/XMing or MobaXterm
• Data—Various sources for datasets to build applications with
• Design Patterns—Various sources for datasets to build applications with
• Design Patterns: Strategy—Define multiple algorithms and let client application pass the algorithm to be used as a parameter.
• Eclipse—One of several choices for a Java IDE
• Enviroment Variables—Reading them from Java code
• Firebase—An interesting development platform
• Game Programming—How to make Java work for Games
• Gauchospace: Clickable URLs—In assignment submissions, urls should be clickable
• git and github—version control, source code configuration and project collaboration tools
• git: basic workflow—The basics: git add..., git commit..., git push ...
• git: cloning your first repo—A guide for those new to git
• git: feature branch workflow—One branch per feature/issue/story
• git: .gitignore files—What they are for and what to put in them
• git: merge conflicts—Not nearly as scary as you may have been told
• git: overview—An introduction. git vs. github.com vs. github.ucsb.edu, repos, etc.
• github: adding collaborators—giving individual users access to a private repo
• github: api—Java Api for Github
• github.com: creating private repos under an organization—for closed source class assignments
• github: issues—working with issues in github
• github: keyboard shortcuts—making the github web UI easier to use
• github: using ssh keys—generating public/private key pair, uploading public key to github
• github.ucsb.edu: creating private repos under an organization—for closed source class assignments
• Gradescope—System for homework grading, feedback and submission
• Gradescope: Regrade Requests—What to do if you have questions about the grading of a problem (e.g. you think there was a grading error)
• Gradescope: Student Self-Submission—Scanning your assignment to PDF
• Heroku—A cloud computing platform
• Heroku: Troubleshooting—Solutions to common problems and errors
• IDEs for Java—Integrated Development Environments for Java (IntelliJ, Eclipse, Netbeans, etc.)
• Java—The language we are studying in CS56
• Java: Annotations—All about those funny @ things that precede methods
• Java: ArrayList to array—e.g. ArrayList<Integer> to int []
• Java: Codacy—A static analysis tool for Java
• Java: Command Line Arguments—how to the access contents of (String [] args)
• Java: == vs. .equals(), and hashCode()—the difference, and how to override .equals and .hashCode()
• Java: Garbage Collection—How and when does memory allocated on heap get reused?
• Java: Garbage Collection: Under the Hood—Can we peek under the hood at how garbage collection is done
• Java: HttpURLConnection—And HttpsURLConnection; a Java object for retrieving content from a URL
• Java: JAR files—Creating and using .jar files
• Java: JVM—The Java Virtual Machine
• Java: Lambda Expressions—Shorter, cleaner code using anonymous functions
• Java: Overriding vs. Overloading—The difference between these
• Java: Plaform Independent Newlines—\n isn't as portable as you might like
• Java: Sorting—Comparable, Comparators, and sorting ArrayLists and such
• Java: static analysis—Tools that analyze source code without running it
• Java: Streams in Java 8 —A whole new style of programming
• Java: Unchecked Operations—That message that says blah.java uses unchecked or unsafe operations. Recompile with -Xlint:unchecked for details.
• Java: Web Applications—Overview of various frameworks (Servlets, Spring, Apache Spark-Java)
• Javadoc—Documentation generator for java
• Javadoc: Legacy Code Projects—step-by-step instructions for javadoc for UCSB-CS56-Projects
• javadoc: publishing to github pages from a private repo (the old way)—step-by-step instructions
• javadoc: publishing to github pages from a private repo—step-by-step instructions
• javadoc: publishing to github pages from a public repo—step-by-step instructions
• javafx—replacement for swing, platform for Java GUI development
• javafx: XQuartz on Mac—when JavaFX doesn't work over X11 forwarding on Mac, how to fix it
• JDBC—Java Database Connectivity--a way to use SQL-based databases with Java
• Jekyll—Creating web sites (like this one) on github-pages using Markdown
• JSON: —JavaScript Object Notation
• JSON: Jackson—A Java Package for processing JSON
• JUnit—Unit testing framework for Java
• JUnit: Hamcrest Matcher style—A different style of writing assertions for Unit testing
• JUnit: Mocking System.out—How do you write a JUnit test for a method that uses System.out?
• Kanban: —visualization of work in progress
• Log4J: —A logging framework for java
• Log4J: SparkJava—Using Log4J with SparkJava
• Log4J: Spring Boot—Using Log4J with Spring Boot
• Lombok: —Automatic generation of getters/setters, etc.
• MacOS—Setting up an environment to do CS56 work on your own Mac (not ssh'ing into CSIL)
• MacOS: Homebrew—Package installer for Mac OS
• Markdown—A simplified syntax to create formatted documents
• Maven: Hello World—A relatively simple Hello World app with Maven
• Maven—A build tool for Java plus a package manager
• Maven: Adding custom jar dependency—Including a jar file that isn't available as a standard Maven dependency
• Maven: Convert Ant to Maven—replacing ant build.xml with maven pom.xml
• Maven: FAQ—Frequently Asked Questions
• Maven: Installing—on Windows, Mac, Linux
• Maven: Javadoc—Generating javadoc when using Maven
• Maven: Xlint options—For example, what to do when you get `Recompile with -Xlint:unchecked for details`
• MongoDB—A particular NoSQL database platform
• MongoDB: Mlab—A cloud provider of MongoDB databases with a free tier
• MongoDB: Spring Properties—How to set properties for connecting to MongoDB when using Spring
• OAuth—The way we implement the 'login with Google, Facebook, or Github' thing you see on some websites
• OOP—Object Oriented Programming
• Refactoring—
• REST—RESTful APIs, etc (Representational State Transfer)
• Scrum—A Software Development Methodology
• Selenium—Remote Control of a Browser (e.g. for end-to-end testing of webapps, web scraping)
• Sockets—An abstraction used in networking
• SparkJava: —A micro framework for creating web applications in Java 8 with minimal effort
• SparkJava: Authentication—login/logout, and securing various pages in your app
• SparkJava: Bootstrap—Adding a nicer looking UI, with common navigation, drop down menus, etc.
• SparkJava: Facebook API—Authenticate with Facebook, then access the Facebook API
• SparkJava: Getting Started—A more clear tutorial
• SparkJava: Github API—Authenticate with Github, then access the Github API
• SparkJava: Image Files—and any other static files your application needs
• SparkJava: MongoDB—Using the NoSQL database MongoDB with SparkJava
• SparkJava: pac4j—Securing a SparkJava webapp, with options for OAuth or LDAP
• SparkJava: RESTful APIs—Creating RESTful APIs with SparkJava
• SparkJava: SLF4J—What is the Simple Logging Framework For Java, and how to configure it
• SparkJava: Templates—The various template engines you can use with SparkJava
• Spring Boot: —A Java web application framework
• SQL—SQL-based relational databases (sqlite3, Postgres, MySQL, etc.)
• Swing—A GUI Framework
• $T and $B—Using environment variables to make navigating a src tree less painful
• Test Driven Development (TDD)—General information about best practices
• Testing—Everything having to do with testing: Unit testing, Integration Testing, Test Coverage
• Testing: Jacoco Reports—How to interpret the reports (red, yellow, green)
• Testing: Jacoco via Maven—Setting up Jacoco test coverage, using Maven
• UML—Unified Modeling Language: A graphical language for software design
• Unix (and Linux)—A variety of resources related to Unix and Linux, esp. command line tools
• Unix: Misc tools—Various useful command line tools you may not know about
• Unix: Search/Replace across multiple files—from the command line, using grep, sed, etc.
• User Stories—As a (who?) I can (what?) so that (why?)
• vim—a widely used text editor among Unix users
• vim: basic eight—eight things you need to know how to do for your survival
• vim: customization—customizing vim for your purposes
• Windows—Setting up an environment to do CS56 work on your own Windows machine (not ssh'ing into CSIL)
• X11—Dealing with X11 DISPLAY issues
• YAML—An alternative to XML and JSON for representing structured data in a machine and human readable format

Resources

• Corgis—A collection of real-world datasets for programming exercises
• Exams—Past Exams
• Java: Tutorials—Online resources for learning Java
• Practicing Coding—Resources for practicing coding