Every software team has experienced this moment. A critical bug is reported in production. A developer opens the relevant file. And immediately confronts the question that haunts every software project that has evolved beyond its original architecture: "How on earth does this actually work?"
Legacy code without documentation. Millions of lines inherited from developers who left years ago. Functions that call functions that call functions with no obvious entry point. The average developer spends 58% of their time understanding code rather than writing it — and in organisations with large legacy codebases, that number is considerably higher.
Understand by SciTools was built specifically for this problem. It turns your codebase from a black box into a transparent, navigable architecture — letting developers understand what code does, how it connects, and what will break when they change it.
The Real Cost of Poor Code Comprehension
Poor code comprehension isn't an inconvenience — it has measurable, expensive consequences:
- Onboarding delays: New developers take 6–12 months to become productive in complex legacy codebases. With Understand, that drops to weeks.
- Regression bugs: Changes with unexpected side effects cost 10–30x more to fix in production than in development. Understand's dependency mapping shows you exactly what a change will affect before you make it.
- Security vulnerabilities in legacy code: Undocumented code paths are where security vulnerabilities hide — functions nobody knows about, with inputs nobody sanitises.
- Failed refactors: Architectural improvements abandoned because nobody could confidently trace all the dependencies they'd need to restructure.
Real scenario: A team is tasked with upgrading a C++ module in a 15-year-old automotive codebase. Without dependency analysis, they'd need weeks to manually trace all callers and callees. With Understand, they have a complete call graph in minutes — and can confidently scope the change, estimate effort, and predict risk.
What Understand Does — Core Capabilities
Instant Architecture Visualisation
Understand parses your entire codebase — whether it's 10,000 lines or 10 million — and builds a complete, navigable model of your software architecture. You get visual call graphs, dependency graphs, include graphs, and class hierarchies that show exactly how your code is structured. Not documentation someone wrote three years ago. The actual, current state of your code.
// Find all functions that depend on: can_transmit_frame()
Direct callers: 14 functions
├─ adas_controller.c:247 send_emergency_brake()
├─ comms_layer.c:891 broadcast_vehicle_state()
├─ diagnostic_mgr.c:134 send_dtc_report()
└─ ... +11 more
Transitive callers: 68 functions across 12 files
// Impact of changing can_transmit_frame() signature:
// 68 potential call sites require review — identified in 0.3s
Code Metrics That Tell You Where the Risk Is
Understand calculates over 800 code metrics — cyclomatic complexity, coupling between objects, depth of inheritance, lines of code per function, comment density, and many more. These metrics are your risk map. A function with a cyclomatic complexity of 80 is a function that is virtually untestable, almost certainly has bugs, and will be a maintenance nightmare. Understand surfaces these issues across your entire codebase, letting you prioritise refactoring effort where it will have the highest impact.
# Project: industrial_control_system | Date: 2025-06-01
HIGH COMPLEXITY FUNCTIONS (Cyclomatic Complexity > 30):
sensor_data_processor() CC=94 Lines=847 CRITICAL RISK
comms_state_machine() CC=67 Lines=534 HIGH RISK
config_parser_v2() CC=52 Lines=421 HIGH RISK
COUPLING VIOLATIONS (Fan-out > 20):
main_controller.c Fan-out=34 modules REFACTOR REQUIRED
UNDOCUMENTED FUNCTIONS: 1,247 of 3,891 (32%) have no comments
DEAD CODE: 89 functions identified as unreachable
Cross-Language Support — One Tool for Your Whole Stack
Understand supports C, C++, Java, Python, Ada, FORTRAN, JOVIAL, JavaScript, TypeScript, PHP, C#, VHDL, and more. In mixed-language environments — common in automotive, aerospace, and enterprise systems — Understand gives you a unified view of the entire codebase rather than forcing you to switch between multiple tools.
Automated Code Documentation
Understand automatically generates documentation from your source code — entity descriptions, call relationships, file dependencies, metric summaries. For teams inheriting legacy code with no documentation, this is transformational. You go from "we don't know what this does" to "here's the auto-generated architecture document" in the time it takes to run the analysis.
🔒 Try Understand by SciTools Free for 14 Days
Point Understand at your codebase and get a complete architectural map, code metrics report, and dependency analysis in your first session. Expert onboarding from our team included.
Start My Free 14-Day Understand Trial →Security Use Case: Finding Hidden Attack Surface in Legacy Code
Understand isn't just a developer productivity tool — it's a security tool. Security engineers use Understand to map data flows through legacy applications, identify all points where external input enters the system, find functions that handle sensitive data (passwords, keys, PII), and locate dead code paths that may still be executable. In many legacy C/C++ codebases, the most critical vulnerabilities are in functions that nobody knows exist — and Understand makes the invisible visible.
Who Uses Understand?
Understand is particularly valuable for teams working with large-scale embedded C/C++ (automotive, aerospace, industrial, defence), inherited enterprise Java applications, safety-critical systems requiring code comprehension as part of certification, security teams performing architectural risk assessments, and engineering managers who need objective metrics to assess technical debt and refactoring ROI.
The single biggest barrier to moving fast in software development isn't writing speed — it's understanding speed. Developers who understand their codebase make better decisions, introduce fewer bugs, and deliver changes faster. Understand by SciTools eliminates the biggest bottleneck in complex software development — the black box problem — and turns your codebase into your most powerful development tool.