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
Delivered a device-to-cloud system pairing a Flutter cross-platform app with IoT sensors over MQTT and CoAP, a Raspberry Pi edge node that filters and aggregates readings, and offline-first local storage that synchronizes with conflict resolution over secured channels.
Expected outcomes
- Explain the architecture of mobile, IoT, and edge computing systems
- Build cross-platform mobile applications with a modern framework
- Analyze mobile UI, lifecycle, and resource-constrained design
- Apply IoT messaging protocols such as MQTT and CoAP
- Integrate sensors and actuators with constrained devices
- Design edge computing architectures and reason about latency trade-offs
- Implement offline-first applications with local storage
- Apply data synchronization and conflict resolution strategies
- Evaluate security and privacy concerns across device boundaries
- Assess trade-offs between cloud, edge, and device computation
Key topics
- Mobile app development
- IoT protocols & sensors
- Edge computing
- Offline-first & sync
Theoretical foundations
The concepts and results this course rests on.
- Ubiquitous and pervasive computing models
- Publish-subscribe messaging and quality-of-service semantics
- Constrained-device RESTful communication and protocol trade-offs
- Edge and fog computing latency and bandwidth economics
- Local-first design and eventual consistency
- Conflict-free replicated data types and merge theory
- Synchronization protocols and conflict detection
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
Mobile
Wk 1
Mobile and Edge Landscape
LectureSurvey mobile, IoT, and edge architectures and the constraints of distributed devices.
PracticeSet up the toolchain and build a first cross-platform mobile app skeleton.
ProjectProject mobile app skeleton runs on a device or emulator.
Wk 2
Cross-Platform UI and Lifecycle
LectureExamine widget composition, the app lifecycle, and resource-aware UI design.
PracticeBuild the core project screens and navigation with a cross-platform framework.
ProjectProject app has core navigable screens.
Wk 3
State, Storage, and Device APIs
LectureDiscuss local persistence, permissions, and access to device sensors and capabilities.
PracticeAdd local storage and device sensor access to the project app.
ProjectProject app stores data locally and reads a device sensor.
IoT
Wk 4
IoT Architecture and Sensors
LectureCover IoT system layers, constrained devices, and sensing and actuation foundations.
PracticeConnect a simulated or physical sensor and publish readings from the project.
ProjectProject ingests readings from an IoT sensor source.
Wk 5
Specification MilestonePresentation
LectureReview IoT messaging protocols and how device constraints shape architecture.
PracticeStudent teams present their project specification: device topology, protocols, and offline and sync goals.
ProjectApproved specification with device and protocol plan is delivered.
Wk 6
MQTT and Publish-Subscribe
LectureExamine the publish-subscribe model, MQTT topics, and quality-of-service levels.
PracticeWire the project devices and app through an MQTT broker.
ProjectProject communicates over MQTT publish-subscribe messaging.
Wk 7
CoAP and Constrained Protocols
LectureDiscuss CoAP, RESTful constrained communication, and protocol trade-offs for low-power devices.
PracticeAdd a CoAP interaction and compare it with MQTT in the project.
ProjectProject supports a constrained-protocol communication path.
Edge
Wk 8
Interim Demo MilestonePresentation
LectureIntroduce edge computing models and the division of work across device, edge, and cloud.
PracticeStudent teams present an interim demo of the mobile and IoT system end to end.
ProjectConnected mobile and IoT system is demonstrated.
Wk 9
Edge Computing
LectureAnalyze edge architectures, latency, bandwidth, and the economics of local computation.
PracticeAdd an edge processing component that filters or aggregates device data.
ProjectProject processes data at the edge before reaching the cloud.
Wk 10
Offline-First Design
LectureExamine local-first principles, offline state, and the theory of eventual consistency.
PracticeMake the project app fully functional offline with a local data store.
ProjectProject app works offline and queues changes locally.
Sync
Wk 11
Data Synchronization
LectureCover synchronization protocols, conflict detection, and reconciliation strategies.
PracticeImplement sync between offline clients and the backend in the project.
ProjectProject synchronizes local and remote data reliably.
Wk 12
Conflict Resolution and Security
LectureDiscuss conflict-free replicated data types, merge strategies, and device security and privacy.
PracticeAdd conflict resolution and secure the project communication channels.
ProjectProject resolves sync conflicts over secured channels.
Capstone
Wk 13
Final Demo and DefensePresentation
LectureSynthesize mobile, IoT, edge, and synchronization principles into a coherent design.
PracticeStudent teams present the final demo with an oral defense of architecture, protocol, and sync decisions.
ProjectFinal mobile and IoT edge system is delivered with documentation and defense.
AI tools in this course.
Students use AI assistants to scaffold Flutter or React Native screens, refactor widget trees and lifecycle code, and generate device-storage and sensor integration. They prompt tools to write MQTT and CoAP client code, simulate sensor streams, and produce sync and conflict-resolution logic, while connecting agents to broker and device MCP endpoints to inspect message flows. AI helps reason about offline-first state, eventual consistency, and CRDT merge behavior, and to generate tests for intermittent connectivity. Because generated sync code can corrupt data under partition or conflict, students test every suggestion against realistic offline and edge scenarios.
Student project
Teams build one connected system spanning a cross-platform mobile app, IoT sensors, and an edge processing component. The system communicates over MQTT and CoAP, processes data at the edge, and works offline with reliable synchronization and conflict resolution. 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% |
Tools & platforms
- Flutter: build cross-platform mobile apps
- Dart: program Flutter applications
- React Native: build native mobile apps from JavaScript
- SQLite: store data locally on devices
- Eclipse Mosquitto: run an MQTT broker
- MQTT.js or paho-mqtt: publish and subscribe over MQTT
- libcoap or aiocoap: communicate over CoAP
- Node-RED: prototype IoT and edge data flows
- Raspberry Pi: host an edge computing node
- PowerSync or CouchDB: synchronize offline data
- Firebase: provide backend messaging and storage
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 to read for graduate-level depth.
- 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.
- DocumentationFlutter 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 |