Award-Winning High School Computer Science Tutors
serving Queens, NY

Getting comfortable with loops, conditionals, and functions early makes every future CS course easier — and Justin explains these building blocks by tying them to problems students can visualize, like simulating physics or processing data. His background spans physics, applied math, and programming, so he can show high schoolers why the code they're writing actually matters beyond the assignment.

Philosophy trains you to break complex arguments into precise logical steps — which turns out to be exactly what high school CS demands when students hit Boolean logic, nested conditionals, and algorithm design. Julie applies that structured reasoning to programming concepts, teaching students to think through what their code should do before they start typing. Her statistics and machine learning certificate at Princeton means she's no stranger to writing and debugging code herself.

For students encountering loops, conditionals, and arrays for the first time, the leap from "I followed the example" to "I can solve a new problem" is the hardest part. Anna bridges that gap by teaching structured problem decomposition — breaking a coding challenge into smaller logical steps before writing a single line. Her background spans multiple programming languages, so she adapts explanations to whatever language the course uses.

High school CS courses often jump from basic print statements to complex topics like arrays, sorting algorithms, and object-oriented design without enough scaffolding in between. Ryan bridges those gaps by connecting each new concept to code students can actually run and modify themselves. His experience with Java, Python, and AP Computer Science A means he can match his explanations to whatever language or curriculum a student is working in.

For students encountering loops, conditionals, and arrays for the first time, the leap from "I typed the code" to "I understand why it works" can be steep. Jonathan bridges that gap by walking through each concept with concrete examples and building up to small projects that make the logic tangible. His CS coursework at Cornell keeps him sharp on the fundamentals that matter most at the high school level.

High school CS often moves fast from basic loops and conditionals to more abstract concepts like arrays, functions, and object-oriented design. Cody minored in computer science at Penn and tutored fellow students in the subject for three years, so he knows exactly where the common stumbling blocks are. He builds understanding by connecting each new concept to something concrete the student already knows.

High school CS courses often jump between block-based logic, basic programming, and conceptual topics like binary and networking without much connective tissue. John ties those pieces together by showing how each concept feeds into real software — an approach that makes AP-level material and IB coursework feel less scattered. His CS degree means he can go as deep as a student needs.

High school CS often covers a grab bag of topics — basic data types, conditionals, loops, maybe some introductory object-oriented programming — without always connecting them into a bigger picture. Diego bridges that gap by showing how each concept feeds into the next, drawing on his own path from high school coding to studying CS and cybersecurity at NYU Courant.

That first real programming class can feel overwhelming when you're staring at a screen full of syntax errors with no idea where to start debugging. Kevin breaks down foundational concepts like loops, conditionals, and arrays with enough detail that students learn to read their own code critically. His patience with beginners stands out — he'd rather over-explain than leave a gap.

The jump from "I can make a program run" to "I understand why it runs" is where most high school CS students get stuck — especially around loops, arrays, and conditional logic. Eric bridges that gap by connecting each concept to tangible examples, drawing on the same foundational thinking he uses daily in Cornell's CS program.

The jump from writing code that runs to understanding *why* it runs — Big-O notation, boolean logic, basic data structures — is the real challenge in high school CS. Dibyendu breaks these ideas down using concrete examples in Python and Java, connecting each concept to problems students can actually visualize. His background in teaching university-level courses means he knows exactly which fundamentals matter most before college.

Starting computer science can feel overwhelming when variables, loops, and conditionals all hit at once. Wesley eases that learning curve by teaching each concept as a building block, drawing on the systematic problem-solving approach he developed across two engineering degrees. Rated 4.7 by students, he's particularly effective at making that first semester of coding feel manageable.

That first encounter with nested loops or recursive functions can make high school CS feel overwhelming in a hurry. Eric, who studies computer science at NYU alongside finance and statistics, breaks down programming logic step by step — tracing through code execution, diagramming how arrays store data, and explaining why certain algorithms run faster than others. He's rated 5.0 by students.

