Happy New Year!
Welcome to the January 2019 edition of the Embedded Artistry Newsletter. This is a monthly newsletter of curated and original content to help you build superior embedded systems. This newsletter supplements the website and covers topics not mentioned there.
This month we'll cover:
- Highlights from 2018
- The Embedded Template Library
- A code "self-review" exercise
- Embedded news from around the web
2018 in Review
We covered a lot of ground with our newsletter in 2018. We focused on four major topics:
- Improving Quality
- Libraries suitable for embedded systems
- Changes to C++ that might impact embedded developers
- Security Flaws & Hacks
2018 was a productive year for Embedded Artistry:
- We published fifty-seven articles on our website, as well as a guest post on Simplify C++.
- We added a Welcome page for first-time visitors.
- We overhauled the design of our three resource pages:
- We created the Embedded Artistry Technology Radar after attending a software architecture workshop.
- We launched a separate consulting website so we can keep our primary domain focused on embedded systems content.
- We added four new projects to our portfolio:
- We began development of our C++ embedded systems framework
On a fun note: according to our Twitter analytics data, 99% of our followers love “dogs”, with “tech news” and “space & astronomy” following closely behind. Our team feels the same!
Embedded Template Library
We've been hard at work on our C++ embedded systems framework. A critical design requirement is that the framework core components do not utilize dynamic memory allocation. Unfortunately, this excludes most of the STL containers, as they get storage from the heap by default.
Rather than reinventing the wheel, we spent some time searching for existing solutions to this problem. We feel lucky to have discovered the Embedded Template Library (ETL), an open-source project created by John Wellbelove at Aster Consulting Ltd.
The ETL provides fixed-size alternatives to STL container types. The ETL containers specify a maximum capacity at compile-time and make no calls to
delete. As an added bonus, the containers are all cache friendly: storage for all container types is allocated in contiguous blocks. The ETL also provides additional utilities and frameworks that are useful for embedded projects. The library can be safely used in conjunction with the STL.
The ETL will be included in our embedded framework and will be seen in our code samples for future articles. You can find additional ETL links and information on our website.
Code Self-Review Exercise
Code reviews are one of the essential practices for improving software quality. Aside from identifying issues with code before its deployed, reviews expose developers to new techniques, approaches, and patterns of thought.
As a consultant, it’s hard to enlist help for internal code reviews. As such, I’ve been testing other strategies to improve the code I write. For example, I use automated processes to check for problems or style inconsistencies, and I run through a checklist of common design mistakes before I merge in any new code changes.
Recently, I’ve been noting mistakes I’m prone to make and screening for them before submitting pull requests. I learned about this exercise in "Social Effects of Peer Review.". Here's a summary of the exercise from the article:
Try this experiment sometime: For one week, make a log of every error you make. Every misspelling in e-mail, every time you accidentally close the application you’re working in, every time you have a bug in your code, even every syntax error you make. Don’t get too specific; keep each item in the list high-level and use hash marks to count how many times you make that type of mistake.
For now, just imagine you’ve done this. As you might guess, certain patterns emerge. A few of the items have an awful lot of hash marks next to them. In fact, by the end of the second day you might have been getting tired of counting some of them!
And that annoyance might live in the back of your mind. You might even start thinking about it consciously. Pretty soon you’ll anticipate the mistake and prevent yourself from making it. Some of those will come easy, others will take work to eliminate. But eventually you develop habits that prevent that type of error completely. If you frequently forget to close parenthesis in your code, perhaps you’ll enable the feature in your code editor that closes parenthesis for you. If you close applications by accident, maybe you’ll pause just a few seconds every time you’re about to hit the close button. Maybe you’ll look up how to spell common words or learn how to input your common mistakes into the auto-correct facility in your e-mail editor. Over time you become more productive and more efficient. You’re working faster and smarter. Not through some self-help seven-step program, just by observing yourself a little more carefully and systematically than you’re used to.
Noting down all of the mistakes you make can also be a humbling experience. Give it a try this week as a New Year’s resolution and see how much you improve by just paying more attention to yourself.
Around the Web
MQTT and CoAP are ubiquitous in IoT applications. Unfortunately, Trend Micro reported that these messaging protocols are insecure. You can read their full report, "The Fragility of Industrial IoT's Data Backbone".
All About Circuits shared an embedded project that we love: How to Make Your Umbrella into a Weather Station with a Particle Photon.
All About Circuits also posted an introduction to MEMS systems. Since many components in our embedded systems utilize MEMS technology, we recommend familiarizing yourself with how it works.
This article provides a nice summary of how different industries are leveraging IoT devices.
Ellisys has created a video series that teaches developers about Bluetooth. Videos include: Intro to Bluetooth Low Energy, Generic Access Profile (GAP), Advertisements, Connections, Generic Attribute Profile (GATT), Power Consumption, Security, Bluetooth 5 and IoT, and Intro to Bluetooth Mesh.
Jee Labs published a six-part series which introduces developers to the CAN bus:
We updated the Embedded Artistry Technology Radar to reflect the changes in various technologies and techniques that are under assessment.
We also updated the following previously published articles with new and corrected content:
- Hofstadter's Law
- Implementing an Asynchronous Dispatch Queue
- Implementing an Asynchronous Dispatch Queue with ThreadX
- Implementing an Asynchronous Dispatch Queue with FreeRTOS
- Embedded Rules of Thumb
- Creating a Circular Buffer in C and C++
- Musings on Supply Chain Vulnerability in Light of the Big Hack
- OSX: Getting Pesky FTDI Debugging Devices to Work
- std::string vs C-strings
- Social Effects of Peer Review
We published the following articles in December:
These were our most popular articles in December:
- Circular Buffers in C/C++
- Jenkins: Configuring a Linux Slave Node
- Installing LLVM/Clang on OSX
- C++ Casting, or: "Oh No, They Broke Malloc!"
- Jenkins: Kick off a CI Build with GitHub Push Notifications
- An Overview of C++ STL Containers
- Jenkins: Running Steps as sudo
- Migrating from C to C++: NULL vs nullptr
- Implementing Malloc: First-fit Free List
Thanks for Reading!
Have any feedback, questions, suggestions, interesting articles, or resources to recommend to other developers? Simply reply to this email!
We’d also love to hear how the code review experiment goes for you.