Crosstwine Labs

Deliver reusable “code IPs”

The difference between “works on my machine” and high-quality, modular deliverables is… a lot of hard work. Our tools:

• Define a lightweight code partitioning scheme, namely packages;

• Generate static API definitions and browsable documentation by combining Doxygen/JSDoc-style “doc comments,” type annotations and a powerful code analysis engine;

• Understand transitive dependencies when loading code units from source;

• Bundle and obfuscate final deliverables with their dependencies, exporting only selected symbols—with renaming. Multiple variants of each procedure can be simultaneously active!

Packaging and delivery tools include:

Package

Partition code into packages, small, goal-oriented, composable units of code which are developed and tests individually.

Easily create new packages—including unit tests!

Optionally annotate packages with metadata such as description and author information, SKILL load order, and dependency information.

Use the SKILL API of our single-file package loader to easily manipulate your code collection.

Bundle

Freeze pcells, PDK code, and CAD applications with a known version of their dependencies into inscrutable, obfuscated “blobs” with well-defined entry points.

It does not matter if app-A.cxt, callbacks-B and pcell-Z use a different and slightly incompatible version of the AwesomeUtility function—once bundled, they are properly isolated and only see the variant they were tested with.

Condense

Process “doc comments” and type annotations, and use a powerful code analysis engine to generate comprehensive static definitions of your distributable code IPs.

The result includes type information, which improves documentation and enables code intelligence features for downstream users/customers—even when source code is not provided.

See a basic example below.

Doc

Generate up-to-date, browsable HTML documentation for single files, packages or package collections, via the SKILL API or as part of your delivery process.

Optionally include hyperlinked, syntax-highlighted, source code for internal documentation or public packages.

Basic Condense Example

Here is a tiny bit of code for those so inclined. Given the following SKILL definitions:

defclass(MyToolClass () ((port) (zn)))

;; Entry point...
;;
;; @param filename - Source data.
;; @param {fixnum} n - Iteration count.
;; @return The initialized tool.
procedure( MyIpFunction(filename n)
  let( ((port infile(filename)))
    makeInstance('MyToolClass ?port port ?zn n-1)
  )
)

condense produces the following machine-readable bundle of static definitions (slightly trimmed-down for readability):

symbols ((MyIpFunction
          description (("Entry point..."))
          params ((filename
                   type (or symbol string)
                   summary "Source data.")
                  (n
                   type fixnum
                   summary "Iteration count."))
          returns (nil
                   type MyToolClass
                   summary "The initialized tool.")))
types ((MyToolClass ...))

Note how we only specified the type of n, and that’s because n-1 implies fixnum||flonum—which is not constrained enough in our fictional example. Veda’s code intelligence features have been engineered to work well without extra… typing!