Archives: Blog posts

RustFest Conference in  Barcelona came to an end, so here is a summary of it.

Saturday

Saturday started with a keynote about the benefits and pitfalls of Rust adoption. The economic gain from the safety Rust offers is now beyond question but some new potential problems are just around the corner. One of the most interesting challenges discussed was what will happen and how to react when the language becomes mainstream and it won’t be used just by a group of loyal enthusiasts but also by unaware developers who happened to join a project based on this sometimes very demanding and difficult language.

A big surprise was to hear about the process of Rust adoption in China which sadly isn’t going well. All the beloved Rust tools like cargo, rustup, and crates.io are literally unusable there because of the Great Firewall. What’s worse the Chinese online Rust community is heavily fragmented because of the monopoly and constrains of certain web communicators.

The first day concluded with a workshop session. I was lucky to book a place on the introduction to embedded development in Rust which received a great deal of interest, causing a long wait-list to emerge. In my case, bare-metal programming with Rust on LPC845 board turned out to be a partial success: the LED was blinking, the state of the button remained a secret.

Sunday: Strange Surprise

Sunday started with a great talk about crowd-sourced, Rust-based train schedule information service from South Africa. What stuck to my mind was that there was no need to back up the state of the service in a database for the possibility of a crash, because the service simply never crashes and it’s only restarted every couple of months because of updates. Great advertisement for Rust! Not to mention the memory usage after switching from Kotlin to Rust was reduced by the factor of 40.

Strange as it may sound RustFest day 2 included also a live music concert! The music was generated using commands of a simple DSL typed by the presenter in the browser running a Rust+WebAssembly web page of his creation.

The Best Comes to Those Who Wait

The conference took place just after the long-awaited async/. await feature had been stabilized so of course, this hot topic was also present in the program. First, the audience learned about the basics of async-std which is, as the name suggests, asynchronous implementation of the Rust standard library, in which not a single potentially long-running operation is blocking until specifically asked to. Just after that, we received a deep insight into how the Rust compiler optimizes the async functions and makes them zero cost.

The day ended with another workshop session and this time I was implementing a 2D game starring (obviously!) a crab – the Rust mascot.

The goal of this project was to experiment with Rust bare-metal programming by implementing a simple game. The chosen hardware platform was STM32F4DISCOVERY. It is similar to F3 DISCOVERY from the official embedded Rust tutorial however, it has some additional features like analog-digital converter required for the snake to be controlled with a joystick. The game is displayed on a 96×64 OLED screen using the SSD1331 controller and SPI interface. In the process of development and debugging two additional versions of the game were created: one with text-based UI for running the game in a terminal and the other one using a game engine called Quicksilver. Quicksilver is capable of targeting WebAssembly, which means the same game can be played both on the microcontroller and in a web browser. Implementation of the game. Embedded HAL  hides a lot of details and allows us to interact with the hardware on a relatively high level of abstraction.
Some remarkable issues are:

* Development without OS and allocator requires #![no_std] flag but Rust’s native test framework depends on standard library facilities. To keep unit tests in the same file as the source code (which is Rust’s convention), a conditional compilation was required.

* Lack of dynamic memory allocation makes it difficult to parameterize application code with the size of “things” – everything has to be set at compile time. It is a problem when unit testing or targeting different screen sizes. The easy solution for this would be to use a feature named “const generics“ which, unfortunately, is not yet fully implemented in Rust. Luckily there is a workaround in the form of crate generic_array, but overall Rust still has to catch up with C++ in this subject.

* Important thing one has to remember when developing with Rust is that the difference in performance between debug and release versions is huge. In the case of this game and microcontroller, the debug version was unusable.

For more information follow the link below:

Once again Microsoft does it again, just yesterday they revealed a “brand-new limitless analytics” called Azure Synapse. The grand revelation took place at Ignite 2019. However, the real question is what does this brand new Azure Synapse do?  As Microsoft would say, “Azure Synapse brings together enterprise data warehousing and Big Data Analytics”. Nevertheless, organizations can use their data quickly, by pulling together insights from all data sources, data warehouses, and big data analytics systems.

Pros of Azure Synapse

1. Azure Synapse Analytics makes building and operating analytics solutions a simple, intuitive and no-code experience.

2. It empowers users to analyze data quickly while bringing high performance and unmatched scale.

3. Project timelines can be measured in hours not months.

4. Enabling Power BI and Azure machine learning is simpler.

5. It provides a unified workspace for data preparation, data management, data warehousing, big data, and Artificial Intelligent tasks.

Feel no Fear

However, you might feel worried about how your business will adapt to this new technology? Feel no fear, your business can continue running with its current data workloads in production today with Azure Synapse and will automatically benefit from the new capabilities. Azure Synapse is all about putting in the information a lot faster, productively and securely. Pulling together insights from all data sources, data warehouses, and big data analytics systems. Integration is a must!

What Lies for The Future

Azure Synapse is breaking boundaries, they want to make data accessible, usable and actionable to organizations, furthermore, they want to make professionals deliver that information as swiftly as possible on a large scale.

Last Words