Most high school CS courses throw students into syntax — loops, conditionals, arrays — without enough time spent on why the logic works. Brendon's approach starts with the reasoning behind each structure, then walks through implementation, so students actually understand what their code is doing instead of pattern-matching from examples. His Columbia CS training keeps him sharp on both Java and Python curricula.

The jump from following along in class to independently writing and debugging code is where most high school CS students get stuck. Justin breaks down programming logic — loops, conditionals, functions, and basic data structures — into small, testable pieces so students build confidence one concept at a time. His computational linguistics coursework keeps him actively coding, which means his examples stay current and practical.

That first real CS course can feel overwhelming when loops, conditionals, and functions all land at once. Stephen's dual math-CS background from RPI lets him explain not just the syntax but the underlying logic — why a while loop behaves differently from a for loop, or how to think through a problem before writing a single line of code. Rated 4.9 by students.

I'm a professional software engineer at a top tech company in New York City. I have a strong passion for software development, most notably in the areas of full-stack web development, iOS development, Artificial intelligence, large scale distributed systems, and micro services.

High school CS often feels like two different classes stitched together — half logic puzzles, half syntax memorization. Ryan bridges that gap by teaching students to think through problems algorithmically before writing a single line of code, building the kind of reasoning that transfers across any programming language.

Getting comfortable with loops, conditionals, and basic data structures early makes every future CS course dramatically easier. Maggie teaches high school computer science by connecting abstract programming concepts to tangible projects, drawing on the computational problem-solving she honed through her engineering coursework. Rated 5.0 by students.

Ankit's chemistry background might seem unrelated to CS, but the systematic thinking required to balance reaction mechanisms and model molecular behavior maps directly onto writing and debugging code. He applies that scientific precision to topics like variables, control flow, and basic data structures — teaching students to trace their logic the same way they'd trace a chemical equation. He also teaches college-level CS, so he can push advanced students toward more rigorous problem-solving when they're ready.

High school CS often feels like learning syntax without understanding why it matters — why use a loop instead of repeating code, or what actually happens in memory when you create a variable. Deeptha bridges that gap by tying programming basics to real problem-solving, drawing on years as a TA for introductory computing courses at UAB. She keeps sessions at whatever pace clicks, whether a student is writing their first "Hello World" or debugging their first data structure.

That first real CS class — where variables, loops, and conditionals suddenly need to work together in actual programs — is where many high schoolers either get hooked or get lost. Kyle bridges that gap by connecting each new concept to a working project, whether it's a simple game or a data tool. His fluency in Python, Java, and C++ means he can match whatever language the course uses.

Laura studied computer science as a minor at Georgia Tech alongside her biomedical engineering major, so she's fluent in the core concepts — loops, conditionals, data structures, and object-oriented design — that high school CS courses build on. She breaks down programming logic step by step, making abstract ideas like recursion or sorting algorithms click through hands-on coding examples.

Stephen's Computer Science degree means he can teach high school CS concepts — loops, conditionals, arrays, object-oriented design — as building blocks that connect to real programming, not just abstract exercises. He also understands New York State Regents requirements, so he tailors sessions to what students actually need to demonstrate on exams.

Whether a student is writing their first loop or debugging a multi-method program, the key is understanding what the computer is actually doing at each step. Serina's CS major at Yale and her experience teaching AP Computer Science A and Principles give her a clear sense of where high schoolers get stuck — conditionals, arrays, and class design — and how to unstick them.

Getting comfortable with loops, conditionals, and arrays early on makes everything that follows in computer science click. Kirollos teaches these building blocks through hands-on coding exercises rather than abstract definitions, drawing on his experience tutoring since high school and his ongoing CS coursework at NYU.

Getting comfortable with loops, conditionals, and basic data structures early makes every future CS course easier. Rohan breaks down programming logic by tracing through code line by line, showing students exactly how a computer processes each instruction rather than letting them guess at what their program is doing. His engineering background adds a practical, problem-solving lens to every lesson.

For students encountering programming for the first time, the leap from following instructions to writing original code can feel overwhelming. Zain tackles that transition by connecting coding logic to the kind of structured, step-by-step reasoning he honed in his interdisciplinary studies, making concepts like variables, functions, and debugging feel less alien and more like problem-solving they've already done.

