Book Details

  • 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

Structure of Connected Devices (my course)

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.

Please NOTE: While I hope the content is useful, please see the documentation and source code usage licenses on GitHub, as well as the Disclaimer for this site.

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.

Although not required or covered in the book / online content, you can incorporate hardware devices as the host systems for the CDA and / or the GDA. In fact, I’ve deployed my own CDA and GDA solutions 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) focuses on development environment setup and the initial edge tier applications (Constrained Device App and Gateway Device App).
  • Part II (Chapters 3 – 5) deals with data management and interoperability.
  • Part III (Chapters 6 – 10) addresses device-to-device communications using MQTT and CoAP.
  • Part IV (Chapters 11 – 12) introduces 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.

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, and 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 protocols – 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:

  1. Part I – Getting Started (Creating your Dev Environment) [Kanban board exercises]
  2. Part II – Connecting to the Physical World (Data Generation and Management) [Kanban board exercises]
  3. Part III – Connecting to Other Things (Protocols and Connectivity) [Kanban board exercises]
  4. Part IV – Connecting to the Cloud (Design and Use Cases) [Kanban board exercises]
  5. Part V – Class suggestions only (not currently part of book content)
    1. 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.
    2. 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:

  1. 25%: Lab Module Assignments
  2. 20%: Semester Project
  3. 5%: Semester Project Presentation
  4. 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.

  1. Book errata and clarifications
  2. Course and book exercises (GitHub Kanban Board)
  3. Source code and document repositories (GitHub)
  4. Additional content (videos, etc.) [forthcoming]
    • Links: Stay tuned for more content!

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.

%d bloggers like this: