About this course
Develop software for mobile, IoT, and edge devices where connectivity, power, and compute are constrained and data is processed close to where it is generated.
Course format. Thirteen weeks, four contact hours each: a two-hour lecture (concepts and theory) and a two-hour practice session. The course is project-based; teams carry one running project end to end and present it three times, in weeks 5, 8, and 13.
What you will build
Teams deliver a connected system spanning an Android mobile app, one or more IoT sensors wired to a Raspberry Pi edge node, and an edge processing component that filters and aggregates sensor data locally. The system communicates device-to-edge over MQTT and edge-to-app over CoAP, operates fully offline, and synchronizes state reliably with automatic conflict resolution when connectivity resumes.
Expected outcomes
- Design and build Android applications using MVVM architecture, ViewModel and Repository patterns, Room for local persistence, and WorkManager for battery-aware background tasks within doze-mode constraints.
- Compose adaptive mobile UIs with Jetpack Compose, applying declarative state hoisting, material design components, and density-independent layouts for varying device form factors.
- Apply structured concurrency with Kotlin Coroutines, managing dispatcher pools for IO, CPU, and UI threads and integrating Retrofit for reactive REST API communication.
- Implement MQTT publish-subscribe messaging and CoAP constrained REST endpoints, configuring QoS levels, broker topology, persistent sessions, confirmable messages, and the Observe option for device-to-edge communication.
- Build and program edge nodes using Raspberry Pi and ESP32, orchestrate sensor-actuator pipelines with Node-RED, and integrate device state bidirectionally with AWS IoT Core using secure MQTT-over-TLS.
- Apply compact binary serialization (Protocol Buffers, CBOR, MessagePack), X.509 mutual TLS fleet provisioning, and offline-first conflict resolution to constrained IoT channels.
Key topics
- Android MVVM & Jetpack
- IoT protocols & sensors
- Edge computing
- Offline-first & sync
Theoretical foundations
The concepts and results this course rests on.
- MVVM presentation architecture: ViewModel lifecycle separation, reactive state streams (StateFlow/LiveData), repository abstraction layer, and back-stack navigation management
- Declarative reactive UI composition: state hoisting, recomposition model, adaptive layouts, and density-independent sizing for device form factors
- Structured cooperative concurrency: suspend/resume execution model, coroutine dispatcher pools (IO, CPU, Main), and backpressure-aware reactive streams
- MQTT publish-subscribe semantics: broker topology, QoS levels 0/1/2, persistent sessions, retained messages, and Last Will and Testament
- CoAP constrained REST: Observe option, block-wise transfer, confirmable messages, DTLS security, and OSCORE
- IoT cloud platform integration: device registration and provisioning, bidirectional shadow/twin state synchronization, rule-based event routing, and MQTT-over-TLS
- Edge computing and pre-aggregation: fog node processing, delta compression, offline buffering, and sync conflict resolution
- IoT device authentication: X.509 mutual TLS, fleet provisioning, certificate rotation, and zero-touch onboarding
- Flow-based IoT programming: visual pipeline composition for sensor-actuator orchestration, digital twin state modeling, and dashboard-driven device monitoring
- Constrained data serialization: compact binary formats (Protocol Buffers, CBOR, MessagePack) and schema evolution for bandwidth-limited channels
Prerequisites
This is a Year-3 course. It assumes the mandatory CS core: data structures and algorithms, operating systems, computer networks, databases, software engineering, and the core mathematics (linear algebra, probability and statistics, calculus, discrete mathematics). It additionally requires the specific prior courses listed below.
Course-specific prerequisites:
- Programming fundamentals
- Operating systems and computer networks
Weekly schedule 13 weeks · lecture + practice
Android
Wk 1
Android & Kotlin Foundations
LectureSurvey mobile, IoT, and edge architectures; introduce MVVM architecture, ViewModel lifecycle management, and the Repository pattern for data abstraction in Android.
PracticeSet up the Android development environment and write a first Kotlin app with a ViewModel and Repository structure targeting the project domain.
ProjectAndroid project skeleton with MVVM structure runs on emulator in Kotlin.
Wk 2
Declarative UI with Jetpack Compose
LectureExamine declarative reactive component composition, state hoisting, material design tokens, and adaptive layouts for varying device form factors and density-independent sizing.
PracticeBuild the project's core screens and navigation using Jetpack Compose with state hoisting and a BottomNavigation scaffold.
ProjectApp has navigable Compose screens wired to ViewModel state.
Wk 3
Local Persistence and Data Abstraction
LectureCover the repository pattern for data abstraction, Room entity-DAO-database model, and the DataStore preference layer; contrast structured and key-value local storage.
PracticeIntegrate Room (SQLite) into the project: define entities and DAOs, expose flows to ViewModel, and persist sensor readings locally.
ProjectApp stores sensor readings in a Room database with DAO-backed queries.
Wk 4
Structured Concurrency and Background Work
LectureExamine structured concurrency: suspend/resume execution model, dispatcher pools for IO, CPU, and UI threads, backpressure-aware reactive streams, and battery and doze-mode background constraints.
PracticeAdd WorkManager tasks to the project for battery-aware periodic background sync, chaining workers and observing status in the UI.
ProjectApp schedules background data sync with WorkManager within doze-mode constraints.
IoT Protocols
Wk 5
Specification MilestonePresentation
LectureSurvey IoT system layers, constrained hardware, and the protocol landscape — MQTT, CoAP, and binary serialization — and how device constraints shape architecture choices.
PracticeTeams present their project specification: Android MVVM design, device topology, protocol choices, offline strategy, and sync goals.
ProjectApproved specification with Android architecture, IoT device topology, and protocol plan is delivered.
Wk 6
MQTT Publish-Subscribe
LectureExamine MQTT broker topology, QoS levels 0/1/2, persistent sessions, retained messages, and Last Will and Testament; discuss broker configuration for reliable delivery at scale.
PracticeDeploy Eclipse Mosquitto as the project broker and connect IoT nodes and the Android app using paho-mqtt clients at QoS 1 with persistent sessions.
ProjectIoT sensors publish readings to the project's Mosquitto broker; Android app subscribes and displays live data.
Wk 7
CoAP Constrained REST
LectureDiscuss the CoAP Observe option, block-wise transfer, confirmable messages, DTLS security, and OSCORE; compare CoAP and MQTT for device-to-app channels under connectivity constraints.
PracticeBuild a CoAP server on the Raspberry Pi edge node and a CoAP client in the Android app using aiocoap; implement the Observe option for live sensor streaming.
ProjectEdge-to-app communication path uses CoAP with Observe for low-latency sensor updates.
Edge & Cloud
Wk 8
Interim Demo MilestonePresentation
LectureIntroduce IoT cloud platform integration: device registration and provisioning, bidirectional shadow/twin state synchronization, rule-based event routing, and secure cloud connectivity over MQTT-over-TLS.
PracticeTeams demonstrate the end-to-end Android and IoT system over MQTT and CoAP; peers review protocol and architecture choices.
ProjectWorking Android app connected to IoT sensors over MQTT and CoAP is demonstrated live.
Wk 9
Edge Hardware and Pre-aggregation
LectureAnalyze fog node processing, delta compression, offline buffering, and sync conflict resolution; examine the economics of moving computation from cloud to edge.
PracticeProvision the Raspberry Pi edge node and wire ESP32 sensors over MQTT; implement a pre-aggregation filter on the edge node that reduces upstream payload volume.
ProjectRaspberry Pi edge node collects ESP32 readings, filters outliers, and forwards aggregated data.
Wk 10
Flow-based IoT Programming and Digital Twins
LectureExamine visual pipeline composition for IoT data flows, digital twin state modeling, and dashboard-driven device monitoring; survey Node-RED's node palette and deployment model.
PracticeAuthor Node-RED flows on the Raspberry Pi to orchestrate sensor-actuator pipelines, model device state as a digital twin, and expose a monitoring dashboard.
ProjectNode-RED flow manages the sensor data pipeline and displays a live device dashboard.
Wk 11
Cloud Integration and Device Security
LectureCover AWS IoT device registration, bidirectional shadow state synchronization, rule-based event routing, X.509 mutual TLS, fleet provisioning templates, certificate rotation, and zero-touch onboarding.
PracticeConnect the Raspberry Pi edge node to AWS IoT Core using the AWS IoT Core SDK; provision X.509 certificates and verify authenticated MQTT-over-TLS message delivery.
ProjectEdge node reports aggregated readings to AWS IoT Core with X.509 mutual TLS authentication.
Wk 12
Data Serialization for Constrained Channels
LectureExamine compact binary formats — Protocol Buffers, CBOR, and MessagePack — their bandwidth trade-offs against JSON, schema evolution on constrained channels, and alignment with offline buffering and conflict resolution.
PracticeReplace JSON payloads on the project's MQTT device-to-edge channel with Protocol Buffers; measure bandwidth reduction and verify backward compatibility on schema change.
ProjectSensor payloads on the device-to-edge channel use binary serialization; offline sync operates without connectivity.
Capstone
Wk 13
Final Demo and DefensePresentation
LectureSynthesize Android MVVM, IoT protocols, edge computing, cloud integration, security, and serialization principles into a coherent system design evaluation.
PracticeTeams present the final connected system with an oral defense of architecture, protocol, security, and conflict-resolution decisions.
ProjectFinal Android + IoT edge system delivered with documentation, conflict-resolution evidence, and oral defense.
AI tools in this course.
Students use AI assistants to scaffold Kotlin and Jetpack Compose screens, refactor ViewModel and Repository code, and generate Room entity mappings and WorkManager chains. They prompt tools to write MQTT and CoAP client code, simulate sensor streams, and produce Node-RED flow configurations, while connecting agents to broker and device MCP endpoints to inspect message flows. AI helps reason about offline-first state, protocol QoS trade-offs, and binary serialization schemas. Because generated sync code can corrupt data under partition or conflict, students test every suggestion against realistic offline and connectivity-resumption scenarios.
Student project
Teams build one connected system spanning an Android mobile app, one or more IoT sensors wired to a Raspberry Pi edge node, and an edge processing component that filters and aggregates sensor data locally. The system communicates device-to-edge over MQTT and edge-to-app over CoAP, operates fully offline, and synchronizes state reliably with automatic conflict resolution when connectivity resumes. Each increment extends the device-to-cloud pipeline.
Requirements
- Build a working system, not a set of disconnected exercises.
- Be original: a new system that solves a real problem, not a re-implementation of a tutorial or course demo.
- Show real depth: real data, real users or realistic load, and engineering trade-offs that are measured rather than assumed.
- Carry one running project from specification to a deployed, defensible result across the whole term.
- Work in a team of three or four and defend the design at each of the three presentations (weeks 5, 8, and 13).
Example projects
Smart home dashboardEnvironmental monitoring networkFitness and wearables trackerAsset and fleet trackingAgricultural sensing systemConnected parking finderIndustrial machine monitorField data collection app
Assessment & grading
Grading is project-based, with no written exam. Teams of three or four present one running project three times.
| Component | What it covers | Weight |
|---|---|---|
| Project · Specification | Presentation 1 (week 5): problem, objectives, and architecture | 20% |
| Project · Interim | Presentation 2 (week 8): the working system demonstrated live | 30% |
| Project · Final | Presentation 3 (week 13): end-to-end demo with oral defense | 50% |
Career roles
Industry roles this course prepares students to enter.
Android Engineer
Builds Android applications in Kotlin with Jetpack Compose, structures projects around ViewModel and Repository patterns, implements local persistence with Room and DataStore, handles background work within battery and doze-mode constraints using WorkManager, integrates REST APIs with Retrofit and Kotlin Coroutines, and tests with Espresso and unit tests on the JVM.
IoT Platform Engineer
Designs and deploys device-to-cloud pipelines using MQTT brokers and CoAP endpoints, authors Node-RED flows for sensor-actuator orchestration, provisions Raspberry Pi edge nodes, defines QoS policies and broker topology for reliable delivery at scale, and implements secure device authentication with certificate provisioning.
Tools & platforms
- Kotlin: write Android applications with concise, null-safe JVM code
- Jetpack Compose: build declarative Android UIs with reactive state and material design
- Room (SQLite): persist structured data locally with DAO-backed entity mapping
- WorkManager: schedule battery-aware background tasks under doze-mode constraints
- Eclipse Mosquitto: deploy and configure a high-throughput MQTT broker
- paho-mqtt: publish and subscribe over MQTT from Python and Android clients
- aiocoap: build async CoAP servers and clients with Observe and DTLS
- Node-RED: compose visual IoT data flows and digital twin dashboards
- AWS IoT Core SDK: register devices, synchronize shadow state, and route events in AWS IoT Core
- Raspberry Pi / ESP32: host edge compute nodes and wire physical IoT sensors
Free online courses
Existing free, video-based courses this course can build on, for self-study or as a teaching basis.
In Hebrew · בעברית
Primary literature
Seminal works for advanced study.
- PaperThe Computer for the 21st Century
- PaperThe Case for VM-Based Cloudlets in Mobile Computing
- PaperFog Computing and Its Role in the Internet of Things
- PaperConflict-free Replicated Data Types
- PaperLocal-first Software: You Own Your Data, in Spite of the Cloud
- PaperRFC 7252: The Constrained Application Protocol (CoAP)
References
Books and resources link to an online or publisher page.
- DocumentationAndroid Developer Documentation
- TextbookDesigning the Internet of Things
- DocumentationMQTT Specification (OASIS Standard)
- DocumentationRFC 7252: The Constrained Application Protocol (CoAP)
- PaperEdge Computing: Vision and Challenges
- PaperLocal-first software: You own your data, in spite of the cloud
- PaperLocal-first software (ACM Onward! 2019 proceedings)
Role in each concentration
| Concentration | Role |
|---|---|
| Intelligent Software Systems | Core · Semester 2 |
| Networking & Cyber Security | Elective |
| AI & Robotics | Elective |
| AI and Quantum Computing for Finance | Elective |
| Immersive Systems & Game Development | Core · Semester 1 |
| Defense Technologies & Autonomous Systems | Core · Semester 2 |