From building championship robots to redesigning core CS courses—here's my journey in education and technology.
Computer science educator passionate about making complex technical concepts accessible to all students. My path from mechanical engineering and FRC robotics to computer science gives me a unique perspective on systems-level thinking and hands-on learning. I believe in creating engaging learning environments where students from any background can thrive—a philosophy directly informed by my master's thesis on heterogeneous architecture and optimal resource scheduling.
Cross-listed project with Quantum Computing. Built a React-based interactive tutorial application using MUI for UI components, guiding users through variational quantum eigensolver (VQE) implementation for predictive protein folding on IBM Osaka quantum hardware via Qiskit. Featured vis-network force-directed graphs illustrating biological computing concepts including Levinthal's paradox, codon matching, and the combinatorial optimization landscape of protein conformation search. Demonstrated how molecular Hamiltonians map to quantum circuit ansatz construction for optimal VQE search space while mitigating Barren Plateaus. Embedded Jupyter notebooks provided executable Python examples progressing from combinatorial problems (Vertex Cover) to full VQE protein folding pipelines using NumPy and SciPy for classical pre/post-processing.
Cross-listed project with Computational Biology. Researched variational quantum eigensolvers for predictive protein folding, mapping molecular Hamiltonians to parameterized quantum circuits executed on IBM Osaka hardware via Qiskit. Built a React and MUI interactive tutorial application with vis-network force-directed graphs visualizing protein conformation search spaces, ansatz construction, and Barren Plateau mitigation strategies. Embedded Jupyter notebooks with progressive code examples from combinatorial optimization (Vertex Cover) to full VQE protein folding pipelines, leveraging NumPy and SciPy for classical simulation components.
Mapped the lambda calculus definitions of 40+ combinators from Raymond Smullyan's "To Mock a Mockingbird" to JavaScript anonymous functions, including their S/K combinator normal forms. Implemented each bird (Bluebird, Cardinal, Starling, Kestrel, Mockingbird, etc.) as composable higher-order functions with an Ohm.js-based parser for combinator expression evaluation. Tested with Mocha and measured coverage with c8.
Continuing research and development of a thesis project for a second semester.
Comparative analysis of MySQL storage engine architectures and their impact on query execution performance. Benchmarked InnoDB, Federated, Memory, CSV, and other engines using MySQL Workbench, examining trade-offs in B-tree indexing, row-level vs. table-level locking, buffer pool utilization, and query execution plan optimization. Demonstrated how engine selection affects throughput for read-heavy, write-heavy, and mixed workloads with representative SQL query patterns.
Extended the Linux kernel system call table with a custom Rust-implemented command, compiled against kernel headers using GCC and Make for kernel module integration. Tested in a QEMU-emulated Ubuntu environment to validate system call registration, user-space invocation via syscall wrappers, and safe FFI boundaries between Rust and the C-based kernel ABI. Managed Rust toolchain and dependencies through Cargo.
Research and development of a thesis project in compliance with the Frank R. Seaver College of Science and Engineering Master's Thesis Requirements.
Formal resource and algorithmic complexity analysis of real-time bidding (RTB) and micro-bidding systems within programmatic advertising infrastructure. Examined demand-side platform (DSP) and supply-side platform (SSP) architectures, second-price auction mechanisms, and the sub-millisecond latency constraints governing bid computation. Analyzed amortized complexity of bid landscape optimization strategies and constructed formal proofs mapping profitability metrics (click-through rate, return on ad spend) to computational variables for constrained optimization under auction-theoretic frameworks.
Investigated Java-specific design decisions affecting application security in a consumer-facing shopping cart, targeting OWASP Top 10 vulnerabilities. Applied parameterized queries to prevent SQL injection, input sanitization and output encoding to mitigate cross-site scripting (XSS), defensive copying to preserve object invariants, and strict type validation with null-safety patterns. Validated security properties through JUnit 5 test suites covering boundary conditions, malformed input, and adversarial payloads.
Implemented expandable stack data structures in C, C++, and Java to compare language-specific secure memory management patterns. Demonstrated manual heap allocation with malloc/realloc/free and bounds checking in C, RAII via unique_ptr with move semantics and custom exception handling in C++, and Objects.requireNonNull validation with type-safe generics in Java.
Collaborative project demonstrating cross-site scripting (XSS) attack vectors and session token hijacking in a banking web application. Implemented CSRF token validation and session expiration policies to prevent unauthorized authenticated actions from unattended browser sessions.
CLI tool implementing AES-256-CBC symmetric encryption and decryption using Node.js's crypto module. Demonstrated proper key derivation, initialization vector (IV) generation, PKCS7 padding schemes, and ciphertext encoding for secure message handling.
Authored a 13-page research paper examining the intersection of programming language pragmatics and programmer intuition for parallel programming. Investigated how language-level abstractions can better expose shared-resource contention, race conditions, and deadlock potential in threaded programming models. Implemented a companion compiler for the Plumb programming language in pure Java (no external libraries), featuring a handcrafted regex-based tokenization pipeline, recursive-descent parser derived from a formal context-free grammar specification, and abstract syntax tree construction. Validated correctness through JUnit 5 test suites.
Built a geospatial clustering pipeline using scikit-learn's K-means implementation to map UNICEF support resources across impoverished regions of Brazil, addressing gaps in official Brazilian government county data for legally unincorporated high-poverty areas. Performed exploratory data analysis and feature engineering with pandas and NumPy, applied SciPy for distance metrics, and evaluated cluster quality via silhouette scoring. Visualized geographic distributions using Matplotlib, Seaborn, and Tableau on the Python side, with ggplot2 and tidyverse for complementary R-based analysis.
Built a web scraping pipeline using Python requests and BeautifulSoup for HTML parsing with http.client for API access. Extracted, cleaned, and structured data into tabular format using pandas, exporting results to CSV for downstream analysis.
Mechanisms for the definition of syntax and semantics of programming languages, covering binding, scope, type systems, control flow, subroutines and coroutines, asynchronous and parallel execution, modularity, and metaprogramming. Denotational, operational, and axiomatic semantics.
Authored a 13-page research paper examining the intersection of programming language pragmatics and programmer intuition for parallel programming. Investigated how language-level abstractions can better expose shared-resource contention, race conditions, and deadlock potential in threaded programming models. Implemented a companion compiler for the Plumb programming language in pure Java (no external libraries), featuring a handcrafted regex-based tokenization pipeline, recursive-descent parser derived from a formal context-free grammar specification, and abstract syntax tree construction. Validated correctness through JUnit 5 test suites.
An introduction to matrix methods with an emphasis on modern computational techniques. Topics include Gaussian elimination, LU factorization, vector spaces and subspaces, orthogonality, determinant, eigenvalues and eigenvectors, diagonalization, least square optimization, and singular value decomposition.
Complex arithmetic, functions of complex variables, analytic functions, integration in the complex plane, Taylor and Laurent expansions and residues; conformal mappings, evaluation of real integrals by residues; integral transforms.
Constructed custom 3D meshes by directly manipulating vertex buffer objects and triangle indices using Three.js, computing UV coordinates and texture mappings from scratch to achieve precise surface detail control. Rendered within a React application harness.
Implemented rasterization algorithms from scratch using the HTML5 Canvas API, including scanline fill for gradient rendering on arbitrary 2D polygons and convolution kernel-based image filters operating on raw ImageData pixel arrays.
Built a web-based 3D modeling library implementing the full model-view-projection pipeline with a handwritten matrix engine supporting homogeneous coordinate transformations, a lighting engine implementing the Phong reflection model, and custom GLSL vertex and fragment shaders for the WebGL graphics pipeline. Rendered within a React application using raw WebGL API calls.
Designed and built a compiler for Plumb, a low-level imperative, modular systems language with custom syntax for threaded pipeline orchestration. Implemented as a syntax-directed transpilation pipeline to JavaScript using Ohm.js PEG grammars for parsing, with semantic actions driving code generation. Plumb's thread safety semantics were mapped to JavaScript's event loop concurrency model, using asynchronous primitives for concurrent execution in lieu of true OS-level parallelism. Tested with Mocha and measured code coverage with c8.
Implemented reinforcement learning agents for uniform multi-armed bandit problems, comparing epsilon-greedy, UCB1, and softmax action selection strategies. Evaluated regret minimization and reward distribution estimation across varying arm configurations. Parallelized Monte Carlo simulations using joblib and visualized convergence behavior with Plotly interactive charts.
Implemented Exact Q-learning, Approximate Q-learning, and Deep Q-learning agents within the Berkeley AI Pac-Man framework. Deep Q-network trained using PyTorch with experience replay buffers and temporal difference learning to approximate state-action value functions. Built Bayesian network inference using pomegranate for causal reasoning, and particle filter-based belief state estimation to track ghost positions from noisy sensor observations. Visualized training metrics with Matplotlib and managed replay datasets with pandas.
Trained a multi-agent team using Approximate Q-learning with custom feature extraction to compete in an adversarial 2v2 Pac-Man capture-the-flag tournament within the Berkeley AI framework. Designed offensive and defensive heuristics for dual-role agents simultaneously pursuing opponent capture and point maximization while avoiding being captured. Competed against other students' trained agents.
Developed handcrafted ARM assembly programs in ARMSim# to implement high-level algorithms at the instruction level, including greedy change-making with optimal register allocation and multi-word arithmetic using carry propagation for scaling integer operations beyond single-register capacity.
Built an automated inference engine using propositional resolution over a conformal knowledge base to guide an agent through a minesweeper-like game. Constructed well-formed classical logic formulas encoding game state, then applied model checking and resolution refutation to determine knowledge base satisfiability, validating whether agent actions would yield optimal or suboptimal outcomes.
Implemented a sequential Monte Carlo particle filter within the Berkeley AI Pac-Man framework to perform belief state estimation of ghost positions under noisy sensor observations. Applied importance weighting and resampling to maintain accurate posterior distributions over possible ghost locations, enabling informed decision-making despite imperfect information.
Built a multinomial Naive Bayes classifier for email spam detection using scikit-learn, trained on text message corpora to identify colloquial language patterns and profanity. Applied bag-of-words representation with TF-IDF vectorization via sklearn.feature_extraction, Laplace smoothing for posterior probability estimation, and evaluated precision/recall via confusion matrices. Performed exploratory data analysis with pandas and visualized feature distributions using Seaborn.
Implemented linear perceptron classifiers using scikit-learn's linear models for the same spam classification task, establishing binary decision boundaries via stochastic gradient descent. Compared convergence behavior and classification accuracy against the Naive Bayes baseline, with feature scaling via sklearn.preprocessing to improve training stability.
Mapped the physical network topology of Los Angeles by conducting on-site hop count analysis using traceroute, nmap, and ipconfig at multiple locations. Performed reverse DNS resolution and autonomous system (AS) identification to trace routing paths from LMU's campus network through regional ISP infrastructure to the broader LA internet backbone. Documented topology with Lucidchart diagrams and supplemented with a Scapy-based Python packet sniffer for traffic inspection.
Built a TCP server and client from scratch using Node.js's net module, manually constructing and parsing protocol buffers with UTF-8 encoding and raw buffer manipulation. Load-tested the server using Python's Locust framework, simulating thousands of concurrent connections with varying request complexities to benchmark throughput, measure response latency distributions, and identify bottlenecks for bandwidth optimization.
Built a PCAP analysis pipeline using Scapy for packet dissection and dnspython for reverse DNS resolution of destination IP addresses extracted from captured traffic. Used TLS master keys to decrypt encrypted session data and examine packet internals for security-relevant content, including URI extraction for image resource tracking. Created a React and MUI visualization dashboard deployed via GitHub Pages to present filtered network data interactively.
Implemented the same 10 algorithm and data structure problems across Python, JavaScript, C++, Java, and Swift, highlighting each language's idioms, type systems, and concurrency models. Problems included a Turing machine simulator, recursive say function, greedy change-making, and generator-based power sequences. Tested with Mocha for JavaScript and JUnit for Java.
Partial derivatives, multiple integrals, three-dimensional space, vectors in two- and three-dimensional space, line integrals, Green's theorem.
Designed and simulated combinational logic circuits in Multisim, including multiplexers, ripple-carry adders, and array multipliers. Verified functional correctness via truth table simulation and propagation delay analysis. Culminated in physical implementation on breadboards using discrete logic ICs, LEDs, and jumper wires to validate circuit behavior against simulation results.
The study of algorithm paradigms, including divide-and-conquer, greedy methods, dynamic programming, backtracking, and randomization, with emphasis on combinatorial search. String processing, advanced sorting, constraint satisfaction, hill climbing, optimization, graph algorithms, and computational geometry.
Exploration of computing system operation with a focus on programming at levels with minimal translation between the code and what the computer can access and manipulate directly. Bit representations, the C programming language, assembly language, calling conventions, and system calls.
Systems of linear algebraic equations, Gaussian elimination, matrices, and matrix algebra. Linear dynamical systems and equilibrium. Analytical solutions of linear differential equations, including Laplace transform and linear time-domain analysis. Eigenvalues, eigenvectors and the matrix exponential.
An introduction to graph theory; trees; coloring; Eulerian circuits. Combinatorics; permutations and combinations; recurrence relations; algorithmic approaches to combinatorics problems.
Specification and design of data types, information structures, and their associated algorithms. Collection classes for sets, lists, stacks, queues, hierarchies, heaps, and dictionaries. Implementation via arrays, linked lists, hash tables, and tree structures. Introduction to asymptotic computational complexity.
Number theory, sets, functions, equivalence relations, cardinality, methods of proof, induction, contradiction, contraposition.
Built a web-based game using Create React App featuring procedural level generation for replayability. Managed global game state through a Redux store with actions and reducers for player state, level progression, and scoring. Styled with CSS Modules for component-scoped styling.
Lab companion to introductory computer programming, emphasizing hands-on practice with software development tools, debugging, testing, and collaborative coding workflows.
Techniques of integration, numerical methods of integration with error analysis, applications of the integral, improper integral, infinite series, an introduction to parametric equations and polar coordinates.
Foundational course on computer programming, stressing software development best practices. Topics include values and types, functions, objects, iteration, recursion, event-driven programming, and graphics and animation. Basic data structures and selected algorithmic paradigms are introduced.
Limits, continuity, derivatives of algebraic and transcendental functions, applications of the derivative, antiderivatives, introduction to the definite integral, Fundamental Theorem of Calculus.
Built a 2D exploration game in Java using the LibGDX game engine simulating the experience of being an exploring cartographer. Used LibGDX's Box2D physics, Ashley ECS framework, and LWJGL desktop backend for rendering.
Completely redesigned course curriculum to emphasize practical applications of discrete math in computer science. Developed new problem sets, interactive examples, and assessment strategies focused on building intuition alongside formal understanding.
Key Achievements:
Rebuilt course from the ground up to reflect modern operating systems concepts and parallel computing paradigms. Focused on how design decisions affect real-world use of devices by incorporating how common software use is altered by small changes to hardware or software features.
Key Achievements:
Redesigning the curriculum to retell the material with a far more interactive approach, structuring the entire course around building from nothing using only tools formally proven from the ground up. Transforming homework from purely written formal work into application projects that teach students to mechanize formal theory into language-agnostic programming assignments, demonstrating how foundational theory underlies all modern systems.
Key Achievements:
Enforces a bidirectional system of learning across all courses, exploring tools alongside their formal theoretical foundations and demonstrating how formal systems manifest in practical tooling. Students build a fully formed intuition for how formal theory enhances their programming abilities in practice, rather than treating theory and application as separate domains.
Key Achievements:
Employs a teaching methodology rooted in the belief that if computer science genuinely models the world, then every topic should have a grounded analogue in everyday human experience. Each new concept is paired with a familiar scenario — social interactions, commuting, cooking, management — giving students an intuitive head start by showing them they have already encountered the underlying pattern; they are now learning to formalize and apply it in code.
Key Achievements:
All lectures include custom-built, interactive website components that allow students to directly manipulate and explore the topic under discussion. These components provide a hands-on, exploratory feel for abstract concepts, enabling students to build physical intuition for computational ideas through direct experimentation rather than passive observation.
Key Achievements:
Participated in departmental curriculum review committee, providing targeted analysis of how programming language pragmatics directly affect student learning outcomes. Recommendations were adopted across 5 courses spanning all four year levels.
Key Achievements:
→ Recommendations adopted department-wide, reshaping the programming language experience for students from freshman through senior year
Discrete Mathematics (CMSI 2820), as the first CS-dedicated alternative to the Math department's equivalent offerings, became a preferred entry point for freshmen and sophomores. Students who took Discrete Math subsequently enrolled in Operating Systems (CMSI 3510) at unprecedented rates, with many requesting prerequisite overrides to take the OS prerequisite concurrently.
Key Achievements:
Organized and led extracurricular lecture series to prepare LMU's ICPC teams for regional competition. Identified a critical gap between the department's industry-focused curriculum and competition requirements: students were strong software engineers but lacked the specialized skills needed for timed algorithmic contests without access to standard tooling — memorizing key mathematical properties, super-optimized compact prime filtering, minimized-memory format designs for dynamic programming, and performing under pressure.
Key Achievements:
Students taught and mentored have secured positions at major technology companies, competitive graduate programs, and entrepreneurial ventures, reflecting the department's and the instructor's emphasis on producing well-rounded, industry-ready and research-capable computer scientists.
Key Achievements:
Across 8 course sections (7 Discrete Mathematics, 2 Operating Systems) serving 182 students over 3 semesters, received consistently strong evaluation scores with a clear upward trajectory. Fall 2025 CMSI 2820 Section 02 achieved a perfect 5.00/5.00 overall effectiveness — above department average on every metric. The primary area for early growth — grading turnaround time across 3 simultaneous sections — directly motivated investment in automated grading tooling (Gradeflows/PostCommit), and subsequent semesters show measurable improvement in feedback scores, demonstrating a commitment to converting student feedback into systemic improvement.
Key Achievements:
Student Feedback:
“A truly magnificent professor. Clear about his expectations from day one. Knows how to start slow and build up effectively. As a new professor, he handled teaching a difficult course impressively well.”
“The passion you show for it makes it so much more fun for all of us... you are such a talented teacher that it is crazy it is only your first year doing it officially.”
“Phenomenal teacher. I loved the simple explanations, and the set up of the overall course being standards based. Loved this class and professor — I wish he taught data structures.”
“Professor Gonzalez's ability to articulate complex concepts clearly demonstrated both his intelligence and knowledge of the field. He answered every question with ease and frequently expanded upon initial inquiries to present more challenging scenarios.”
“I think Julian understands closely what it was like in our shoes as a student so he's very sympathetic and always wants us to succeed.”
“Every one of the professor's lectures were entertaining, which led to a deeper understanding of the complex course content. The activities throughout the semester were extremely fun.”
“The professor is a great lecturer and down-to-earth.”
Guided student through computer graphics fundamentals and GLSL shader programming, culminating in custom hand-built shaders for the video game Minecraft.
→ Student gained practical experience in GPU programming and real-time rendering techniques.
Mentored development of a full-stack, multi-threaded HTTP REST server written in Rust that uses containerization to run student code in a sandboxed environment to provide faculty with additional support in grading student assignments with analytics. Went on to receive additional faculty support and university research funding and is now deployed as an official tool used by faculty across the Computer Science department.
→ Project received additional faculty support and university research funding and is now deployed as an official tool used by faculty across the Computer Science department.
Advising student research on kernel-level anti-cheat systems for video games with dedicated servers, exploring low-level security and driver development.
Provided weekly tutoring sessions and code reviews as students worked through 5 programming languages (Python, JavaScript, Java, C++, Swift), helping them understand each language's unique paradigms and strengths.
Key Achievements:
Mentored students through the design and implementation of complete interpreters and compilers from scratch, reinforcing formal automata theory through hands-on project work.
Key Achievements:
Extended tutoring support to freshman and sophomore courses, helping students build foundational programming skills and computational thinking.
Key Achievements:
International Collegiate Programming Competition
Competed 3 times at ICPC regionals hosted at Riverside Community College. Led team of 3 to achieve the highest point total in LMU history through self-taught competitive programming skills, as the university curriculum does not specifically prepare students for algorithmic competitions.
Google & Loyola Marymount University
Summer 2019
Completed Google's Computer Science Summer Institute extension program hosted at LMU, building web applications using Python, Google App Engine, and Jinja2 templating. Created an ASL learning platform and a recipe web app. Included visits to Google's Venice Beach offices and mentorship from Google engineers.
Team 4201 Vitruvian Bots, Da Vinci Science High School
2018 - 2019
Led manufacturing division of 8 team members to World Championship victory by managing CNC machining operations, coordinating $3K+ budget, and ensuring precision fabrication of competition robot components.
Whether you're a current student, prospective student, or fellow educator interested in course design and CS pedagogy, I'd love to hear from you.