CS Education

I am currently pursuing my Master of Computer Science degree (specializing in Data Science). What follows is some of the CS education I underwent in the years before starting the graduate program.

During my engineering undergrad studies at Georgia Tech, I took a CS intro class and a numerical analysis class, both of which used MATLAB heavily. I’ve expanded my CS education substantially since then, taking online courses, reading books, and building projects at home and work. My main interests and experience involve data analysis and organization.

I took MIT 6.00SC first, which was an intro to CS that used Python. I then went through the book/course “Learn Python the Hard Way”, which was nice because it taught how to use a regular text editor and the terminal instead of an all-in-one IDE like MATLAB or Python’s IDLE.

Python logo

After taking those two Python courses, I built a few projects to apply my knowledge.

I created a contact-sync program in Python that takes a contact-list export from either iPhone or Outlook (different formats) and converts them to Mozilla Thunderbird format using pandas DataFrames. This allows me to view and maintain my master list in Thunderbird. The program integrates new exports and incrementally updates the master list, adding new entries and replacing any modified ones – but not propagating deletions. This allows me to keep my phone contacts list at a manageable size, but I retain all old entries in the master list. This project gave me a chance to expand my Python skills and use Git on a real project for the first time; I’ve used Git for every project since. Click here to see the code on my GitHub page.

iOS, Thunderbird, and Outlook contact synchronization

 

Next I read Pro Git by Scott Chacon and Ben Straub (available for free online) to expand my knowledge and abilities in the software, beyond just push/pull/commit.git logoI then built a networked garage-door controller that allowed me to open my garage door from my phone (before this was commonplace w/ IoT). I used a Raspberry Pi to host a Python web server and actuate a relay to mimic a wall-button switch. Before tackling this project, I read the (lengthy) book Exploring Raspberry Pi by Derek Malloy. I learned a lot about the Raspberry Pi, Linux, Git, embedded electronics, sensors, etc. It was my first introduction to Linux and Raspberry Pi, both of which I’ve worked with extensively since. Click here to see the code on my GitHub page.

Raspberry Pi and relay board installed
Raspberry Pi garage-door control server

Another project I built is a test data-processing program for work, again using Python. I had just finished performing high-altitude testing on some vehicles in the mountains to validate our new EFI system was adjusting properly for the decreased air density. I collected data with two different data-acquisition systems, each with their own start time and sampling rates, and I needed a way to combine the data and plot them together with proper “time alignment”. Both systems measured engine speed, so the program aligns using that data. Then it “spaces out” any channels that were recorded at a lower sampling rate, so everything is in sync and shares a common time vector/index. Using Matplotlib, it plots the pertinent data (engine speed, TPS, AFR), which is also saved to PDF for portability/archival. It also generates a CSV with the combined and synced data for each run, so someone with no knowledge of my data-combining program can still use the combined data for future analysis; a goal of the project was ensuring future use of the test data did not require knowledge of my Python program or Python in general to understand or make use of. We used these plots to make decisions about the speed and effectiveness of the EFI control system’s adjustments.

 

At this point, I wanted a more structured CS learning plan, and TeachYourselfCS.com fit the bill. TYCS is a free resource compiled by two CS profs to help self-directed learners. It lays out a concise catalog of nine essential CS topics with recommend book(s) and online lectures for each. Here are some highlights of my coursework:

  • The book and exercises of Structure and Interpretation of Computer Programs by Abelson and Sussman are recommended in the Programming subject of TYCS. The book uses Scheme, a dialect Lisp, to explore fundamental topics like recursion and argument evaluation order as well as deep concepts like sameness, state, and scoping. After reading this book and doing all the exercises, recursion comes very naturally, and I have an appreciation for what is possible with such a simple, elegant language.
  • As part of the Computer Architecture topic, the book and projects of The Elements of Computer Systems (a.k.a. “Nand2Tetris”) guided me through building a computer from the NAND up using HDL (hardware description language) in an emulator program. One of the major tasks was writing an assembler, and it was rewarding to see the machine language I generated running on the functioning computer architecture I built.
  • The book Operating Systems: Three Easy Pieces by Remzi and Andrea Arpaci-Dusseau was a fascinating and engaging read. The exercises allowed me to explore the implementation of each topic on my own laptop.

