Show description
CSE240: Programming Languages Mastery
CSE240: Programming Languages Mastery
CSE240: Programming Languages
Master Multiple Programming Paradigms
Imperative Programming (C)
Memory management & pointers
Arrays and string manipulation
Functions and parameter passing
Structs and unions
File I/O operations
Dynamic memory allocation
// C pointer manipulation
int *ptr = malloc(sizeof(int) * 10);
for(int i = 0; i < 10; i++) {
ptr[i] = i * 2;
}
free(ptr);
Object-Oriented (C++)
Classes and objects
Inheritance and polymorphism
Encapsulation and abstraction
Virtual functions
Operator overloading
Templates and STL
// C++ class with inheritance
class Animal {
protected:
string name;
public:
virtual void speak() = 0;
};
class Dog : public Animal {
public:
void speak() override {
cout = Y, !.
max(X, Y, Y).
Study Tips
Practice pointer arithmetic daily - it's the foundation of C mastery
Understand memory layout: stack vs heap vs data segment
Master recursion in Scheme - think in terms of base cases and recursive calls
For Prolog, visualize the search tree and backtracking process
Compare paradigms: how would you solve the same problem in each language?
Build mental models for each paradigm's execution model
CSE240: Programming Languages Mastery
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>CSE240: Programming Languages Mastery</title>
<style>
* {
margin: 0;
padding: 0;
box-sizing: border-box;
}
body {
font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
background: linear-gradient(135deg, #0c0c0c 0%, #1a1a1a 100%);
color: #e0e0e0;
line-height: 1.6;
min-height: 100vh;
}
.container {
max-width: 1200px;
margin: 0 auto;
padding: 20px;
}
.header {
text-align: center;
margin-bottom: 40px;
padding: 40px 0;
background: linear-gradient(45deg, #2d1b69 0%, #11998e 100%);
border-radius: 15px;
box-shadow: 0 10px 30px rgba(0,0,0,0.5);
}
.header h1 {
font-size: 3em;
margin-bottom: 10px;
text-shadow: 2px 2px 4px rgba(0,0,0,0.7);
}
.header p {
font-size: 1.2em;
opacity: 0.9;
}
.paradigm-grid {
display: grid;
grid-template-columns: repeat(auto-fit, minmax(350px, 1fr));
gap: 30px;
margin-bottom: 40px;
}
.paradigm-card {
background: linear-gradient(145deg, #1e1e1e, #2a2a2a);
border-radius: 15px;
padding: 30px;
box-shadow: 0 8px 25px rgba(0,0,0,0.4);
border: 1px solid #333;
transition: transform 0.3s ease, box-shadow 0.3s ease;
}
.paradigm-card:hover {
transform: translateY(-5px);
box-shadow: 0 15px 40px rgba(0,0,0,0.6);
}
.paradigm-title {
font-size: 1.8em;
margin-bottom: 15px;
padding-bottom: 10px;
border-bottom: 2px solid;
}
.imperative .paradigm-title { border-color: #ff6b6b; color: #ff6b6b; }
.oop .paradigm-title { border-color: #4ecdc4; color: #4ecdc4; }
.functional .paradigm-title { border-color: #45b7d1; color: #45b7d1; }
.logic .paradigm-title { border-color: #f9ca24; color: #f9ca24; }
.concept-list {
list-style: none;
margin-bottom: 20px;
}
.concept-list li {
padding: 8px 0;
padding-left: 20px;
position: relative;
}
.concept-list li::before {
content: "▶";
position: absolute;
left: 0;
color: inherit;
}
.code-sample {
background: #0d1117;
border: 1px solid #30363d;
border-radius: 8px;
padding: 15px;
margin: 15px 0;
font-family: 'Courier New', monospace;
font-size: 0.9em;
overflow-x: auto;
}
.syntax-highlight {
color: #79c0ff;
}
.keyword { color: #ff7b72; }
.string { color: #a5d6ff; }
.comment { color: #8b949e; font-style: italic; }
.function { color: #d2a8ff; }
.week-timeline {
background: linear-gradient(145deg, #1a1a1a, #2d2d2d);
border-radius: 15px;
padding: 30px;
margin: 30px 0;
border: 1px solid #333;
}
.week-timeline h2 {
color: #11998e;
margin-bottom: 20px;
text-align: center;
}
.timeline-grid {
display: grid;
grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
gap: 20px;
}
.week-item {
background: rgba(255,255,255,0.05);
border-radius: 10px;
padding: 15px;
text-align: center;
border: 1px solid rgba(255,255,255,0.1);
}
.week-number {
font-size: 1.2em;
color: #11998e;
font-weight: bold;
}
.cheat-sheet {
background: linear-gradient(145deg, #1a1a1a, #2d2d2d);
border-radius: 15px;
padding: 30px;
margin: 30px 0;
border: 1px solid #333;
}
.cheat-sheet h2 {
color: #f9ca24;
margin-bottom: 20px;
text-align: center;
}
.quick-ref {
display: grid;
grid-template-columns: repeat(auto-fit, minmax(280px, 1fr));
gap: 20px;
}
.ref-section {
background: rgba(255,255,255,0.05);
border-radius: 10px;
padding: 20px;
border: 1px solid rgba(255,255,255,0.1);
}
.ref-section h3 {
margin-bottom: 15px;
color: #4ecdc4;
}
@media (max-width: 768px) {
.header h1 {
font-size: 2em;
}
.paradigm-grid {
grid-template-columns: 1fr;
}
.container {
padding: 10px;
}
}
</style>
</head>
<body>
<div class="container">
<div class="header">
<h1>CSE240: Programming Languages</h1>
<p>Master Multiple Programming Paradigms</p>
</div>
<div class="paradigm-grid">
<div class="paradigm-card imperative">
<h2 class="paradigm-title">Imperative Programming (C)</h2>
<ul class="concept-list">
<li>Memory management & pointers</li>
<li>Arrays and string manipulation</li>
<li>Functions and parameter passing</li>
<li>Structs and unions</li>
<li>File I/O operations</li>
<li>Dynamic memory allocation</li>
</ul>
<div class="code-sample">
<span class="comment">// C pointer manipulation</span>
<span class="keyword">int</span> *ptr = <span class="function">malloc</span>(<span class="keyword">sizeof</span>(<span class="keyword">int</span>) * 10);
<span class="keyword">for</span>(<span class="keyword">int</span> i = 0; i < 10; i++) {
ptr[i] = i * 2;
}
<span class="function">free</span>(ptr);
</div>
</div>
<div class="paradigm-card oop">
<h2 class="paradigm-title">Object-Oriented (C++)</h2>
<ul class="concept-list">
<li>Classes and objects</li>
<li>Inheritance and polymorphism</li>
<li>Encapsulation and abstraction</li>
<li>Virtual functions</li>
<li>Operator overloading</li>
<li>Templates and STL</li>
</ul>
<div class="code-sample">
<span class="comment">// C++ class with inheritance</span>
<span class="keyword">class</span> <span class="syntax-highlight">Animal</span> {
<span class="keyword">protected</span>:
<span class="syntax-highlight">string</span> name;
<span class="keyword">public</span>:
<span class="keyword">virtual</span> <span class="keyword">void</span> <span class="function">speak</span>() = 0;
};
<span class="keyword">class</span> <span class="syntax-highlight">Dog</span> : <span class="keyword">public</span> <span class="syntax-highlight">Animal</span> {
<span class="keyword">public</span>:
<span class="keyword">void</span> <span class="function">speak</span>() <span class="keyword">override</span> {
cout << <span class="string">"Woof!"</span> << endl;
}
};
</div>
</div>
<div class="paradigm-card functional">
<h2 class="paradigm-title">Functional Programming (Scheme)</h2>
<ul class="concept-list">
<li>Lambda expressions</li>
<li>Higher-order functions</li>
<li>Recursion patterns</li>
<li>List processing</li>
<li>Closures and scope</li>
<li>Immutable data structures</li>
</ul>
<div class="code-sample">
<span class="comment">;; Scheme recursive list processing</span>
(<span class="keyword">define</span> (<span class="function">map-square</span> lst)
(<span class="keyword">if</span> (<span class="function">null?</span> lst)
'()
(<span class="function">cons</span> (* (<span class="function">car</span> lst) (<span class="function">car</span> lst))
(<span class="function">map-square</span> (<span class="function">cdr</span> lst)))))
<span class="comment">;; Using lambda</span>
((<span class="keyword">lambda</span> (x) (* x x)) 5) <span class="comment">;; returns 25</span>
</div>
</div>
<div class="paradigm-card logic">
<h2 class="paradigm-title">Logic Programming (Prolog)</h2>
<ul class="concept-list">
<li>Facts and rules</li>
<li>Pattern matching</li>
<li>Backtracking and unification</li>
<li>Cut operator (!)</li>
<li>List manipulation</li>
<li>Database queries</li>
</ul>
<div class="code-sample">
<span class="comment">% Prolog family relationships</span>
<span class="function">parent</span>(tom, bob).
<span class="function">parent</span>(bob, ann).
<span class="function">parent</span>(bob, pat).
<span class="function">grandparent</span>(X, Z) :-
<span class="function">parent</span>(X, Y),
<span class="function">parent</span>(Y, Z).
<span class="comment">% Query: ?- grandparent(tom, ann).</span>
</div>
</div>
</div>
<div class="week-timeline">
<h2>Course Timeline</h2>
<div class="timeline-grid">
<div class="week-item">
<div class="week-number">Week 1-2</div>
<div>C Fundamentals<br>Pointers & Memory</div>
</div>
<div class="week-item">
<div class="week-number">Week 3</div>
<div>Advanced C<br>C++ Basics</div>
</div>
<div class="week-item">
<div class="week-number">Week 4</div>
<div>OOP in C++<br>Midterm</div>
</div>
<div class="week-item">
<div class="week-number">Week 5-6</div>
<div>Scheme Functional<br>Programming</div>
</div>
<div class="week-item">
<div class="week-number">Week 7</div>
<div>Prolog Logic<br>Programming</div>
</div>
<div class="week-item">
<div class="week-number">Week 8</div>
<div>Final Exam<br>Integration</div>
</div>
</div>
</div>
<div class="cheat-sheet">
<h2>Quick Reference Guide</h2>
<div class="quick-ref">
<div class="ref-section">
<h3>C Memory Management</h3>
<div class="code-sample">
<span class="function">malloc</span>() - allocate memory
<span class="function">free</span>() - deallocate memory
<span class="function">calloc</span>() - zero-initialized allocation
<span class="function">realloc</span>() - resize allocated memory
<span class="comment">// Always check for NULL!</span>
<span class="keyword">int</span> *ptr = <span class="function">malloc</span>(<span class="keyword">sizeof</span>(<span class="keyword">int</span>));
<span class="keyword">if</span> (ptr == <span class="syntax-highlight">NULL</span>) {
<span class="comment">// handle error</span>
}
</div>
</div>
<div class="ref-section">
<h3>C++ Key Concepts</h3>
<div class="code-sample">
<span class="comment">// Virtual functions for polymorphism</span>
<span class="keyword">virtual</span> <span class="keyword">void</span> <span class="function">method</span>() = 0; <span class="comment">// pure virtual</span>
<span class="comment">// Constructor initialization list</span>
<span class="syntax-highlight">MyClass</span>(<span class="keyword">int</span> x) : member(x) {}
<span class="comment">// RAII pattern</span>
<span class="syntax-highlight">unique_ptr</span><<span class="keyword">int</span>> ptr = <span class="function">make_unique</span><<span class="keyword">int</span>>(42);
</div>
</div>
<div class="ref-section">
<h3>Scheme Essentials</h3>
<div class="code-sample">
<span class="comment">;; Basic list operations</span>
(<span class="function">car</span> '(1 2 3)) <span class="comment">;; returns 1</span>
(<span class="function">cdr</span> '(1 2 3)) <span class="comment">;; returns (2 3)</span>
(<span class="function">cons</span> 1 '(2 3)) <span class="comment">;; returns (1 2 3)</span>
<span class="comment">;; Conditional</span>
(<span class="keyword">if</span> (<span class="function">null?</span> lst)
'empty
'not-empty)
</div>
</div>
<div class="ref-section">
<h3>Prolog Patterns</h3>
<div class="code-sample">
<span class="comment">% Basic query patterns</span>
<span class="function">member</span>(X, [X|_]).
<span class="function">member</span>(X, [_|T]) :- <span class="function">member</span>(X, T).
<span class="comment">% List append</span>
<span class="function">append</span>([], L, L).
<span class="function">append</span>([H|T1], L2, [H|T3]) :-
<span class="function">append</span>(T1, L2, T3).
<span class="comment">% Cut to prevent backtracking</span>
<span class="function">max</span>(X, Y, X) :- X >= Y, !.
<span class="function">max</span>(X, Y, Y).
</div>
</div>
</div>
</div>
<div class="paradigm-card" style="margin-top: 30px; text-align: center;">
<h2 style="color: #11998e; margin-bottom: 20px;">Study Tips</h2>
<ul class="concept-list" style="text-align: left; max-width: 600px; margin: 0 auto;">
<li>Practice pointer arithmetic daily - it's the foundation of C mastery</li>
<li>Understand memory layout: stack vs heap vs data segment</li>
<li>Master recursion in Scheme - think in terms of base cases and recursive calls</li>
<li>For Prolog, visualize the search tree and backtracking process</li>
<li>Compare paradigms: how would you solve the same problem in each language?</li>
<li>Build mental models for each paradigm's execution model</li>
</ul>
</div>
</div>
</body>
</html>