My Spring 2020 JPL Reading List

In January 2020, I began a very pleasant internship at NASA Jet Propulsion Laboratory, studying graphics preprocessors and how to invoke parallelism with large terrain rendering tasks. As I had barely any background in either of these very interesting subjects, and needed to build a bridge between the two, I spent nearly every day going to the JPL library. That is, until the work-from-home order struck. So, this has been my Plague Reading List, Part 1.

Standard C++ IOStreams and locales : advanced programmer’s guide and reference

Earths of distant suns : how we find them, communicate with them, and maybe even travel there

Introduction to applied nonlinear dynamical systems and chaos

Graph-based natural language processing and information retrieval

Explanatory nonmonotonic reasoning

Learning GNU Emacs

Computer systems : digital design, fundamentals of computer architecture and assembly language

Qualitative approaches for reasoning under uncertainty

MySQL reference manual : documentation from the source

Introduction to high performance computing for scientists and engineers

Data communications and networks : an engineering approach

Extraterrestrial intelligence

High performance scientific and engineering computing : hardware/software support

Regression modeling strategies : with applications to linear models, logistic regression, and survival analysis

Machine learning and systems engineering

Concrete abstract algebra : from numbers to Grobner bases

Nets, terms and formulas : three views of concurrent processes and their relationship

Mathematical foundations of computer science

Categorical data analysis

Matching theory

Data integration blueprint and modeling : techniques for a scalable and sustainable architecture

Parameterized complexity

High performance computing : paradigm and infrastructure

TCP/IP protocol suite

Large-scale C++ software design

Encountering life in the universe : ethical foundations and social implications of astrobiology

Other minds : the octopus, the sea, and the deep origins of consciousness

Modern C++ design : generic programming and design patterns applied

Reverse engineering of object oriented code

Software abstractions : logic, language and analysis

Extraterrestrial languages

Algorithms and theory of computation handbook

Secure programming cookbook for C and C++

Archaeology, anthropology, and interstellar communication

Semiparametric theory and missing data

The pocket handbook of image processing algorithms in C

Design of experiments : ranking and selection : essays in honor of Robert E. Bechhofer

Designing digital systems with SystemVerilog

C++ network programming

Intelligent control and computer engineering

Operations research : an introduction

Logic-based methods for optimization : combining optimization and constraint satisfaction

Applied combinatorial mathematics.

Visual complexity : mapping patterns of information

Dawn of the new everything : encounters with reality and virtual reality

Handbook of logic and language

Recurrent neural networks : design and applications

Handbook of computational methods for integration

Data structure programming : with the standard template library in C++

If the universe is teeming with aliens … where is everybody? : fifty solutions to the Fermi paradox and the problem of extraterrestrial life

The computational beauty of nature : computer explorations of fractals, chaos, complex systems, and adaptation

Tutorial: Neural Networks

Neural networks are a paradigm rather than just a single algorithm.

They originally resembled human neurons in that they received an input, then output a signal only if a threshold was met. This is an all-or-nothing process: either the neuron fires a transmitter or it does not. The paradigm was extended dramatically by modern computation power and now allows for massively complicated binary decision problems to be performed.

Although many neural networks have a ton of arcane connections and “hidden layers” (hidden only in that displaying them all is tedious), I have hand-drawn an example. This is a fully working neural network. My inspiration comes from participating in YCombinator’s Startup School over this summer. It solves the problem many of us keep running into: how to rapidly tell if a startup is BS (a bad startup).

This is a functional neural network. It takes in a set of words and decides if a start-up venture is a “bad startup” or not. It does not say whether the start-up is good; just is if it is a “bad startup.” At each layer, a series of keywords are in circles; if a sufficient number of these nodes get activated, then the neural network tells you that the idea is BS.

So, for example, if a startup is going to disrupt the cloud using crypto, and has a web 2.0 big data blockchain, you can assume their initial coin-offering, despite being full-stack, is really just a slow spreadsheet done in a browser by math minors. That’s BS man!

Many thanks to William Gasarch at UMD for inspiring this.

Introducing: Guardia-NN

At Hacktech 2019, I intend to build a functioning prototype of the Guardia-NN system.

The hardware prototype system consists of the following:

A hardware device that features a huge button (representing “I DON’T WANT TO SEE THIS”) and an indicator (representing “YOU SAID YOU DON’T LIKE STUFF LIKE THIS”).

The device solves two problems at once: Firstly, people don’t like to see things that offend/traumatize them. But secondly, people generally don’t like being told by others (who may not share the same views and values) what is and is not offensive or triggering.

In other words, the machine serves as a guardian, using neural networks (hence the name Guardia-NN) — and replaces the almost universally reviled trope of the overly politically-correct “social justice warrior” with a machine. Now that’s automation we can all get behind!

It performs this task by picking up on user-defined trigger warnings (text tags that indicate that content will cause distress, offend, or otherwise bother the user), and relies on neural networks (large chains of decision making procedures) in order to learn from from repeated use what the end-user does and does not want to see. The device warns users that content ahead may trigger them, and allows them to navigate around said content with minimal exposure.

Because of its limited computational power, and reliance upon user interaction, it does not represent a feasible means of censoring others’ internet use. Rather, its intended use is to allow people to have a warning sign before exposure to content that may cause psychological harm and thus mitigate their exposure, akin to an allergen warning system.