Three books: Structure and Interpretation of Computer Programs, The Elements of Computing Systems, and Operating Systems: Three Easy Pieces

  • I also went through the Algorithms and Data Structures and Math for CS subjects.

A few years ago, I made the transition to using Linux full-time on my laptop. I enjoyed the experience of programming on the Raspberry Pi. This was a big boost for my CS education, as I now have more opportunities to interact with the terminal and automate tasks.

The Linux penguin, Tux

Around 2019, I build a large Python project that automates the incremental offloading, organizing, categorizing, and archiving of my iOS photos and videos. For years, I’ve used a manual system to back up these pictures/videos to my computer storage hierarchy and copy them into the right directories for later access. I wrote a program to automate this; it finds and offloads new images and videos from the phone’s virtual file system. Then it prepends datestamps to the filenames and sorts them into folders by month and year [a few years later, the iOS device vfs adopted the same folder naming/organization, so I’ll take that as a compliment!]. The program employs Phil Harvey’s awesome ExifTool Perl utility with Sven Marnach’s PyExifTool wrapper to extract the photo’s “date taken” info from the file’s EXIF metadata. There are multiple dates stored in EXIF data, and identifying which one is the correct, original capture date was a substantial task, differing by file type. Then my program displays each photo and provides an interface to quickly direct each file to the appropriate final destination – family pictures, documentation of an electronics project, cats, etc. I have continued to use and update this several times a year.

Another project I created is a set of bash rsync scripts to automate tiers 2 and 3 my computer backup strategy. Tier 1 is an automated, continuous backup to my NAS. Tiers 2 and 3 involve monthly and bi-monthly (respectively) detailed rsync jobs to back up my computers to external drives that both are stored offline, with Tier 3 also stored off-site. The rsync script runs multiple rsync jobs with various options, including different handling of symlinks, includes, excludes, propagating deletions, etc. All the jobs use verbose logging to file, compression, and partial-copy buffering.

See my WORK page for some other software programs I’ve built to facilitate my engineering work.

As I became more confident that computer science and data science were my passion and where I wanted to transition my career, I decided to pursue formal education. Since Fall 2024, I’ve been pursuing my Master’s in Computer Science in Data Science with University of Illinois at Urbana-Champaign; expected graduation is May 2027. My strategy has been to take only one class per semester and use any extra bandwidth to dive into related supplemental materials. For example, while taking Intro to Data Mining, I spent many nights and weekends building a substantial program for my job that mines insights from field diagnostic data (still in use today). During my Applied Machine Learning Course, I took the opportunity to read seven related ML books alongside the assigned text. During and after my Database Systems course, I built a SQLite database for logging state and performance of my vehicle’s auxilliary lithium-battery system. During my Statistical Modeling course, I learned a lot about eBird citizen-science data and various GIS data products to conduct a (more-ambitious-than-necessary) statistical analysis of woodpecker observations vs. habitat covariates for that class’s final project. For my data visualization class’s final project, I again used eBird data to create a guided visualization that contrasts migration paths for two common American birds of prey.

 

 

Here is a list of each course I completed as part of this graduate program:

  1. CS 412 – Introduction to Data Mining
  2. CS 441 – Applied Machine Learning
  3. CS 411 – Database Systems
  4. STAT 420 – Methods of Applied Statistics / Statistical Modeling in R
  5. CS 598 – Advanced Bayesian Modeling
  6. CS 416 – Data Visualization

Currently taking in Fall 2026:

  1. CS 598 – Foundations of Data Curation
  2. CS 598 – Practical Statistical Modeling

Slated for Spring 2026:

  1. CS 437 – Internet of Things

 


After each course, I reviewed my (extensive) notes and compiled a list of takeaways to help cement the “big picture” of what I learned and also to serve as an entry point for revisiting my notes in the future. Here are my summaries for each course (note these are not AI-generated):

CS 412 – Introduction to Data Mining

Pattern discovery  ─────────────────────────────────────────

Frequent itemset discovery – how to find frequently co-occurring items in an unordered “itemset”

To be considered frequent, a pattern must appear in the dataset with some minimum frequency – called “minimum support“.
Take advantage of the closure/”Apriori” property – every subset of a frequent n-itemset must be frequent.

Want to know prediction value of certain set of items on the presence of another item or set of items

