Firmware & Software Eng.
Software engineering fundamentals, embedded C/C++, RTOS, embedded Linux, DevOps for embedded, and testing.
320 topics · 0 with articles
Intern Engineer· 40
- Agile Methodology: Sprint, Backlog, Scrum, Kanban
- Behavior-Driven Development (BDD): Gherkin, Cucumber
- Change Control Board (CCB): Impact Analysis, Approval
- Code Metrics: Cyclomatic Complexity, Lines of Code, SLOC
- Code Review: Best Practices, Checklist, Pull Request
- Communication Skills: Technical Writing, Presentation
- Continuous Delivery (CD): Deploy to Staging Automatically
- Continuous Integration (CI): Automated Build and Test
- DRY, KISS, YAGNI: Code Quality Principles
- Defensive Programming: Assert, Precondition, Postcondition
- Dependency Injection: Decoupling Components via Interfaces
- Design Patterns: Singleton, Observer, Factory, Strategy
- Documentation: Doxygen, Markdown, API Reference
- Error Handling Strategies: Return Code, Exception, Callback
- Ethics in Software: Responsible Disclosure, Privacy Design
- Git Branching: Feature Branch, GitFlow, Trunk-Based Dev
- Git Merge vs. Rebase: Difference and When to Use
- Git Version Control: init, clone, add, commit, push, pull
- IP Management: Copyright, Trade Secret, Patent for SW
- Infrastructure as Code (IaC): Ansible, Terraform Basics
- Interface Segregation: Header-Only Interface in C
- Licensing: Open-Source Licenses (MIT, GPL, Apache, BSD)
- Mentoring and Knowledge Transfer: Junior Developer Support
- Module Coupling and Cohesion: High Cohesion, Low Coupling
- Pair Programming and Mob Programming
- Programming Paradigms: Procedural, OOP, Functional, Event-Driven
- Refactoring: Code Smell Identification and Improvement
- Risk Management in Software: FMEA, Risk Register
- SDLC Models: Waterfall, V-Model, Agile, Spiral
- SOLID Principles: Single Responsibility, Open/Closed, etc.
- Semantic Versioning (SemVer): Major.Minor.Patch Rules
- Software Architecture: Monolith, Layered, Microkernel
- Software Bill of Materials (SBOM): SPDX, CycloneDX
- Software Configuration Management (SCM) Plan
- Software Requirements: Functional, Non-Functional, Constraints
- Software Traceability Matrix: Req → Design → Test → Code
- Technical Debt: Identification, Quantification, Reduction
- Test-Driven Development (TDD): Red-Green-Refactor Cycle
- UML Diagrams: Class, Sequence, State Machine, Activity
- Use Case Diagram: Actors, Use Cases, Relationships
Junior Engineer· 80
- AUTOSAR C++ Coding Guidelines: Key Rules Summary
- AUTOSAR OS: Conformance Classes BCC1, BCC2, ECC1, ECC2
- AUTOSAR OS: Task, ISR Category 1 / Category 2, Alarm
- Bit Manipulation: Set, Clear, Toggle, Test a Specific Bit
- Bit-Field Struct: Hardware Register Mapping Pattern
- Bitwise Operators: AND, OR, XOR, NOT, Left Shift, Right Shift
- C Language Standards: C89, C99, C11, C17 Key Differences
- C++ RAII: Resource Acquisition Is Initialization Pattern
- C++ Standard Library (STL): Overhead and Embedded Use
- C++ Templates: Zero-Cost Abstraction for Embedded
- C++ Virtual Functions: vtable, Runtime Polymorphism Overhead
- C++ constexpr and static_assert: Compile-Time Checking
- C++ for Embedded: Namespaces, Classes, Templates
- CPU Load Measurement: DWT CYCCNT Method
- Context Switch Time Measurement and Minimization
- Data Types and Sizes: char, short, int, long, long long
- Deadline-Monotonic Scheduling (DMS) for Sporadic Tasks
- Deadlock Conditions: Mutual Exclusion, Hold-and-Wait, etc.
- Earliest Deadline First (EDF): Optimal Dynamic Scheduling
- Embedded Rust: Memory Safety Without GC, no_std Crate
- Endianness-Safe Code: Byte Swapping, Portable Structs
- Exact-Width Integer Types: uint8_t, int32_t (stdint.h)
- Extern Keyword: Shared Variables Across Compilation Units
- Fixed-Size Memory Pool: Pool Allocator for Embedded
- Formal Timing Analysis Tools: RapiTime, aiT, SymTA/S
- FreeRTOS Event Group: xEventGroupWaitBits Pattern
- FreeRTOS Heap Management: heap_1 to heap_5 Strategies
- FreeRTOS Queue: xQueueCreate, xQueueSend, xQueueReceive
- FreeRTOS Semaphore: Binary, Counting, Mutex Variants
- FreeRTOS Software Timer: One-Shot and Auto-Reload
- FreeRTOS Stack Overflow Detection: uxTaskGetStackHighWaterMark
- FreeRTOS Trace: Tracealyzer Integration and Visualization
- FreeRTOS: xTaskCreate, vTaskDelete, xTaskGetHandle
- Heap Memory: malloc, calloc, realloc, free — Embedded Risks
- Hierarchical State Machine (HSM): Active Object Pattern
- Idle Task: Low-Power Mode Entry in Idle Hook
- Inline Functions vs. Macros: Trade-offs
- Interrupt Latency: Worst-Case Interrupt Response Time
- Interrupt Nesting: NVIC Priority, Critical Section Depth
- Linker: Symbol Resolution, Strong vs. Weak Symbol
- Lua Scripting Engine on Embedded: Flexibility vs. Overhead
- MISRA-C:2012 Compliance Checking: PC-lint, Polyspace
- Macro Pitfalls: Side Effects, Operator Precedence
- Memory Leaks and Dangling Pointers: Detection Strategies
- Memory Sections: .text, .data, .bss, .rodata, .stack, .heap
- MicroPython / CircuitPython: Python on MCU Trade-offs
- Modern C++ (C++11/14/17): auto, range-for, lambda, nullptr
- Multi-Core RTOS: SMP Scheduler, Core Affinity, Load Balance
- OSEK/VDX: History and Relationship to AUTOSAR OS
- POSIX PSE51 Profile: POSIX Subset for Real-Time Embedded
- Pointer Basics: Declaration, Dereferencing, Pointer Arithmetic
- Pointer to Function: Callback Pattern, ISR Registration
- Preprocessor: #define, #include, #ifdef, #pragma
- Printf-Free Logging: Lightweight Log via UART Ring Buffer
- Priority Ceiling Protocol (PCP): Preventing Deadlock
- Priority Inheritance Protocol (PIP): Mutex Solution
- Priority Inversion: Mars Pathfinder Bug Case Study
- RT Linux Latency Sources: Scheduling, IRQ, Spinlock
- Rate-Monotonic Scheduling (RMS): Schedulability Test
- Real-Time Linux: PREEMPT_RT Patch, cyclictest Benchmark
- Real-Time System Definition: Hard, Soft, Firm RT Deadlines
- Response Time Analysis (RTA): Task Blocking, Preemption
- Ring Buffer / Circular Buffer: Lock-Free Implementation
- Signed vs. Unsigned Arithmetic: Overflow and Wrap-Around
- Stack Memory: Local Variables, Function Call Frame Layout
- State Machine in C: Enum States, Function Pointer Table
- Static Keyword: File Scope, Function Scope, Static Local
- Struct and Union: Memory Layout, Padding, Packing
- Task Scheduling: Preemptive Priority-Based, Round-Robin
- ThreadX / Azure RTOS: Preemption-Threshold, Byte Pool
- Tickless IDLE: Dynamic Tick to Reduce Power in RTOS
- Worst-Case Execution Time (WCET): Measurement and Analysis
- Xenomai / RTAI: Hard Real-Time on Linux Core
- Zephyr IPC: k_msgq, k_pipe, k_fifo, k_lifo
- Zephyr Power Management: Device PM, System PM Hooks
- Zephyr RTOS: Kernel, DTS, Kconfig, West Build System
- Zephyr Threads: k_thread_create, k_sleep, k_yield
- Zephyr Workqueue: k_work, k_delayed_work, k_work_poll
- const, volatile, restrict: Qualifiers in Embedded C
- volatile Keyword: Preventing Compiler Optimization on HW Regs
Middle Engineer· 80
- ALSA: Sound Card Driver, PCM Substream, Codec Driver
- Artifact Management: Firmware Binaries, Checksums, Metadata
- Automated Flashing: OpenOCD, pyOCD, nrfjprog in CI
- Automated Test Execution: pytest, Unity, Robot Framework
- Binary Signing: GPG Sign, Hash Verification of Releases
- Block Device Driver: gendisk, request_queue, blk_mq
- Board Support Package (BSP): HW Abstraction for New Board
- Branching Strategy: Feature, Release, Hotfix Branches
- Buildroot: Package Recipe, Config Fragment, BR2_PACKAGE
- CI Pipeline Stages: Build → Static Analysis → Unit Test → Deploy
- CMake Build System: CMakeLists.txt, Targets, Toolchain File
- Cache Management: dma_sync_single_for_device / CPU
- Change Management: RFC Process for Embedded Architecture
- Character Device: file_operations, cdev_init, cdev_add
- Clock Framework: clk_get, clk_prepare_enable, clk_set_rate
- Code Review Automation: Danger, Reviewdog in CI
- Continuous Integration for Embedded: GitHub Actions, GitLab CI
- Cross-Compilation Toolchain: arm-none-eabi-gcc, Setup
- Cross-Platform Abstraction: HAL Layer for Portability
- DMA Engine API: dmaengine_prep_slave_single, dma_cookie
- Debugfs: Debug Entries for Runtime Kernel Info Export
- Delta OTA: Binary Diff (bsdiff, VCDIFF) for Tiny Payloads
- Dependency Management: Conan for C++, vcpkg, Git Submodules
- DevOps Metrics for Embedded: DORA Metrics Adaptation
- Device Farm Management: Serial, Network, Power Cycling
- Device Tree Overlay (DTBO): Dynamic Hardware Description
- Device Tree: Node, Property, Compatible String, reg
- Docker for Embedded Build: Cross-Compile Container Image
- ESP-IDF Build System: idf.py, Kconfig, Component Makefile
- Embedded Linux Boot Optimization: Initramfs, kexec, Prelink
- Embedded Software Release Train: Coordinated HW/SW Release
- Firmware Size Optimization: Link-Time Optimization (LTO)
- GPIO Interrupt: devm_request_irq, IRQF_TRIGGER_RISING
- GPIO Subsystem: gpiod_get, gpiod_direction_output, IRQ
- Hardware-in-the-Loop (HIL) CI: Actual Board in Test Farm
- I2C Bus Driver: i2c_driver, i2c_smbus_read_byte_data
- IIO (Industrial I/O) Subsystem: iio_dev, iio_chan_spec
- IRQ Threading: request_threaded_irq, Handle in Thread
- Input Subsystem: input_dev, input_report_abs, input_sync
- Kernel Debugging: KGDB, Kprobes, ftrace, perf, eBPF
- Kernel Module: module_init, module_exit, MODULE_LICENSE
- Kernel Space vs. User Space: Privilege Levels, Syscall Gate
- LCOV / gcov: Code Coverage Measurement for Embedded C
- Linux Kernel Architecture: Process Mgmt, Memory, VFS, Net
- Linux Security: SELinux Policy, AppArmor Profile
- MISRA-C Checking in CI: Polyspace, Helix QAC
- Makefile: Variables, Rules, Automatic Variables, Pattern
- Map File Analysis: bloaty, nm, size for Binary Analysis
- Memory Management: kmalloc, vmalloc, dma_alloc_coherent
- Misc Device: misc_register, simpler char dev interface
- Module Parameters: module_param, MODULE_PARM_DESC
- Network Device Driver: net_device, ndo_start_xmit, NAPI
- Ninja Build System: Speed Advantage over Make
- OTA Deployment Pipeline: Build → Sign → Upload → Deploy
- OTA Monitoring: Deployment Status, Success Rate Dashboard
- Pinctrl Subsystem: Pin Mux, Pin Config in DTS
- Platform Driver Model: probe, remove, of_match_table
- PlatformIO: Multi-Framework Build, Library Manager
- QEMU Emulation: ARM Cortex-M, ARM Cortex-A Targets
- Regmap API: Register Map Abstraction over SPI / I2C
- Regulator Framework: regulator_get, enable, set_voltage
- Release Management: Changelog, Tag, Release Notes
- Renode Simulation: Platform-Accurate MCU Emulation
- Rollout Strategy: Canary, Staged Rollout for OTA
- SPI Bus Driver: spi_driver, spi_transfer, spi_sync
- Semantic Release: Automated Versioning from Commit Messages
- Software Composition Analysis (SCA): Black Duck, FOSSA
- Static Analysis in CI: cppcheck, clang-tidy, PC-lint
- Sysfs Interface: kobject, kset, store/show Attributes
- System Call Interface: write, read, ioctl, mmap, poll
- USB Gadget Driver: usb_function, composite_driver
- USB Host Driver: usb_driver, probe, urb, complete
- User-Kernel Interface: copy_to_user, copy_from_user
- V4L2 (Video4Linux2): Camera Driver, Video Buffer Queue
- Version Control for Embedded: Git LFS for Binary Artifacts
- West (Zephyr Build Tool): Init, Update, Build, Flash
- Wokwi: Browser-Based ESP32 / Arduino Simulation
- Yocto SDK: Standard SDK, Extensible SDK (eSDK)
- Yocto: Layer, Recipe (.bb/.bbappend), Bitbake Commands
- mmap Implementation: remap_pfn_range, vm_fault Handler
Senior Engineer· 80
- ADAS Middleware: ROS, AUTOSAR Adaptive, Apollo Cyber
- ARINC 429: Avionics Data Bus Label, Rate, BCD/BNR Format
- AUTOSAR ComStack: PDU Router, COM, CanIf, CanNm
- AUTOSAR DCM: Diagnostic Communication Manager, UDS
- Automated Test Execution: pytest-embedded, Renode, QEMU
- BLE GAP: Discovery, Connection, Pairing, Bonding Procedures
- BLE GATT: ATT Protocol, Handle, UUID, Permission
- Bluetooth HCI: Host-Controller Interface, HCI Command/Event
- CAN Bus: Frame Format, Arbitration, Bit Stuffing
- CAN FD: Faster Data Phase, Up to 64 Byte Payload
- CANopen: DS301 Object Dictionary, NMT, PDO, SDO
- CAPA (Corrective and Preventive Action) Process
- CMock: Auto-Generated Mocks from C Header Files
- CoAP Library: libcoap, microcoap, aiocoap
- Code Coverage: gcov / lcov, Line, Branch, Function Coverage
- DDS (Data Distribution Service): Fast DDS, Cyclone DDS
- DTLS: Datagram TLS over UDP for CoAP Security
- Defect Tracking: JIRA, Mantis, Bugzilla Issue Lifecycle
- DoIP (Diagnostics over IP): ISO 13400, Vehicle Identification
- Dynamic Analysis: AddressSanitizer, Valgrind (qemu)
- EMC Pre-Compliance Testing: Near-Field Scan, Conducted
- Environmental Testing: Temp Cycling, Humidity, Vibration
- EtherCAT: Distributed Clocks, Process Data Object (PDO)
- Fault Injection Testing: Hardware Glitch, Software Fault
- Fieldbus Selection Guide: Real-Time, Determinism, Cost
- Fuzz Testing: AFL, LibFuzzer for Protocol Parsers
- Google Mock: Expectations, Actions, EXPECT_CALL Syntax
- HTTP Client: libcurl, esp-http-client, lwIP HTTP
- Hardware-in-the-Loop (HIL) Test: Automated Regression
- I2C Protocol: Addressing, ACK/NACK, Clock Stretching
- Integration Test: Module Interaction on Real or Simulated HW
- LIN Bus: Master Schedule Table, Break Field, Checksum
- Lessons Learned: Post-Project Retrospective Documentation
- MC/DC Coverage (DO-178C): Modified Condition/Decision
- MIL-STD-1553: Dual Redundant, BC/RT/BM Message Types
- MISRA-C Static Analysis: Helix QAC, Polyspace Code Prover
- MQTT Client Library: Paho Embedded C, ESP-MQTT
- Mbed TLS / wolfSSL: TLS 1.3 Certificate Handshake on MCU
- Memory Analysis: Heap Profiling, Leak Detection
- Metrics: Defect Density, Test Coverage, Escape Rate
- Modbus RTU: Function Codes 01-06, 15-16 over RS-485
- Modbus TCP: Same PDU over TCP, Unit Identifier
- Mutation Testing: Fault Seeding to Validate Tests
- OPC UA SDK: open62541 C Library, Node Management
- OTA Update Testing: Successful, Interrupted, Rollback Scenarios
- PROFIBUS DP: GSD File, Master Class 1/2, Slave
- PROFINET RT / IRT: IO Device, IO Controller, Cycle Time
- Performance Testing: Throughput, Latency, CPU Load
- Power Consumption Testing: Current Profile, Average Power
- Processor-in-the-Loop (PIL): Code on Target, Stimulus from PC
- Protocol Fuzzing: Boofuzz, Scapy for Embedded Protocol Test
- ROS2 micro-ROS: Micro-XRCE-DDS Agent on MCU
- Regression Testing: Automated Nightly Suite on CI
- Review Process: Design Review, Code Review, Test Review
- Robot Framework: Keyword-Driven Test for Embedded Systems
- Root Cause Analysis (RCA): 5-Why, Fishbone Diagram
- SOME/IP: Service-Oriented Middleware for Automotive Ethernet
- SPI Protocol: CPOL/CPHA Modes, Clock Polarity and Phase
- Safety Testing: IEC 61508, ISO 26262 Verification Evidence
- Security Testing: Penetration Test UART/JTAG/BLE/Wi-Fi
- Software-in-the-Loop (SIL): Model-Based Testing
- SpaceWire: High-Speed Link for Spacecraft, ECSS-E-ST-50
- Stack Analysis: Static Stack Size Analysis (IAR, GCC)
- Static Analysis: clang-tidy, cppcheck, PC-lint Plus
- Stress Testing: Boundary Values, Long-Duration Soak Test
- System Test: End-to-End Test on Target Hardware
- TDD for Embedded: Mock Hardware Abstraction Layer (HAL)
- Test Doubles: Mock, Stub, Spy, Fake, Dummy Definitions
- Test Framework: Unity (C), Google Test (C++), Catch2
- Time Synchronization: gPTP (IEEE 802.1AS) in Automotive
- Timing Analysis: WCET Measurement with DWT, Logic Analyzer
- UART Protocol: Baud Rate Calculation, Parity, Flow Control
- UDS (ISO 14229): Diagnostic Session Control, DID, ECU Reset
- USB CDC: ACM Subclass, Virtual COM Port, Control Requests
- USB DFU: DFU State Machine, Alternate Settings
- USB HID: Report Descriptor, Boot Protocol, Usage Page
- USB Protocol Stack: Enumeration, Descriptor, EP, URB
- Unit Testing Basics: Arrange, Act, Assert (AAA) Pattern
- fff (Fake Function Framework): Lightweight Mock for C
- lwIP TCP/IP Stack: Socket API, Netconn API, Raw API
Distinguished Engineer· 40
- AI on MCU: TFLite Micro, Edge Impulse on ARM Cortex-M
- AUTOSAR Adaptive: Service, Execution Management, COM
- AUTOSAR Classic: Component, Port, Runnable, RTE Layer
- Active Object (AO) Pattern: Task with Private Message Queue
- Board Support Package (BSP): MCU Init, Clock, Peripherals
- Command Pattern: Undo, Macro Commands in Firmware
- Community Contribution: Upstream Patches to Zephyr/Linux
- Component-Based Architecture: Interface, Component, Connector
- Cybersecurity Architecture: Defense-in-Depth for Firmware
- Digital Twin for Firmware: Simulation-First Development
- Embedded Platform Strategy: Common Platform, Multiple Products
- Event-Driven Architecture: Event Queue, Dispatcher, Handler
- Executable Architecture: Early Simulation of Architecture
- Firmware for AI Wearable: Sensor → Inference → BLE Pipeline
- Functional Safety SW Architecture: Redundancy, Diverse Coding
- Future Trends: Rust for Safety, WASM on MCU, LLM at Edge
- HPC Embedded: Multi-Core ARM + GPU for Autonomous Driving
- Half-Sync / Half-Async: Combining Sync and Async Processing
- Hardware Abstraction Layer (HAL): Portability Strategy
- Machine Learning Ops (MLOps) for Embedded: OTA Model Update
- Microkernel Architecture: Core Services + Plugins
- Mixed-Criticality System: Isolation, QoS, RTOS Partition
- Model-Based Development (MBD): Simulink + Embedded Coder
- Model-Based Systems Engineering (MBSE): SysML on SoC
- NPU Integration: ARM Ethos-U55 for Neural Inference
- Neuromorphic Firmware: SNN on Intel Loihi Interface
- Observer Pattern: Event Notification Without Tight Coupling
- Open-Source Embedded OS: Zephyr, NuttX, RIOT, Contiki-NG
- Post-Quantum Firmware: Hybrid Classical + PQC on MCU
- Publish-Subscribe Pattern for Decoupled Modules
- QP/C and QP/C++ Frameworks: Hierarchical State Machine
- RISC-V in Automotive: Open ISA for Safety-Critical ECU
- Reactor Pattern: Single-Threaded Async Event Handling
- Robustness and Resilience: Watchdog, CRC, Error Recovery
- SOTIF (ISO 21448): Safety of the Intended Functionality SW
- Secure Coding Architecture: OWASP Embedded Top 10
- Software Architecture for Embedded: Layered, Component-Based
- Software Reuse ROI: Component Library, Certified Modules
- SysML / UML for Embedded System Modeling
- Zero-Trust Firmware: Verify Every Module, Least Privilege