Clean Architecture: Patterns, Practices, and Principles indeed talks about patterns, practices and principles of the aforementioned architecture paradigm, and hints at how to build maintainable and testeable software. The problem is that with a 2.5 hours course, half of which is a code example walkthrough, is impossible to go below the surface of most of the topics.
The example is a C# ASP.NET MVC 5 clean architecture application, is really easy to follow and is nicely explained. I liked this approach of half-slides, half-code for a change from other courses. Serves well to see specific implementations and not just theory. The author also mentions quite a few design patterns, some very briefly, others detailed. I liked the "screaming architecture" practice: organization of each layer of your system screams the intent of the application.
Topics are many but far from deep, so you should take that into account. Not saying it is bad, just warning that a 15 minutes lecture on microservices won't make you an expert building them ;)
UX-Driven Software Design consists of 3.5 hours about the methodology that gives name to the course, which basically is a top-down methodology based on emergent design, applying lean/agile practices. We will learn about the benefits of starting with mockups, wireframes and prototypes and why heavily iterating is a better approach than just delivering a version after long development cycles.
And when entering in the implementation details, it suggests using event sourcing, CQRS and bounded contexts.
You can consider this course as a kind of continuation of another from the same author, Domain Models CQRS and Event Sourcing, although this one is much more focused on examples, advices and high level rules. Still it provides many examples and a simple but clean TODO list code walkthrough (of the most relevant parts).
Microservices Architecture lasts for 2.5 hours, and its contents are really good as a general summary of microservices design patterns, good practices, pitfalls and problems to avoid, and some techniques for approaching both greenfield projects and introducing microservices in existing platforms. The slides and diagrams are very clean and direct to the point. The language used is mostly technology agnostic, with a slight tendency towards Microsoft technologies, but everyone will understand the examples.
My only complaint is that the author is clearly reading a script and the cadence is many times artificial, too continuous, either without pauses or with them when the author needs to breathe instead of when stops should go. That said I could still follow the speech ok and the English is well spoken, but sounds weird when changing slides or topics.
Modern Software Architecture: Domain Models, CQRS, and Event Sourcing is a 4.5 hours course about Domain-Driven Design (DDD) fundamentals, Command Query Responsibility Segregation (CQRS) and Event Sourcing, plus introductions to Event Storming and UX-Driven Design (Top-Down Design instead of the classic Bottom-Up).
I really liked the content and everything is very well explained, with simple diagrams and examples. Code examples are C#, which shouldn't be a problem as it's a clean easily readable language and the examples are uncluttered and direct to the point. What you should be aware of is that "spoken examples" are also mainly focused on .NET, so if you haven't worked with that stack you might not know what frameworks like LINQ or Entity Framework are. Nothing terrible, and some examples are language-agnostic, but the majority are focused for .NET developers/architects.
Recommended for anyone wanting to learn some basic DDD concepts.
I was listening to a Hanselminutes podcast episode about LEGO education's new Spike Prime set, when I heard something quite interesting: After generations of C-based firmwares for the LEGO Mindstorms family of intelligent bricks, the Spike Prime actually runs a MicroPython micro-controller. I feel joy but at the same time I feel a bit old, to think how much we've advanced so that now any kid can easily build and code a robot using Python...
When I was young, I fell in love with the original Mindstorms, and since then, I've collected all three generations (four if we count the Micro Scout). While I gifted most of robots and pieces last year to an electronics and robots lover friend, I still remember the fun weekends and nights learning how to build the robots and how to modify the firmware to code them with my language of choice. Steps that you don't need to take anymore it seems :)
If you haven't heard before about the Mindstorms LEGO family, hackeducation.com has a small but nice technical summary, and I will provide links to the Wikipedia relevant versions too below.
Let's be honest: The Micro Scout was a glorified motor and IR receiver that came with the pieces and instructions to build a cool AT-AT with the Dark Side Developer Kit, or an even cooler R2-D2 with the Droid Developer Kit.
I don't keep decent-quality photos of it but a photo from the instructions is good enough:
The RCX was the first generation, and it was released in 1998 but I got mine either on 1999 or 2000, I don't remember exactly.
It was a v1.5 (there were a v1.0, v1.5 v2.0 revisions). I coded it in C at first, then in C# with LEGO.NET. It was the most entertaining one to "hack" as there was no official custom firmware support, plus initially I had to connect it via a serial port. I bought a USB IR tower later and what a difference! It also meant more portability as serial ports dissapeared long ago :)
I had all expansions I could get my hands of, from Vision Command (camera was terrible but still great to do color recognition back then) to Exploration Mars (the springs/suspensions and different sized wheels were awesome), plus some extra LEGO Technic pieces.
At the end of the instructions you could see the back of a modified R2-D2 using the RCX brick. Again I don't keep non-terrible photos of my build, but was the same as the one in the following image. Note that the R2-D2 head is turned, we're shown actually the back of the droid, it is like a V-shape seen from above, with the tip forward, not backward:
The second generation of Mindstorms bricks, the NXT, allowed a much easier development as if I recall correctly the specifications of the commands were published so interacting with it was very easy. I got mine the year it was released, in late 2006, during a trip to Australia.
I coded on it with C#, using NXT.NET but also directly from Microsoft Robotics Developer Studio. As you can see not only you didn't needed a custom firmware, it also provided an IDE-friendly interface, especially since you could send the data and commands via Bluetooth. You could even use a PocketPC PDA to remote-control it.
The EV3 is the current generation of Mindstorms, released in 2013.
Much more powerful, it is so hacker-friendly that supports booting custom firmwares via Micro-SD card (instead of overriding the built-in one), LEGO has published the full source code of the operating system, and is even compatible with the NXT sensors, so it has really very few limitations to what you can do, except of course your imagination.
Although I skipped trying to do it with the NXT version, my beloved R2-D2 was due for an update, so my last project before deciding to stop playing with the Mindstorms family is an EV3-based R2-D2:
The front is missing some panel or cover, but I wanted easy access to the steering wheel/leg until was finished, and it was missing also the famous beep sounds (which you can add to the EV3 too), but is mostly functional and moves forward, backwards and rotates (plus can be controlled remotely via Bluetooth).
I never got to build real sumo or racing robots, but I feel that with Mindstorms, I've spent two decades doing almost the same, just forgetting about the hardware and solding aspects. Thank you LEGO for providing such great tools and being so developer-friendly.