Assess using “confidence” – the conditional probability of the target set’s appearance when the “base” set is there. When the pattern {x, y} appears, how confident can we be that {z} will appear too?

Just because you have high support and confidence doesn’t mean that {x,y}→{z} is a positive correlation. Even if {z} appears in 80% of the cases where {x,y} does, if in the global population, {z}’s appearance rate is 90%, then it is actually negatively correlated w/ {x,y}. Need a way to assess the impact {x,y}’s appearance has on the probability of {z} co-occurring.

Use correlation measures. Many exist – lift, chi-squared, cosine, Jaccard. Most have drawbacks – most are not null-invariant (thrown off by null tuples – portion of population that lack both {x,y} and {z}), and others provide a measure of correlation in one direction only.
Kulczynski is null-invariant and can be used with imbalance ratio to assess both {x,y}→{z} and {x,y}←{z} simultaneously.

Frequent sequential patterns

Like frequent itemset mining but respecting order
Gapped vs. non-gapped – choice is different for different types of data.

Frequent subgraphs

Data and pattern constraints and pruning methods can be used to reduce computational burden.

Most take advantage of monotonic or antimonotonic properties of the data or pattern.
Some constraints are convertible, requiring the dataset be sorted before application.

 

BasicVertical data formatPattern-growthClosed/MaxColossal
ItemsetAprioriEclatFP-GrowthCLOSET+Pattern-Fusion
Sequential PatternGSPSPADEPrefixSpanCloSpan
SubgraphAGM
FSG
PatternGrowthGraph
gSpan
CloseGraphSpiderMine

 

Cluster analysis  ──────────────────────────────────────────

Many different ways to compute similarity b/w two data entries based on attribute values

Partitioning-based

k-means/medoids/medians/modes
Based on some measure of distance or dissimilarity (depending on data type)
Progressive-refinement technique
Greedy; can be sensitive to initial cluster selection. Methods for better-than-random initialization exist – some use probabilistic initialization to spread out starting cluster centers, others just repeat algo w/ different random initializations and keep best outcome.
Different methods exist to automatically determine optimal number of clusters for a given data, attempting to automate assignment of k value.

Hierarchical

Create entire hierarchy instead of just the given partitioning of the data with a set number of clusters (k).
More deterministic; no iterative refinement. Still greedy though.
Dendrogram (tree) used to represent a clustering hierarchy
Agglomerative vs. divisive (bottom-up vs. top-down)
Have to choose a “linkage criterion” – how will data-point/cluster proximity “closeness” be measured to split or merge?

Density-based

Can discover clusters of arbitrary shape (e.g. non-convex)
Don’t specify #clusters k; instead, specify the minimum number of points a cluster requires, and the max distance a point can be away (ε) and still be part of a cluster.
DBSCAN
OPTICS – produces reachability plot showing cluster count vs. density
Can discretize data space and apply a grid-based algo like CLIQUE. CLIQUE can find subspace clusters in high-dimensional data, iteratively applying apriori principle while increasing dimensionality of search space.

Probabilistic and generative models

Perform MLE using expectation-maximization iterative algo to derive model of most-likely generative function (e.g., Gaussian(s))that could have produced data.
Allows for a data point to contribute to mulitiple clusters, with a probability of membership in each.

How to handle non-convex/linearly-inseparable clusters

Kernel methods (e.g., kernel k-means)
Density-based clustering
Probabilistic clustering (MLE via expectation-maximization)

Different evaluation metrics exist to determine how well an algo finds clusters, compared to the “ground truth” provided for a given dataset.

Curse of dimensionality

High-dimensional data is very sparse; distance metrics become less useful
Subspace-clustering methods like CLIQUE can be used.
Dimensionality-reduction methods like PCA can be used.

 

Classification  ────────────────────────────────────────────

Decision trees

Different ways of determining how to split dataset at each node

Information Gain
Gain Ratio
Gini impurity

Random forest – ensemble of trees w/ bagging

Bayes classifier

Naïve Bayes classifier that assumes class-conditional independence
Bayesian network w/ conditional probability table for each node

Metrics to assess performance

Accuracy, Error Rate
Sensitivity, Specificity
Precision, Recall

Classification eval

Cross validation
Bootstrap
Holdout method
ROC curve (comparison)

