Matthew Heath

What happens when you connect state-of-the-art research with a real-world application?     Yesterday at ECML-PKDD 2025 in Porto, we presented GraphPCBs during the poster session.   Our project focuses on applying GNNs to optimize circuits in the schematics design phase, and it is a collaboration between CELUS and the University of Kassel, with the support of the BMFTR.   The response? Great interest, valuable discussions, and lots of curiosity from both the ML community as well as from people working with electronics.   Have you seen other examples where AI is making a difference in engineering workflows? 👇   #GraphPCBs #ECMLPKDD2025 #Electronics #MachineLearning #PCBDesign #CELUS

48

A recent post talked about mesh distortion affecting displacement results. However it looked very much like direct nodal forces had been applied to the edge of the rectangular plate used. These dominated the results. If you define a constant distributed edge load in a preprocessor it calculates a set of equivalent nodal forces. These nodal forces effectively take into account the stiffness of the Degrees of Freedom at each node and make sure the actual force applied creates a kinematic balance. The right hand model shows the classic 'corner curl' ; there is a full nodal force (2 units) applied at the edge nodes which only have a stiffness contribution of one element. This is in contrast to the interior nodes which have contribution from two elements. Hence double the deflection at the corners! The left hand model shows the correct nodal force distribution created by defining an edge loading. I have also introduced varying element lengths as in the original post, just to make it more interesting. You can find out the actual nodal forces by using a freebody tool as I did. FEMAP also has an interesting option to convert a distributed load, or pressure, to equivalent nodal forces - but it's one way only! The bottom line is - don't try to second guess the nodal forces, particularly with higher order elements and non-uniform load distributions. AND DON'T TRUST SUSPICIOUS RESULTS!

272

59 comentários

Electrical and mechanical engineers often work side by side—but not together. Design misalignment, late discoveries, and endless re-spins don’t come from lack of skill—they come from disconnected workflows. In our latest Wevolver article, Altium's Filipa de Melo Sofio explores how breaking down ECAD–MCAD silos helps teams design faster, reduce errors, and build confidence across disciplines. Read the full article to see how modern hardware teams are turning collaboration into true co-creation. Read the article here: https://bit.ly/4oj7hdp #altium #wevolver #ECAD #MCAD #cocreation

26

5 comentários

If you have not checked out our latest MATLAB & Simulink Challenge Project in collaboration with Arm, now is a great time. 👉 https://lnkd.in/ePS9sp_R This project guides students through a complete model-based design and verification workflow for an automotive controller, from requirements and MIL testing to automatic C code generation and Processor-in-the-Loop (PIL) execution on an Arm Cortex-M7 target (virtual or physical hardware). A great fit for: 🎓 Capstone & senior design projects 📘 Embedded systems or automotive courses 🔬 Master’s-level V&V work Students gain hands-on experience with real automotive development practices, including timing analysis, coverage, and traceability. Thanks to Kieran Hejmadi and Robert Iannello for their support on this collaboration. #MATLAB #Simulink #Arm #EmbeddedSystems #Automotive #EngineeringEducation #Education #IndustryPartnerships #Students #StudentChallenge #CasptoneProjects #SeniorDesign

92

1 comentário

I’ve just got another important advance in plimanshiny engine by including a native C++ Reverse Polish Notation interpreter that allows users to compute complex raster operations with up to seven layers at hardwar speds. In this test, I calculated a standard NDVI, a boolean mask, a complex conditional NA filter, and a custom Red-Edge index—all in a single memory pass. What makes the new engine a game-changer isn't just the raw speed; it's the unprecedented efficiency. While gold-standard tools often spike GB of RAM for these types of multi-layer operations, plimanshiny maintains a footprint of just a few KBs. By executing complex logic like ifelse(NDVI > 0.5 & CIRE > 1.5, EVI, NA) directly in compiled Kernels, we’ve eliminated the memory-heavy intermediate files that usually slow down high-res UAV processing. Precision Agriculture requires tools that run as smoothly on a field laptop as they do on a server. With native support for R, G, B, RE, NIR, SWIR, and TIR bands, logical operators, and custom formulas, the new engine ensures that hardware is no longer the bottleneck for remote sensing. The era of "One-Pass" processing has officially arrived; and this is only the first step🛰️🌱 #AgTech #RemoteSensing #Cpp #RStats #PrecisionAgriculture #OpenSource #Geospatial #DataEngineering

