- Book Title: Programming the Internet of Things. An Introduction to Building Integrated, Device-to-Cloud IoT Solutions
- Author: Andy King
- URL: Programming the Internet of Things
- Formats: Paperback, Kindle, eBook
- ISBN: 978-1492081418
- Publisher: O’Reilly Media, Inc.
- Release Date: June 2021
- Pages: ~417
- Topics: Programming, Internet of Things, Java, Python, Design, Protocols
Summary for Instructors
Programming the Internet of Things was written primarily to support the course I teach at Northeastern University called ‘Connected Devices’. It essentially represents the lab-portion of the course, and focuses on the design and implementation (in Java and Python) of a basic IoT ecosystem – from the edge (where devices collect data and trigger actions) to the cloud (where historical data is stored and more complex decisions can be made). Each chapter’s exercises build upon those implemented in previous chapters, so it’s important for students to go step-by-step, chapter-by-chapter, to develop their system.
Programming the Internet of Things and my associated course ‘Connected Devices’ does not require hardware for completion of the required exercises. The edge tier applications – the Constrained Device App (CDA) and Gateway Device App (GDA) – can be developed and executed on a modern computer running Ubuntu or Raspbian. If you’d like, you can incorporate hardware devices as the host systems for the CDA and / or the GDA. I’ve executed both applications on a variety of Raspberry Pi SBC’s running the Raspbian OS. You can also make use of the additional exercises introduced in Part II of the GitHub Kanban Board that require hardware for implementation and testing.
- Part I (Chapters 1 – 2) focus on development environment setup and the initial edge tier applications (Constrained Device App and Gateway Device App).
- Part II (Chapters 3 – 5) deal with data management and interoperability.
- Part III (Chapters 6 – 10) address device-to-device communications using MQTT and CoAP.
- Part IV (Chapters 11 – 12) introduce cloud integration and discuss some notional use cases, enabling your students to use their IoT environment to process edge-to-cloud telemetry while incorporating simple decision making characteristics into their system.
By the end of the course, students can use what they’ve learned as the basis to build out more advanced solutions as extensions to their applications and cloud service functionality. All exercises are technically tracked as ‘issues’ within their own repository.
- Read more about this repository, the tagging approach used, usage license, etc. by clicking this link.
What Students Will Learn
In addition to learning HOW to build a basic, end-to-end IoT solution from device to cloud, students will also learn about:
- IoT Value Proposition: Learn about why outcomes matter within an IoT ecosystem
- IoT System Design: Learn about the key components of an IoT ecosystem and what they do
- Measure, Model and Manage: Learn about the core features of an IoT ecosystem and how they map
- IoT-specific DevOps: Learn about dev env setup, source code management, Git-based branching
- Unit and Integration Testing: Learn some basic about testing approaches – unit and integration
- Data Management: Learn why data-centric thinking is important, and how to create interoperable data
- Communications: Learn about the MQTT and CoAP prototocols – how they work, are used, and why
- Cloud Integration: Learn about various IoT-enabled cloud service provider integration approaches
- IoT Use Cases: Learn how to apply systems-thinking to building different IoT ecosystems
- IoT Agile Governance: Learn about managing complexity and how to provide guidance for IoT projects
Class Structure Considerations
Programming the Internet of Things is segmented into four parts and twelve chapters. It’s designed such that each chapter from the book can be used as the basis to teach a single class. For semesters that run longer than 12 weeks (e.g., more than 12 classes total), let’s consider an example with 15 teaching weeks:
- Classes 1 – 12: Each week follows each chapter in the book (e.g., Class No. 1 = Chapter 1, etc.)
- Class 13: Can be dedicated to a deep-dive working session related to the semester project, guest lectures, a deep dive into a particular cloud service provider’s IoT stack, etc.
- Class 14: Can extend Week 13 with additional cloud service provider exercises, advanced IoT use case explorations, more guest lectures, a discussion of advanced device management considerations, etc.
- Class 15: Can be used as a final exam, for end of semester project presentations (which is what I do), even more guest lectures, a round table discussion, etc.
Sample Syllabus (Overview)
The following represents a simplified sample syllabus for the Connected Devices course and follows the exercises discussed in Programming the Internet of Things using the associated GitHub Kanban Board:
- Part I – Getting Started (Creating your Dev Environment) [Kanban board exercises]
- Part II – Connecting to the Physical World (Data Generation and Management) [Kanban board exercises]
- Part III – Connecting to Other Things (Protocols and Connectivity) [Kanban board exercises]
- Class No. 6 (Chapter 6): MQTT Integration – Overview and Python Client [Kanban board exercises]
- Class No. 7 (Chapter 7): MQTT Integration – Java Client [Kanban board exercises]
- Class No. 8 (Chapter 8): CoAP Server Implementation [Kanban board exercises]
- Class No. 9 (Chapter 9): CoAP Client Integration [Kanban board exercises]
- Class No. 10 (Chapter 10): Edge Integration [Kanban board exercises]
- Part IV – Connecting to the Cloud (Design and Use Cases) [Kanban board exercises]
- Part V – Class suggestions only (not currently part of book content)
- Class No.’s 13 and 14: Semester project working session, guest lecture(s), cloud service provider IoT stack deep dive, advanced IoT data analysis, advanced device management, etc.
- Class No. 15: Final exam or Semester Project presentations
Grading Considerations (Example)
Evaluation methods and specific criteria will vary depending on your learning objectives for the course. For weighting, one approach I’ve found helpful is to split the overall grade into two parts: 50% for lab module and project work, and 50% for quizzes, with the following in mind:
- 25%: Lab Module Assignments
- 20%: Semester Project
- 5%: Semester Project Presentation
- 50%: Quizzes (one per Part with 4 total)
The rubrics I created for my own course to evaluate lab and project work are comprised of various criteria that consider design, code documentation and formatting, functionality and accuracy, and of course testing. Quiz questions are drawn from a larger question bank mapped to each Part and include many that are associated with the additional lecture content I deliver during each class.
If you’re interested in learning more, feel free to fill out the information request form at the bottom of this page.
Course Content and Links
- Book errata and clarifications
- Course and book exercises (GitHub Kanban Board)
- Source code and document repositories (GitHub)
Review the Book Online
For a limited time, if you’re new to the O’Reilly Media platform, you can access Programming the Internet of Things online free for 30-days using the link below:
Where to Buy the Book
How to Get in Touch
If you’re teaching a course based on Programming the Internet of Things, a limited-time 40% discount may be available for eBook versions of the book prior to the start of your course. Please provide your information below, including the expected start date of your course, and I’ll respond with details on how to obtain discounted eBook copies.
If you’re interested in additional course content, or would like to discuss potential commercial usage for some of the referenced or additional content, please click ‘Yes’ in the appropriate fields below.