2021-05-30 Saturday: Book Review - Creative DIY Microcontroller Projects with TinyGo and WebAssembly

 

Creative DIY Microcontroller Projects with TinyGo and WebAssembly

A practical guide to building embedded applications for low-powered devices, IoT, and home automation

https://www.amazon.com/Creative-Microcontroller-Projects-TinyGo-WebAssembly/dp/1800560206/

Published: May 14, 2021, 322 pages

By Tobias Theel, Lead Software Engineer with ClariLab

Caveat: Teny Thomas (Marketing Coordinator at PacktPublishing) graciously provided me with an eBook copy to review.

My Amazon Review Headline: Crisp, Concise, Well-Written - Focused on Building Practical Hands-on Skill and Knowledge

Things I Liked About This Book:

• There is no fluff in this book – the writing is crisp, clear, concise, and packed with interesting hands-on exercises. For a technologist who wishes to begin their exploration of micro-controller programming - it is highly entertaining - and informative. Highly recommended.
  
• This book was a fun read. Although it focuses on hardware aspects that are outside of my normal day-to-day professional work – it opened new doors for me to new insights and knowledge that expands my breadth of awareness – which I can integrate and use to elevate my understanding of many other practical problems in both my professional and personal domains of interest.
• The accompanying github and Code In Action YouTube videos.
• The book is focused on immediately developing knowledge and skills.
• The project/coding examples are interesting – and extensible to other types of projects.
• The example of writing a driver for a servomotor.
• Controlling devices.
• Writing a library for a sensor, and reading data from a sensor.
• The environment/tooling setup instructions in the first chapter covered several different scenarios.
• The discussions of the differences/benefits between different Arduino device specs.
• Understanding the purpose and use/fit of the SPI and I2C interfaces.
• The building of the reader’s knowledge to tackle a practical and interesting Internet of Things (IoT) type project – that also incorporates Wi-Fi and an MQTT broker to demonstrate pub/sub event handling.
• The writer gently takes the reader by the hand – and guides them step-by-step. Even a hobbyist/neophyte programmer should be able to enjoy working through the well-written instructions for the projects.
• The inclusion of the Questions section at the end of each chapter – providing further stimulus for the reader to develop further confidence in the knowledge they have just gained.
• The author has managed to maintain a keen balance of information imparted, pace of interesting hands-on exercises – without becoming mired in minutiae. Yet, there are subtle but important points that the author calls out – so that the neophyte is well advised to consider additional concerns that are beyond the scope of the book (e.g., security, encrypted communications, authentication).
• I am keenly interested in practical applications of both Go and Wasm. Learning more about TinyGo was also of interest. The book is written for Go 1.15 and newer releases.
• I have a number of personal automation projects I would like to develop (many related to my 1963 35 ft. Pearson Alberg sailboat)  – but my knowledge of microcontrollers is very limited. This book provides many practical examples that I feel will give me the practical hands-on foundations from which to explore further on my own.

 

Chapters:

1 – Getting Started with TinyGo

2 – Building a Traffic Lights Control System

3 – Building a Safety Lock Using a Keypad

4 – Building a Plant Watering System

5 – Building a Touchless Handwash Timer

6 – Building Displays for Communication using I2C and SPI Interfaces

7 – Displaying Weather Alerts on the TinyGo Wasm Dashboard

8 – Automating and Monitoring Your Home Through the TinyGo Wasm Dashboard

 

 

Additional Notes

Source code for the book’s project:

• https://github.com/PacktPublishing/Creative-DIY-Microcontroller-Projects-with-TinyGo-and-WebAssembly

YouTube: Code in Action

• https://www.youtube.com/playlist?list=PLeLcvrwLe186FvJDhkARfbIB_JjMptiFh

TinyGo

• https://tinygo.org/
• https://play.tinygo.org/
• https://github.com/tinygo-org/tinygo
• https://github.com/tinygo-org/drivers
• https://github.com/tinygo-org/tinygo/releases
• https://tinygo.org/docs/
• https://tinygo.org/docs/reference/

Errata reported to Packt:

• Page-5, this link is not found: 
• https://tinygo.org/lang-support/stdlib/

• should be: 
• https://tinygo.org/docs/reference/lang-support/stdlib/

2021-05-28 Friday - Dean Wampler's Scala, 3rd Edition published

 

https://deanwampler.github.io/books/programmingscala.html

https://medium.com/scala-3

https://www.amazon.com/Programming-Scala-Scalability-Functional-Objects/dp/1492077895/  

"Get up to speed on Scala--the JVM, JavaScript, and natively compiled language that offers all the benefits of functional programming, a modern object model, and an advanced type system. Packed with code examples, this comprehensive book shows you how to be productive with the language and ecosystem right away. You'll learn why Scala is ideal for building today's highly scalable, data-centric applications, while maximizing developer productivity."

"While Java remains popular and Kotlin has become popular, Scala hasn't been sitting still. This third edition covers the new features in Scala 3.0 with updates throughout the book. Programming Scala is ideal for beginning to advanced developers who want a complete understanding of Scala's design philosophy and features with a thoroughly practical focus."

https://en.wikipedia.org/wiki/Scala_(programming_language)

https://www.scala-lang.org/

• https://docs.scala-lang.org/scala3/new-in-scala3.html 
• https://docs.scala-lang.org/scala3/
• https://dotty.epfl.ch/docs/ 
  

2021-05-27 Thursday - Working Definitions - Epic-Feature-Story-Task

Image by Wokandapix from Pixabay

There is much variation in the definition of agile terminology - particularly when it comes to establishing consensus on seemingly simple terms, such as Epic, Feature, Story, Task.

Lets examine some of the sources of various definitions.

 Wikipedia

•  https://en.wikipedia.org/wiki/User_story
• "User stories are written by or for users or customers to influence the functionality of the system being developed."
• Epic: "Large stories or multiple user stories that are very closely related are summarized as epics. A common explanation of epics is also: a user story that is too big for a sprint." 
• Initiative: "Multiple epics or stories grouped together hierarchically, mostly known from Jira" 
• Theme: "Multiple epics or stories grouped together by a common theme or semantic relationship."

ScaledAgileFramework.com (SAFe)

• https://www.scaledagileframework.com/epic/
• Multiple Epic types are mentioned (Portfolio, Program, Large Solution)
• "Epics are not projects"
• "Implemented by...Value Streams and ARTs"
• "No definitive start and end date; scope is variable"
• "Progress is measured as outcomes against the benefit hypothesis"
• "Analysis of an epic includes the definition of a Minimum Viable Product (MVP) for the epic. In the context of SAFe, an MVP is an early and minimal version of a new product or business Solution that is used to prove or disprove the epic hypothesis."
  
• https://www.scaledagileframework.com/features-and-capabilities/
• "A Feature is a service that fulfills a stakeholder need. Each feature includes a benefit hypothesis and acceptance criteria, and is sized or split as necessary to be delivered by a single Agile Release Train (ART) in a Program Increment (PI)"
  
• https://www.scaledagileframework.com/story/
  

 

AgileAlliance.org

• https://www.agilealliance.org/glossary/epic/
• "An epic is a large user story that cannot be delivered as defined within a single iteration or is large enough that it can be split into smaller user stories." 
• https://www.agilealliance.org/epic-confusion/
•  "As I started writing that entry I thought crafting a definition of epic should be really straight forward. Then I reflected on the various conversations I’ve had with teams over the years, and realized writing a definition for epic isn’t nearly as simple as it should be."
• "`Epic` has taken on a variety of different meanings over the course of the last 16 years."

 

Atlassian.com

• https://www.atlassian.com/agile/project-management/epics-stories-themes
  
• "An epic is a large body of work that can be broken down into a number of smaller stories. For example, performance-related work in a release. An epic can span more than one project, if multiple projects are included in the board to which the epic belongs."
• https://community.atlassian.com/t5/Jira-Core-Server-questions/epic-vs-story-vs-task/qaq-p/204224 (2018)
  
• "Epic - A general use case that is a collection of features (user stories). (Use Fibonacci numbers to estimate.)"
• "User Story - Represents a user feature. (Use Fibonacci numbers to estimate.)"
• "Sub-Task - Represents development tasks to accomplish the user story. (No story point estimates.) Generally no more than 1-day tasks. You can either count the number of sub-tasks or time estimate in days in your retrospective to evaluate if your story point estimate for the User Story was accurate and adjust accordingly - assuming you have some velocity history to compare to."
• "(Engineering) Task - We used to call these "Dev Stories" (in a pre-Jira project) - represents a set of engineering work that is not directly related to a user story. The team should try to anticipate "Dev Stories" and add them to the backlog sooner than later with estimates (Use Fibonacci numbers to estimate) so the PO can plan milestones."
• Note: Also see the discussion thread...
  

 

SolutionsIQ.com

• https://www.solutionsiq.com/agile-glossary/epic/ 
• "A very large user story that is eventually broken down into smaller stories."

• https://www.solutionsiq.com/agile-glossary/story-user/
• "A requirement, feature and/or unit of business value that can be estimated and tested. Stories describe work that must be done to create and deliver a feature for a product. Stories are the basic unit of communication, planning, and negotiation between the Scrum Team, Business Owners, and the Product Owner."
• https://www.solutionsiq.com/agile-glossary/task/
• "Tasks are descriptions of the actual work that an individual or pair does in order to complete a story. They are manageable, doable, and trackable units of work. Typically, there are several tasks per story." 

 

SmartSheet.com

• https://www.smartsheet.com/ultimate-agile-dictionary#epic-stories
• "Epic or epic stories are defined as large user stories that, in their current state, would be  difficult to estimate or to complete in a single iteration. Epic stories are typically lower priority and are waiting be broken down into smaller components." 
• https://www.smartsheet.com/ultimate-agile-dictionary#story
• "A story, or user story, is a brief, non-technical statement of a software system requirement written from the end-user’s point of view."

• https://www.smartsheet.com/ultimate-agile-dictionary#task
• "A task is a single unit of work broken down from a user story. A task is usually completed by just one person."
  

 

Other Definition Sources & Interesting Viewpoints

• https://clickup.com/blog/agile/agile-terms/
• https://www.scrum.org/resources/scrum-glossary
• https://www.freecodecamp.org/news/epics-are-dead-heres-what-we-should-do-instead-279bada1e644/
• "An epic is a story that is too big to be implemented in a Scrum sprint. The items at the top of the Product Backlog are thus not epics, but little stories. Down in the backlog you will typically find epics. Over time, the epics are “sliced” into stories that can be pulled into a sprint."
• See example of Jeff Patton's Story Mapping (see Amazon book suggestion below).
• https://www.knowledgehut.com/blog/agile/what-is-an-epic-agile
• "Epic - A requirement that is just too big to deliver in a single sprint. Epics need to be broken into smaller deliverables (stories)."
• "Story - A requirement that the business wants. It is something that is deliverable within a single sprint."
• "Tasks - The essentials of a story, these are the milestones to take the story to ‘Done’."
• https://techfarhub.cio.gov/learning-center/field-guides/2/
• "A story should be small enough to be coded and tested within an iteration—ideally just a few days. When a story is too large, it is called an epic. Backlog items tend to start as epics when they are lower priority."
• https://www.yodiz.com/blog/what-is-epic-in-agile-methodology-definition-and-template-of-epic/ 
• "An Epic can be defined as a big chunk of work that has one common objective. It could be a feature, customer request or business requirement. In backlog, it is a placeholder for a required feature with few lines of description. It tells compactly about final output of user needs. In the beginning, it may not contain all the details that team needs to work on. These details are defined in User Stories. An epic usually takes more than one sprint to complete."
• "Think of epic as a book and user stories are its’ chapters."
• https://www.jeremyjarrell.com/eliminating-epics/
• "...epics can encourage poor refinement of ideas by enabling people to capture details in epics that they would otherwise consider too poorly refined for a normal user story." 
• "epics themselves should never be loaded as a sprint level item" 
• "Remember that epics are just another type of user story."
• https://www.pluralsight.com/guides/refine-user-stories-and-acceptance-criteria-with-agile
• https://softwareengineering.stackexchange.com/questions/182158/relationship-between-user-story-feature-and-epic 
• https://medium.com/@PherricOxide/scrum-gone-wrong-part-1-85c907d64098
  

 

