3500 Midterm Cheat Sheet (DRAFT) by _allisonwalker

Abstra­ction
Removing( or hiding) unnece­ssary complication/detail
Good: Array.Sort();
Bad: nested for loops etc.

API-Ap­pli­cation Progra­mming Interface
High level specs of ops, e.g. Array, Add, Remove, Contains, IsEmpty, Graphi­cs.D­raw, etc.

Software Practices Stepps
1. Analysis – what do we need to do?
2. Design – how do we do it?
3. Implement it - Coding Yay!
4. Test, debug, improve
5. Go back to 1-4 as needed

XML Syntax
<ta­­g> info </t­­ag> e.g.,
<su­mma­ry> … </summary
<param name=‘­­va­l­’> … </p­­ar­a­m>

Why XML?
Machine readable, parsable, intell­­is­e­n­sable

Delegates
A delegate is a way to provide a TYPE for a function return type, parameter list/types
You can use delegate types to store functions in variables “call” those saved functions using the variable name

Delegate is the definition of the “Type” of function. Lookup is just a name I choose!

Delegates as Params
Delegates allow you to “pass” functions to other functions int doit(s­tring x){ … } // ← Meets Delegate Requirements
…
Evaluate(“1+var”, doit)

C# Simila­rities w/ Java
Compiled to an interm­ediate form Run with a “runtime environment”
Automatic memory management
Syntax mostly the same (or one-to-one transi­tion)

C# Access Modifiers
public, protected, and private are the same as in Java. Internal means any method in the compil­ation unit (e.g., project) can treat the variable as public, but “outside” users treat it as private.
Why do we have these?
Answer: Because progra­mmers are human and progra­mming is hard. These modifiers “say”: Only allow the person most familiar with the code to make changes to data; e.g., the library code itself has private variables (such as the stacks) and only the person writing that code “knows enough” to use them. The “outside world” user just uses the Evaluate method.

Interfaces
Same as java
Contract for a method (somewhat like a delegate)

Escaped Strings
How do you put a “new line” into a string?
Answer: “\n” The \ (back slash) is called the “Escape Character”
Used to combine “regular charac­ters”, i.e., ‘n’ and ‘\’ to form a special character Common escaped charac­ters: /t, /n, /e
Example: string filename = “c:\\d­ocu­men­ts­\\fi­les­\\a­bc.t­xt”; Note: Unix uses slashes, so you don’t have to “double up”: (e.g., /home/­ger­main)

Interp­olated Strings - $
Do This! (Almost always!)
How do you put variable values into a string?
Old, Bad way: string s = “Your score of ” + score + “ is a good one!”;
New, Good way: string s = $“Your score of {score} is a good one!”;

Lambdas
Shorthand notation for: Defining small anonymous functions Inline
Useful for: Testing, “One offs”, Some GUI applic­ations, etc.
Syntax:
( [param1, param2, …] ) => { code };
( [param1, param2, …]) => expression to return;

Version Control Use
Collaborative development
Branching/Merging Code
archeology/File history
Differences
Backup

Extensions
Extensions allow us to add “dot methods” to classes we don’t own, use this new functi­onality as if it is “built in”
Example: name.C­api­tal­ize­Fir­stL­etters( );

Interface
A specif­ication guaran­teeing that an implem­enting class will have certain functions
Guarantee made by the compiler
There is no guarantee the functions work, just that they are there.
Aside: Useful also with Polymo­rphism:
Movable x; // A Movable must have a .move() method
Car c = new Car();
x = c; // public class Car : Movable
x.move(); c.move()

IEnume­rable
A high level type (inter­face) that allows us to apply actions to a list of objects
Useful with foreach loop
Useful when we don’t care (or know) the underlying data structure
Makes our code more robust and general!

Unit Tests
Test the “smallest” pieces of the software system {[nl}}­E.g., methods
Simplifies tests, simplifies debugging
“Easy” to find the failure point

Code Review
Higher Quality Code
Fewer Defects
Easier to Maintain
Developer Training Learn about other parts of codebase Learn about other techniques

Immutable
Strings are immutable, they cannot change.
Thus once we write:
string s = “jim”;
That string object will _always_ contain “jim”
Question: s = “jess” does not change the string, but instead creates a reference.

Methods that Modify­(Mu­tate) an Object
are called mutators
The stack class is “Mutable”
Can be modified after creation
The string class is “Immut­able”
Cannot be modified after creation
Q: How can you make any object Immutable (to a programmer using your object?)
A: Make all fields­/Pr­ope­rti­es/­setters PRIVATE! (prote­cted)

