The world of microcontroller programming is witnessing a shift as high-level languages make their way into traditionally low-level domains. PicoRuby, an alternative mruby implementation designed for small-footprint devices, has sparked discussions among developers about the merits and trade-offs of using interpreted languages like Ruby on resource-constrained hardware.
Size and Resource Requirements
PicoRuby requires approximately 256 KB of ROM and 128 KB of RAM on a 32-bit architecture, specifications that have generated mixed reactions from the developer community. While these requirements enable the language to run on devices like the Raspberry Pi Pico (featuring an Arm Cortex-M0+ processor with 264 KB RAM and 2 MB Flash), some developers point out that these aren't particularly small footprints by historical standards.
One commenter noted that these specifications exceed the capabilities of average computers through about 1990, highlighting how our perception of small has evolved over time. This observation is particularly relevant since RAM and Flash memory significantly impact microcontroller pricing and form factor.
PicoRuby Specifications:
- ROM: 256 KB (depending on build config)
- RAM: 128 KB or less (depending on app code)
- Architecture: 32-bit
- Reference hardware: Raspberry Pi Pico (Arm Cortex-M0+, 264 KB RAM, 2 MB Flash)
Key Features:
- Portable - Depends only on standard C library
- Produces three executable binaries:
- picorbc: Compiler for Ruby code to VM bytecode
- picoruby: Ruby interpreter
- r2p2: POSIX version of R2P2
Competition with MicroPython
PicoRuby enters a space where MicroPython has already established dominance. MicroPython offers similar capabilities for running a high-level interpreted language on microcontrollers and has built a substantial ecosystem. Developers familiar with both projects suggest that those interested in PicoRuby might also want to explore MicroPython, which currently holds the larger market share in this niche.
The competition between these projects reflects a broader trend of bringing developer-friendly languages to embedded systems, potentially making hardware development more accessible to those without extensive C programming experience.
The C Language Debate
Perhaps the most passionate discussions center around whether high-level languages like Ruby are appropriate replacements for C in microcontroller programming. The community appears divided on this fundamental question.
Some people hate to use C. Some people embrace it, even love it (including many game devs!). You have full control! But I wonder... is C really that bad??
Proponents of C emphasize its efficiency and the direct control it provides over hardware resources. However, critics point to its lack of safety features and the ease with which developers can introduce critical bugs through simple typos or memory management errors. As one developer noted, C trades very fast execution for slower development, especially when building larger codebases with correctness as a priority.
Development Experience and Safety
The discussion around PicoRuby highlights a fundamental tension in embedded systems development: the trade-off between execution efficiency and development efficiency. Ruby's dynamic typing and higher-level abstractions can accelerate development cycles and reduce certain classes of bugs, but at the cost of runtime performance and memory overhead.
Some developers argue that the safety features of higher-level languages justify their resource costs, especially as microcontroller capabilities continue to improve. The ability to avoid common pitfalls like buffer overflows, null pointer dereferences, and memory leaks can lead to more robust systems, particularly for developers who aren't embedded systems specialists.
PicoRuby represents an interesting middle ground in this debate, offering Ruby's syntax and programming model while maintaining a relatively small footprint compared to full-featured Ruby implementations. As embedded devices continue to grow in processing power and memory capacity, we may see increased adoption of such high-level language runtimes, especially in prototyping and educational contexts where development speed outweighs absolute performance efficiency.
Reference: PicoRuby