Ensemble methods

Bagging
Boosting

Special accomodations needed for class-imbalanced datasets (where positive tuples very rare)

Linear classifiers (discriminative instead of generative)

Logistic regression

Adapts linear regression by using the logistic (sigmoid) function to map a linear-regression result to a value in the (0, 1) range, indicating a probability of belonging to one class or another.

SVM

Finds best separating line or hyperplane separating data points in two classes.
Can use nonlinear kernel mapping to higher dimension for linearly-inseparable data.
Low model complexity – only determined by number of support vectors.

Neural networks

Multi-layer Perceptron – fully-connected layers. Gets too computationally complex quickly.
Each unit takes as input a weighted sum of the input connections plus some bias (weights and bias are the params to be learned).
Activation functions – need nonlinearity function to “switch on” the unit based on input.

sigmoid
tanh
ReLU
…

Nonlinear activation functions allow approximating any function.

CNN

Used for grid-like data like images.
Much more sparse mappings than a fully-connected MLP. Same params being applied at each point too.

RNN

Used for sequence data like text.
Previous state affects processing of subsequent. Can have future state feedback too.
Need special methods to handle longer-term “memory” – SLTM, attention mechanisms, Transformer model.

Pattern-based classification

Use frequent-pattern mining to discover combinations of features to use in classification inference.

k-nearest neighbor

 

CS 441 – Applied Machine Learning

… [still under construction]

 

CS 411 – Database Systems

… [still under construction]

 

STAT 420 – Methods of Applied Statistics / Statistical Modeling in R

What is modeling?

Creating a simpler representation of a phenomenon (data) so we can use it to predict future results or understand the underlying generating mechanism.

What do we get out of modeling?

Insight
Prediction

Simple linear regression and multiple linear regression

Linear regression assumptions:

○ Linear (in terms of the betas)
○ Independence (errors independent of each other)
○ Normality (all errors follow normal distribution)
○ Equal variance (homoscedasticity)

How to calculate estimates of β parameters
How to calculate confidence intervals around β parameter point estimates.

Significance-of-regression testing

Can do a t-test to determine if each regression coefficient is significant in the context of the others. Is it possible βj=0? Is 0 in this parameter estimate’s confidence interval?

Can calculate a confidence interval around the “mean response” – the prediction returned by the model when new predictor values provided.
Can also calculate the prediction interval – where you expect most of the data to lie.
In hypothesis testing, you’re assuming a null hypothesis and a distribution centered at the value the null hypothesis asserts, e.g., that a β parameter’s true value is 0. Then you look at where your estimate falls on that distribution – how far into the tail is it? What percentage of expected outcomes are expected to fall this far away from the prediction (+ or -) or farther? The significance level is a threshold you apply to say, “If a result appears so far away [like in one of the tails where only 5% of results fall], I will reject the null hypothesis and conclude this distribution isn’t the true distribution, or at least this parameter value where it’s centered is wrong.”
Hierarchical models – comparing w/ ANOVA to determine if larger model is significant w.r.t. nested one.
When you don’t know the true standard deviation, estimate it based on the sample. This estimate is called the standard error.
Sometimes variables “interact”, and you include interaction terms in the model to represent that their contributions to the prediction are not independent. Test whether the added term is significant a hypothesis test.

How to check linear regression assumptions

Linearity: inspect fitted vs. residuals plot
Independence: look for autocorrelation
Normality: normal Q-Q plot and Shapiro-Wilk test
Equal-variance: fitted-vs.-residuals plot and Breusch-Pagan test.

How to identify high-leverage points.
How to identify outliers (using standardized residuals).
Cook’s distance – combines effect of leverage and outlier status

Transformations – predictor and response

Can use response transformations to help problem better conform to LINE assumptions
Variance-stabilizing
Response transformations include log and adding polynomial terms.

You have to use tools other than visual inspection to evaluate multiple regression results – have to “fly by instruments”

Multicollinearity

When there’s correlation among the predictors, it causes higher variance in the parameter estimates.
Makes it harder to tell which predictors are significant because each one by itself might look like a fail-to-reject since the other(s) are providing the predictive power already, so removing this one doesn’t change the model much. But this can be misleading if those other predictors are varying in response to this one.
Doesn’t typically hurt predictive power, but definitely can make explanatory inference harder.