80

Two papers recently accepted to IEEE CDC 2025 in Rio de Janeiro 🇧🇷🌎 1. *On Composable and Parametric Uncertainty in Systems Co-Design* https://lnkd.in/dV4R2QMz We extend our compositional co-design framework by introducing probabilistic and parametric uncertainty, enabling formal reasoning about risk, confidence, and adaptation in complex system design. *Case study*: uncertainty-aware co-design of UAVs 2. *Iterative VCG-based Mechanism Fosters Cooperation in Multi-Regional Network Design* https://lnkd.in/d5hdEDNf We propose an iterative, VCG-based approach for infrastructure planning across regional boundaries, motivated by real-world challenges like the European railway system. The mechanism fosters cooperation among self-interested regional operators and a central organization to co-invest in infrastructure with fair cost-sharing and subsidies. *Case study*: European cross-border railway planning 📚 Both projects reflect our broader vision of making systems co-design scalable, explainable, and robust, especially under uncertainty and diverse stakeholder interests.

119

3 comentários

92.5% of Zephyr RTOS functions are low complexity. That’s the result of a McCabe Cyclomatic Complexity analysis I ran to understand the testability and maintainability of the Zephyr codebase. It’s a strong sign of thoughtful design, but complexity still exists in places that matter. Here’s the full breakdown: - 92.5% of functions are Low Complexity (≤10) - 5.3% are Medium (11–20) - Just 2.3% fall into the High (21–30) or Very High (>30) range So, where does the real complexity live? - parser_execute() in the HTTP parser has a staggering CCN of 318 - tcp_in() in the TCP stack hits 129 - Most high-complexity functions are concentrated in networking, Bluetooth, and clock drivers Why this matters: Functions with high complexity are harder to test, maintain, and debug. They increase technical risk and slow down development. Spotting them early helps guide refactoring efforts and improves long-term quality. Zephyr’s overall profile is impressive, but the outliers are worth watching. So what do you think? How do you feel about these complexity levels? #embedded #firmware #codequality #RTOS

332

16 comentários

If you're a C++ programmer, you must read the latest paper by Bjarne Stroustrup: "21st Century C++". In it, he highlights how to use the language in a type-safe and resource-safe manner while embracing modern best practices. After reading it, here are my key takeaways: 1️⃣ Type and Resource Safety 🛡️ Type and memory safety can be enforced at compile time through profiles, a feature currently in development within the ISO C++ committee. This aims to prevent common issues such as uninitialized variables, buffer overflows, and use-after-free errors. 2️⃣ Moving Away from the C Preprocessor Modern C++ is shifting away from the C preprocessor. Since C++20, the import keyword enables module-based compilation, leading to: ✅ Faster builds (20x improvement in some cases). ✅ Elimination of header-ordering issues. ✅ Better encapsulation and tooling support. 3️⃣ Improved Generic Programming With C++20 concepts, constexpr, std::span, and std::ranges, generic programming is now: ✅ More readable ✅ Type-safe at compile time ✅ Zero-cost abstraction These additions represent the biggest upgrade to Generic Programming since C++98. 4️⃣ Eliminating Redundant Copies Since C++17, copy elision is part of the standard, ensuring that expensive copies are avoided, preferring move semantics where possible. 5️⃣ RAII is a Must Even good programmers are bad at remembering to return what they borrowed. Therefore, keywords like delete, free(), and unlock() should be confined to resource-handling sections of the code. All other code should rely on RAII, which guarantees the release of borrowed resources and minimizes their retention without the need of techniques like garbage collection. What are your thoughts on these guidelines? Are you already applying them in your projects? Let’s discuss! 👇

266

🚨New package alert! I’ve just released Pocketeer, a lightweight protein pocket finder written entirely in Python. It’s a small project I built because I wanted an fpocket-style workflow that was easier to extend, worked cleanly with modern Python tooling, and worked on biotite atom arrays (to be compatible with atomworks!!) The basic idea is simple: Delaunay tessellation → alpha-spheres → clustering → scoring, implemented in a way that’s easy to read and extend (I have plans to implement many things with sub pockets etc.) A few things it already supports: • Pure Python with numba JIT • CLI and Python API • Native biotite/atomworks compatibility • PDB and mmCIF input • Optional notebook visualisation • MIT licensed - fully open-source It’s early alpha, so the feature set is still light. On the roadmap: • Pocket similarity / overlap search • Improved scoring • Sub-pocket clustering Very happy for people to try it, break it, and tell me what’s missing. 📦 Install: pip install pocketeer (or uv add pocketeer) If you work in protein modelling or SBDD and have thoughts on what would make this genuinely useful, I’d love to hear them. Links in comments!

