Home / Cheat sheets / MAD1

MAD1 cheat sheet

Code patterns and facts collected automatically from the lessons. Print it, or read it the night before an exam or viva.

Week 1 - How the web works: clients, servers, URLs and HTTP

• Requests per second = 1 / (seconds per request); with n workers multiply by n
• Bits = bytes x 8; Gbps = 1000 Mbps; throughput = (requests per second) x (response size)
• Download time = size in megabits / speed in Mbps
• Defaults: http port 80, https 443, Flask 5000, python -m http.server 8000
• Flask: request.args.get("k") (query), <int:id> (path), abort(404), jsonify(x) gives 200 and application/json
• Status: 200 OK, 201 Created, 301/302 redirect, 400 Bad Request, 401 not logged in, 403 forbidden, 404 not found, 405 wrong method, 500 server error
• curl: curl -i URL, curl -X POST URL -H "Content-Type: application/json" -d '{"a": 1}'

Week 2 - HTML and CSS: building and styling pages

• Skeleton: <!DOCTYPE html><html><head><title></title></head><body></body></html>
• Links: <link rel="stylesheet" href="s.css">, <script src="a.js"></script>, <a href="">, <img src="" alt="">
• Specificity: inline 1000, #id 100, .class [attr] :pseudo-class 10, tag ::pseudo-element 1
• Visible width (content-box) = width + 2 padding + 2 border; space = + 2 margin
• Flex: display: flex; justify-content: ...; align-items: ...; gap: ...
• Bootstrap 5 CSS: https://cdn.jsdelivr.net/npm/bootstrap@5.3.3/dist/css/bootstrap.min.css
• Breakpoints: sm 576, md 768, lg 992, xl 1200; grid = 12 columns

Week 3 - Views: Jinja2 templates, Bootstrap and forms

