Overview
We tutor introductory and intermediate programming in Python, Java, C and C++, JavaScript and SQL, along with core computer science topics: data structures, algorithms and complexity, object-oriented design, recursion, databases, computer architecture basics and discrete structures. School students in IB Computer Science, A-Level and IGCSE Computer Science, AP Computer Science A or AP CSP, and the French NSI spécialité are supported, as are university students in CS1, CS2 and data structures courses and non-majors in required programming modules.
Sessions are hands-on. You share your screen or a collaborative editor and write the code; the tutor asks questions, suggests the next small step and explains concepts as they arise. We teach a repeatable routine for programming problems: restate the problem, work examples by hand, write pseudocode, implement in small pieces, test and debug. This routine is what transfers to exams and future courses.
Computer science exams often include written or on-paper questions: tracing code, writing code by hand, explaining algorithms and analyzing complexity. We practice these explicitly, because students who only code with autocomplete and an interpreter often struggle when those are removed. Current exam formats vary; AP Computer Science A, for example, is delivered digitally through College Board's Bluebook app, so check your course's current exam description.
Who it’s for and the problems it solves
This is for you if you are…
- Secondary students in IB, A-Level, IGCSE, AP or NSI computer science
- University students in introductory programming, data structures, algorithms or database modules
- Students from other majors (engineering, business, science) in a required programming course
- Graduate students learning Python or R for research who want to understand programming principles, not just copy scripts
- Career changers building programming fundamentals alongside a course or bootcamp
Common problems we help with
- You understand the lecture examples but freeze when facing a blank editor
- Error messages and stack traces are intimidating, so you change things at random
- Loops, recursion and nested data structures are hard to trace mentally
- Object-oriented concepts (classes, inheritance, interfaces) feel abstract
- Big-O analysis and algorithm design questions feel like guesswork
- You rely on AI tools or copied snippets and worry you can't code without them
What’s included — and what isn’t
Included
- Diagnostic session: a short coding task and a tracing task to see how you approach problems
- Programming fundamentals: variables, types, control flow, functions, scope, input and output, files
- Data structures: arrays and lists, stacks, queues, hash tables, linked lists, trees, heaps and graphs
- Algorithms: searching, sorting, recursion, divide and conquer, greedy methods, dynamic programming basics, graph traversal
- Complexity analysis: Big-O reasoning and comparing algorithmic approaches
- Object-oriented programming: classes, encapsulation, inheritance, polymorphism and basic design principles
- Databases and SQL: relational modeling, queries, joins and normalization
- Debugging and testing practice: reading errors, using a debugger, print tracing, writing test cases
- Development tools setup and use: IDEs, the command line and basic Git
- Paper-based exam practice: code tracing, handwritten code and pseudocode questions
Not included
- Writing or fixing code for graded assignments, projects or online judges that you will submit
- Completing IB internal assessment solutions, A-Level NEA projects or capstone projects for you
- Help during live coding tests or proctored exams
What you receive
- Diagnostic notes
- What you can already do, where your process breaks down (planning, syntax, debugging or concepts), and the plan to address it.
- Practice exercises
- Graded coding exercises between sessions, each with a sample solution and explanation to compare with yours after you attempt it.
- Session code and notes
- The code written in the session (by you), with comments added together, plus concept notes and diagrams of data structures.
- Debugging checklist
- A personal checklist built from the errors you actually make, to use before asking for help.
- Exam practice pack
- Tracing, handwritten-code and complexity questions matched to your course, with worked answers.
How it works
Tell us your course
Language, course or syllabus, current topics, and whether you're catching up, keeping pace or preparing for an exam.
Diagnostic and setup
A short coding task reveals your approach; we also make sure your development environment works.
Concepts through code
Each topic is introduced with a small example, then you extend or modify it, then write a new program from scratch.
Debugging and testing habits
We deliberately practice finding bugs, including in code the tutor writes with planted errors.
Exam and project readiness
Timed tracing and code-writing practice, plus coaching on planning larger projects so you can build your own.
Languages, tools and teaching approach
- Python
- The most common first language in schools and universities; also used for data analysis and research scripting.
- Java
- Common in AP Computer Science A, A-Level and university object-oriented courses.
- C and C++
- Memory, pointers and lower-level concepts in systems or engineering courses.
- JavaScript
- Web programming fundamentals and interactive projects.
- SQL
- Relational database design and queries for database modules.
- Pair programming (you drive)
- You type and make decisions; the tutor navigates by asking questions, so the skill stays with you.
- Code tracing and memory diagrams
- Drawing the call stack, variables and references to understand recursion, aliasing and pointers.
- Git basics
- Version control habits for keeping your own work organized and recoverable.
Typical sticking points by stage
Programming difficulties follow a fairly predictable sequence, and knowing it helps us check the right things early.
- Beginners: variable assignment versus equality, loop boundaries (off-by-one errors), and functions that print instead of return
- Early intermediate: nested loops, lists of lists, dictionaries and string manipulation
- Recursion: base cases, trusting the recursive call, and tracing the call stack
- Object-oriented: when to use a class, references versus copies, and inheritance versus composition
- Data structures and algorithms: choosing the right structure, and analyzing time and space complexity
Learning to code alongside AI tools
AI coding assistants can speed up experienced programmers but can prevent beginners from building the mental models they need, and many courses restrict their use in assessed work. Tutoring focuses on skills that AI tools don't give you: decomposing problems, predicting what code will do, and diagnosing why it doesn't. When your course permits AI assistance, we can discuss how to use it to explain rather than replace your thinking, within your course's rules.
Assessed projects and coursework
Many courses include substantial projects: the IB Computer Science internal assessment, the A-Level non-exam assessment (NEA), AP CSP's Create performance task and university capstones. We can teach the techniques you'll need, help you practice on separate examples and coach you on planning and testing your own project. We don't write or debug the code you'll submit. For documentation skills, see software project documentation support.
What the work can look like
Illustrative example — fictional data
Sample progress note: recursion in Python
A fictional first-year student could write loops but failed recursion questions on a practice exam. The note below is invented to show format and detail.
Diagnostic
The student wrote recursive functions without a reachable base case and couldn't trace calls deeper than two levels. Loops and lists were secure.
Sessions 1–2
Call-stack diagrams for factorial and sum-of-list; the student wrote recursive versions of five familiar loop tasks, then predicted outputs before running them. Introduced the 'trust the recursive call' mindset with a string-reversal example.
Current status
Traces four-level recursion correctly on paper; writes base and recursive cases independently for list problems. Next: recursion on trees, and comparing recursive versus iterative complexity.
Illustrative example with an invented student. Real notes reflect your own course and progress.
What you’ll need to provide
- Course outline, lecture slides or syllabus, and the language and version used
- A working computer with the course's development environment (or willingness to set it up with us)
- Examples of practice problems or past exams (not live graded assignments)
- Any rules your course sets about collaboration and outside help
You don’t need everything ready to ask for a quote — tell us what you have and we’ll say what’s missing.
What affects price and turnaround
Price depends on
- Level and topic, from beginner programming to advanced algorithms
- Language or technology required
- Session length and frequency
- Amount of custom exercises and exam practice material between sessions
Turnaround depends on
- Tutor availability for your language and level
- Time needed to set up your development environment
- Exam or course deadlines
Every project is quoted individually. How we price our work.
Questions people ask before starting
Can you help me finish my programming assignment?
We can teach the concepts your assignment uses with separate examples, and help you develop a strategy for approaching it. We won't write or fix the code you'll submit. Most courses treat that as a violation of their collaboration policy, and it would leave you unprepared for exams that test the same skills.
Which languages do you tutor?
Most commonly Python, Java, C, C++, JavaScript and SQL. If your course uses something else, like Haskell, MATLAB or Kotlin, tell us and we'll confirm availability before starting.
Do I need special software for sessions?
You need the environment your course uses, such as a Python installation with VS Code or PyCharm, or a Java JDK. We can help set it up in the first session. Screen sharing or a shared online editor lets the tutor see your code as you write it.
I'm a complete beginner. Is tutoring useful before my course starts?
Yes. A few sessions on fundamentals, including how to think about problems and read error messages, can make the first weeks of a course much less stressful.
Do you prepare students for coding interviews?
The algorithms and data structures content overlaps, and we can practice problem-solving and explaining your reasoning aloud. For career-focused preparation, mention it in your request so we can tailor the plan.