SCCH Logo

SCCH Codeanalytics

SAE Logo SAE Logo
 title!

dlg text text

DKE

Extract Knowledge from Software

 Understand the meaning of your source code.

 Extraction of domain knowledge from source code as mathematical formulas, figures, decision tables or state charts.

 Automated redocumentation of complex technical software.


Store & Query Analysis Results

 Use a lightweight, graph-based repository to store the results of your software analysis

 Use an intuitive, graph inspired language for effectively querying your database

 Implement your custom queries to identify dependencies specific to your software system

Analyze System Evolution

 See how a system evolves over time

 Analyze code, design, and architecture changes of your system

 Identify modified system parts and plan incremental quality control activities


 Extract Knowledge from Software

Go To Top

Select one of the following C code examples:

  • (1) A simple sum example
  • (2) Standard deviation function
  • (3) Magnetic flux example
  • (4) Plotting some physical functions within a given range
  • (5) The Taylor Row for Sinus Function
  • (6) A large decision table

Or just enter some C code below to experience the power of domain knowledge extraction:

 Here you can test an application built from our  eKnows  suite: The Rulebook Generator (RbG).

You may choose some prepared samples or write/paste some of your own program code (ANSI C only !) and run the eKnows online application, which will then generate a word-editable document for you (see a sample here). In order to achieve more sophisticated results you may provide some of the code annotations described below.

  •  Use the annotation @symbol to improve typesetting of variable names in generated documents.
    You can annotate local variables (e.g. double x; // @symbol \vec{v}) or function parameters (e.g. // @param p @symbol X_{\alpha}).
    Symbols may be specified by a very limited subset of LaTeX commands including greek letters (e.g. \alpha becomes α in the document), subscript and accents (e.g. \vec).
  •  Use @symbol[dectab2] to represent a decision table as a two-dimensional table.
  •  Use @symbol[decbracket] to represent a decision table in classical mathematical style.
  •  Use @substitute to trigger algebraic substitution of variables by last expression (e.g. double x; // @substitute).
  •  Use @suppress to suppress formulae, i.e. assignments to a variable are not included in the generated document (e.g. double x; // @suppress).
  •  Use the @plot annotation to generate a function plot for a C function. Assuming a C function double func(double a, double b), the annotation @plot(a=42, b=0:100)[color=blue]{func} generates a function plot with parameter b rendered as x-axis (range 0 to 100). The @plot annotation must be surrounded with @begindiagram and @enddiagram.

The RbG offers much more capabilities (e.g. other language frontends or integration of texts or graphics from external files into your documents), which are not provided in this online demo.

 Store & Query Analysis Results

Go To Top

 Query the graph database!

  • (1) Functions calling other Functions?
    MATCH (a)-[:`CALLS`]->(b) RETURN a,b LIMIT 50
  • (2) Calling Functions on shortest Path?
    MATCH (f1:Function {name:"main"}), (f2:Function),p = shortestPath((f1)-[*..1]-(f2)) RETURN f1, f2
  • (3) Functions Reading Structures?
    MATCH (a)-[:`READS`]->(b) RETURN a,b LIMIT 50
  • (4) Functions Writing Structures?
    MATCH (a)-[:`WRITES`]->(b) RETURN a,b LIMIT 50
  • (5) Functions above a certain Complexity?
    MATCH (f:Function) WHERE f.mccabe > 8 RETURN f

 Here you can try out predefined queries to a database containing the analysis result of the source code of the well known terminal utility PuTTY.

The result is stored in a Neo4J graph database, which can be queried with Cypher, a declarative query language. A distinct characteristic of Cypher ist that the query syntax (at least for MATCH) resembles a graph iself. Of course, Cypher ist not only for querying a database, but also for manipulating its content.

However, for this demo here, we only allow read ('MATCH') queries.

A reference card briefly explaining the syntax and the capabilities of Neo4J Read Queries can be found here.

The result graph: Function nodes appear as blue boxes displaying the function name, while fields/structures appear as green ellipses.

The shading of function nodes refers to the McCabe complexity. The darker a function node appears, the more complex its implementation is.

Zoom in and out to your liking (using the mouse wheel) and interact with nodes and edges to explore details



 Once a query has been issued, the resulting graph shall appear here.

System Evolution Analysis

Go To Top

Filter

Hides selected namespaces.

 Here you can test the eKnows Evolution Explorer.

The diagram on the left visualizes the evolution of namespace dependencies of the JUnit framework across different versions.

Instructions

  •  Select the module to be analyzed
  •  Select the base version
  •  Activate "Show Dependency Strength" Option to show the number of type dependencies between namespaces.
  •  Activate "Show Diff" Option to analyze dependency evolution
  •  Select the version to be compared to the base version.
  •  Click the filter button to hide selected namespaces from the diagram.

eKnows Evolution Explorer provides more functionality than provided in this demo, e.g., the visualization of sustainability metrics, different code and evolution diagrams, and a code view enhanced with results of different static analyses.