ASU CSE 240: Introduction to Programming Languages
CSE 240 surveys programming-language paradigms after the Java sequence — C and C++ for imperative programming with pointers and manual memory, Scheme for functional programming, and Prolog for logic programming. It's a core CS requirement designed to break students out of the one-language thinking CSE 110 and 205 built.
Fennie is independent and not affiliated with Arizona State University. This is an unofficial study guide.
Build my CSE 240 study planWhat makes it hard
Pointers are the first wall: C exposes memory directly, and students raised on Java's managed world suddenly own segmentation faults and memory leaks. Then the paradigm shifts hit — recursion-only thinking in Scheme and declarative rules in Prolog feel like starting over — and exam questions test whether you can think in each paradigm, not just translate Java habits into new syntax.
What you'll cover
- • C programming and pointers
- • Memory management, stack vs. heap
- • C++ and object-oriented features
- • Functional programming in Scheme
- • Logic programming in Prolog
- • Comparing language paradigms
The CSE 240 study guide
How to study for ASU CSE 240, step by step.
- 1
Front-load the pointer material
Pointers and manual memory are CSE 240's first wall and everything in the C unit assumes them. Give them concentrated practice in the first weeks rather than hoping they click later.
- 2
Diagram memory, don't just run code
For each C example, draw what's on the stack, what's on the heap, and what each pointer references. Segfaults stop being mysterious once the diagrams become habit — and exams ask exactly these questions.
- 3
Do Scheme exercises without loops on purpose
Functional programming only clicks when you stop reaching for iteration. Rewrite familiar problems — sums, list processing — recursively in Scheme until the recursive shape comes first.
- 4
Write small Prolog rule sets from scratch
Logic programming is declarative: you state facts and rules, and the engine searches. Build tiny knowledge bases yourself and trace how queries resolve — reading examples alone won't rewire the habit.
- 5
Build a paradigm comparison sheet before exams
One page contrasting how each language handles state, control flow, and data. Exam questions love 'how would this look in each paradigm,' and the contrast is the actual course content.
- 6
Schedule the paradigm shifts with Fennie
Upload the CSE 240 syllabus and Fennie's Daily Plan front-loads pointer practice and gives Scheme and Prolog their own runway before exams, with quizzes generated from your actual course material. It's free to start.
Start my CSE 240 plan free
How Fennie helps with CSE 240
Fennie's Daily Plans give each CSE 240 paradigm its own runway — concentrated pointer practice early, then scheduled Scheme and Prolog reps before each exam instead of a cram across three unfamiliar languages. Chat explains why a segfault happens or how a Prolog query resolves, building the mental models the exams actually test.
FAQ
Is CSE 240 at ASU hard?
It's moderately hard in an unusual way: three unfamiliar paradigms in one course. The C pointer unit causes the most early pain, while Scheme and Prolog cause the most exam-week pain. Students who practice in each language weekly handle it fine.
What languages does CSE 240 cover?
C and C++ for imperative and object-oriented programming, Scheme for functional programming, and Prolog for logic programming — with the goal of understanding paradigms and language design, not mastering any single language.
Why do I have to learn Scheme and Prolog in CSE 240?
Because the course is about how languages think, not job-market syntax. Functional and logic paradigms show up inside modern languages and later CS coursework, and learning to reason in them is the transferable skill being graded.
Pass CSE 240 with a plan, not a cram
Upload your CSE 240 materials and Fennie generates a Daily Plan paced to your deadline — plus chat, flashcards, and quizzes built from the actual course content.
Get started freeMore ASU courses
CSE 110 — Principles of Programming
CSE 110 is ASU's first programming course, teaching problem solving and structured programming in Java — variables, control flow, methods, arrays, and intro object-oriented concepts. It's the gateway for CS, software engineering, and informatics majors, and one of the most-taken courses on ASU Online.
CSE 205 — Object-Oriented Programming and Data Structures
CSE 205 follows CSE 110, deepening Java with object-oriented design — inheritance, polymorphism, interfaces — plus core data structures like lists, stacks, queues, and recursion. It's the course that determines whether students continue smoothly into the CS major's core.
CSE 230 — Computer Organization and Assembly Language Programming
CSE 230 takes ASU CS majors below the high-level language for the first time — number representation, MIPS assembly programming, how the processor actually executes instructions, and the basics of datapath and pipelining. It's a core requirement that shows students what their Java from CSE 110 and 205 compiles down to.