Altametrics · ML intern

• Sales forecast error 12% → 5% across 4 chains, thousands of locations.
• 30+ features: weather, zip-code demographics, holidays, school calendars, CPI, unemployment.
• Back-tested on 2+ years of history, cross-validated tuning.
• 5 model families benchmarked: XGBoost, LightGBM, CatBoost, Prophet, TimesFM.
• 2 summers full-time, both alongside a Berkeley course load.

Residual Robotics · 5-person team · my part: CAD and design-for-manufacturing

• Designed the gripper in CAD in Onshape — full assembly, jaw linkage, camera mount, IMU housing, fiducial plate.
• Re-specced a ~$500 UMI rig off its $298 GoPro to webcam + microcontroller + IMU. Target 5× per-unit cost cut, not yet measured on a built unit.
• Audited 16 printed parts for overhangs past 45°. Reorientation cleared 4, gussets cleared a 5th.
• Breakaway scaffolding designed into 3 STLs — tapered post, weak neck, release gap — taking the set to 0 slicer supports.
• AprilTag fiducials to CAD-measured 20.00 × 20.00 mm recesses, plus a printed scale-check bar to catch printer scaling error.
• Built for mass UMI data collection from skilled laborers in India, sold to robotics foundation model labs.

CS 184 final project · 2-person team with Ninad Atale