In the world we live today, the role of IT and developers is becoming increasingly important, however, here at Thaumatec, we are up-to-date in new revelations and technologies so we can deliver them to you. After all, we make the future matter and connect to you.

Rust is one of the most talked about languages in recent years, as the Firefox browser is gradually being rewritten to use it and more and more companies are starting to use it. While its most prominent feature – borrow checker – has been discussed numerous times, there are also many smaller features, which provide a comfortable experience while developing in Rust.

Convenient switching between toolkit versions
One of the most common issues that affect Rust programmers is that the most tempting language features are always available only in nightly. On the other hand, for professional development, it’s a good idea to keep the ecosystem quite stable, with one toolkit version that is expected to make our codebase work, and which will be supported for as long as possible. Is it possible to seamlessly switch between different releases of the Rust toolkit?

Enter rustup – the Rust toolchain installer. It’s the tool that allows not only for installing, but also updating and switching between different toolchains.

The main rustup website is rather minimalistic, but anyone in need of more information can find it in a quite extensive rustup project’s README.

Module system
Project’s source code rarely can be contained in a single source file. Different programming languages have different approaches to solving this problem – one of the most known in the embedded programming world is the C/C++ way – #include, which essentially causes the referenced file to be directly pasted in its entirety by the preprocessor.

This solution is simple to implement, easy to understand and usually works. There are pretty severe issues with this approach though: any changes made in one file can spill into all others which include it – directly or indirectly. It can be a rogue #define which changes the behaviour of the code or using a namespace directive.

There’s also a risk of including one file more than once, that would cause things to be defined twice – and every C/C++ developer has the include guard already in their muscle memory or editor templates. Rust solves the problem differently – by using a module system.

Modules in Rust can work inside of one file in a way similar to namespaces in C++, with the additional possibility of default privacy of module contents – anything that needs to be visible outside of the module needs an extra pub keyword.

But when a module itself is prepended with a pub, then it can be used in other source files, while being completely independent of them. More information can be found in The module System to Control Scope and Privacy chapter of the Rust Book.

Crates
Almost all software developed stands today on the shoulders of giants by using at least one third party library. Most modern programming languages provide an easy way for the code to depend on a given version third-party library, which can be automatically downloaded and built by the build system. Rust isn’t different in this matter – cargo, build system used by Rust, gets the current project information from Cargo.toml file, where dependencies on other libraries (called crates) and their versions can be also stored. Then, during the build process, crates are downloaded and built.

Crates can be browsed using Rust Package Registry, which also conveniently provides a snippet that can be pasted into the Cargo.toml to use the chosen crate.

As an interesting side note, cargo and crates are both references to Cargo Cult. Knowing current development practices of stitching libraries together until it works, it’s a pretty humorous touch.

Integrated testing
Software testing is one of the basic elements of modern code hygiene. There are testing frameworks for almost all programming languages, but Rust decided to be a step ahead and a simple test framework is provided with the language itself. Citing a simple example that can be found in the Writing tests chapter of the Rust Book:

#[cfg(test)]
mod tests {
#[test]
fn it_works() {
assert_eq!(2 + 2, 4);
}
}

In this example, module tests will be available only during the test execution, and the it_works function is marked as a test, therefore it will be run when the cargo test command is invoked.

But that’s not all – it’s possible not only to test the correctness of our program, but also to benchmark it. To do that, it’s needed to create a function marked as bench, taking a Bencher object, which will do the measurement. Thanks to that initialization of objects can be done outside of the measured code fragment. At the time of writing this text, benchmarking is an unstable feature and needs to be enabled using the test flag. More information can be found in the test library features in the Unstable book.

Documentation tests
Rust also provides rustdoc, which is an automatic documentation generation system, similar to Doxygen or Sphinx. But one of the most common problems when documenting the rapidly moving codebases is to keep the documentation up to date. Rust tackles the issue by allowing one to include code samples with assertions, which can be easily compiled and evaluated. More information can be found in the rustdoc documentation.

Summary
Rust provides not only a lot of nice programming constructs, but also a really comfortable ecosystem that aims at solving practical problems that programmers have in their daily jobs; therefore, it shapes up to be not only an academic-only curiosity, but a tool that could be used in long running commercial projects. If you haven’t played with it, then try it out – Rust is not only a useful tool, but it’s also lots of fun.

Finally, Microsoft Cloudfest at Rust is just around the corner, meaning its next week and Thaumatec for sure will be attending such event. For a third year Cloudfest, takes place in different location but same objective; have fun while solving real life problems. Thaumatec in the other hand is excited in building further our expertise in the IoT and embedded capabilities and extent it with MS Azure IoT and cloud application modernization. After all there exists a broad market in those areas and great advances that can simplify many day to day tasks and few know about it, luckily Thaumatec can help you.

Cloudfest is the place to be next week, especially because Thaumatec will be there learning new ways to improve what we already know so well, embedded and IoT skills. However, our services on Azure IoT and cloud modernization are for data driven companies who embrace digital transformation; meaning everything is controlled by a cloud, monitored and even automated. Automation is just one of the qualities that Azure IoT and cloud modernization have, this also includes connectivity, 2-way communication and everything being handled from one place, the cloud.