Properties
Properties are similar to named fields in the object
Properties should be aspects of an object that can be understood indepe­ndently of the rest of the repres­ent­ation
Think, for example, of the current hour of the day (from a Date class where internal repres­ent­ation is seconds since a prior date)
Public properties (which is usually the case) provide a “contract” with user of your code
Has a convenient notation for building getter­s/s­ett­ers­{[nl}} Can control access to get and set (i.e., private) indepe­ndently
As always, don’t make every member variable public
“private” properties can often just be private member variables

Delgate v.s. Func
Why Use Delegate?
Named, Docume­nted, Provides More Context
Evalua­te(­string formula, Variab­leL­ook­UpM­ethod lookup)
Why Use Func?
Shortcut, Types are “right there to see”
Evalua­te(­string formula, Func<s­tri­ng,­int> lookup)

Global Variables
Data that is accessible from “anywhere” in the program
If a method modifies one, it is a “hidden side-e­ffect”
Software Practice - Almost always:
Best Case: Data → Function → return New Data
Nothing else changes!
Okay Case: Data → Function → parameters “change” (see out/ref params)

Memory Diagram
Every function should be labeled on the stack
Every variable is kept on the call/a­cti­vation stack
References (to objects) have “arrows” to heap
Value variables have values on stack
Object methods should show “this” explicitly on the stack
Every new object is kept on the heap

In, Out, Ref Params
In
- makes Reference constant
WARNING: does not make object constant
Out
- refers to calling methods variable
Places object “in” calling methods variable
Must be assigned a value
Cannot use “what was there before”
Ref
- refers to calling method variable
Can use what is there
Does not have to assign a value
Out and Ref the same except compiler enforces semantics

Structs
Constructors allowed, but not required
new() → calls constructor
Does not put object on heap
Can have methods
Getters/Setters/Properties
Usually do not!
Why do structs go on the stack?
Efficiency!
No allocation!
No deallo­cat­ion­/Ga­rbage Collec­tion.

IEnume­rable
What is the “High Level English” meaning of an IEnume­rable?
Guarantees a “list” of “stuff” coming back.
What are some classes that implement IEnumerable?
List, HashTable, BST, Array, etc.
IEnumerable iterable = new BST();
IEnumerable iterable = new List<s­tri­ng>( … ); // etc
What does an IEnume­rable “give you”?
A way for OUTSIDE CODE to “walk” the data:
foreach (var item in iterable) { Print(­item); }