427

14 comentários

There is a nice talk about writing safety-critical C++ by "lauriewired": https://lnkd.in/eKzXNj_G It’s about the JSF++ coding guidelines for flight control that I had a major hand in: https://lnkd.in/eg6Fccmu The title is clickbait: far more than 10% of C++ is allowed, in fact most of modern C++. To use JSF++, well you need pool and stack allocators and a large subset of the STL using them, rather than new. The JSF++ is a direct ancestor of the C++ core guidelines: https://lnkd.in/evhbsNjr And Profiles: https://lnkd.in/eMkFyWVC

1.264

33 comentários

🚀 SCIP++ v1.3.0 is out! We’ve just released a new version of SCIP++ — our modern C++ interface for SCIP, now updated to SCIP 9.2.3. This release brings several enhancements aimed at improving usability and performance for developers working with mixed-integer programming: ✨ New in v1.3.0: Accelerated summation of variables — making model construction faster and cleaner. Support for adding primal solutions — enabling more flexible solution injection and warm starts. These features are part of our ongoing effort to make SCIP++ a robust and intuitive tool for optimization practitioners, researchers, and developers. 🔧 Contributions, feedback, and ideas are always welcome — check out the repo and join the conversation: 👉 https://lnkd.in/eHVwYXDX Thanks to everyone involved, especially Tilo Wiedera, for driving these improvements! #OperationsResearch #Optimization #SCIP #SCIPplusplus #OpenSource #MixedIntegerProgramming #Cplusplus #ORTools

53

C++ templates let the compiler do some of your work before the program runs. Here’s a tiny snippet demonstrating four powerful abilities: 1️⃣ Write code once, use it for any type 2️⃣ Make decisions at compile time (if constexpr) 3️⃣ Build type-aware utilities (using traits like is_integral) 4️⃣ Handle many types easily using parameter packs This is the foundation of how std::vector, std::variant, std::optional, and much of modern C++ work under the hood. Metaprogramming isn’t about complexity, It’s about letting the compiler generate fast, type-safe code for you.

55

5 comentários

Announcement: rclrs 0.5.0 Release, the latest official release of rclrs (0.5.0) [1], the Rust client library for ROS 2! This latest version brings significant improvements and enhancements to rclrs, making it easier than ever to develop robotics applications in Rust. Some of the highlights of this release include: - Fully async API, compatible with any async runtime (tokio, async_std, etc.) - Support for Windows - Support for Jazzy, Kilted and Rolling - Parameter services In addition to the new release of rclrs, rosidl_generator_rs is now released on the ROS buildfarm ( ROS Package: rosidl_generator_rs [2] ). Paving the way for shipping generated Rust messages alongside current messages for C++ and Python. #ros #ros2 #rust #rclrs #rosidl #opensource [1] https://lnkd.in/dGUvF5bw [2] https://lnkd.in/dMwZMMDM

169

2 comentários

Running tests across 150 configurations and 10,000+ cases? Static reports and scattered logs make debugging slow and scaling painful. You need live visibility, not PDFs. In this session, José Miguel Campos from Qt Group shows how teams use Test Center to bring order to complex, cross-platform test pipelines: • Run and analyze tests (Including Selenium tests) across Windows, Linux, and macOS • Auto-capture screenshots and video logs on test failure • Export structured results for audits and certifications • Replace manual result tracking with live dashboards and API-driven uploads Watch the walkthrough to see exactly how it's done: https://lnkd.in/d43P8ynr

24

Learn how to implement the Domain Layer of a Clean Architecture application using modern C# and Domain-Driven Design (DDD) principles! https://lnkd.in/d2szaQ-u I will walk through modelling a football league application domain model, focusing on the tactical patterns that ensure high encapsulation and maintainability. #CleanArchitecture #DDD #DomainDrivenDesign #DotNetTutorial #CSharp #DomainLayer #SoftwareDesign #ValueObjects #Aggregates #AggregateRoot #MarkerInterface #Entities

12