Thaumatec’s visit to Cloudfest will help us comprehend more complex problems about Azure IoT and cloud modernization and will also give us a broader perspective about other areas such as universal acceptance, manage services and controlling data, enabling Big-data, machine learning and many more. Come and join the fun but most of all, let us talk about posibilities of MS Azure!

The Things Network is a unique in its kind, huge and publicly available global LoRaWAN™ network, connecting over six thousand gateways in more than 130 countries. Because LoRa technology is tightly coupled with the Thaumatec’s DNA, we didn’t hesitate a minute to save our spots at the annual event – The Things Conference – that took place in Amsterdam, Netherlands at the turn of January and February 2019. It’s been two long days, full of workshops and presentations explaining new trends and directions of the in LoRa industry.

We arrived at the venue in the very morning and quickly confirmed our assumptions regarding the activeness of the community. Walking by the conference booths we had a lot of great conversations with the representatives of leaders in the industry and just after grabbing a cup of coffee and making our way to the main stage we stumbled upon giant wall presenting multitude of recent, LoRa related hardware developments, being it new sensors, gateways, antennas or microchips. It took a significant amount of time event to just briefly review all the gadgets.

The main stage was where the most interesting stuff have happened, and there were indeed a lot of engaging announcements to be made by the event hosts and invited guests. The first thing that is important to notice is the launch of “The Generic Node” device, which is an answer to the problem of high TCO of the LoRa based systems. You no longer need to design, develop and fabricate a specific device to server your project needs. You can quickly deploy the generic device and focus on prototyping your solution. The Generic Node can be easily connected to the TTN network and provide you with telemetry data from many internal sensors, such as light, accelerometer, temperature, touch, humidity, etc. Want to use the LoRa technology without hardware design – The Generic Node is for you.

It is also worth noting that The Generic Node takes advantage of the other piece of engineering art that was presented at the conference, the ATECC609A microchip that provides hardware based security to the LoRa transmission layer. Introduction of the chip makes the device provisioning secure and makes it impossible to tamper with the embedded cryptographic keys.

Source: https://www.electronicdesign.com/iot/teaming-secure-lorawan

But the ultimate announcement was still there to be made. The founders of The Thing Networks decided that the LoRaWAN stack should become accessible for everyone to use. Therefore, just during the presentation on the main stage they made the GitHub repository of the V3 software stack public, giving everybody access to the implementation of the network stack that strictly follows the LoRaWAN Network Reference Model. What a news!

In between the engaging presentations we had a chance to participate in several workshops. One of them was related to the Azure IoT Hub and the ways one can utilize it to quickly develop IoT applications in the cloud. During the hands-on workshop specialists from Microsoft explained how you can connect your IoT device to the Azure Cloud in literally less than 30 minutes and that even included flashing the device with appropriate software. Once your telemetry data land in the cloud you can use straightforward drag&drop mechanisms to quickly prototype your solution.

Finally, at the end of the second day just before leaving the conference, we were once again nicely surprised. Everyone who attended the event was given a brand new LoRa gateway, whose launch was also announced during the conference. This is the fully functional, indoor LoRa gateway which is going to be available for purchase at the disruptively low price. It’s amazing that you no longer need to spend a lot of money on a gateway nor you need to have professional hardware development skills to start your adventure with LoRa communication.

All the information above is just a small excerpt of the entire content available during The Things Conference. If you plan to extend your LoRa related knowledge or you are just going to get acquainted with the technology we definitely recommend visiting the conference next year.

At the beginning of November, we visited the Embedded Conference Scandinavia that took place in Stockholm, Sweden. It has been two days very well spent on listening to fascinating lectures and chatting with the endless amount of professionals that came there to present their most recent activities in the field of the embedded world.

This year was even more interesting since we decided to join the noble group of presenters and share our thoughts and experiences with the LwM2M protocol in the IoT world. If you follow our blog you could definitely see that LwM2M is the next big thing in the area of device management.

The exhibition hall has been crowded since the very morning, confirming the forecast that the IoT industry develops very promptly these days. While wandering between the exhibition booths we were amazed by the amount of thought and ideas that have been put into all kind of different products presented there. Sensors, displays, antennas, cameras, drones, industrial automation devices… you name it. Taking into consideration that at each booth you could meet with the helpful and engaged staff we found it hard to find some time to participate in the lectures.

Speaking of lectures – this year the ECS team organized more than fifty presentations covering a broad variety of topics, including wireless communication, security, quality, etc. But the conference was not only about gathering the theoretical knowledge. If you prefer to make your hands dirty, you could join one of the six workshops and get acquainted with new technologies the practical way.

Spending two days surrounded by the novelties in the embedded business is very exciting. You have a chance to grow your contact network very rapidly and get back in touch with the people you met during the previous editions of the conference. We were also pleasantly surprised that some of our customers have also attended this year’s edition of the gathering.

You can clearly see that Stockholm, Sweden is on the bleeding-edge with regards to innovations in the embedded world and we cannot wait to visit the ECS next year!