Technology tree and support levels

How CAST Profiler detects technologies and packages, the architectural role taxonomy it applies, and what each support level means for a CAST Imaging analysis

Overview

The technology tree is the inventory of frameworks, libraries and packages CAST Profiler found, arranged as a hierarchy and tagged with two pieces of metadata that drive every scoping decision you will make: an architectural role and a CAST Imaging support level. This page explains where those tags come from and how to act on them.

How technologies are detected

Detection is evidence-based and lexical. CAST Profiler extracts identifiers from file content and matches them against a bundled reference knowledge base, whose version and content hashes are recorded in every result file. The evidence it uses:

Import statements and using directives - Java, C#, Python, Go, C, C++, Objective-C, JavaScript and TypeScript.
Annotations and decorators, for example @RestController or @GetMapping.
Declared dependencies in project descriptors, for example a Maven coordinate in pom.xml or a dependency name in package.json.
Characteristic code patterns, for example CREATE TABLE in a SQL file or axios.get( in JavaScript.

Two consequences follow from this being lexical:

A dependency that is declared but never used is still reported, because the declaration is the evidence.
A framework used only through configuration, reflection or a generated client may be missed, because there is no import to match. This is why the results page asks whether you are seeing all the frameworks your application uses.

Each technology in the tree carries a parent, which is how the hierarchy is built - Spring Web and Spring Data JPA both sit under Spring, which sits under JEE - and a density, which is its share of the scanned files.

Support levels

Every language and technology is tagged with the level of CAST Imaging support available for it. This is the field to read first.

Level shown	Value in the result file	What it means for a deep analysis
Technology Deep Scan	`product`	Fully supported in the CAST Imaging product. Objects, links and transactions are resolved.
Partial	`partial`	Supported, but some constructs or file extensions of the technology are not recognised.
Labs	`labs`	Available as a CAST Labs extension rather than in the product. Confirm availability before committing to it in a scope.
Community	`community`	Available as a community extension. Not covered by product support.
Not Supported	`none`	No analyzer coverage. Files in this technology are inventoried but will not be analyzed.

The results page also reports the percentage of the application that is not supported, together with the list of the unsupported languages. Take that list into the scoping conversation: an unsupported technology in a peripheral role is usually acceptable, while an unsupported technology in the persistence or presentation role removes a whole layer from the resulting CAST Imaging knowledge base.

Role taxonomy

Each technology is tagged with one or more roles, written as namespace:subrole in the result file. A technology can hold several roles - Spring Web is tagged both presentation:web and communication:rest.

Communication

Role	Meaning
`communication:rest`	Exposed or called REST API artifacts
`communication:webservice`	Exposed or called SOAP and RPC artifacts
`communication:messaging`	Messaging, publish/subscribe, message bus and message-oriented middleware
`communication:realtime`	Synchronous real-time transport - sockets, RMI, streams, WebSocket, SignalR
`communication:callexecutable`	Calls to executables and external systems
`communication:ftp`	FTP client artifacts
`communication:ssh`	SSH client artifacts
`communication:ldap`	LDAP client artifacts
`communication:mail`	Mail client artifacts
`communication:notification`	Push notification towards mobile devices

Persistence

Role	Meaning
`persistence:rdbms`	Relational database access
`persistence:orm`	Object-relational or other mapping access
`persistence:nosql`	NoSQL database access
`persistence:storage`	Cloud storage and file storage access

Presentation

Role	Meaning
`presentation:web`	Artifacts using web application libraries
`presentation:mobile`	Artifacts using mobile client libraries
`presentation:richclient`	Artifacts using rich client or desktop libraries
`presentation:terminal`	Artifacts using terminal client libraries

Security

Role	Meaning
`security:authentication`	User authentication and authorization
`security:encryption`	Data encryption libraries
`security:hash`	Hashing libraries
`security:token`	Tokenization libraries

System, tooling and cross-cutting

Role	Meaning
`system:gateway`	API and event gateways, proxies, load balancers
`system:orchestration`	Microservice orchestration
`system:monitoring`	Application health and activity monitoring
`system:scheduler`	Program schedulers
`toolkit:build`	Build automation frameworks
`toolkit:testing`	Mocking and unit test libraries
`toolkit:learning`	Documentation and learning libraries
`toolkit:logging`	Libraries writing log messages to files, databases or other sinks
`toolkit:dependencyinjection`	Inversion of control and dependency injection containers
`reporting`	Reporting artifacts producing PDF or Excel output

The results page groups some of these under friendlier headings - Logging and Tooling both come from the toolkit: namespace. The reference data also carries roles that no filter exposes. If you read roles out of the result file rather than off the page, treat the list above as a guide rather than a closed set.

Using roles for scoping

Roles are what make the inventory actionable. Read the tree by role rather than alphabetically:

Missing persistence:* roles in an application you know talks to a database means the delivery is incomplete, not that the application has no persistence. Cross-check against the alerts.
communication:rest and communication:webservice on the exposed side tell you which entry points a CAST Imaging transaction analysis will be able to anchor on.
A presentation:terminal role in an otherwise web application usually signals a mainframe or legacy component that was delivered alongside it, and may need its own scope.
tooling:testing density tells you how much of the delivery is test code, which is never excluded automatically by CAST Profiler.

Packages and imports

Below the technology level, the tree lists the packages identified from file content, with an icon indicating the source file each one came from. Where a package cannot be attributed to a known technology it still appears in the inventory, which is how you find in-house libraries and internal frameworks that no reference knowledge base will ever recognise. Those are worth listing explicitly in the onboarding notes.