Linq
Adds “Datab­ase­-like” syntax to C# (somewhat modeled on SQL database language).
Can convert IEnume­rable to Arrays or Lists
Using System.Linq;
public void doit( IEnume­rable container ) {
List list = contai­ner.To­List();

Yield Return Explained
When the line with yield return is encoun­tered:
The runtime saves the entire STATE of the method
Local Variables
Parameters
When the method is called again, the runtime restores the state and continues
From the last point of execution!

REGEX
[abc] ← Square Brackets: match any character in here
a|b ← OR - Match an ‘a’ or ‘b’ character
a ← Match zero or more (little) a’s
d+ ← Match one or more (little) d’s
\d+ ← Escape: Match one or more digits!
\s ← Match whitespace
a? ← Match zero or one little a’s
(a) ← If we find this, put it in “group” 1
a$ ← a at end of string!

Yield Return BSTpse­udocode
IEnumerable traverse( Node current )
{
if (current == null) return;
yield return this.V­alue;
traverse ( this.left );
traverse ( this.right );
}

What does == do?
== is REFERENCE equality
Are X and Y the same object in memory.
overloaded ==
Can mean anything you want it to mean, but…
Usually means VALUE equiva­lence “jim” == “jim”
.Equals
Means value equiva­lence

Dry Code
Move common code to helper method(s) Make Library for common code Use Extensions Library

How do we ensure the Invariant on this?
public void Replac­eDe­pen­den­ts(­string s, IEnume­rab­le<­str­ing> newDep­end­ents) { }
Answer: this function should not touch Map 1 or Map 2 Answer 2: this function should only use addDep­endency and remove­Dep­endency

NameSpaces
SpreadsheetUtilities
Internal namespace to your project for your use/protection
SS ← Added to project now
External namespace your project “shows” to the world, similar to System, or Math, or Collec­tions…

Abstract Class
Defines WHAT must be done (via methods)
Defines Return and Parameter Type Signatures
Defines generic (reusable) code
Defines generic data (if applicable)
A child class can only implement one
Can have a constr­uctor

MVC
Model - Working on this now
Data→ Cells - Contents / Values
Functionality → Depend­encies
(See requir­ements in Abstract class)
View - GUI (not working on this now)
Controller - actions available to user
often initiated through the GUI
Not working on this now

<in­her­itd­oc>
Does just that. {[nl}}­Inh­erits docume­ntation from parent (class)
Why is this DRY?
DRY since we don't repeat oursel­ves­/code

Self-D­ocu­menting Code
Wrong - “Don’t Comment your Code!”
Right Comment for Why
Provide links to algori­thms, examples, docs
Rename compli­cated expres­sions with unders­tan­dable names

Yield Return
Used for Enumer­ations (IEnum­erable)
Operationally: Saves Code/M­ethod Call Stack
Used for: “infinite” or “costly” enumer­ations

GSP- Good Software Practices
Good use of Versioning
Multiple Commits. Good Commit Messages
Tags at “Releases”
Good use of Testing
Extensive Unit Tests
Well named/­useful tests.
Documentation
READMEs
Located in Solution Folder (and all Project Folders)
Hour tracking
Software Practice Section
Header Comments
Who, what, verification
Method and Field Docume­ntation

UML -Unified Modeling Language
Unified Modeling Language
“Syntax” for drawing diagrams
Progra­mming Language agnostic
Not all fields­/me­thods need to be shown
Only those required for an unders­tanding

Connec­tivity
Arrow indicates that one class is aware of another Direction indicates whom is aware of whom

Compos­ition
Entities within are not whole on their own (“strong” ownership)
e.g. A Student containing a Transc­ript, and the transcript “goes away” when the student leaves the University

Increm­ental Testing
Test increm­ent­ally!
The longer you go without testing, the bigger your “haystack” becomes
Catch design flaws early
Problems will become apparent before bolting it all together
Keep the “haystack” small!
Testing is a lot like debugging

Regression Testing
Regression refers to “going backward” (regressing)
When new code is added the number of bugs goes up, therefore the code “regresses”
Try to minimize this
Run existing (old) tests regularly
As code changes, tests might start failing
Note: Sometimes the Test needs to be updated
Test suite contin­uously grows
Never discard a valid test!
Must start test suite on “day one”
or it won’t get done
Must keep tests up to date (prior­itize them)
Or it won’t get done
Must run tests every day
Or it won’t get done!

Code Coverage
100% coverage is often difficult
Huge systems – countless paths
Irregular intera­ction (e.g. GUIs)
That being said:
“Model” code is easier to cover
Eliminate “dead” code
You have access to the “white box”

Debug Assert­ations
Assert­ations in regular code:
Debug.Assert(some condit­ion);
Condition should always be true – fails otherwise
Sprinkle these throughout your code where invariants should hold
Get removed in release builds – important for performance!
Use them if your code assumes precon­ditions
Good use of assertions can save countless hours of debugging
Fail Fast!

Explicit Nullables Syntax
? - The Question Mark is used to denote that a variable is allowed to contain nulls:

How to use Non-Nu­llables
Non nullables REPLACE the old syntax:
public Student functi­on(­Student s) // s must contain an object
{
Student temp = s; // temp must contain an object
…
return temp; // temp cannot contain null (compiler enforced)
}

Testing
Coverage != Good Tests
Necessary but Not Sufficient
Tests should be small and targeted
(Hence Unit Tests)
A _deep_ unders­tanding of the project goals is very important to unders­tanding the code
A full reading of all specif­ica­tions (both in the starter code and written docume­nta­tion) is necessary!
Stress Tests show correct use of comple­xit­y/big O
Harder to write
Harder to debug

Saving Files
Need a “protocol” (i.e., what does a file structure mean?)
XML and JSON
Notations for saving inform­ation
Machine readable
Supported by Abstra­ctions and Libraries

XML-At­tri­butes
Attributes - inside of tag < >s
Add extra inform­ation to tag
Probably should be avoided (most of the time*)
Examples:
<te­acher name=“­Jim­">
<param name=“­len­gth­”>
<list type=“number”>
<record id=“57­”>

JSON
JSON – Repres­ent­ation – Object is {}
Key Name/Value:
{ “key” : “value” }
Value can be a JSON object
{ “key” : { key1 : value, key2 : value } }
JSON Arrays:
{ “key” : [ { key: value, … }, { … }, … ] }

Serial­ization
Uses Reflection to determine Run-Time structure of object
Turns this structure into a machine readable format
Can do this automa­gically

Properties vs. Fields
Serialization works on Properties instead of fields
Field: int name;
Property: int Name { get; set; }
Warning
Default serial­ization works on public Proper­ties.
If you want Private access, or to change the names, you must use some “meta-­tags”

Business Logic
Where does the business logic error checking go?
M, V, or C ?
Answer:
Model and Controller (mainly) but also in the View! ←Trick Question!
Example:
Model checks for cycles in graph
Controller does input saniti­zation
View only allows inputs in valid cells; View restricts input to only numbers (where approp­riate)

GUI
Real world programs (usually using GUIs) are driven by inputs
Unpred­ictable (based on human input)
Execution is non-de­ter­min­istic
You don’t know the order of the users actions…

C# Event Handling
Note: Directly supported by the language!
Define a delegate for handling the event
All handlers match this signature
Declare an event (in the notifier)
Register a handler (in the listener)
Trigger the event (in the notifier)

Event Abstra­ction
The event syntax provides:
a list
a foreach loop
an assignment operator
All “hidden” (abstr­acted) with simple­/co­mpact syntax!

Good Software Practices
All of the techniques and principles (e.g., DRY) that we discuss are designed to give developers “Best Practices” for creating code that:
a. Contains fewer defects
b. Is more maintainable
Easier to understand
Easier to modify
Safer to modify (see (a) above)

(S)ingle Respon­sib­ility
Each class (dare we say even method) should have a single respon­sib­ility
Example: the spread­sheet model does not deal with:
The GUI
Dependency Graph
(Other than by using the Depend­enc­yGraph library)

(L)iskov Substi­tution Principle
Variables in a program of a give (Parent) type should be replac­eable with instances of their subtypes without altering the correc­tness of the code.
Example: The need for an Abstract Spread­sheet can be fulfilled with any students Spread­sheet implem­ent­ation

(D)epe­ndency Inversion Principle
Classes should depend upon Abstra­ction not Concreteness.
Where possible, variab­les­/fields should be Interfaces or Abstract Classes rather than a concreted class.
Example: Spread­sheet GUI should have an Abstract Spread­sheet member variable, not a Spread­sheet.
This allows flexib­ility in expanding the project in the future
class GUI
{
private Spread­sheet Spread­sheet; // WRONG
private Abstra­ctS­pre­adsheet Spread­sheet; // CORRECT

Software Practice and Parallel
Does Parallel make code easier to unders­tand?
Does Parallel make code have fewer defects?
NO!
It might inspire you to better document, but it is intrin­sically more compli­cated than single thread execution
So why do we do it?
Answer: efficiency gains out weight complexity
We must be even more diligent in our naming, docume­nta­tion, testing, etc., when writing parallel code

Dennard Scaling
Robert Dennard, 1974: As transi­stors shrink, power-­density remains constant
•What does this mean?

Parallel Computing
•We told the algorithm how to divide the work
•And more import­antly, how to combine the results
•Writing code without thinking about parall­elism will not (usually) produce a parallel solution

Non-Bl­ocking
•threa­d.S­tart() is a non-bl­ocking statement
• It returns right away
• Even though the other thread is still running
•thread.Join() is blocking
• Calling thread waits until thread finishes
• What defines when thread is finished?
• When the work function returns

Concurrent
•Concurrent
• Multiple tasks running
• Thread can be interr­upted, preempted at any time
•Achieved by either:
• OS rapidly switching thread­s/p­roc­esses
• Two thread­s/p­roc­esses executing simultaneously
•Concurrency via Context Switching

Multi-­Thr­eading
•Multithreading does not (neces­sarily) mean parallel
• But it does mean concurrent
•The issues that arise with multit­hreaded progra­mming are due to concur­rency, not parall­elism

C# Form
•How does a C# Form control program flow?
static void Main()
{
...
Application.Run(new Form1());
}
public Form1()
{
Initia­liz­eCo­mpo­nent();
}

Handeling Messages
while(m = NextMessage())
{
HandleMessage(m);
}
•If handling the message is expensive, then other messages get stalled
•GUI becomes unresp­onsive

Modals­(Po­p-Ups)
async void doit() { //async bool Displa­yAlert( … )
overwrite = await Displa­yAlert(
"­War­nin­g", // Title
"­Spr­ead­sheet changed, do you want to contin­ue?­", // Message
"Yes", // True choice
"­No" ); // False Choice

Good Software Practices lead to
Better Archit­ecture 🡪 FDMM
MVC, Client Server, Event Driven
Use of “tried and tested” libraries
SOLID → FDMM
Smaller “units” (multiple single respon­sib­ility functions)
Documentation 🡪 FDMM
Versioning 🡪 FDMM
Testing 🡪 FDMM
Design Patterns → FDMM
FDMM – Fewer Defects, More Mainta­inable

Code Alignment
Makes code:
Easier to Read
Easier to spot “one offs” or “copy paste” mistakes
float thousands = 1000;
float millions = 1000000;
float billions = 100000000;
Even Better: Use number unders­cores

Shared Data is Proble­matic
Parallelism
When possible do work on separate data
When NOT use locking
We’ll talk more about this later
Slows down the process

Parallel Vocab
Thread
A separate unit of execution (assigned a method/function)
Race Condition
Two (or more) threads have access to same data at the same time
Lock
Protects a critical region of code (which almost always should contain a shared resource, e.g., a common variab­le/data structure)
Deadlock
Two+ threads are waiting for each other in order to continue

Charac­ter­istics of GSP
Defects (bugs) Reduction
Testing, Archit­ecture, SOLID
Mainta­ina­bility
Understandable/Readable
Testing 🡪 Regression resistant

Software Practice - Problem Solvin­g(C­oding)
Problem: I want to choose where to save a file (sprea­dsheet) in my MAUI application
Solution:
Software Practice in practice
Step 1: Google - choose good keywords
Step 2: Stacko­verflow - verify it “looks legit”
Step 3: Nuget and Troubleshoot

Two way Commun­ication
Address and recipient
Address and sender

Archit­ecture: Client ⬄ Server
Client wants to do some “work”­/“play”
Server controls functionality
Client usually shows the GUI
Server usually manages the Model/Data

IP Version 6 and local nets: Too many computers…
Note IPv4 vs. IPv6 (number of addresses)
Think license plates in Utah vs. California
Local network: 192.0.0.1
Most of your home routers

Client ⬄ Server Commun­ica­tions
Needs:
The address of the server machine
Initial port to talk to
A unique port for future commun­ication
The Protoc­ol(s)!

Initial Port vs. Continuing Port
For Query/­Res­ponse programs (e.g., a web server):
the server will use a specific low port that is “known” so anyone can make an initial connection
i.e., 80
Ongoing connec­tions will be moved to a different (high) port number
So that new clients can talk to server at the same time

Ports -2
Who decides number?
Some programs have official ports
Other programs have “taken” over ports
Some ports screen­ed/­blocked by firewalls!
Especially low ports under 1000

Socket
An identifier repres­enting a particular point to point commun­ication connection between two pieces of software
My IP ADDRESS
Their IP ADDRESS
My Port Number
Their Port Number
Combined into a single unique commun­ication channel

XML Commenting Protocols
How do we define comments about parameters?
<param name=”­abc­”> info </p­ara­m>

TCP -Trans­mission Control Protocol
Runs on top of IP (Internet Protocol)
One to One Reliable Commun­ication
Data will arrive
Verified Ordering
Verified Uncorr­upted
Does not verify when data arrives or how much arrives at a given time!
C# libraries do all the work for you
Take the Networking course! CS 4480

Basic Network Commun­ication Facts:
Happen at the BYTE level!!!!
Your program must
Translate useful data into bytes and
Translate bytes into useful data (e.g., strings, objects, etc)
TCP does not guarantee
When Inform­ation Goes Out
When Inform­ation Arrives
How much inform­ation is sent at any one time…
TCP does guarantee
order and validity

Need our own Protocol
If you can’t guarantee when or how much data the program receives, how do you know when you have a full message:
jim is great… ☺
…ly overrated ☹
Answer: define a protocol
For example: the character ‘.’ will mean we are done:
jim is great.
Problems?
Other Sugges­tions?
How about writing the number of characters as the first byte?

What the server's connection thread does
A SERVER DOES TWO THINGS:
“NETWORK STUFF” (E.G., HANDLE MULTIPLE CLIENT REQUESTS AND CONNECTIONS)
“APPLI­CATION STUFF” (E.G., MANAGES A GAME)

GSP Overview
GSPs refer to tools, techni­ques, processes, etc., that are used to ensure our code is:
Easier to maintain
Contains fewer defects
Examples include:
Versioning (git/g­ith­ub/­github projects)
Design Patterns
System Archit­ecture decisions (e.g., MVC)
SOLID, DRY
Diagramming/UML
Testing
Unit Testing, Integr­ation Testing, open/c­los­ed-box testing, C# test syntax, e.g., TestCl­ass­()]…)

More Key Issues
Watch for Race Conditions in your code
What values can multiple threads access?
E.g., Client array
Removing items from a shared list
Network Realities
How much data comes at once?
Protocols: “what is a message?”
127.0.0.1 (local­host)

Simple Chat Client­/Server Key Concepts
Key Concepts
“Event” callbacks
Older vs. Newer
Await Async

New Version of Code
Async - tells the system that the code may “pause” and “return” later
Allows other threads to execute
Await - tells the system to “wait” here (pause thread) until an “event” happens
Let’s look at the tcpclient version of the code.