Our workshops, tutoring, and follow-up support are built around the real computational questions researchers bring to us. We teach durable habits, help learners reason through concrete problems, and keep open science at the center of the work.

Collaborative Problem-Solving

Learners work in small groups, compare approaches, and practice explaining technical decisions so new skills become shared lab knowledge.

Open Materials and Methods

We teach with reusable notebooks, code examples, and open-source tools so participants can revisit, adapt, and share what they learned.

Practical Follow-Up Support

After a course, we remain available for tutoring, project discussions, and gentle code review that helps researchers turn lessons into everyday practice.

Questions Researchers Bring Us

Between structured workshops and project work, many conversations begin with a very concrete question. These are the kinds of practical problems we like to think through together.

Refactor a Matlab Script

"We have one giant script with everything in it. How can we break it into logical modules?"

Turn one long analysis script into smaller functions with clear inputs, outputs, and tests.

Freeze Python Environments

"Different machines give different results. Can you help us pin our Python environment?"

Define shareable environments so collaborators can run the same analysis on different machines.

Start Testing in R

"We want to avoid reintroducing old bugs. How do we start adding basic tests in R?"

Add a first layer of practical checks around statistical functions and analysis steps.

Profile Slow Code

"Our code runs, but it is incredibly slow. Can you help us find what is dragging it down?"

Use profiling tools to find bottlenecks before deciding whether to optimize or parallelize.

Merge Diverged Tools

"We have three different forks with conflicting changes. How do we bring them back together?"

Plan a careful merge strategy for forks, duplicated scripts, and shared lab utilities.

Translate Matlab to Python

"We would like to switch to Python. Can you help us translate our Matlab codebase?"

Map old analysis code to open Python tools while preserving scientific intent and outputs.

Debug R Data Wrangling

"We keep getting NA-related errors when reshaping our data. Can you help us trace the bug?"

Walk through missing values, factor levels, indexing mistakes, and reshaping bugs together.

Use Local Parallel Processing

"Can we distribute these loops across cores on a normal PC, or do we need a cluster?"

Speed up desktop workflows with multiprocessing, joblib, or vectorized library calls.

Dockerize Old Analysis Code

"We still use Python 2.7. Could you help us wrap it in Docker so collaborators can run it?"

Keep an older but still important codebase runnable on modern systems.

Add Automatic QA Checks

"Could a nightly job label suspicious runs and check basic data integrity for us?"

Create checks that flag missing files, suspicious outputs, or failed quality metrics.

Organize Project Folders

"Our file structure is a mess. Can you help us make a layout collaborators can understand?"

Design a folder structure that supports current analysis and future handover.

Define Metadata Templates

"We need metadata for our recordings but do not know where to start. What is a minimal template?"

Capture acquisition parameters, subject information, and processing notes while they are fresh.

Prepare Data for Publication

"We are about to submit a paper. Can you guide us through publishing the data?"

Choose a repository, clean up folders, add documentation, and prepare a data release.

Choose Code and Data Licenses

"We are not sure how to license our code and data. Can you help us choose?"

Discuss open licenses for datasets, scripts, and derived outputs in collaborative projects.

Standardize NWB Files

"We want to adopt NWB, but how should we handle our custom metadata?"

Plan conversion from older proprietary formats into reusable, documented data structures.

Merge New Recordings

"We get new recordings daily. How do we streamline merges and avoid duplicates?"

Append new data to a master dataset without duplicating or reprocessing old records.

Build Reproducible Figures

"We have random seeds in different places. How do we make our final figures reproducible?"

Connect final plots to versioned data, stable seeds, and rerunnable scripts.

Draft a Project README

"We are ready to publish our data but do not know what belongs in the README."

Write practical documentation so collaborators and reviewers know what is in a release.

Track Data Provenance

"How do we trace which raw file generated which final figure?"

Create manifests that connect raw files, cleaned datasets, parameters, and final figures.

Plan a Lab Data Policy

"We need a basic policy so everyone in the lab handles data consistently. Can you help?"

Create lightweight group conventions for storage, naming, archiving, and handover.

Fix 50 Hz Noise

"We see a strong 50 Hz artifact in our signals. Where should we start troubleshooting?"

Reason through grounding, shielding, and acquisition setup issues that affect signal quality.

Synchronize Cameras

"We want all cameras to share timestamps so we can merge footage reliably. What works?"

Design timestamped multi-camera setups that can be aligned during analysis.

Log Real-Time Sensors

"We need to integrate real-time sensor logs with our experiment. What would you try?"

Integrate multiple data streams with a shared time base during live experiments.

Preprocess Calcium Imaging

"What are the best practices for preprocessing calcium imaging data before motion correction?"

Plan file conversion, downsampling, filtering, motion correction, and segmentation checks.

Model Behavioral Data

"How can we build a predictive model from trial data for mouse behavior analysis?"

Structure trial data, smooth signals, and validate predictive models with interpretable diagnostics.

Analyze Periodic Responses

"What alternative statistical models can we use for asymmetric periodic neural data?"

Compare model choices for asymmetric or circular neural response patterns.

Generate Most Exciting Images

"How do we construct an inception loop pipeline for generating MEIs from neural data?"

Structure a deep learning workflow for neural response prediction and MEI generation.

Review Student Code

"Can someone check our scripts for readability before we turn them in?"

Use code review as a learning moment around clarity, structure, and maintainability.

Create Handover Checklists

"I am leaving soon. Can you help me make sure the next person can pick this up?"

Package scripts, data notes, and project context before a student or postdoc leaves.

Set Up Continuous Integration

"Can you help us set up automatic testing so we catch errors before merging?"

Run tests automatically when a shared repository changes.

Our Research Support Helpdesk

Email Request

Send a short note to any team member with the question, project, or blocker you want to discuss. We will help route it to the right person.

Online Consultation Meeting

We clarify the problem, your goals, and the current state of the project, then agree on a focused strategy and schedule.

Pair-Programming Sessions

We usually meet 1-2 times per week, online or in person, and work directly with you on the code, data, workflow, or analysis decision.

Project Review

At the end, we review what changed, document the outcome, and discuss next steps so your team can keep moving independently.