nanoFramework: Unleashing the Power of C# in Embedded Systems and IoT with José Simões
Summary
In this episode of The Modern .NET Show, host Jamie Gaprogman-Taylor speaks with José Simões, CEO of Echo Solutions and a Microsoft MVP in IoT, about the .NET nanoFramework. José explains how this platform brings the power and productivity of C# and .NET to the world of embedded systems and IoT development. He clarifies the distinction between embedded systems (any electronic board with computation, not necessarily internet-connected) and IoT (things connected to the internet), and positions nanoFramework as a tool that abstracts the hardware complexities for both.
The conversation delves into the technical aspects of nanoFramework, highlighting how it is a trimmed-down version of .NET designed to run on resource-constrained microcontrollers with as little as 128KB of flash and 64KB of RAM. José details the API alignment with full .NET, noting the current lack of generics and async/await support, but the presence of multithreading, reflection, and familiar namespaces for networking, GPIO, and more. He emphasizes the massive productivity gains, as developers can use Visual Studio, IntelliSense, NuGet packages, and even AI coding assistants to build applications, then deploy and debug over a simple USB cable with F5.
José provides compelling real-world examples, from a proof-of-concept on an ESP32 breadboard built in 30 minutes to large-scale commercial projects. These include evaluation boards and production-line testing systems for silicon manufacturer Skyworks, and solar-powered telemetry units for oil fields. He contrasts this with the arduous process of traditional C/C++ embedded development, which requires deep knowledge of microcontroller datasheets, manual memory management, and significant code rewrites when hardware changes.
The episode concludes with practical advice for getting started: installing the Visual Studio extension, using the nanoFramework firmware flasher .NET tool, and joining the active Discord community for support. José makes a strong case for nanoFramework as a production-ready platform that empowers .NET developers to enter the embedded space quickly, reuse code across projects and hardware, and deliver robust solutions with modern tooling.
Recommendations
Communities
- .NET nanoFramework Discord — The primary community support channel for nanoFramework, with various topic channels where users can ask questions and get help from the team and other developers.
Tools
- .NET nanoFramework Visual Studio Extension — The extension to install in Visual Studio to get project templates and debugging support for nanoFramework development.
- nanoFramework Firmware Flasher — A .NET tool (CLI) used to connect to a device, identify it, and flash the appropriate nanoFramework firmware onto it.
- ESP32 — A popular, low-cost microcontroller module frequently used with nanoFramework for prototyping and production, mentioned as a great starting point.
Topic Timeline
- 00:00:00 — Introduction to the episode and .NET nanoFramework — Host Jamie Gaprogman-Taylor introduces the episode and guest José Simões. He previews the topic: using .NET nanoFramework for embedded systems and IoT development. Jamie shares his initial impression of how quickly one can get started with an ESP32 and a breadboard, contrasting it with the difficulty of doing the same in C.
- 00:03:11 — José Simões’ background and introduction to embedded vs IoT — José introduces himself, sharing his start with a ZX Spectrum and his current role at Echo Solutions. He explains the difference between embedded systems (any electronic board with computation) and IoT (embedded systems connected to the internet). Examples given include a boiler controller, garage opener, and the host’s Zoom H4n recorder.
- 00:08:51 — What is .NET nanoFramework and how it fits in — José explains that .NET nanoFramework fits into both embedded and IoT scenarios. It provides the familiar .NET project system and NuGet packages. Developers can bring in packages for IoT cloud connectivity or just basic GPIO control for local projects, abstracting the hardware complexities.
- 00:13:50 — Technical details and API alignment with full .NET — José describes nanoFramework as ‘.NET with bits removed’ to fit on small microcontrollers. The API is aligned with full .NET where possible, though it currently lacks generics and async/await. It supports multithreading, reflection, string manipulation, networking, and more, allowing code sharing with desktop applications.
- 00:25:47 — Hardware requirements and supported platforms — José clarifies that nanoFramework requires specific firmware for each microcontroller (e.g., ESP32, STM32, NXP) due to differences in pin mapping and architecture. It cannot run on a Raspberry Pi (which uses full .NET IoT) and has a minimum requirement of a 32-bit MCU with 128KB flash and 64KB RAM.
- 00:32:02 — Productivity gains for C# developers vs C/C++ — José argues that a C# developer can become productive in embedded development with just a few days of training using nanoFramework. He contrasts this with the high cost and scarcity of specialized C/C++ embedded developers. The managed language eliminates pointer and memory management issues, and the Visual Studio toolchain (IntelliSense, debugging) provides a massive productivity boost.
- 00:38:50 — Abstracting hardware complexity with NuGet and APIs — The discussion highlights how nanoFramework abstracts low-level hardware details. In C, reading a GPIO pin requires consulting datasheets for register addresses. In C# with nanoFramework, you simply reference a NuGet package and call a method to read the pin state. This abstraction makes hardware changes and code reuse across projects significantly easier.
- 00:47:17 — Real-world use cases and killer applications — José shares two major use cases. First, Skyworks uses nanoFramework for evaluation boards, desktop configuration apps, and production-line QA, sharing C# code across all layers. Second, solar-powered telemetry units in oil fields read sensors and send data via satellite to IoT Hub. He reiterates that nanoFramework is for most embedded systems, except those requiring microsecond-level timing control.
- 00:58:59 — Professional tooling: CI/CD, testing, and deployment — José explains that nanoFramework is production-ready with professional tooling. Command-line tools allow for automated builds and flashing via CI/CD pipelines like GitHub Actions. The ecosystem also includes unit testing frameworks, integration testing, benchmarking, and logging libraries, mirroring the tools available in full .NET development.
- 01:03:40 — How to get started and find community support — José outlines the getting started process: install the Visual Studio extension ‘nanoFramework’, which adds project templates. Use the ‘nanoFramework’ firmware flasher .NET tool to deploy the correct firmware to a device like an ESP32. He directs newcomers to the active Discord community for help and mentions he is also available on Twitter and LinkedIn.
Episode Info
- Podcast: The Modern .NET Show
- Author: Jamie Taylor
- Category: Technology
- Published: 2024-02-23T07:30:00Z
- Duration: 01:09:38
References
- URL PocketCasts: https://pocketcasts.com/podcast/the-modern-net-show/91f7d1c0-7bea-0136-7b90-27f978dac4db/nanoframework-unleashing-the-power-of-c-in-embedded-systems-and-iot-with-jos%C3%A9-sim%C3%B5es/b72e0fe1-c03d-4a30-a54c-e622fd4eeb36
- Episode UUID: b72e0fe1-c03d-4a30-a54c-e622fd4eeb36
Podcast Info
- Name: The Modern .NET Show
- Type: episodic
- Site: https://dotnetcore.show
- UUID: 91f7d1c0-7bea-0136-7b90-27f978dac4db
Transcript
[00:00:00] Welcome to the Modern.NET Show,
[00:00:12] formerly known as the .NET Core Podcast.
[00:00:15] We are the go-to podcast for all .NET developers worldwide,
[00:00:19] and I am your host, Jamie Gaprogman-Taylor.
[00:00:23] In this episode, I spoke with José Simoes about the .NET Nano Framework,
[00:00:28] a powerful platform for embedded systems and IoT development.
[00:00:32] I was incredibly impressed when José spoke about just how quickly you can get started
[00:00:37] with the .NET Nano Framework and an ESP32.
[00:00:41] You grab a breadboard, you stick an ESP32 module onto it,
[00:00:46] and you plug an LED or a sensor or whatever,
[00:00:49] and in half an hour, you have a proof of concept of something that you are building
[00:00:56] or just having fun with.
[00:00:57] And this is great not only for learning to code,
[00:01:00] but to come up with a proof of concept that you want to show to a customer.
[00:01:05] If you want to do that in C, I dare you to do that at the same time.
[00:01:11] You won’t be able to.
[00:01:14] Meaning that with that code and that proof of concept,
[00:01:18] then you can evolve, you can keep working on it,
[00:01:21] and then you can easily migrate that to a production-grade system,
[00:01:27] because you will be using the same code.
[00:01:31] You don’t have to change much to get it working.
[00:01:36] So let’s sit back, open up a terminal, type in .NET New Podcast,
[00:01:41] and we’ll dive into the core of modern.net.
[00:01:52] Hello, hello, hello.
[00:01:55] Welcome to the show.
[00:01:56] Oh my goodness.
[00:01:57] We’ve been working on this episode for a while.
[00:02:01] We got chatting at MVP Summit back in April of 2023,
[00:02:04] because I’m not sure when this is going out.
[00:02:06] I’m hoping for a November release, but it will depend.
[00:02:10] And it’s been a while.
[00:02:12] My goodness.
[00:02:13] Welcome to the show.
[00:02:15] Oh, thank you, Jamie.
[00:02:17] Very excited to be here, and thanks for having me.
[00:02:23] Not a problem, my friend.
[00:02:24] Not a problem.
[00:02:25] I’m always interested to talk to you.
[00:02:27] Interesting people.
[00:02:28] And you’ve got some very interesting stuff to talk about today,
[00:02:32] because I know, we’ll come on to it in a minute,
[00:02:34] but I know next to nothing about the .NET Nano framework,
[00:02:38] and I know almost nothing about IoT.
[00:02:40] All I really know about IoT at this point when we’re recording
[00:02:43] is it’s something to do with Raspberry Pis, perhaps.
[00:02:49] A bit more than that and a bit less than that.
[00:02:52] So I guess we’ll cover that in a moment.
[00:02:56] Cool.
[00:02:57] Okay.
[00:02:57] So I guess before we get started, though,
[00:02:59] would you mind giving the listeners a bit of a brief introduction to yourself?
[00:03:03] Maybe a quick, like an elevator pitch,
[00:03:06] or like how you got started in dev, something like that?
[00:03:09] Oh, sure.
[00:03:11] My name is José Simões,
[00:03:13] and I started coding when I was a teen with an ZX Spectrum.
[00:03:19] So that gives you pretty much an idea on my age.
[00:03:24] I’m CEO of Echo Solutions,
[00:03:26] a company that works with monitoring solutions for a bunch of markets,
[00:03:32] like cold chain, info, agriculture, industry, and all that.
[00:03:39] We’ve been lately working with consulting and engineering services around Nano framework,
[00:03:47] and we also work with embedded systems development from hardware to production.
[00:03:55] I’m three times MVP on developer technologies in the IOT, and I guess this is me.
[00:04:07] Excellent.
[00:04:08] Excellent.
[00:04:08] That’s a lot of stuff.
[00:04:10] I do remember one of my first programming gigs was working on some Zigbee stuff,
[00:04:15] which I take to be embedded rather than IOT, but I don’t know all these names for stuff, right?
[00:04:22] There’s too many names.
[00:04:23] It touches both, so no worries.
[00:04:28] Well, there you go then.
[00:04:29] So maybe I should put that on the resume, right?
[00:04:31] I’m an embedded IOT .NET developer.
[00:04:35] Yeah, I guess that won’t work.
[00:04:39] Absolutely.
[00:04:40] I mean, we all know that as soon as you have 30 seconds of experience with something,
[00:04:45] you become the expert in it, right?
[00:04:47] You’re the expert in the team or whatever.
[00:04:50] Yeah, you’re right on that.
[00:04:53] So I guess before we talk about .NET Nanoframework,
[00:04:59] mainly because I was a little confused coming in,
[00:05:01] is there a difference between embedded and IOT,
[00:05:05] and is it more of a personal difference for you,
[00:05:09] or is it like an industry difference?
[00:05:11] Like if somebody was to come to me and say,
[00:05:13] hey, Jamie, I want to be an embedded engineer,
[00:05:17] like an embedded systems engineer,
[00:05:19] am I telling them go get Nanoframework?
[00:05:21] Am I telling them go get a Raspberry Pi?
[00:05:22] Am I telling them go get a Raspberry Pi?
[00:05:23] Am I telling them go get a Raspberry Pi?
[00:05:23] Am I telling them go do some ZigBee stuff?
[00:05:25] We’re not sponsored by ZigBee or anything like that.
[00:05:27] It’s just something that I have experience with.
[00:05:29] What is the difference, if there is a difference,
[00:05:31] between embedded software engineering and IOT-based software engineering?
[00:05:36] Yeah, there are differences, and they also touch.
[00:05:39] IOT stands for Internet of Things.
[00:05:42] So that’s things connected to Internet.
[00:05:46] And that can be an embedded system.
[00:05:49] But also, an embedded system,
[00:05:52] does not necessarily need to be connected to the Internet.
[00:05:56] If you have a board sitting there,
[00:05:58] like an evaluation board for a component sitting on your bench,
[00:06:03] on which you connect something and you try a component or a chip or whatever,
[00:06:08] that’s an embedded system there.
[00:06:10] And it’s not connected to the Internet.
[00:06:13] You can find embedded systems pretty much everywhere.
[00:06:17] From your controller on the boiler,
[00:06:20] then your garage,
[00:06:22] to your garage controller,
[00:06:25] your set-top box that’s connected to the Internet.
[00:06:29] And wherever you find a board,
[00:06:32] an electronic board or a printed circuit board,
[00:06:35] you have an embedded system there.
[00:06:38] So I guess this is basically it.
[00:06:43] Okay, okay.
[00:06:45] So I think we were chatting just before we got started,
[00:06:50] and I was talking about how I use a hardware recorder.
[00:06:52] So I run a cable from my microphone into a box called a Zoom H4n,
[00:06:59] which I’m guessing from your description makes it an embedded system
[00:07:02] because it’s an electronic system that is running some software
[00:07:06] that is not connected to the Internet.
[00:07:08] Yes, yes.
[00:07:09] Maybe that’s one of those. Cool.
[00:07:11] Does that mean that perhaps a power supply is also an embedded system,
[00:07:15] or are we talking just something that runs a rudimentary operating system?
[00:07:22] Yeah.
[00:07:22] It depends on how complex it will be.
[00:07:25] If you have a display there and you have maybe some current control going on there,
[00:07:35] I guess that will classify it as an embedded system
[00:07:38] because there is some sort of computation going on there,
[00:07:42] and you’ll find there a microcontroller inside,
[00:07:45] so that makes it an embedded system.
[00:07:49] Okay, cool.
[00:07:50] All right.
[00:07:51] So maybe, like,
[00:07:52] perhaps,
[00:07:52] a capture card.
[00:07:54] So I have a capture card,
[00:07:56] a USB capture card sitting on my desk,
[00:07:58] a HD60S+,
[00:08:01] which allows me to capture the footage going towards an HDMI display
[00:08:06] and send it via USB down to my computer
[00:08:09] so that I can maybe make video based on something I’m showing on screen.
[00:08:13] That could possibly be an embedded system, right?
[00:08:15] Because that’s got some computation going on.
[00:08:17] Yeah, I agree with you.
[00:08:20] Cool.
[00:08:21] Okay.
[00:08:21] So there’s literally embedded systems all around us, like you said, right?
[00:08:25] Oh, yes, everywhere.
[00:08:26] Pretty much everywhere,
[00:08:27] from the most simplest to the most complex ones.
[00:08:33] Okay, excellent.
[00:08:34] And so how does .NET Nano Framework fit in with that, then?
[00:08:39] Because obviously we’re going to have to talk a little bit about .NET Nano Framework as well
[00:08:42] because that’s the topic of the show.
[00:08:43] But, like, how do I go from IoT embedded to .NET Nano Framework?
[00:08:48] And, like, what is it?
[00:08:49] Yeah.
[00:08:51] Great question.
[00:08:53] And .NET Nano Framework fits into pretty much all those
[00:08:59] because being .NET, and for the folks familiar with it,
[00:09:07] you have your project system, you have your solution,
[00:09:11] and then you start adding and you get packages to do whatever you need to do.
[00:09:17] And this is exactly the same because this is .NET,
[00:09:21] so if you need to connect your device to IoT Hub, the cloud,
[00:09:29] or whatever provider you are working with,
[00:09:31] you bring in the network you get,
[00:09:37] possibly the wrapper for the IoT provider that you connect to,
[00:09:42] and you start coding with it.
[00:09:45] Instead, if you are just having fun
[00:09:50] and you have a lot of time,
[00:09:51] and you have a lot of time,
[00:09:51] and you have a lot of time,
[00:09:51] and you have a lot of time,
[00:09:51] and you are making a controller for your sprinkler system,
[00:09:55] you don’t need any of that
[00:09:57] because I don’t know if you want to connect that to the Internet.
[00:10:01] And assuming you don’t,
[00:10:03] you bring in just the basic stuff with the GPIOs,
[00:10:08] and that’s it.
[00:10:10] So this is how it works in a nutshell.
[00:10:15] Okay, okay.
[00:10:16] So from what you’re saying there,
[00:10:19] I can use, I mean,
[00:10:21] we’ve only touched on it slightly a little bit there,
[00:10:23] but I can use .NET Nano Framework to do some kind of,
[00:10:27] we’ll talk about what kind of programming in a minute,
[00:10:29] some kind of programming using my embedded hardware.
[00:10:32] Let’s say, because I know what one of them is,
[00:10:35] let’s say I’ve got one of the Raspberry Pis, right,
[00:10:37] like a Raspberry Pi Zero or something,
[00:10:39] that’s one of those really small ones,
[00:10:41] like a proper embedded chip.
[00:10:44] And let’s, I don’t know whether it runs on it,
[00:10:46] but let’s pretend I can run Nano Framework on there,
[00:10:49] and let’s pretend I want to make some kind,
[00:10:51] a kind of rudimentary server that I can just poke out and say,
[00:10:55] give me some data.
[00:10:57] But I can do that with Nano Framework, right?
[00:10:59] Yes, you can do that with Nano Framework.
[00:11:03] Going back to the example I was trying to describe a moment ago,
[00:11:08] you bring in the NuGet package with a web server,
[00:11:11] and you set up your thing pretty much in on ASP.NET fashion,
[00:11:18] on which you define the endpoints
[00:11:21] that you are connecting to.
[00:11:22] Hopefully, this is something kind of modern,
[00:11:25] and you’ll have a REST API on it.
[00:11:28] And with a couple of attributes and springing some methods there on your classes,
[00:11:35] you’ll be up and running your web server on which you can connect to
[00:11:41] and start querying it and possibly sending data,
[00:11:44] requesting sensor data or whatever data it’s generating with just like you do
[00:11:51] on a traditional .NET application with a REST API.
[00:11:58] Cool. Okay.
[00:11:59] So like from a 10,000-foot view,
[00:12:02] I’m using .NET Nano Framework, pulling a NuGet package.
[00:12:06] I do .NET new, maybe, Nano Framework web application.
[00:12:13] I’m not sure what the name would be, but something along those lines.
[00:12:15] And then I hit run, and guess what?
[00:12:17] I’ve got a web server sitting on my embedded device.
[00:12:20] That’s pretty cool.
[00:12:21] Yes, that’s about it.
[00:12:24] The only thing that’s different from your description is that you don’t do .NET new
[00:12:30] because we are not in the same page as the .NET tooling.
[00:12:38] We are still using the old project system, but that’s only a nuance on this.
[00:12:45] You go to Visual Studio, you go to the project templates,
[00:12:49] and you’ll have there.
[00:12:50] The class template, the application template,
[00:12:53] as you are used to with just like any other C-Sharp application.
[00:12:57] Sure, sure. Okay.
[00:12:59] I mean, so I just do, in my head, I do .NET new
[00:13:03] because I spend a lot of time on the command line.
[00:13:06] And I’ve told this story several times.
[00:13:08] The listeners will be bored of me telling the story,
[00:13:11] but in the intro to every episode, I say, .NET new podcast,
[00:13:15] because I used to actually spin up new episodes of the podcast recording
[00:13:18] and all the ephemera that comes with it.
[00:13:19] Fair enough. But I do it here.
[00:13:20] I do it here. But I do it here.
[00:13:20] I do .NET new podcast in the command line,
[00:13:22] because you can do almost anything with the new templates, right?
[00:13:25] Makes sense. The concept is exactly the same.
[00:13:30] Cool. Okay.
[00:13:31] So is it, are we talking .NET Framework?
[00:13:35] Are we talking .NET Core, .NET 5.6.7, what I’m calling modern .NET?
[00:13:41] Like what is it, right?
[00:13:43] Is it, like I said, is it .NET Framework with bits removed?
[00:13:46] Is it .NET Core? Is it modern .NET?
[00:13:48] How does that bit work then?
[00:13:50] The description with the .NET with bits removed,
[00:13:55] it’s pretty much a good description for it.
[00:13:58] Because as you can imagine, on a small microcontroller with the limitations
[00:14:04] of flash and RAM there, you can’t possibly have all the API
[00:14:10] that you have on a full desktop or server computer.
[00:14:16] So it has to have something removed from there.
[00:14:18] What we do,
[00:14:20] we try to align as much as possible, and that’s been accomplished so far with an
[00:14:30] API, which is the same that you find on the full .NET, let’s call it this way.
[00:14:36] And then you bring in a NuGet packages and we have this pretty much
[00:14:41] split in the various NuGet packages for the simple reason that when you’re building
[00:14:50] your embedded system or your project, Nano Framework project, if you will,
[00:14:54] you, and because the flash and RAM are usually scarce, you just bring in the absolute minimum
[00:15:06] that you need, so you don’t go past those limits of the available memory and flash storage.
[00:15:15] That said, we have an alignment,
[00:15:20] as much as possible with the API.
[00:15:22] The only difference that you’ll notice is that we don’t have support for generics yet,
[00:15:29] but that it’s in the works and we don’t have the other most obvious thing.
[00:15:35] We don’t have also the async and await pattern there.
[00:15:39] Although we have multithreading and all that stuff, we can do pretty much the same.
[00:15:43] Just that we don’t have the async and await pattern.
[00:15:46] Apart from that,
[00:15:49] all the basic stuff,
[00:15:49] like string manipulation, byte arrays, encoding, whatever you have there,
[00:16:00] math, library, all the same API as you have on the system.net for networking, sockets,
[00:16:07] all that stuff, it’s there and it’s the same.
[00:16:11] You can follow that mantra from .NET, you compile once and you run everywhere.
[00:16:18] It’s pretty much the same,
[00:16:20] although our execution engine is different because it has to run on a microcontroller.
[00:16:25] But basically, this is it.
[00:16:27] You can port your code from a desktop application.
[00:16:30] You can share code from your desktop application and the nano framework project.
[00:16:36] All that is possible and everything that the .NET ecosystem allows you to do,
[00:16:42] you can do it with .NET nano framework.
[00:16:48] Okay, I mean, that makes sense, right?
[00:16:50] The current lack of async await makes sense because you were saying earlier on about how it is,
[00:16:59] you’ve got an embedded system, you’ve got very small amount of memory to play with.
[00:17:03] You don’t necessarily want to have to deal with setting up the whole task management
[00:17:09] and the finite state machine and awaiting things.
[00:17:14] I’m imagining an IoT or embedded system situation where
[00:17:18] you don’t really want to be hyper-threaded.
[00:17:22] You don’t really want multiple threads.
[00:17:24] You want to be able to take a request and deal with it, send the response out straight away.
[00:17:28] You don’t want to have to take a request, put it on a thread, fire up a new thread,
[00:17:34] put it onto all sorts of stuff.
[00:17:36] You’re not doing multi-user.
[00:17:38] You’re not really aiming for millions of people sending requests all at once.
[00:17:43] You’re likely aiming to deal with maybe, I don’t know.
[00:17:47] I’m going to just pull a number out
[00:17:48] there, I’m going to be way off, but maybe 10 requests every second rather
[00:17:51] than a million requests every second, right?
[00:17:54] Yeah, on that aspect, you are correct.
[00:17:58] If you need a system which is performant enough to deal with hundreds of,
[00:18:06] maybe hundreds, it can deal with that.
[00:18:10] But if you need a device capable of handling millions of requests, .NET, NanoFrameworks,
[00:18:18] that’s not the thing for you.
[00:18:19] But from all the rest, that is basically correct.
[00:18:25] You have on the need for having async await,
[00:18:30] you can replace that with what we have, which is multi-threading.
[00:18:34] And you’ll be using here the same API of, I would say, the 4.7 or 4.8 network,
[00:18:43] which is the new thread start, that thing, because you can have as many
[00:18:48] threads as the amount of available memory allows you to.
[00:18:52] So you can split things between threads,
[00:18:55] just like you would do on a desktop application.
[00:18:59] Because, for example, you can have one thread or timer pulling
[00:19:04] a sensor reading every 30 seconds and then storing it on whatever storage you have.
[00:19:11] You can have another thread which is responsible for dealing with the LEDs,
[00:19:17] giving you the visual output on the system, or even a display on where you want to output
[00:19:24] a sensor reading, and you may want to have another thread which is dealing with the network connection
[00:19:31] and sending the telemetry or maybe connecting to IoT Hub.
[00:19:36] So all that is possible.
[00:19:38] And you can have pretty much the same and equivalent stuff on what you get with async await.
[00:19:46] But just with,
[00:19:47] I would call it, the old .NET patterns with the around system thread.
[00:19:54] Sure, sure.
[00:19:55] And again, that totally makes sense, right?
[00:19:57] Because my understanding from my one or two projects with the embedded system that I
[00:20:04] mentioned earlier in the episode is that it’s a completely different paradigm for software development, right?
[00:20:12] I’m used to building web apps or maybe server side based apps,
[00:20:17] where you can guarantee you have enough RAM to be able to do things like reflection and to use generics and to rely on the fact that I can just spin up a new thread whenever I can say async await this because I’m running on a modern operating system on pretty powerful hardware, perhaps in the cloud, perhaps on my computer, so I can rely on that.
[00:20:40] Whereas I guess with embedded systems, with IoT, it’s a completely different paradigm, right?
[00:20:47] Yes, again, you are correct.
[00:20:50] We have support for reflection, so you can even load an assembly on the fly and do whatever you want with it.
[00:20:58] Do the type crawling and all that stuff.
[00:21:00] It’s available on the other aspect.
[00:21:08] Yes, you have to deal with the differences.
[00:21:15] And that can be something.
[00:21:17] Yes. You have to deal with the differences. And that can be something.
[00:21:17] That kind of improves your skills as a developer, because you have to be very
[00:21:29] careful with the memory usage because it’s short.
[00:21:33] And it’s scarce.
[00:21:35] And you just don’t go and declare and
[00:21:40] buy the rate of 1 mega because you don’t have enough from there.
[00:21:46] And
[00:21:47] you you have to be careful on you don’t want to declare your variables and
[00:21:54] having having them around just because you have to be wise on all that and you
[00:22:03] have to be careful with with everything that relates with with memory so it’s
[00:22:09] it’s kind of a nice exercise as a as a developer to do some coding in nano
[00:22:16] framework because you have to to mind about all those things that you don’t
[00:22:22] when you have a bunch of RAM and storage space and everything that you are used
[00:22:28] to when you are coding for desktop do you have a WPF application and want to
[00:22:34] take it to macOS or Linux Avalonia XPF a binary compatible cross-platform fork
[00:22:41] of WPF enables WPF apps to run on new platforms with minimal
[00:22:46] effort
[00:22:46] and maximum compatibility with a few tweaks to your project file your WPF app
[00:22:52] and all of its dependencies are ready for testing on new platforms start your
[00:22:58] app transformation journey with a 30-day free trial head over to Avalonia UI dot
[00:23:04] net forward slash the modern dotnet show to get started today or press the link
[00:23:10] in the show notes as it will have the full URL sure sure yeah there was
[00:23:16] someone I was talking to a few days ago who was talking about like extreme
[00:23:21] performance at the edge and this is back to web development but he talked about
[00:23:25] how you know we’re kind of spoiled as developers right we have these
[00:23:30] incredibly powerful perhaps laptops perhaps perhaps desktops with oodles of
[00:23:35] RAM right we have more RAM CPU and hard drive space than we have ever had in our
[00:23:40] lives and we can store all of the you know all of the data in RAM we can store all of the
[00:23:45] requests in ram we can stop everything we can run an entire operating system in ram you know if
[00:23:50] you’re doing this isn’t exactly how it works but if you’re doing docker based stuff that’s kind of
[00:23:54] how that’s doing it so you’re running an entire operating system and your application and all of
[00:23:59] the debugging tools all in ram which is just mad whereas uh like you were saying there you know the
[00:24:05] the iot paradigm means we’ve got to strip all of that away strip all of that back to perhaps back
[00:24:10] to um the style of programming that people did in the you know 70s and 80s where it was like you
[00:24:16] know we have to do precisely just what we need and nothing more exactly exactly and to me that makes
[00:24:24] you a better programmer because you are aware of the system resources and limitations uh and
[00:24:31] you need to to make your way through that
[00:24:35] a hundred percent um no i agree completely um
[00:24:40] because
[00:24:40] i’ve i’ve seen a whole bunch of projects where the answer to how do we solve this performance
[00:24:47] bottleneck was we’ll just throw more resource at it just have more cpus more ram more hard drive
[00:24:52] space and it’s like well yeah but what about when you you know when you run out our cpu hard drive
[00:24:59] space or ram right you’re gonna if it’s already happened it’s gonna happen again
[00:25:02] indeed and then you throw either throw more cpu and ram there uh or you go and find the
[00:25:09] whatever
[00:25:11] you’ve got you can probably do all that here if there’s anything else
[00:25:14] that’s not up to you um lapse here that’s dave milk that works um
[00:25:20] i’m not aware of it how the game works for you
[00:25:23] do you have any other questions
[00:25:26] about your code
[00:25:29] i don’t have any i can shy away from telling you a bit more about decision-making
[00:25:35] uh but you know i want a good analysis for as much time as possible of is Сегодня
[00:25:38] um a very common problem with any kind of software as well is 501 renders
[00:25:39] it’s causing it on the code and fix it there where it’s supposed to be fixed sure or indeed as happens in my experience um you know you can you keep running it until it all falls over and the entire system comes crashing down around you then you hire someone like me to figure out why your code is running so slowly there you go
[00:25:40] So let’s say I’ve got a hold of .NET Nano Framework
[00:25:43] and I’ve got a whole bunch of devices laying around me.
[00:25:47] Can I just run .NET Nano Framework on any of my devices?
[00:25:52] Let’s say I’ve got Raspberry Pi and I’ve got a couple of Arduinos
[00:25:55] and a bunch of different boards that have different CPU architectures on it.
[00:26:01] Is there a version of .NET Nano Framework that runs on all of those?
[00:26:04] Or do I have to get a specific version?
[00:26:07] Let’s say I’m using an Arduino.
[00:26:08] Do I need to get Arduino flavor, I guess, of .NET Nano Framework?
[00:26:12] Or do I need to just get a generic thing?
[00:26:16] No, you can’t use a generic because every microcontroller out there,
[00:26:21] it’s different and it’s not just the architecture.
[00:26:25] It’s different on the way the pins are mapped, how the clock works,
[00:26:29] the internal flash and RAM.
[00:26:32] All that stuff is different from microcontroller to microcontroller.
[00:26:35] So you have to grab the firmware,
[00:26:37] which is specific.
[00:26:38] It’s specific to the microcontroller that you’re using and expanding a bit on this.
[00:26:46] On Raspberry Pi, you can go with the full .NET.
[00:26:51] There is the IoT core that you can run there on the Raspberry Pi.
[00:26:57] So it doesn’t make much sense to run on a framework there.
[00:27:01] You’ll be running .NET, but just not just Nano Framework.
[00:27:05] Nano Framework targets more resource,
[00:27:08] but it also constrains microcontrollers,
[00:27:11] meaning that the all-famous ESP32s out there and the likes,
[00:27:20] STM32s, NXP microcontrollers, Silicon Labs, Giant Jackos,
[00:27:28] these couple of microcontroller series from Texas Instruments,
[00:27:35] NXP, I’ve already mentioned that.
[00:27:37] There are firmware specifics for all those.
[00:27:40] And so you have an idea.
[00:27:42] The absolute minimum requirement in terms of storage to run on a framework,
[00:27:49] it’s a microcontroller with 32 bits and 128 Ks of flash and 64 Ks of RAM.
[00:28:02] If you have more than that, it will run and you can have a C-Sharp application,
[00:28:06] .NET, .NET, .NET, .NET, .NET.
[00:28:07] There.
[00:28:08] What you need beyond that,
[00:28:10] it depends on how complex your application is
[00:28:15] or how fast you want to,
[00:28:17] or how performant you want the computation to work.
[00:28:22] So that’s the minimum requirements to run .NET Nano Framework.
[00:28:29] Am I making sense?
[00:28:30] You know, I was saying to myself whilst you were listing all of those things, right,
[00:28:35] that my,
[00:28:37] the computer I’m using to talk to you with today is like billions of times more in capacity
[00:28:47] than what the Nano Framework allows you to do.
[00:28:52] And yet Nano Framework has, it’s targeting, you were saying they’re the bare minimum.
[00:28:56] So obviously anything less than this, it will not run.
[00:29:00] And when you’re talking bare minimum, I’m guessing it won’t run brilliantly,
[00:29:04] but it will still run, right?
[00:29:06] But like what you were talking about there,
[00:29:09] what sounded very much like the very first computer I ever had.
[00:29:14] Yeah.
[00:29:15] That’s probably, yes.
[00:29:18] Whereas I’m sitting here talking to you using a MacBook Air
[00:29:22] that has 24 gigabytes of RAM
[00:29:24] and eight cores of some weird new CPU architecture
[00:29:28] that no one’s ever heard of.
[00:29:29] Well, I mean, they have heard of it.
[00:29:31] It’s an M2, but you know what I mean?
[00:29:32] Like it just boggles my mind
[00:29:35] the difference in system requirements, right?
[00:29:41] And I’ve, like I said, I’ve worked on,
[00:29:43] I’ve consulted on applications that are sitting on boxes,
[00:29:47] like servers, very expensive servers
[00:29:49] that are about as powerful as this Mac Air M2,
[00:29:53] which was top of the line when I bought it,
[00:29:56] that can’t handle more than 200 requests coming in a second.
[00:30:00] And you’re saying, yeah, it’s fine.
[00:30:02] I mean, just go get yourself an ESP32 with,
[00:30:04] say, teeny amounts of RAM.
[00:30:06] And guess what?
[00:30:07] We’ve got a system running.
[00:30:10] Yeah, that’s the thing there.
[00:30:12] And it’s kind of that mantra,
[00:30:15] just take what you need and not more than that.
[00:30:19] I mean, you could have one of those beef machines
[00:30:23] sitting on your garden and reading a soil moisture sensor
[00:30:28] and then sending out the signal
[00:30:29] to turn on or off the sprinkler system.
[00:30:33] You could do that.
[00:30:34] But it’s a complete waste of power, of CPU, of RAM, of everything.
[00:30:41] When you can do that with a tiny Mac controller
[00:30:44] that can run on a battery for years and years,
[00:30:50] or even not even a battery, a solar panel,
[00:30:53] which can make it run to the end of the world.
[00:30:56] And you cannot do that with a desktop system
[00:30:59] because you need it connected to the power plug.
[00:31:02] And it will…
[00:31:04] It will consume energy, which is expensive, and so on.
[00:31:09] Yeah, it boggles my mind.
[00:31:12] Just like…
[00:31:13] Yeah, like my first computer was around as powerful
[00:31:17] as these devices you’re talking about.
[00:31:20] You can plug a solar panel into and run forever
[00:31:24] and run effectively .NET on.
[00:31:28] I just want to…
[00:31:30] I’m going to take a moment internally
[00:31:32] and just think about that, right?
[00:31:34] No.
[00:31:35] Yeah, you do that, and that’s the thing.
[00:31:38] And you can have…
[00:31:39] And that’s one of the key things
[00:31:44] of the .NET Network framework proposal.
[00:31:47] That you can have a regular desktop developer
[00:31:53] and you can have it coding for embedded systems
[00:31:56] in a very short time.
[00:31:58] And a very short time is just a few days training.
[00:32:02] Because everything which is complicated,
[00:32:04] on embedded systems development,
[00:32:06] and this is complicated, don’t get me wrong,
[00:32:09] it’s abstracted by the NAR framework
[00:32:13] and the firmware that you have it.
[00:32:15] Because when you are coding for it,
[00:32:18] you just need to be made aware of how you connect
[00:32:23] to that chip using that bus and the GPIOs,
[00:32:27] which are the inputs outputs on the microcontroller work,
[00:32:31] which is something that we just…
[00:32:33] Which is something that we just…
[00:32:34] A few explanations, you will understand that right away.
[00:32:38] And that makes you productive.
[00:32:40] And considering what you have to pay these days
[00:32:46] to a specialized developer on C, on C++,
[00:32:50] and how much more common a C-sharp developer is,
[00:32:59] you can see where this is going.
[00:33:01] You can even have people coding
[00:33:04] in the morning to embed the system
[00:33:06] and in the afternoon to the cloud API
[00:33:09] that’s running on Azure.
[00:33:13] And the same person can handle that.
[00:33:15] But if you want to change that to a C-sharp,
[00:33:20] sorry, to a C, C++ programmer,
[00:33:24] you won’t be able to do that.
[00:33:26] And not to mention all the productivity gains
[00:33:29] that you have on coding with a manager,
[00:33:33] with a managed language like C-sharp is,
[00:33:38] if you code in C,
[00:33:41] you know that it can be painful to deal with the pointers.
[00:33:46] You have to deal with the memory management.
[00:33:50] You have to allocate memory,
[00:33:51] you have to de-allocate memory.
[00:33:53] If you have a byte array,
[00:33:56] it will happily overrun it and start doing bad things.
[00:34:01] And you have to be aware of some of those things, right?
[00:34:02] have to be aware of that and that can cost you time if you do a bug around that and you have to
[00:34:08] find it and you have to fix it if you are using a managed language like c-sharp all of that
[00:34:15] goes away and you can just focus on the on your task at hand it’s a breeze to work with stream
[00:34:24] manipulation which is hard in c you don’t have to worry whatsoever with memory management the
[00:34:32] garbage collector will do that for you happily and you just have to code and this is something
[00:34:39] huge in terms of efficiency and if you are a company you are obviously worried with the time
[00:34:48] to market and being efficient and the customer comes up with with a bug and you can find it
[00:34:54] very easily you can come up with a fix and you do a new release everything it’s much
[00:35:02] different and it’s very easy to do a new release and you can find it very easily you can come up
[00:35:02] with a fix and you do a new release everything it’s much easier when you are coding in c-sharp
[00:35:04] not to mention the the coding experience you have the the visual studio ide to work with
[00:35:12] you have intellisense just like you have on on a desktop project you you have all those helps
[00:35:20] from git copilot if you are lucky enough to have it with everything that you we are spoiled as
[00:35:27] developers when coding in visual studio you just need a new sbk
[00:35:32] the software or you can add some new settings with the sbk and you can go with the code in the
[00:35:34] sbk it’s an easy way to go on the board with the sbk you have a simple usb cable to deploy to your
[00:35:43] nano framework board you hit f5 you are running the application right on the board with just a
[00:35:49] plain simple usb cable as compared to and they can if you go into the debug session you can set
[00:35:56] breakpoints you can go with the code back and forth you can inspect locals you can change the
[00:36:00] variable contents everything that you are used to and all that or most of that doesn’t happen
[00:36:01] and then all that or most of that doesn’t happen
[00:36:02] or it’s not available, or it’s much harder if you are doing it with C or C++
[00:36:09] on one of those wacky IDEs that are out there for embedded system developers.
[00:36:19] Yeah, there’s something you said there I hadn’t even thought of.
[00:36:23] So thank you for bringing that up.
[00:36:26] And it leads into my next question, and that would be, like,
[00:36:29] there’s two parts to this one, so I totally appreciate that we’ll need to cover both
[00:36:33] before you can answer, but, like, so I hadn’t even thought about that.
[00:36:37] There are two parts to this question, right?
[00:36:41] I hadn’t even thought this far ahead.
[00:36:44] There’s a second part that we’ll need to cover in a second,
[00:36:46] but we’ll need to cover both so you can answer, I guess,
[00:36:49] but you could go to an assistive technology thing like ChatGPT
[00:36:54] or any other large language model, and you could presumably say
[00:36:57] something along the lines of,
[00:36:59] supposing I have an ESP32 and I’m using .NET Nano framework,
[00:37:04] how do I initiate a web request versus, you know, I’ve got an ESP32,
[00:37:11] I’m writing in C++, how do I do web requests, right?
[00:37:14] The answers will be dramatically different.
[00:37:19] Yeah, absolutely.
[00:37:20] You can do that, and you can even go even further
[00:37:24] because this is C Sharp, and we have our APIs pretty much aligned,
[00:37:29] the differences are minimal.
[00:37:31] You can ask, or you can even use every C Sharp coding skills
[00:37:39] that those tools have and take advantage of it.
[00:37:43] Like you go with the Microsoft Learn Portal, or you go to Stack Overflow or GitHub,
[00:37:50] everything that you found out there, which is C Sharp, and which is a lot,
[00:37:56] you can reuse on, I can use on another platform.
[00:37:58] Yeah, that’s a good point.
[00:37:59] Yeah, that’s a good point.
[00:37:59] Yeah, that’s a good point.
[00:37:59] Yeah, that’s a good point.
[00:37:59] Yeah, that’s a good point.
[00:37:59] Yeah, that’s a good point.
[00:37:59] Yeah, that’s a good point.
[00:37:59] Because at the end of the day, this is .NET C Sharp that you are coding with.
[00:38:07] Yeah, that makes total sense.
[00:38:09] And the second part of that would be like,
[00:38:12] supposing I’m using something like an ESP32 or some off-the-shelf hardware,
[00:38:17] presumably whatever I want to do, there’ll be a NuGet package for it,
[00:38:21] or a NuGet package that gets me most of the way, right?
[00:38:24] Like I said there, right?
[00:38:25] I’ve got an ESP32, I’m running .NET Nano framework.
[00:38:28] I want to…
[00:38:29] Read something over, I don’t know, some thing over the GPIO port.
[00:38:35] Yeah.
[00:38:35] Yeah, some sensor over the GPIO port, and then send it out using HTTP over the web.
[00:38:40] Well, I’m guessing I could use WebClient, or if we’re lucky enough, HTTP client, either way.
[00:38:45] Yes.
[00:38:46] But reading from the GPIO port, I’m guessing there’s probably a NuGet package
[00:38:50] for whatever I’m reading over the GPIO port, right?
[00:38:53] I’m going to say, right, I need to read pins one, two, and three.
[00:38:56] I need to read four bytes of data.
[00:38:58] Done.
[00:38:59] Right?
[00:39:00] Whereas with C++, it would be like,
[00:39:02] interrogate these individual memory addresses for this much time,
[00:39:06] and then format the answer, you know?
[00:39:08] I feel like a lot of .NET devs don’t realize just how much effort there is.
[00:39:14] You are correct on that.
[00:39:17] I’ll start with a hard approach.
[00:39:18] If you want to get on C or C++,
[00:39:21] you have to go through the datasheet or the manual for your Mac controller.
[00:39:25] You have to find the address for the register.
[00:39:29] That’s holding the contents for those GPIO ports that you want to read,
[00:39:35] you want to know which byte, exactly, it matches the GPIO that you want to read.
[00:39:40] And you need to read that register,
[00:39:42] and then you need to parse it and see if it’s high or low.
[00:39:46] With C-Sharp and NanoFramework, as you were saying,
[00:39:50] you just reference system device GPIO NuGet package,
[00:39:57] and
[00:39:58] cál,
[00:39:59] depending on the encoding of the microcontroller you’re using,
[00:40:01] hey, I want to read bit 2 from port C, and that’s it.
[00:40:10] You get the pin value object, which is high or low,
[00:40:14] depending on the state of the object, and that’s it.
[00:40:18] Because getting back to the C-sharp,
[00:40:20] to the C description that I was giving a moment ago,
[00:40:24] before that and for the GPIO to work,
[00:40:27] you have to find also the registers that configure the GPIOs
[00:40:33] to behave the way that you want,
[00:40:36] and if you want them to be input, output,
[00:40:41] and if they are transitioning state,
[00:40:43] if you want to be aware of transition high to low,
[00:40:46] low to high, or both, blah, blah, blah.
[00:40:48] And you have a bunch of stuff,
[00:40:50] which you don’t even have to think about it
[00:40:53] when you are coding with NanoFramework,
[00:40:55] because all that is abstracted from you.
[00:40:57] And you just need to focus on the task at hand.
[00:41:01] Hey, I want to read the state of pin 2 on port C,
[00:41:07] and that’s it, one line of code.
[00:41:11] Wow.
[00:41:12] Like, obviously, you know, I’m a huge fan of .NET anyway,
[00:41:16] and so I know that on a standard desktop application
[00:41:19] or on a server, you know, for instance,
[00:41:22] opening a port and opening a connection, sorry,
[00:41:25] to a web server and saying, hey,
[00:41:27] I have this information, in .NET is a trivial task,
[00:41:31] in C, a non-trivial task.
[00:41:33] Oh, yes.
[00:41:34] But I hadn’t even thought, yeah,
[00:41:38] I hadn’t even thought that far down about, like,
[00:41:41] in order to enable GPIO, I need to tell it what mode to be in,
[00:41:46] and then I need to tell it if it becomes a,
[00:41:49] so for folks who are maybe listening to this
[00:41:53] and don’t have the background that I’m guessing you have,
[00:41:57] that I also have, you know, I tinkered a lot with electronics
[00:42:01] and learned digital electronics from that.
[00:42:03] When we say a low value, that’s a voltage level of maybe 0
[00:42:06] up to maybe 1.25 volts, depending on your system.
[00:42:10] And when we say a high value, that might be 3.75 or 4 volts
[00:42:14] up to 5 volts.
[00:42:15] So that’s your 0 and that’s your 1 of binary, right?
[00:42:18] You’re literally working in binary.
[00:42:20] And so if you’re telling the GPIO port in C
[00:42:23] through some registers that configure it,
[00:42:26] you’re saying, hey, I want you to,
[00:42:27] you read every, you know, this much data,
[00:42:30] and when it flips from being 0 to 1, let me know.
[00:42:33] And, you know, I want this much, you know,
[00:42:36] maybe byte 2, byte 4 on a regular basis or whatever.
[00:42:40] That’s just, like, setting all of that up, like you said,
[00:42:43] would take perhaps a couple of hours.
[00:42:47] Yes, because especially if you are not familiar
[00:42:51] with that microcontroller that you are using,
[00:42:53] you have to chase the data shift,
[00:42:55] and you have to chase the manual,
[00:42:56] you have to find all that stuff.
[00:42:58] And then you have to make sure that because microcontrollers,
[00:43:02] even on the same device, have different packages,
[00:43:06] the encapsulations that you see on the PCBs,
[00:43:10] that port, pin 2 on port C could be on different pins,
[00:43:17] even on the same microcontroller,
[00:43:18] just because the package is different.
[00:43:20] And you have to chase that.
[00:43:21] And you have to grab the schematic off the board.
[00:43:24] And so that can take you a long time.
[00:43:26] It can take you a lot of time.
[00:43:28] And you are not being productive with that.
[00:43:32] .NET Neuroframework helps you be more productive
[00:43:37] because it abstracts most of the complications.
[00:43:41] Of course, you still need to know which pin you want to talk to.
[00:43:44] But that’s easy to get that information.
[00:43:52] Sure, sure.
[00:43:53] And we didn’t even talk about the biggest complication,
[00:43:55] which is when the…
[00:43:56] When the project manager goes,
[00:43:57] actually, it would be prohibitively expensive
[00:44:00] for us to use that particular sensor on the GPIO port.
[00:44:03] So we’ve changed it.
[00:44:04] And you’ve got like an hour to change the code
[00:44:07] because we’re sending devices out tomorrow.
[00:44:12] Yeah, that’s exactly it.
[00:44:13] Because it abstracts the complication from you.
[00:44:17] If you want to switch devices and, for example,
[00:44:20] if this is connected to an SPI bus,
[00:44:24] you just have to come up with…
[00:44:26] with all that is there.
[00:44:29] You reference the SPI nuget,
[00:44:32] which brings you the connection to SPI buses.
[00:44:37] And you just have to configure,
[00:44:41] hey, this is connected to this and this pin.
[00:44:43] And you can start sending commands and reading data from the sensor.
[00:44:49] You can even, if that was a sensor that you use a few projects ago,
[00:44:55] you still have the…
[00:44:56] the code around on a class, hopefully.
[00:44:59] And you just bring in that…
[00:45:01] that code file with that class and it will be working in no time.
[00:45:07] You can do something similar with C,
[00:45:10] but it’s not as easy as it is when you are doing it with C-Sharp.
[00:45:22] If you’re enjoying this show,
[00:45:23] would you mind sharing it with a friend or colleague?
[00:45:25] Check out Podcatcher for a link to the show notes,
[00:45:28] which has an embedded player within it and a transcription and all that stuff,
[00:45:32] and share that link with them.
[00:45:34] I’d really appreciate it if you could indeed share the show.
[00:45:37] But if you’d like a few other ways to support it,
[00:45:39] you could leave a rating or review on your podcatcher of choice.
[00:45:43] So if you head over to dotnetcore.show slash review,
[00:45:47] you’ll find loads of ways to do that.
[00:45:48] You could consider buying the show a coffee.
[00:45:51] The buy me a coffee link is available on each show’s show notes page on the website.
[00:45:55] This is a one-off financial support option.
[00:45:58] You could become a patron.
[00:46:00] This is a monthly subscription-based financial support option,
[00:46:03] and the link to that is included on each episode’s show notes page as well.
[00:46:08] I’d love it if you could share the show with a friend or colleague,
[00:46:10] or leave a rating or review.
[00:46:13] The other options are completely up to you
[00:46:15] and are not required at all to continue enjoying the show.
[00:46:19] Anyway, let’s get back to it.
[00:46:25] Sure, sure.
[00:46:27] Yeah, just like that.
[00:46:30] Like you were saying, the productivity, the ease of use,
[00:46:33] when you need to change something because it’s all abstracted away makes it so much simpler.
[00:46:38] I really like that.
[00:46:39] Yeah, yeah.
[00:46:40] Okay, so let’s say I’m listening to this conversation and I’m like,
[00:46:44] that’s it, I’m getting .NET on our framework.
[00:46:46] I’m going to buy one of these microcontrollers.
[00:46:48] What can I build?
[00:46:50] Like, we talked a lot about sensor readings.
[00:46:53] We talked, I mentioned a couple of times,
[00:46:55] about maybe being a web server or supplying some data on demand.
[00:46:59] Like, is, I’m going to use the Bonnie quote, say they come,
[00:47:03] is that all you can do?
[00:47:05] Like, what are some of the sort of killer apps of the .NET Nano framework and IoT with .NET?
[00:47:17] Like we’ve talked about on the beginning of our conversation,
[00:47:22] you can do pretty much everything
[00:47:24] that you want to do on embedded systems with Nano framework.
[00:47:28] This, I mean, this is not meant to replace embedded system development on C and C++
[00:47:37] because there are limitations for this.
[00:47:39] If you need to be really tight control on timings
[00:47:45] and if you need the response times on the system on the microseconds,
[00:47:53] this is not for you and you have to go with the traditional C and C++.
[00:47:58] But I would dare to say that for the vast majority of the systems out there,
[00:48:04] you can do exactly the same and be much more productive
[00:48:08] using .NET C Sharp for embedded systems development.
[00:48:13] Okay.
[00:48:14] And so, having said that,
[00:48:18] the productivity, we already covered that.
[00:48:23] And the fact that you can have regular desktops developers using it is also a plus.
[00:48:32] And regarding the usage fields,
[00:48:37] let me give you a couple of examples.
[00:48:41] One of the large projects that we’ve just wrapped up a couple of months ago
[00:48:48] is for a customer on the US, which is Skyworks.
[00:48:52] They are a silicon manufacturer
[00:48:57] and we’re working with their timing division.
[00:49:00] They were for a long time a .NET shop,
[00:49:04] but they use .NET for coding the desktop applications.
[00:49:09] There are applications on which you configure the various parameters on the timing devices.
[00:49:15] And here, on timing devices, these are chips that generate clock signals
[00:49:20] and they are used from SATA.
[00:49:22] From satellites to regular cellular devices
[00:49:27] and everything that needs timing,
[00:49:29] which is pretty much everything on the embedded systems.
[00:49:32] And you have those desktop applications that are coding in C Sharp.
[00:49:38] And the EVBs, which stands for evaluation boards for the various components,
[00:49:45] were coded in C and C++.
[00:49:48] They choose to switch that to nano framework
[00:49:52] in order to use .NET C Sharp
[00:49:55] from the microcontroller up to the production line,
[00:50:02] which they now have.
[00:50:04] Meaning that they are using code and classes across these different applications.
[00:50:12] They have the EVBs running firmware, which is nano framework.
[00:50:18] They have the desktop application,
[00:50:20] which is connected to the EVBs through an USB cable running .NET,
[00:50:26] but the full .NET.
[00:50:28] They have C Sharp .NET applications on the production lines,
[00:50:33] doing the Q&A on the devices, on the boards.
[00:50:39] When they are developing, they have huge test rigs
[00:50:44] with a bunch of wires connected to the boards.
[00:50:47] And they have temperature chambers
[00:50:49] to evaluate the stability of the chips
[00:50:52] across the temperature range that they work with.
[00:50:56] It’s a very complex system.
[00:50:58] Everything runs around .NET and with nano framework.
[00:51:03] They manage to reach the last mile, if you want,
[00:51:07] to be able to do that on the boards.
[00:51:10] And that’s a typical usage for nano framework.
[00:51:16] And then you have other customers,
[00:51:19] that are using this on boards,
[00:51:23] which run a telemetry system for oil fields,
[00:51:27] which are deployed out there in the desert.
[00:51:31] You have a small box, which is powered by a solar panel.
[00:51:36] And the device sits there.
[00:51:38] Every hour or so, it wakes up,
[00:51:41] reads a bunch of the sensors that you have there,
[00:51:45] from the simplest, what’s the level on the oil there,
[00:51:48] what’s the temperature, and a bunch of others.
[00:51:51] It composes a package with all that telemetry data.
[00:51:56] It sends that telemetry data through a satellite connection,
[00:52:00] which will go into IoT Hub,
[00:52:03] and then get back to sleep.
[00:52:05] On the next couple of hours, it will wake up again.
[00:52:08] It will do the same thing.
[00:52:10] And this is over and over and over.
[00:52:13] So this is kind of two, I would say,
[00:52:17] because it fills applications on embedded systems,
[00:52:21] running nano framework.
[00:52:23] One of them is highly connected to the cloud,
[00:52:26] to the Internet of Things,
[00:52:27] and the other one, it’s not.
[00:52:29] It’s just a desktop application, if you will,
[00:52:34] because it’s not even connected to the Internet,
[00:52:36] because it doesn’t need to.
[00:52:40] Cool. Okay.
[00:52:43] Yeah, I like those,
[00:52:46] because it’s making all of that so much simpler to get started.
[00:52:52] We’ve said it hundreds of times, right?
[00:52:54] It’s all about getting started very quickly
[00:52:56] and getting to, I guess, from zero to production, right?
[00:53:01] It is, it is.
[00:53:02] And you can, now in C Sharp,
[00:53:05] you know that you can be very productive,
[00:53:07] and you can code pretty much everything very efficiently,
[00:53:12] which makes this a great platform.
[00:53:14] You grab a breadboard,
[00:53:16] you stick an ESP32 module onto it,
[00:53:20] and you plug an LED or a sensor or whatever,
[00:53:23] and in half an hour you have a proof of concept
[00:53:27] of something that you are building or just having fun with.
[00:53:31] And this is great not only for learning to code,
[00:53:34] but to come up with a proof of concept
[00:53:36] that you want to show to a customer.
[00:53:39] If you want to do that in C,
[00:53:43] I dare you to do that on the same time.
[00:53:45] You won’t.
[00:53:46] You won’t be able to.
[00:53:48] Meaning that with that code and that proof of concept,
[00:53:52] then you can evolve, you can keep working on it,
[00:53:55] and then you can easily migrate that to a production-grade system
[00:54:02] because you will be using the same code.
[00:54:05] You don’t have to change much to get it working.
[00:54:10] And even if you change platform,
[00:54:13] if you go, for example,
[00:54:15] your proof of concept is on an ESP32 device
[00:54:19] and that you have on your breadboard,
[00:54:21] okay, that’s working.
[00:54:22] You have your project in C-sharp, all good.
[00:54:25] You need to move to production,
[00:54:27] but for some reason you are not using an ESP32.
[00:54:31] You are using an NXP microcontroller.
[00:54:34] That’s good.
[00:54:35] You just grab the code on that other device
[00:54:39] that will go and that will be your production platform.
[00:54:44] And everything works.
[00:54:46] You may have to adjust a couple of GPIOs,
[00:54:49] which are not in the same location,
[00:54:51] but 99% of the code will just work.
[00:54:56] And despite you have changed the platform,
[00:54:59] because the firmware has abstracted
[00:55:02] all the hardware intricacies from you,
[00:55:05] and you can do that.
[00:55:07] If you were doing it with C,
[00:55:10] you could not do that, ever.
[00:55:13] You have to change everything
[00:55:15] because you are on a different platform.
[00:55:17] You have a different vendor.
[00:55:19] You have a different SDK.
[00:55:21] You have different APIs.
[00:55:23] You have a different architecture
[00:55:25] on the processor, possibly.
[00:55:27] You have different GPIOs, all that.
[00:55:29] And it’s not going to work, at least easily.
[00:55:35] Sure.
[00:55:37] I don’t think it’s possible for us to downplay
[00:55:42] just how non-trivial it is
[00:55:46] to swap out hardware for a system
[00:55:50] that you’ve written in C or C++.
[00:55:52] My first bit of actual academic programming,
[00:55:58] I guess you’d use the phrase,
[00:56:00] when I was at college or whatever,
[00:56:02] we were doing assembler on a Motorola 68K.
[00:56:06] And this was part of a…
[00:56:07] I’ve said it in other episodes as well.
[00:56:09] It was part of a development kit,
[00:56:10] a hardware development kit,
[00:56:11] called a Flight 68K.
[00:56:14] So it was a Motorola 68K
[00:56:15] with loads of different bits plugged into it.
[00:56:17] And you could swap them out.
[00:56:18] You could be like,
[00:56:19] now I want the LEDs.
[00:56:21] And then you’d take that out
[00:56:22] and then you’d say,
[00:56:23] I don’t think it used GPIO.
[00:56:25] I can’t remember what it used,
[00:56:26] but it didn’t use that.
[00:56:27] And then you could plug in
[00:56:28] loads of different sensors.
[00:56:29] And one of the tasks that I was given
[00:56:31] was calculate how fast a bullet traveled.
[00:56:34] And they didn’t have…
[00:56:36] They had to get a technician to build a…
[00:56:39] using an air rifle,
[00:56:40] to build the hardware
[00:56:41] that I could plug into the board
[00:56:43] to measure the speed of the…
[00:56:45] It was an airsoft bullet,
[00:56:46] but it was still a bullet, right?
[00:56:48] And that took a couple of days
[00:56:51] for them to put together.
[00:56:53] And I had made loads of assumptions
[00:56:55] about how it would work
[00:56:56] and where it would plug in
[00:56:57] and what the registers would be
[00:56:59] for my bit of code that would read this.
[00:57:02] And then they presented me with this.
[00:57:05] Essentially, it was a rifle
[00:57:06] glued to a piece of wood
[00:57:09] with two sets of crocodile clips
[00:57:13] that I could put sheets of tin foil in.
[00:57:18] I’m not sure what the cross-country name
[00:57:22] of tin foil is,
[00:57:23] but just sheets of thin metal
[00:57:27] that I could put in between them.
[00:57:29] And then I could replace those.
[00:57:31] But then they went through
[00:57:32] into individual cables
[00:57:34] that were bundled together
[00:57:36] that I had to then plug into the board.
[00:57:38] And all of my code had to be rewritten.
[00:57:40] I’d say about 90% of my code
[00:57:42] had to be rewritten completely
[00:57:44] because I had assumed,
[00:57:45] oh, there’ll be, you know,
[00:57:46] it’ll be register one
[00:57:47] or it’ll be register two.
[00:57:48] And it wasn’t.
[00:57:49] It was like I was messing
[00:57:50] with individual memory addresses.
[00:57:52] And so I don’t think it can be underplayed
[00:57:55] just how much messing around is required
[00:57:59] when you’re writing in C, C++ or Assembler
[00:58:01] and the hardware changes.
[00:58:03] Absolutely, yeah, yeah.
[00:58:05] Because the thing,
[00:58:06] as you were describing,
[00:58:07] changing a platform
[00:58:09] or changing my controller
[00:58:11] really changes everything.
[00:58:13] And if you have this
[00:58:16] on a very layered approach,
[00:58:18] which is what we are doing
[00:58:19] with NanoFramework,
[00:58:21] all the upper layer on the application,
[00:58:23] all the layers that are on the application
[00:58:26] will remain the same
[00:58:27] because it’s up to the firmware
[00:58:30] on the lower layers
[00:58:31] to map this to whatever registers
[00:58:34] is different on that platform.
[00:58:36] But all that
[00:58:37] is abstracted from you.
[00:58:38] So you can see
[00:58:39] the mass productivity gains
[00:58:40] that you can just swap platforms
[00:58:41] and you can reuse code
[00:58:42] with the library
[00:58:43] that you have
[00:58:44] for another device
[00:58:45] for another project.
[00:58:46] And you can bring that in
[00:58:47] and you can simply just move
[00:58:48] from one more controller
[00:58:49] to the other
[00:58:50] with the minimal changes
[00:58:51] on your code,
[00:58:52] which is something huge.
[00:58:53] Sure.
[00:58:54] Okay.
[00:58:55] So let’s say
[00:58:56] I’ve got myself
[00:58:57] some bits of code
[00:58:58] that I want to change.
[00:58:59] And I want to change
[00:59:00] a little bit of code
[00:59:01] that I want to change
[00:59:02] and I want to change
[00:59:03] a little bit of code
[00:59:04] that I want to change
[00:59:05] and I want to change
[00:59:06] some bits of hardware.
[00:59:08] I’ve used .NET Nano Framework
[00:59:10] to build something
[00:59:11] and I’ve gone proper
[00:59:13] like evil genius mode.
[00:59:14] And I’m like,
[00:59:15] okay, I’ve bought
[00:59:16] 50,000 of these chips
[00:59:17] and I want to deploy
[00:59:19] to all of them.
[00:59:20] Is there some kind of
[00:59:21] automated way
[00:59:22] that I can do that?
[00:59:23] Can I use things
[00:59:24] like GitHub Actions
[00:59:25] or is it just a case of,
[00:59:26] you know, hit F5,
[00:59:27] plug it all in,
[00:59:28] hit F5, unplug it,
[00:59:30] plug the next one in,
[00:59:31] F5, unplug it,
[00:59:32] plug the next one in?
[00:59:33] Yeah, that would be painful.
[00:59:35] But yeah,
[00:59:36] all this is,
[00:59:40] everything is available
[00:59:42] to use this
[00:59:43] at a professional level,
[00:59:45] not only hobbyists
[00:59:46] or if you are a student
[00:59:47] on a school bench.
[00:59:50] This is production grade
[00:59:52] and you can do this commercially.
[00:59:54] There are available command lines
[00:59:58] that you can use
[00:59:59] on which you don’t need
[01:00:02] Visual Studio.
[01:00:03] You can use MSBuild
[01:00:04] and the command staff
[01:00:05] and you can use
[01:00:06] Visual Studio
[01:00:07] and at the end
[01:00:08] of the build pipeline,
[01:00:09] which can be
[01:00:10] a GitHub Action,
[01:00:11] by the way,
[01:00:12] you will have
[01:00:13] a binary file
[01:00:14] which is
[01:00:15] what’s going to be
[01:00:16] deployed
[01:00:17] or flashed
[01:00:18] on the microcontroller
[01:00:19] and then
[01:00:20] you can use
[01:00:21] those CLIs
[01:00:22] to do that
[01:00:23] on a very
[01:00:24] automated fashion
[01:00:25] and you can even
[01:00:26] have some interaction
[01:00:27] with the devices,
[01:00:28] meaning
[01:00:29] that you can
[01:00:30] use them
[01:00:31] in a very
[01:00:32] automated fashion
[01:00:33] and you can even
[01:00:34] have
[01:00:35] a firmware
[01:00:38] which is running
[01:00:39] the production tests,
[01:00:40] which will be
[01:00:41] the very first application
[01:00:42] that will be deployed
[01:00:43] and run on your board
[01:00:45] and you can do
[01:00:46] the usual stuff
[01:00:47] that you can find
[01:00:48] on QNA
[01:00:51] electronic production line.
[01:00:53] You can see
[01:00:54] the LEDs blinking
[01:00:55] on some pattern.
[01:00:56] If you have a display,
[01:00:57] you’ll see those messages
[01:00:59] with the various tests
[01:01:00] that the system
[01:01:01] is running into.
[01:01:03] If it’s connected
[01:01:04] to the network,
[01:01:05] it will connect
[01:01:06] to some service
[01:01:07] and will get
[01:01:08] some reply
[01:01:09] and everything
[01:01:10] will be tested
[01:01:11] with that application.
[01:01:12] Then you can
[01:01:13] just use
[01:01:14] the same command line
[01:01:15] to deploy
[01:01:16] the final application
[01:01:17] that will go
[01:01:18] into the field
[01:01:19] and deploy
[01:01:20] in the real device.
[01:01:21] So,
[01:01:22] you can do
[01:01:23] all that.
[01:01:24] And speaking
[01:01:25] of professional tools,
[01:01:26] you have
[01:01:27] also
[01:01:28] a lot
[01:01:29] of
[01:01:30] tools
[01:01:31] that you can
[01:01:32] use
[01:01:33] on our framework.
[01:01:35] Other tools
[01:01:36] that help
[01:01:37] you
[01:01:38] develop
[01:01:39] a better product
[01:01:40] and be sure
[01:01:41] on what
[01:01:42] you are doing.
[01:01:43] For example,
[01:01:44] we have
[01:01:45] a framework
[01:01:46] with unit tests
[01:01:47] just like
[01:01:48] you have
[01:01:49] on the
[01:01:50] full.net.
[01:01:51] Meaning that
[01:01:52] if you want
[01:01:53] to get crazy
[01:01:54] with unit tests,
[01:01:55] which you should be,
[01:01:56] you can do
[01:01:57] that on our framework
[01:01:58] and that’s
[01:01:59] available.
[01:02:00] If you
[01:02:01] want
[01:02:02] to do
[01:02:04] integration
[01:02:05] testing,
[01:02:06] you can
[01:02:07] do that
[01:02:08] also with
[01:02:09] the variation
[01:02:10] of the unit
[01:02:11] tests that
[01:02:12] can run
[01:02:13] on the
[01:02:14] device.
[01:02:15] And we’ll
[01:02:16] take care
[01:02:17] not just
[01:02:18] the code
[01:02:19] but the
[01:02:20] hardware
[01:02:21] interaction.
[01:02:22] We have
[01:02:23] libraries
[01:02:24] for doing
[01:02:25] benchmarking
[01:02:26] and logging.
[01:02:27] You can
[01:02:28] log to
[01:02:29] a file
[01:02:30] on an
[01:02:31] internet
[01:02:32] network service
[01:02:33] that you
[01:02:34] are connected
[01:02:35] to sockets,
[01:02:36] you name it.
[01:02:37] All those
[01:02:38] advanced
[01:02:39] tools
[01:02:40] that you
[01:02:41] find on
[01:02:42] the full.net
[01:02:43] and that
[01:02:44] you have
[01:02:45] on the
[01:02:46] desktop
[01:02:47] or on
[01:02:48] a cloud
[01:02:49] project,
[01:02:50] you have
[01:02:51] pretty much
[01:02:52] the same
[01:02:53] equivalence
[01:02:54] on nano framework
[01:02:55] to make
[01:02:56] sure
[01:02:57] that you
[01:02:58] are delivering
[01:02:59] a quality
[01:03:00] experience
[01:03:01] and you
[01:03:02] can be
[01:03:03] as much
[01:03:04] sure as
[01:03:05] you can
[01:03:06] be on
[01:03:07] anything
[01:03:08] that is
[01:03:09] software.
[01:03:10] Cool.
[01:03:11] Okay.
[01:03:12] I like
[01:03:13] that.
[01:03:14] Because
[01:03:15] like you
[01:03:16] said,
[01:03:17] it would
[01:03:18] be painful
[01:03:19] to have
[01:03:20] to boot
[01:03:21] Visual Studio,
[01:03:22] hit F5
[01:03:23] deploy.
[01:03:24] I’m
[01:03:25] all for
[01:03:26] unit tests
[01:03:27] whenever
[01:03:28] I can
[01:03:29] but that’s
[01:03:30] also really
[01:03:31] good that
[01:03:32] you’ve
[01:03:33] thought about
[01:03:34] that.
[01:03:35] So then,
[01:03:36] how do I
[01:03:37] get started
[01:03:38] with .net
[01:03:39] nano framework?
[01:03:40] Is it
[01:03:41] just go to
[01:03:42] the website
[01:03:43] and like
[01:03:44] there’s
[01:03:45] maybe a
[01:03:46] hello world
[01:03:47] or something
[01:03:48] that I can
[01:03:49] copy down
[01:03:50] and figure
[01:03:51] out?
[01:03:52] Yeah,
[01:03:53] you have
[01:03:54] the hello
[01:03:55] world
[01:03:56] as the
[01:03:57] project
[01:03:58] framework.
[01:03:59] It will
[01:04:00] show you
[01:04:01] the Visual Studio
[01:04:02] extension,
[01:04:03] which the
[01:04:04] name will
[01:04:05] be nano
[01:04:06] framework.
[01:04:07] Not very
[01:04:08] surprising.
[01:04:09] And you
[01:04:10] install that.
[01:04:11] With that,
[01:04:12] you have
[01:04:13] all the
[01:04:14] debugging
[01:04:15] stuff
[01:04:16] that’s
[01:04:17] required
[01:04:18] for
[01:04:19] Visual Studio
[01:04:20] to work
[01:04:21] and build
[01:04:22] and deploy
[01:04:23] the project
[01:04:24] system
[01:04:25] and the
[01:04:26] templates.
[01:04:27] So,
[01:04:28] you have
[01:04:29] the nano
[01:04:30] framework
[01:04:31] folder,
[01:04:32] the
[01:04:33] class
[01:04:34] library
[01:04:35] template
[01:04:36] and the
[01:04:37] standalone
[01:04:38] application
[01:04:39] template.
[01:04:40] And that
[01:04:41] one is
[01:04:42] exactly
[01:04:43] a
[01:04:44] hello
[01:04:45] world,
[01:04:46] which
[01:04:47] will
[01:04:48] give
[01:04:49] you
[01:04:50] a console
[01:04:51] dot
[01:04:52] write
[01:04:53] line
[01:04:54] hello
[01:04:55] world
[01:04:56] framework
[01:04:57] flasher,
[01:04:58] which is
[01:04:59] a CLI
[01:05:00] application.
[01:05:01] It’s
[01:05:02] a dot
[01:05:03] net
[01:05:04] tool.
[01:05:05] So,
[01:05:06] you can
[01:05:07] run it
[01:05:08] everywhere
[01:05:09] that
[01:05:10] dot
[01:05:11] net
[01:05:12] runs.
[01:05:13] You
[01:05:14] install
[01:05:15] that
[01:05:16] with
[01:05:17] dot
[01:05:18] net
[01:05:19] tool,
[01:05:20] and then
[01:05:21] you
[01:05:22] have
[01:05:23] a very
[01:05:24] simple
[01:05:25] version
[01:05:26] of
[01:05:27] your
[01:05:28] ESP32
[01:05:29] which is
[01:05:30] whatever
[01:05:31] your
[01:05:32] ESP32
[01:05:33] is connected
[01:05:34] to.
[01:05:35] And then
[01:05:36] the tool
[01:05:37] will connect
[01:05:38] to the
[01:05:39] device.
[01:05:40] We’ll
[01:05:41] find out
[01:05:42] exactly
[01:05:43] what’s
[01:05:44] the series
[01:05:45] and the
[01:05:46] model.
[01:05:47] We’ll
[01:05:48] grab
[01:05:49] the correct
[01:05:50] firmware
[01:05:51] and we’ll
[01:05:52] flash it
[01:05:53] and that’s
[01:05:54] it.
[01:05:55] On five
[01:05:56] minutes you
[01:05:57] are up
[01:05:58] and running.
[01:05:59] Excellent.
[01:06:00] Excellent.
[01:06:01] And so,
[01:06:02] like,
[01:06:03] if I’m
[01:06:04] new to
[01:06:05] the
[01:06:06] dot
[01:06:07] net
[01:06:08] nano
[01:06:09] framework
[01:06:10] whole
[01:06:11] thing,
[01:06:12] is there
[01:06:13] like a
[01:06:14] support
[01:06:15] place
[01:06:16] that I
[01:06:17] can go?
[01:06:18] Maybe like
[01:06:19] a Slack
[01:06:20] or a
[01:06:21] Discord
[01:06:22] or something
[01:06:23] like that
[01:06:24] where I can say,
[01:06:25] Hey,
[01:06:26] I’m
[01:06:27] a
[01:06:28] Discord
[01:06:29] community
[01:06:30] around
[01:06:31] nano
[01:06:32] framework
[01:06:33] on which
[01:06:34] you can
[01:06:35] go and
[01:06:36] have
[01:06:37] there are
[01:06:38] a bunch
[01:06:39] of channels
[01:06:40] with
[01:06:41] different
[01:06:42] topics.
[01:06:43] So you’ll
[01:06:44] go to
[01:06:45] the
[01:06:46] welcome
[01:06:47] channel
[01:06:48] and say
[01:06:49] hello
[01:06:50] if you
[01:06:51] want.
[01:06:52] And then
[01:06:53] you can
[01:06:54] ask
[01:06:55] questions
[01:06:56] and we’ll
[01:06:57] guide you
[01:06:58] through
[01:06:59] to make
[01:07:00] sure that
[01:07:01] you are
[01:07:02] up and
[01:07:03] running
[01:07:04] in no
[01:07:05] time.
[01:07:06] Cool.
[01:07:07] Awesome.
[01:07:08] What about
[01:07:09] like,
[01:07:10] can folks
[01:07:11] get in
[01:07:12] touch
[01:07:13] with you
[01:07:14] or would
[01:07:15] you prefer
[01:07:16] they go
[01:07:17] through
[01:07:18] like Discord
[01:07:19] and ask
[01:07:20] folks
[01:07:21] there
[01:07:22] instead?
[01:07:23] I spend
[01:07:24] a lot of
[01:07:25] time with
[01:07:26] helping people
[01:07:27] there.
[01:07:28] So I’m
[01:07:29] available
[01:07:30] there and
[01:07:31] also on
[01:07:32] Twitter,
[01:07:33] on
[01:07:34] LinkedIn.
[01:07:35] There’s
[01:07:36] a number
[01:07:37] of channels
[01:07:38] that you
[01:07:39] can get
[01:07:40] hold of
[01:07:41] me.
[01:07:42] Excellent.
[01:07:43] Excellent.
[01:07:44] Well,
[01:07:45] I mean,
[01:07:46] I’ve
[01:07:47] really
[01:07:48] enjoyed
[01:07:49] our
[01:07:50] conversation
[01:07:51] today and
[01:07:52] I’ve
[01:07:53] seen
[01:07:54] a lot
[01:07:55] of
[01:07:56] great
[01:07:57] things
[01:07:58] in
[01:07:59] any
[01:08:00] one
[01:08:01] of
[01:08:02] my
[01:08:03] machines.
[01:08:04] And I’m
[01:08:05] really
[01:08:06] looking
[01:08:07] forward
[01:08:08] to
[01:08:09] grabbing
[01:08:10] a couple
[01:08:11] of
[01:08:12] different
[01:08:13] pieces
[01:08:14] of
[01:08:15] embedded
[01:08:16] hardware
[01:08:17] and seeing
[01:08:18] what I
[01:08:19] could
[01:08:20] come up
[01:08:21] with.
[01:08:22] I’d
[01:08:23] like to
[01:08:24] thank this
[01:08:25] episode’s
[01:08:26] guest,
[01:08:27] José
[01:08:28] Simoes,
[01:08:29] for graciously
[01:08:30] sharing his
[01:08:31] time,
[01:08:32] expertise
[01:08:33] and knowledge.
[01:08:34] Be sure
[01:08:35] to check out
[01:08:36] the show
[01:08:37] notes for a
[01:08:38] bunch of
[01:08:39] links to
[01:08:40] some of
[01:08:41] the stuff
[01:08:42] that we
[01:08:43] covered and
[01:08:44] a full
[01:08:45] transcription
[01:08:46] of the
[01:08:47] interview.
[01:08:48] The show
[01:08:49] notes,
[01:08:50] as always,
[01:08:51] are linked
[01:08:52] in the
[01:08:53] show
[01:08:54] notes.
[01:08:55] But above
[01:08:56] all,
[01:08:57] I hope
[01:08:58] you have
[01:08:59] a fantastic
[01:09:00] rest of
[01:09:01] your
[01:09:02] day,
[01:09:03] and I
[01:09:04] hope
[01:09:05] I’ll
[01:09:06] see
[01:09:07] you
[01:09:08] again
[01:09:09] next
[01:09:10] time
[01:09:11] for
[01:09:12] more
[01:09:13] .NET
[01:09:14] goodness.
[01:09:15] See
[01:09:16] you
[01:09:17] later,
[01:09:18] folks!
[01:09:21] .
[01:09:28] .
[01:09:45] .