• Render: render_template("page.html", name=value)
• Static link: href="{{ url_for('static', filename='style.css') }}"
• Loop: {% for x in xs %}...{{ loop.index }}...{% else %}empty{% endfor %}
• If: {% if a %}..{% elif b %}..{% else %}..{% endif %}
• Inheritance: {% extends "base.html" %} and {% block content %}...{{ super() }}{% endblock %}
• Macro: {% macro name(arg, opt='x') %}...{% endmacro %} then {{ name(1) }}
• Whitespace trim: {%- ... -%}; comment: {# ... #}
• Form data: request.form.get("k"), request.args.get("k"), request.method
• Count: {{ items|length }}; default: {{ x|default('n/a') }}
• string.Template: $name, substitute() (KeyError) / safe_substitute()

Week 4 - Models: databases, SQL, ER diagrams and SQLAlchemy

• CREATE TABLE t(id INTEGER PRIMARY KEY, name TEXT NOT NULL UNIQUE, n INTEGER DEFAULT 0 CHECK(n>=0));
• SELECT cols FROM t JOIN u ON t.id=u.t_id WHERE ... GROUP BY ... HAVING ... ORDER BY ... LIMIT n;
• Aggregates: COUNT SUM AVG MIN MAX; NULL test: IS NULL
• SQLite file URI: sqlite:///name.sqlite3; memory: sqlite:///:memory:
• db = SQLAlchemy(app); models extend db.Model; db.Column(db.String(80), nullable=False, unique=True)
• db.relationship("Child", backref="parent") plus db.ForeignKey("parent.id") on the child
• db.session.add(obj), db.session.commit(), db.session.rollback(), db.session.delete(obj)
• Model.query.all() / .first() / .filter_by(a=1) / .filter(Model.a > 1) / .order_by(...) / .count()
• db.session.query(func.max(M.col)).scalar()
• with app.app_context(): db.create_all()

Week 5 - Controllers: Flask routes and business logic

• @app.route("/x/<int:id>", methods=["GET", "POST"])
• request.args.get("q"), request.form.get("f"), request.json, request.method
• return "text", 201; return {"a": 1}; return jsonify(list)
• redirect(url_for("endpoint", arg=1)); abort(404)
• @app.errorhandler(404); flash("msg"); get_flashed_messages()
• app.secret_key = "..."; session["k"] = v; session.get("k"); session.pop("k", None)
• Blueprint("name", __name__, url_prefix="/p"); app.register_blueprint(bp)
• db.init_app(app); def create_app(): ...; return app
• python -m venv venv; pip install -r requirements.txt; pip freeze > requirements.txt
• Status codes: 200 OK, 302 redirect, 400 bad request, 401 unauthorised, 403 forbidden, 404 not found, 405 wrong method, 415 wrong media type, 500 server error

Week 6 - APIs and REST: OpenAPI and Flask-RESTful

• api = Api(app); api.add_resource(Cls, "/x", "/x/<int:id>")
• class Cls(Resource): def get(self, id): return {...}, 200
• parser = reqparse.RequestParser(); parser.add_argument("n", type=int, required=True, location="json"); args = parser.parse_args()
• @marshal_with({"id": fields.Integer, "name": fields.String})
• abort(404, message="...") from flask_restful
• curl -X POST URL -H "Content-Type: application/json" -d "{\"a\":1}"; curl -v URL
• requests.post(URL, json={...}), .status_code, .json()
• 201 created, 204 no content, 400 bad input, 401 not logged in, 403 not allowed, 404 missing, 405 wrong verb, 409 conflict
• OpenAPI: openapi: 3.0.3, info, paths: /x: get: parameters/responses, components: schemas

Week 7 - Backend systems: indexing, search, caching and logging

• Levels: DEBUG 10, INFO 20, WARNING 30 (default), ERROR 40, CRITICAL 50
• logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
• breakpoint(); pdb: n, s, c, p x, l, q; flask --app app shell
• CREATE INDEX idx ON t(col); EXPLAIN QUERY PLAN SELECT ...; SCAN vs SEARCH USING INDEX
• CREATE VIRTUAL TABLE t USING fts5(a, b); WHERE t MATCH 'word OR pre*'
• @cache.cached(timeout=60), @cache.memoize(), cache.delete(key), cache.clear()
• Cache-Control: public, max-age=60, ETag and If-None-Match give 304
• DDR bandwidth = (bus bytes) x (2 x clock) x channels; worst disk latency = 60000 / RPM ms
• Round trip = 2 x distance / speed; requests per second = 1000 / RTT ms
• Data = rate (Mbit/s) x seconds / 8 (MB); 1.5 million x 4 KB = 6 GB

Week 8 - The frontend: JavaScript, the DOM and fetch

• <script src="app.js" defer></script>
• document.getElementById("id"), document.querySelector("#id .cls"), querySelectorAll("li")
• el.textContent, el.innerHTML, el.style.fontWeight = "bold", el.classList.add("x")
• const li = document.createElement("li"); ul.appendChild(li)
• el.addEventListener("click", e => { e.preventDefault(); })
• JSON.parse(text), JSON.stringify(obj)
• const res = await fetch(url, {method:"POST", headers:{"Content-Type":"application/json"}, body: JSON.stringify(data)}), res.ok, res.status, await res.json()
• localStorage.setItem(k, v), getItem(k), removeItem(k)
• display: block, inline, inline-block (side by side), flex (row)

Week 9 - Security: authentication, sessions, tokens and attacks

• generate_password_hash(pw) and check_password_hash(stored, pw) from werkzeug.security
• login_user(user), logout_user(), @login_required, current_user, @login_manager.user_loader
• @roles_required('admin') (all), @roles_accepted('a','b') (any)
• session['k'] = v, session.pop('k', None), app.config['SECRET_KEY'] = os.environ['SECRET_KEY']
• SESSION_COOKIE_HTTPONLY = True, SESSION_COOKIE_SECURE = True, SESSION_COOKIE_SAMESITE = "Lax"
• Cookie header: Set-Cookie: session=...; HttpOnly; Secure; SameSite=Lax
• Parameterised SQL: cur.execute("select * from u where name=?", (n,))
• Jinja: {{ x }} escapes; {{ x|safe }} does not
• Status codes: 401 unauthenticated, 403 forbidden, 404 not found, 429 too many requests, 302 redirect
• Basic auth = base64 (not encryption); Digest = hash; HTTPS = encrypted channel

Week 10 - Testing web applications with pytest

• pip install pytest pytest-cov; run: pytest, pytest -v, pytest -x, pytest file.py::test_name
• Selection: -k name_part, -m marker, -m "not slow", -m "a and b"
• Fixture: @pytest.fixture (use yield for teardown); parametrize: @pytest.mark.parametrize("a,b", [(1,2),(3,4)])
• Checks: assert x == y, pytest.approx(0.3), with pytest.raises(Err):, tmp_path
• Flask: app.test_client(); client.get("/"); client.post("/x", data={...}); client.post("/api", json={...})
• Response: .status_code, .data (bytes), .get_json(), .headers["Location"]
• Test database: {"TESTING": True, "SQLALCHEMY_DATABASE_URI": "sqlite:///:memory:"}
• Mock: from unittest.mock import patch, MagicMock; @patch("module.name")
• Coverage: pytest --cov=app --cov-branch --cov-report=term-missing
• Summary words: passed, failed, deselected, error, warnings

Week 11 - HTML5, accessibility, encoding and beyond HTML

• Bits per character (fixed, minimum) = ceiling of log2 of the number of distinct characters; total = characters x bits
• UCS-4 bits / 32 x 7 = ASCII 7-bit bits; UCS-2 bits / 16 x 7 = ASCII bits
• UTF-8: U+0000-007F 1 byte; to U+07FF 2; to U+FFFF 3; to U+10FFFF 4. UTF-32 always 4 bytes
• <meta charset="utf-8"> and <meta name="viewport" content="width=device-width, initial-scale=1">
• localStorage.setItem(k, v), getItem(k), removeItem(k); use JSON.stringify / JSON.parse
• POUR = Perceivable, Operable, Understandable, Robust; ARIA: role, aria-label, aria-live
• ws:// / wss:// WebSocket; new EventSource(url) for SSE; navigator.serviceWorker.register("/sw.js")
• Custom element: customElements.define("my-tag", Class) (name has a hyphen)

Week 12 - Deployment: Git, WSGI, servers and the cloud

• Git setup: git config --global user.name "N", git config --global user.email "e"
• Git basics: git init, git status, git add ., git commit -m "msg", git log --oneline, git diff
• Branches: git branch, git branch x, git checkout x or git switch x, git checkout -b x, git merge x, git branch -d x
• Remote: git clone URL, git remote add origin URL, git push -u origin main, git pull
• Untrack but keep: git rm --cached file; ignore: .gitignore
• Env: python -m venv venv, pip freeze > requirements.txt, pip install -r requirements.txt
• Config: os.environ.get("NAME", "default")
• Serve: gunicorn -w 4 -b 127.0.0.1:8000 app:app; nginx proxy_pass http://127.0.0.1:8000;
• Docker: docker build -t myapp ., docker run -p 8000:8000 myapp, docker compose up
• Migrate: flask db init, flask db migrate -m "msg", flask db upgrade, flask db downgrade
• Logging levels: DEBUG, INFO, WARNING, ERROR, CRITICAL