For students encountering loops, conditionals, and functions for the first time, the leap from "I followed the lesson" to "I can write this myself" can feel enormous. Sam closes that gap by teaching students to decompose problems before writing a single line of code — a habit from his engineering background that translates directly to introductory programming. He keeps the focus on logical thinking so that syntax never becomes the bottleneck.

High school CS courses often move fast through topics like arrays, functions, and object-oriented basics without checking whether the underlying logic actually landed. Alisha slows down at exactly those sticking points, walking through how a for-loop iterates or why a method returns a value instead of just showing the syntax. She's rated 5.0 by students, which tracks with her patient, concept-first teaching style.

For students taking their first CS class, the jump from "I can follow the example" to "I can solve a new problem on my own" is the hardest part. Abrar bridges that gap by walking through how to plan a solution before writing a single line — whether the assignment involves loops, arrays, or basic sorting algorithms. Rated 5.0 by students.

That first real CS course can feel overwhelming when you're simultaneously learning to think algorithmically and wrestle with syntax errors. Kevin takes topics like loops, arrays, sorting algorithms, and basic object-oriented design and ties each one to a tangible problem so the logic sticks before the code gets more complex. His 5.0 rating speaks to how well that approach lands with students.

High school CS courses often jump quickly from basic syntax to projects involving loops, arrays, and object-oriented design — and that's where students get lost. Jeff breaks down each programming concept into its logical components, showing how a for-loop actually iterates or why a function needs a return statement, so the code starts making sense instead of feeling like memorized spells.

That first encounter with loops, conditionals, and functions can feel overwhelming when everything is new vocabulary. Allison breaks programming logic into small, testable pieces — write three lines, run them, see what happens — so students build intuition for debugging and problem decomposition before projects get complex. Rated 4.9 by students.

Running STEM summer programs for younger students gave Sophia a knack for explaining core CS concepts — variables, conditionals, loops, and basic data structures — in ways that click the first time. She connects these building blocks to real mini-projects so students see how abstract logic turns into working code. Her psychology background also means she's tuned into how different learners process new technical material.

Most high school CS courses move fast from basic control flow to arrays and object-oriented programming, and that jump is where students tend to get lost. Roshni tackles each concept by writing code alongside students, debugging in real time so they learn to read error messages and trace logic instead of just copying solutions. Her 4.9 rating speaks to how well that approach clicks.

I am a junior Computer Science major in the College of Engineering at Cornell University. I have experience tutoring in the National Honor Society in high school, as well as on numerous occasions with acquaintances of mine who were struggling and needed a hand. I tutor high school computer science especially in java and python, as well as algebra (1 & 2) and calculus 1. I love tutoring the math subjects especially, because I feel very comfortable with the subjects and enjoy abstracting them in different ways to help any individual. I believe that success in education is key to building a great life for oneself, and that any person can succeed with the proper work ethic and support network. Even more, I love to see when people I have helped are successful, regardless of area of life. In my spare time, I love to follow college football and basketball and talk about games.

The jump from "I can write a for-loop" to "I understand why this algorithm is efficient" is where most high school CS students get stuck. Jack bridges that gap by connecting introductory programming concepts — conditionals, arrays, functions — to the deeper logic underneath, drawing on his own CS studies at UNC Chapel Hill.

A Princeton postdoctoral researcher in machine learning, Firas brings PhD-level computer science depth to high school topics that often get taught superficially — things like how recursion actually works under the hood, or why an O(n²) sort matters even in an intro course. He teaches Python, Java, and JavaScript across his tutoring practice, so he can match whatever language a student's class uses and still keep the focus on the conceptual reasoning underneath. Rated 5.0 by students.

High school CS courses often jump from basic loops to complex projects without enough scaffolding in between. Adel fills those gaps — he unpacks concepts like arrays, conditional logic, and object-oriented programming step by step, using the structured problem-solving approach that comes naturally from his engineering training. Rated 4.8 by students.