How to prevent overfitting

Use metric like AIC or BIC to decide which parameters add enough predictive power to be worth the added variance they entail.
Use a stepwise process of adding, removing, or trying both iteratively to improve model based on AIC or BIC.

Cross-validation directly attacks overfitting by testing error on unseen data.
Logistic regression and use for classification

 

CS 598 – Advanced Bayesian Modeling

… [still under construction]

 

CS 416 – Data Visualization

How to use Tableau

Model human processor

How long it takes for eye to process and communicate information, how long before you can act on it, how long it takes to react, how long to communicate to your muscles to act

1. Eye, ~230 ms
2. Perceptual processor, ~100 ms
3. Cognitive processor, ~70 ms
4. Motor processor, ~70 ms

Visual image store

17 letters max
Decay ~200 ms

Auditory image store

~5 letters
Decay ~1500 ms

Fitts’ Law: larger movements are faster but less accurate than smaller ones
Feedback loop and all the delays along the way are why mouse use is so much slower than keyboard. Motor-processor delay + movement time, then perception of your attempted aim (eye+percep+cog delays), possibly another iteration of all that, then motor-processor delay of click. Keyboard is just motor-processor delay ⇒ ~4-8x faster.

Working/short-term memory, long-term memory
How things get from short-term memory to long-term memory
Sensory memory
Various ways our memory is distorted

Vision

Rods perceive brightness; cones perceive color
Center of vision is mostly cones (color)
Rods are denser away from the fovea centralis (part of the eye where everything focused)

Diffraction of every lense depends on wavelength of light; this is chromatic aberration.

Due to our eye’s lens, blue wavelengths tend to blur. Avoid pure blue text.

We tend to focus on warmer colors and bring them to the forefront (red closer than blue).

Temporal inhibition, lateral inhibition

Peculiarities in how the eye and vision system process things
Distorts our perception, for example, adjacent grey blocks have an accentuated edge.

Some perceptual processing mechanisms we rely on to perceive the 3D world from effectively a 2D image can end up tricking us.

Our perception of size is influenced by our brain’s habit of using size to infer distance.
Lines in a 2D arrangement that appear as they would in 3D when receding away from us can distort our perception.

Vector and raster graphics

Coordinate systems
Vector graphics have hierarchical coordinates (canvas within canvas)
SVG basics

Photorealism cues to perceptual system to interpret a 2D images as a 3D scene

Occlusion used as a cue to imply a visual sort from near to far. It’s one of the strongest cues the brain uses.
Illumination helps us perceive the orientation of a surface.
…

Non-photorealism

Illustrations often more can clearly depict the intended message than a photograph can.
Can get lighting exactly right, do unrealistic things like cutaways, include and eliminate exactly what’s needed, etc.

Non-photorealistic lighting

Photorealistic lighting causes a lot of information to be removed (things in shadowed side of an object).
Instead, can mix the “brightness” color map (black-to-whatever color) and mixing with a cool-to-warm color map.

We have varying accuracy at the perceptual tasks of evaluating relative magnitude/intensity, ordering, or grouping, depending on how the data are presented.

From greater to less perceptual accuracy:

QuantitativeOrdinalNominal/categorical
PositionPositionPosition
LengthDensityHue
Angle/slopeSaturationTexture
AreaHueConnection
VolumeTextureContainment
DensityConnectionDensity
SaturationContainmentSaturation
HueShape
LengthLength
AngleAngle
SlopeSlope
AreaArea
VolumeVolume

Position being better than an angle is a reason bar charts are better than pie charts.

A viewer will reason about visual ordering and confer some importance to it, often even without realizing it.

Chart types

Use a scatter plot to show two (possibly) independent variables, where no functional relationship is implied.
Tables are for two (possibly) independent categorical/nominal variables. No functional relationship is implied.
Bar chart shows quantitative measures for discrete/categorical independent variables.
Various methods of bar stacking for bar charts, depending on what is being presented

Line chart

Lines between points imply interpolation is possible/appropriate, both horizontally and vertically.
Use this format to communicate a measure changing as the dimension (x axis) changes.

Stacked line charts are a challenge, mostly due to removing the common baseline and upper lines displacing more as the lower lines displace; careful ordering of the stack can mitigate but is not usually enough. Other methods have been developed, each appropriate for different use cases:

ThemeRiver
Streamgraph

Parallel coordinates are a method to illustrate >3D data. Uses a sequence of vertical axes, and each data point is shown as a line connecting its position on each axis.

Dimensionality reduction

PCA – Principal-component analysis
MDS – Multidimensional scaling

Map-based

Cartogram: a distortion of a map of regions by data values associated with those regions.

Choropleth: data plotted over regions of a map – typically with color map where more color saturation corresponds to higher intensity of some measure like population density.

Much better than cartogram because density/saturation/hue are better at communicating ordinal position than area.

Graphs

Planar embeddings

Tutte’s method using Laplacian matrix (special type of adjacency matrix)
Force-directed layout w/ GEM algorithm

Node centrality metrics

Used to assess where to place nodes in graph.
Node degree, isolation metric, closeness centrality, graph centrality, betweenness centrality

Networks

Community discovery

Hierarchies

Trees – typically a height-based layout
Tree maps – visualize hierarchy w/ recursively-divided rectangular areas

Dashboards/interactive visualizations

Schneiderman’s mantra [for visualization systems]

a. Overview first
b. Zoom and filter
c. Then details on demand

There are different zoom “lenses” like fisheye that keep the surrounding context while still expanding the area of interest.
Cross-filtering – changing filter in one view and having it affect the other views.
Brushing – dragging filter window across a dataset.
Lots more filtering, view manipulation, providing-details guidance

Dashboard Design Patterns by Bach et al

“Dashboards offer a curated lens through which people can view large and complex data sets at a glance”
“I learned not to try to ask too many questions for one graph. One graph can give several different answers, but the question should just be one question.”
“If you try to simplify [your design] too much, you risk imposing your own story.”

Modes of data visualization

• Interactive visualization

Used for discovery, typically by a single investigator
Rerenders based on input
Prototype quality

• Presentation visualization

Used for communication to a large group or mass audience
No user input
Highly polished

• Interactive storytelling – middle ground between interactive/prototype and presentation

○ Presentations via interactive webpages
○ Narrative, using data to tell the story
○ Invites viewers to explore further
○ A medium for data journalism

DOM

Document object model – the hierarchical representation of the structure (tags) in a webpage
Use Javascript to dynamically update the content on the web page.

SVG

D3.js – data-driven documents

Facilitates interactive data visualization on the web
Works alongside DOM and SVG. Treats the document as a database.
Associates a data element to each html element.
Fundamental contribution is integration of data into html, not the chart creation.

User interface design: Task Analysis first then Dialog Design.
Model-View-Controller

Event loop, callbacks

Promises to avoid blocking
async/await pattern

Narrative-vis design

Affordances: hints in the appearance of an object that imply the object’s function
Transitions help provide visual continuity when changing data values or visualization methods.

Elements of narrative structure

Ordering – Linear, user-directed, or random-access
Interactivity
Messaging

Review of many visual-ordering genres (video, magazine, partitioned poster, etc.), what they’re suited for, how the use each element of narrative structure.

Narrative Spectrum

Author-driven visualizationsHybrid StructuresFree-form reader-driven visualizations
• Message-focused• Martini Glass• Query-focused
• Linear• Interactive Slideshow• Free-form
• Non-interactive• Drill-Down Story• Interactive
cinema, commercialsGoogle search engine, Tableau

The three most effective narrative visualization structures combine author-driven and reader-driven structures

• Martini Glass

Leads with author-driven content to show what the data is and how you can interact with it.
Follows a prescribed path then lets the reader explore freely.

• Interactive Slideshow

Follow an author-led slideshow that gives you opportunities along the way to do deeper analysis.
Can drill down in a particular slide then takes you to the next slide when done.
Stronger messaging than drill-down story.

• Drill-down story

Gives you one large overview with lots of options of what to explore/drill down.
More of a free-form interface than the interactive slideshow.

Four fundamental elements of narrative visualization

• Scenes, consisting of charts – like slides of a presentation
• Annotations of those charts – for messaging
• Parameters used to create those charts
• Triggers used to transition between charts and interact with the visualizations

Declarative vs. imperative programming for graphical specification

Tableau, JS, D3, Vega, Vega-Lite, Ellipsis