Anti-Definitions

I've encountered agile practitioners, and a few engineering teams, that seem to have badly calibrated their definitions.

• No, a Feature is not appropriate for planning the addition of a widget on a UI (e.g. like a button, or a drop-down), nor is a Story. That is appropriate for a Task - for which, usually, two or more are associated to a Story.
  

 

Epic Estimation Techniques

1. Assign a relative weight to an Epic (expressed as a number from the Fibonacci sequence: : 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, … and so on.
2. Multiply by 10 (versus a Story, to reflect the relatively larger scope of an Epic - as a collection of Stories).
   

Suggested books:

• User Stories Applied: For Agile Software Development (2004)
• User Story Mapping: Discover the Whole Story, Build the Right Product (2014) 
  

2021-05-04 Tuesday - Book Review - Software Architecture with C++

 

image source: Amazon.com

Full Disclosure: Naved Mahdi (Marketing Coordinator at Packt, very graciously offered to provide me with an eBook copy to review.

Software Architecture with C++, by Adrian Ostrowski and Piotr Gaczkowski

Software Architecture with C++: Design modern systems using effective architecture concepts, design patterns, and techniques with C++20

https://www.amazon.com/Software-Architecture-effective-architecture-techniques/dp/1838554599/

Imagine spending thousands of dollars to attend some of the best world-class conferences. In addition to the cost of the conference, you will also incur travel costs, hotels, meals, parking, and the costs of the time spent being away from your full-time job. While attending such conferences – you have the opportunity to sit in on sessions – presented by leading practitioners – but you will be challenged to decide which sessions to select – and you will inevitably have to miss out on some when choices must be made. Embodied in this book are some of the most important lessons that you might glean from attending several such conferences. The additional value of this book – is that it is concisely written – and in the latter chapters, provides a specialized focus through the lens of Software Architecture with C++. However, many of the lessons conveyed in its pages are applicable, regardless of your language choice. By learning C++ you will become a better programmer. Period. You will have a deeper understanding of the underlying design and performance considerations of all programming languages – and you will have added a powerful tool to your toolbox.

This book is the equivalent of a Master Class on Software Architecture with C++

What I Particularly Liked About this Book

• Coverage of C++ 20, and discussion of the evolution of changes from C++98, C++11, C++17
• Holistically examines Software Architecture.
•  Provides an opinionated view of C++ usage in implementing Software Architecture – that has a fair representation of broad industry practices and conventions.
• Touches on Cloud Native Architecture – as well as older Service Oriented Architecture – as well as Microservices.
• Domain Driven Design
• The discussion of SOLID and DRY principles – and the suggested list of some well-written (and mature) libraries/frameworks.
• The discussion on stateless and stateful,  in Chapter-2
• Chapter-3’s discussion on architecture view and documentation generation
• Chapter-4’s inclusion of the Fallacies of Distributed Computing and CAP Theorem, as well as the discussion on IaaS, PaaS,  SaaS, and FaaS models. Overall, this is a substantial chapter that covers a lot of significant material – and is notable for its concise and broad coverage of architecture patterns.
• Chapter-5’s demonstration of the evolution of a design – starting with a C++17 implementation – and showing the transition to a C++20 implementation.
• I greatly appreciated the inclusion of the suggested entries in the “Further reading” at the end of each chapter.

There is much more I could say about the goodness in each of the chapters of this book - but I will leave that discovery for you to enjoy yourself.

Chapters:

1. Importance of Software Architecture and Principles of Great Design
2. Architectural Styles
3. Functional and Nonfunctional Requirements
4. Architectural and System Design
5. Leveraging C++ Language Features
6. Design Patterns and C++
7. Building and Packaging
8. Writing Testable Code
9. Continuous Integration and Continuous Deployment
10. Security in Code and Deployment
11. Performance
12. Service-Oriented Architecture
13. Designing Microservices
14. Containers
15. Cloud-Native Design

Note: I rarely give 5-star reviews - this book exceeded my expectations. 

For a deeper exploration of C++ Object Oriented Programming concepts, I highly recommend Dorothy Kirk's new book: Demystified Object Oriented Programming with C++, also from Packt.