Modern Application Development I 16 Jul 26 - 19 Jul 2026

Concepts this paper tests

Auto-generated summary from the source site. Handy as a checklist; the lessons above explain each idea from scratch.

Here's a summary of the core topics, concepts, principles, and equations essential to study for the exam, followed by a knowledge graph.

Summary of Core Topics and Concepts

The questions cover fundamental aspects of Web Development, specifically focusing on Frontend Technologies (HTML, CSS) and Backend Development with Python Flask, alongside core Python Programming concepts and some Mathematical/Networking Fundamentals.

1. Web Technologies (HTML, CSS, HTTP)

• HTML Structure and Elements:

  • Understanding the basic document structure (<!DOCTYPE html>, <html>, <head>, <body>).
  • Common HTML elements and their attributes: <div>, <h3>, <input>, <form>, <ul>, <li>.
  • Block-level vs. Inline-level Elements: Differentiating elements that start on a new line and take full width (e.g., <div>, <p>, <h1>) from those that flow with text and take only necessary width (e.g., <span>, <a>, <img>, <input>).
  • Form elements: <input type="text">, <input type="submit">.

• CSS Styling and Selectors:

  • Embedding CSS within the <style> tag in HTML.

  • CSS Selector Specificity: The mechanism by which browsers decide which CSS rules to apply.

    • ID selectors (#id) have higher specificity than Class selectors (.class), which in turn have higher specificity than Type selectors (element_name).
    • Rules with higher specificity override less specific ones. If specificity is equal, the last declared rule in the stylesheet takes precedence.
  • Basic CSS properties: color, display, width, height, border, margin, text-align.

  • Flexbox Layout (display: flex):

    • Making a container a flex container by setting display: flex.
    • Default Flexbox behavior: items (div children) are arranged in a row (flex-direction: row), do not wrap (flex-wrap: nowrap), and typically align to the start of the main axis and stretch along the cross axis. Margins, borders, and padding contribute to the item's total size within the layout.

• HTTP Request Methods:

  • GET: Used to request data from a specified resource. It's the default method when directly typing a URL in a browser or submitting an HTML form without a specified method.
  • POST: Used to send data to a server to create or update a resource. Commonly used for submitting HTML forms.

2. Python Web Framework (Flask)

• Flask Application Structure:

  • Importing necessary modules: Flask, request, render_template.
  • Initializing a Flask application: app = Flask(__name__).
  • Running the development server: app.run(debug=True).

• Routing:

  • Route Decorators: Using @app.route() to associate URL paths with Python functions.
  • Dynamic Routes: Defining routes with variable parts using <variable_name> (e.g., /user/<name>).
  • Type Converters: Specifying expected data types for dynamic route parameters (e.g., <int:value>). If a URL segment cannot be converted to the specified type, Flask typically returns a 404 Not Found error.
  • Route Matching Precedence: Flask generally prioritizes more specific routes. A static route (e.g., /user/admin) will be matched over a dynamic route (e.g., /user/<name>) if the URL exactly matches the static path.

• Request Handling:

  • Accessing Form Data (POST requests): request.form.get("input_name") to retrieve values from submitted forms. Values are always strings.
  • Accessing Query Parameters (GET requests): request.args.get("param_name", default_value) to retrieve values from the URL's query string (e.g., ?key=value). Values are always strings. A default value can be provided.
  • Checking HTTP Method: request.method allows conditional logic based on the incoming request method (e.g., if request.method == "POST":).

• Template Rendering:

  • Using render_template("filename.html") to serve HTML templates.
  • Passing Python variables/data structures to Jinja2 templates for dynamic content generation.

• Error Handling:

  • Python's try-except blocks are used for handling runtime exceptions that occur within the route function's logic (e.g., ZeroDivisionError). Note that route matching errors (like failed type conversion) are handled by Flask's routing layer, often resulting in a 404 Not Found.

3. Python Core Concepts

• Data Types and Structures:

  • Lists: Creation ([]), adding elements (list.append(element)), accessing elements by index (list[index]).
  • Strings: String conversion (str(value)), f-strings for formatting (f"..."), string repetition ("text" * integer).
  • Integers: Type conversion (int(value)).
  • Dictionaries: Storing key-value pairs, accessing values (dict["key"]).

• Control Flow:

  • for loops: Iterating over iterable objects (lists, ranges).
  • if/elif/else statements: Implementing conditional logic.
• Functions: Defining and calling Python functions, understanding return values.

• sys Module:

  • Command-line Arguments (sys.argv): sys.argv is a list containing the command-line arguments passed to a Python script. sys.argv[0] is the script name, and sys.argv[1:] is a list of all arguments after the script name. len(sys.argv) gives the total number of arguments.
• String Templating (string.Template): A built-in Python module for simple string substitutions using $placeholder or ${placeholder} syntax.
• Type Conversion/Coercion: The necessity of explicitly converting string inputs (from web requests) to appropriate numeric types (int(), float()) before performing mathematical operations, to prevent TypeError or unintended string operations (like repetition).

4. Jinja2 Templating Language

• Basic Syntax:

  • Variables: {{ variable_name }} (double curly braces).
  • Control structures (loops, conditionals, assignments): {% control_statement %} (curly brace-percentage sign).

• Control Flow:

  • for loops: {% for item in sequence %} and {% endfor %} for iterating over data.
  • if/elif/else statements: {% if condition %}, {% elif condition %}, {% else %}, {% endif %} for conditional rendering.

• Filters:

  • Applying filters: variable | filter_name.
  • Common filters: sum (calculates sum of list elements), length (calculates length of a list/string), sort (sorts a list).
  • Filter arguments: sort(reverse=True) for descending order.

• Assignments:

  • set statement: {% set variable = expression %} for creating variables within the template.

5. Mathematical and Networking Fundamentals

• Bandwidth and Concurrent Requests:

  • Understanding units of data transfer rates (bps, Kbps, Mbps, Gbps).
  • Unit Conversion: Ensure consistent units for calculations (e.g., $1 \text{ Gbps} = 1000 \text{ Mbps}$).
  • Calculation Principle: The maximum number of concurrent requests is determined by dividing the total available bandwidth by the bandwidth required per client.
  • Equation: $$ \text{Max Concurrent Requests} = \frac{\text{Total Bandwidth}}{\text{Bandwidth per Client}} $$

• Round Trip Time (RTT):

  • Propagation Delay: The time it takes for a signal to travel from one point to another.
  • Equation for Propagation Time: $$ t_{\text{prop}} = \frac{\text{Distance}}{\text{Speed}} $$
  • RTT Definition: The total time taken for a signal to travel from the sender to the receiver and back.
  • Equation for RTT: $$ \text{RTT} = 2 \times t_{\text{prop}} $$
  • Importance of unit consistency (meters for distance, meters/second for speed, seconds for time, converting seconds to milliseconds).

• Information Theory (Data Encoding):

  • Minimum Bits for Encoding: To uniquely encode $N$ distinct symbols, each with a fixed-length binary code, you need at least $k$ bits per symbol such that $2^k \ge N$.
  • Equation: This can be found using the ceiling of the base-2 logarithm: $$ k = \lceil \log_2 N \rceil $$ Where $N$ is the number of distinct symbols.