Video summary

FEB BISDI UNPAD - Pemrograman Komputer 1 - #14 - 3 June 2026

Main summary

Key takeaways

Educational

Main ideas / concepts taught

1) Procedural vs Object-Oriented Programming (OOP) using a GUI example

  • The lecturer compares an earlier procedural version of a program to a redesigned OOP version.
  • Key difference highlighted:
    • Procedural style: handle UI components “flatly” and sequentially (write logic directly for button/radio/dropdown events).
    • OOP style: first define abstractions as objects/classes, then let the GUI interact with instances of those objects.

Example abstraction: gas station

  • The object inside the context is gasoline/petrol (or other fuels).
  • Fuel objects include data/behavior, such as:
    • price
    • how to calculate cost depending on purchase mode

2) How OOP modeling maps to a “gas station” purchase system

The lecturer outlines a conceptual OOP design:

  • Context: a gas station
  • Objects (classes): different fuels (e.g., petrol/diesel/pertamax), each with:
    • Attributes like price (conceptually)
    • Methods to calculate total cost based on purchase mode:
      • Per Rupiah
      • Per liter

GUI interaction (conceptual flow)

  • User selects fuel type from a dropdown/menu.
  • User selects purchasing method via radio buttons:
    • Per Rupiah
    • Per Liter
  • User enters quantity (e.g., liters).
  • When the calculate/purchase button is clicked:
    • The program uses the selected fuel object’s logic to compute totals.

Java-specific note (as described)

  • Use classes/derived classes (inheritance), such as:
    • a base Gasoline/Petrol class
    • derived classes like Diesel, Pertamax, etc., which reuse/calibrate calculation behavior

3) OOP is useful but not mandatory for everything

  • The lecturer emphasizes that:
    • not every project must be designed with OOP
    • implementation can vary
  • The goal is to understand the object-based paradigm
  • Analogy: small business bookkeeping can use simpler tools (e.g., Excel) and doesn’t require heavy systems.

4) Python libraries: why use them instead of re-writing everything

The lecturer introduces the idea of using pre-built libraries as a “toolbox,” especially in environments like Google Colab.

Commonly mentioned libraries and their roles

  • NumPy
    • Numerical computing and random number generation/statistics
    • Building datasets; computing averages/min/max, etc.
  • Pandas
    • Data analysis and converting inputs into a structured form
    • Converts data (TXT/CSV/JSON/etc., or nested structures) into a DataFrame
    • DataFrame benefits:
      • easier sorting
      • adding/removing/swapping columns
      • easier per-row/per-column operations and summary statistics
    • Lecturer warning:
      • if you don’t understand the library’s output type (e.g., you expected raw data but got a DataFrame), you may not know how to access it—so use Pandas methods.
  • Matplotlib
    • Visualization/plots (e.g., line/bar graphs) from Pandas/NumPy data
  • Turtle
    • Simple educational graphics/drawing with loops and geometry (teaching shapes)
    • Notes about installation/name conflicts (e.g., overwriting turtle.py locally)
  • Pygame
    • Building games (installation and different runtime behavior; may face limitations in Colab such as display/animation constraints)
  • OpenCV (cv2)
    • Computer vision tasks:
      • reading from camera/webcam streams
      • face/object detection demonstrations
      • mention of YOLO later as an AI object detection method (details improvised in subtitles)
  • Pillow (PIL)
    • Image processing (e.g., resizing and format/size conversion)
  • Requests
    • Calling web APIs / fetching data from internet endpoints
    • Example: scraping/collecting social media data via APIs (noted complexity like authentication/service accounts)
  • BeautifulSoup
    • Parsing HTML and extracting data from web pages
    • Emphasis: you must match HTML patterns correctly; otherwise issues like “no price data” can occur
  • Selenium
    • Scraping sites that require browser-like interaction (click/scroll/dynamic content)
    • Positioned as more advanced than BeautifulSoup because it controls a real browser
  • Streamlit
    • Building interactive dashboards/apps from Python
    • In Colab: mentions the need for a tunneling service (e.g., “grok”-style proxy) so the dashboard is externally accessible
    • Mentions app features such as tables/graphs and possible auto-refresh
  • Grok / tunneling proxy (as described)
    • Exposes a Streamlit app running in Colab to the public internet
    • Lecturer warns about token/API security risks and time limits
  • TensorFlow
    • Machine learning tasks, demonstrated conceptually with a skin disease classification prototype
    • Key point: model quality depends heavily on dataset size/quality
      • incomplete/small dataset → lower confidence and potential misclassification
  • Additional mentions
    • General mention of ML/detection components (CNN/RCNN/random forest)
    • No single mandatory approach
    • Mentions course logistics at the end (WF materials / assignment / exam)

Methodology / structured instructions (as presented)

A) Conceptual OOP conversion checklist (gas station example)

  1. Identify the context
    • Example context: a gas station
  2. Identify the primary objects/classes
    • Example objects: Gasoline/Petrol, Diesel, Pertamax, etc.
  3. Define object attributes
    • Example attribute: fuel price
  4. Define behaviors/methods
    • Example behavior: calculate total cost based on purchase mode:
      • if “per Rupiah”: compute using the rupiah input and price-per-liter concept
      • if “per liter”: compute total = liters × price
  5. Connect GUI events to object methods
    • dropdown/menu selection → create/select the corresponding fuel object instance
    • radio buttons selection → choose the pricing mode
    • input field → enter quantity (e.g., liters)
    • button click → call the fuel object’s calculation method and display the result on a label

B) Library usage workflow (general “don’t reinvent, use tools” approach)

  1. Decide the task domain
    • e.g., numerical simulation, data cleaning, plotting, scraping, vision, ML, dashboarding
  2. Use the appropriate library
    • NumPy → math + random numbers
    • Pandas → tabular data → DataFrame transformations
    • Matplotlib → plots
    • OpenCV/Pillow → images + computer vision
    • Requests/BeautifulSoup/Selenium → web data collection
    • Streamlit → dashboard/UI from Python
    • TensorFlow → machine learning training/inference
  3. Convert inputs into the library’s expected data types
    • Example: convert raw data into a Pandas DataFrame
  4. Perform operations using library functions
    • Sorting/column operations in Pandas; plotting in Matplotlib; detection in OpenCV
  5. Visualize or export results
    • Example: dashboard graphs using Streamlit

C) Web scraping decision logic (described)

  • If a page can be fetched and parsed from HTML patterns:
    • Prefer Requests + BeautifulSoup
  • If the site is dynamic and requires interaction (click/scroll, JS-rendered content):
    • Prefer Selenium

Speakers / sources featured (as identifiable from subtitles)

  1. Unspecified lecturer / “ma’am” (main speaker; the video appears to be a class session by the instructor).
  2. Course name/source (from title): FEB BISDI UNPAD (institution mentioned in the video title; not a person).
  3. No other clearly named speakers are consistently identified in the provided subtitles.

Original video