• Three subsystems: a mesher, an FEM evaluator, and a graph neural network trained on the evaluator's own output.
• Mesher: Assimp loads CAD and COLLADA, a manifold check gates validity, TetGen discretizes the domain into tetrahedra. Connectivity likely via a half-face structure, the 3D analogue of the half-edge mesh from HW2.
• Evaluator: fixed supports and point loads applied as boundary conditions, then the elastostatic PDE (Cauchy's equation) solved across the mesh for displacement and stress.
• The premise that makes it work: under linear elasticity any load combination is a superposition of solved load cases, so a swept training set covers a continuous space of loads the network never saw.
• GNN: message-passing layers over node and edge features (position, length, loading) predicting per-node displacement and stress. Budget: under 10 minutes to train, meshes under 10,000 elements.
• Interactive viewer: apply loads by hand and watch the deformation and stress field update live, with no solver in the loop.
• Scoped to linear elasticity and direct forces. No torques, no anisotropy. Error measured against our own FEM solution, since matching topology against a commercial solver is a separate problem.
• Reading: MeshGraphNets (arXiv 2010.03409), arXiv 2002.01927. None of the prior work builds the interactive viewer.
• Proposal submitted 27 Jul 2026. Milestone report 4 Aug, deliverable 12 Aug. No results claimed yet.

CS 61C · Logisim Evolution

• 36 instructions: 8 I-type, 12 R-type incl. mul/mulh/mulhu, 6 branch, 6 load/store, 4 jump and upper-immediate.
• 32-register file, x0 hardwired to zero, 2 read ports; 5 immediate encoding formats; byte/halfword lane logic.
• 9 control signals decoded from the instruction word, widest the 4-bit ALUSel.
• Single-cycle re-architected to a 2-stage pipeline. Decode and writeback share a stage, so there are no data hazards — every hazard is control, flushed with the nop 0x00000013.
• 12 integration tests compile real RISC-V onto the circuit and diff 8 registers against Venus. Memory is not compared, so a store bug passes all of them.
• 8-week summer session: 1 week between the single-cycle and pipelined deadlines, against ~3 in the regular term.

CS 161 · Go · 2-person team

• 8-function client against a fully untrusted server that can read, overwrite, inject and diff the entire store between calls.
• Encrypt-then-MAC on every value under per-purpose derived keys, MAC verified before decryption. AES-CTR, HMAC-SHA-512, constant-time compare.
• Argon2 salted with the username, which blocks a record-splice attack a random salt would allow.
• Filenames and their lengths never leak — pointer records live at UUIDs derived from a secret master key.
• Transitive revocation via a share tree: re-key, relocate, then rewrite every surviving access node, including sub-shares under filenames the owner has never seen.
• Backward-linked chunk chain: 100 bytes appended to a 10 TB file moves 100 bytes, not 20 TB.
• Graded by a hidden adversarial suite plus a live design review.

CS 184 · C++ · partner project

• Bounding volume hierarchy with recursive spatial partitioning and interval pruning on traversal; split on midpoint or centroid average.
• Direct lighting implemented 2 ways — uniform hemisphere vs. importance sampling by light — compared at matched sample counts.
• Russian roulette at 0.3–0.4 continuation probability, always at least 1 indirect bounce. Unbiased, bounded expected depth.
• Adaptive sampling: halt a pixel once 1.96σ/√n is within 5% of its running mean, checked every 32 samples.
• Final renders at 2048+ spp, max ray depth 5.

CS 186 · Java · 5 subsystems

• B+ tree indices with node splitting and redistribution under a fixed fill factor.
• 4 join strategies — block nested loop, sort-merge, grace hash — plus external merge sort, inside a fixed buffer-page budget.
• Cost-based optimizer, System R style: histogram selectivity estimation, then DP join ordering across passes.
• Multigranularity 2PL: lock manager, intent locks, escalation.
• ARIES recovery end to end — write-ahead log, 3 passes, compensation log records, fuzzy checkpointing.

CS 161 · C / x86 / GDB

• 7 working exploits, each named for a star, escalating from an undefended stack to canaries + ASLR together.
• Return-address overwrite 20 bytes past an unbounded gets, with injected shellcode.
• Defeated 4-byte canaries by overwriting the saved RIP with the canary left intact through the epilogue.
• Off-by-one overflow with shellcode staged in an environment variable.
• Format string turned into an arbitrary write via 2 %hn half-writes of a 32-bit address.
• NOP sled against canaries and ASLR simultaneously, landing within 5 attempts.

CS 61B · Java · partner project

• Seeded across the full positive long range, 0 to 9,223,372,036,854,775,807, with no fixed world size.
• 3 structural guarantees: ≥50% floor coverage, 100% mutual reachability, 0 dead-end hallways.
• Line-of-sight renderer, keypress-toggleable, drawing only tiles the avatar can see with walls occluding behind them.
• Byte-identical save/load: same seed and keystrokes reproduce exact state, which requires RNG state to persist, not just the tile grid.
• Assessed by live TA checkoff, so it has to run in front of a person.

CS 61A · Python · 18 problems

• Wrote the evaluator: eval/apply mutual recursion, frame construction, lexical scoping, and the lambda / define / quote / short-circuiting and–or forms. Tokenizer and reader were provided.
• mu, a dynamically-scoped procedure differing from lambda by exactly one line: whether the new frame's parent is the defining or the calling environment.
• Tail-call optimization by trampolining — thunks returned from tail positions, forced in a driver loop — giving unbounded tail recursion inside a Python host with none. Not required by the spec; I wanted it to work.

CS 61C · hand-written RV32, no C

• 2-layer fully-connected network classifying handwritten digits entirely in assembly: argmax(matmul(m1, relu(matmul(m0, x)))) over 784-element flattened 28×28 inputs.
• Kernels from scratch: absolute value, ReLU, argmax with lowest-index tie-breaking, strided dot product, matrix multiply.
• Strides given in elements, not bytes — every address computation scales by 4.
• Binary matrix file I/O through raw syscalls with 9 distinct error codes.
• s0–s11 banned in Part A; 100% test coverage and a calling-convention checker enforced.

CS 184 · C++ · partner project

• Edge flip and edge split on a half-edge mesh — local rewirings of twin, next, vertex, edge and face pointers, where one missed reassignment tears the mesh on subdivision.
• Loop subdivision: 4-to-1 split, selective flipping of new edges joining old vertices to new, repositioning at 3/8(A+B) + 1/8(C+D).
• de Casteljau Bezier curves and surfaces, evaluated separably across an n×n control grid.
• Area-weighted vertex normals by half-edge circulation. Write-up, 25 figures →

CS 188 · Python · 5 projects

• DFS, BFS, uniform-cost and A* with admissible and consistent heuristics, graded on node-expansion counts — correct but weak fails.
• Minimax, alpha-beta pruning, expectimax against stochastic opponents.
• Value iteration, tabular Q-learning with epsilon-greedy exploration, approximate Q-learning over feature extractors.
• Exact Bayes-net inference by variable elimination, then particle filtering to track multiple invisible ghosts from noisy distance readings.

EECS 16A · Python

• Localized a microphone in 2D from 6 speakers at 44.1 kHz over a ~2.5 s recording. Speed of sound 34,029 cm/s.
• Beacon separation by cross-correlation against 511-chip Gold codes, 20 samples/chip, a 231.7 ms loop averaged over ~10.8 repetitions.
• 12 kHz carrier, complex-demodulated through a 45-tap FIR low-pass.
• 3 unknowns, not 2 — the reference beacon's absolute time-of-flight is unknown too, the same reason GPS needs 4 satellites for a 3D fix.
• Linearized by differencing into an overdetermined 5×3 system; least-squares solver written from scratch, built-ins forbidden.

EECS 16A · Python

• 48 kHz audio, 2.88 M samples a track, spectrogram to hash database to match.
• 4096-point STFT, the DFT length production fingerprinting systems use.
• Constellation map by 51×51 maximum filtering above amplitude threshold 40, on the linear spectrogram — converting to dB fails the tests.
• Each peak chained to the next 15 into a 9,184-row database.
• Identifies correctly with 50% of the audio zeroed and under Gaussian noise at mean 10,000, σ 10,000.

CS 61B · Java

• ~300 MB Google Ngram corpus under a hard 60-second load ceiling.
• Directed graph written from scratch over the WordNet hierarchy — graph libraries forbidden.
• Reachability composed with set intersection across query words, then top-k ranking by corpus frequency over arbitrary year ranges.
• 8 autograder categories passed under a rule that no method may re-read the input file when called.

CS 184 · C++ · partner project

• Supersampled antialiasing at 1, 4 and 16 spp, sampled on a √n × √n grid into a floating-point buffer, resolved into 8 bits.
• Bounding-box-limited point-in-triangle handling both winding orders, attributes interpolated barycentrically.
• Mipmap level sampling in 3 modes up to full trilinear, derived from UV-space screen derivatives.
• 6 sampling configurations benchmarked on speed vs. memory vs. antialiasing power.

EECS 16A · Python · Arduino

• Full 2D image from 1 photosensor and no lens, solving a 1200×1200 system over 1200 sequential exposures.
• Multiplexed masks illuminating ~300 pixels per exposure instead of one.
• Hadamard over random masks on eigenvalue grounds — reconstruction error is H^-1 applied to noise, so small eigenvalues amplify it directly.

CS 61B · Java

• Circular doubly-linked deque with a sentinel plus a circular array-backed deque, both generic and iterable, 0 java.util structures permitted.
• Constant time on insert, remove and indexed access; loops and recursion banned from the add/remove paths.
• Backing array from capacity 8, geometric growth, downward resize at 25% utilisation.
• Autograder times operations 2⁸ to 2¹⁶ across 100 runs per size and fails any method whose curve contradicts its claimed complexity.

EECS 16A · Python

• 80% per-word accuracy on a 70:30 split from ~40 samples per word at 5400 Hz, demonstrated live.
• PCA via SVD onto the first 3 principal components, nearest-centroid classification.
• Onset alignment — rectify, 100 Hz envelope, threshold, extract, normalise — dominates accuracy far more than the SVD does.
• 4 feature pipelines compared against one classifier: raw and Mel spectrograms (n_fft=256, n_mels=100) crossed with flattening and aggregation.

EECS 16B · open-ended design problem

• The single open-ended lab after 4 directed ones, carrying more weight than any of them.
• Full hardware loop: hand design from a frequency-domain spec, SPICE verification, physical build, bench measurement against spec.
• Transfer functions and pole-zero placement applied directly — a treble boost is a high-pass filter with gain, so corner placement is the design. Topology was given.

CS 61C · C

• Fully heap-allocated 18×20 board with every allocation's lifecycle managed by hand.
• Arbitrary saved boards with ragged row widths reconstructed in a single forward fgets pass into realloc-grown buffers — no seeking, rewinding or reopening.
• make valgrind-test-free-game is a graded target, so leak-freedom is enforced rather than encouraged.

Research · machine-readable knowledge base

• 190 providers screened, 95 verified against primary sources, 121 free-tier offers catalogued into a normalised queryable base with a regeneration script.
• Comparative architecture teardown of 3 open-source aggregators.
• Every figure labelled measured or estimated; incompatible units never summed; ToS restrictions on aggregation documented.