October Newsletter 2023

Welcome to the October 2023 newsletter from 3SL!

This newsletter contains a mixture of news and technical information about us, and our requirements management and systems engineering tool “Cradle”. We would especially like to welcome everyone who has purchased Cradle in the past month and those who are currently evaluating Cradle for their projects and processes.

We hope that 3SL and Cradle can deliver real and measurable benefits that help you to improve the information flow within, the quality and timeliness of, and the traceability, compliance and governance for, all of your current and future projects.

If you have any questions about your use of Cradle, please do not hesitate to contact 3SL Support.

Controlling PDUIDs in Import and Export

The primary method of moving data into or out of Cradle databases is import/export. Regardless of the form of the data files used, there are some basic characteristics of import operations that affect the handling of PDUIDs and which can be controlled by the user when importing. These choices can be saved with other import options in an import format file. Such formats can be used for later imports, and specified for command-line based imports using the c_io utility. Using import format files is recommended as it ensures consistency between imports.

Further Details

For further details on this part 4 of a description of PDUIDs, please see the full blog entry here.

Latest Updates

The latest technical and related topics in our blog are:

Follow these links to see the latest blog updates and then use the blog’s search to find other topics of interest! With over 500 posts in the blog, we are sure that you will find lots to interest you in the details of Cradle and 3SL!

We would also like to thank all attendees on our Document Publisher course which we provided in September.

Halloween

Halloween is a celebration observed in many countries on 31st October, the eve of the Western Christian feast of All Saints’ Day. It begins the observance of Allhallowtide, the time in the liturgical year dedicated to remembering the dead, including saints (hallows), martyrs, and all the faithful departed.

Spirits, Cauldrons, Witches and Jack-O-Lanterns

Cauldron
Cauldron

The masses were hungry, they needed a solution. The Requirements Master toiled over her cauldron. Into the mix she added a freshly cut bunch of requirements, a handful of ideas and a sackful of luck. The brew steamed for day and night, and as members of her family walked by they threw in their ha’p’orth of comments.

The requirements soon stewed and disintegrated, but all could see the ideas floating to the top.

The swirling liquor produced a heady vapour, caught by the nostrils of the management team. They liked what they smelled and believed the Requirements Master was doing just fine.

When the soup was dished up to the masses, the flavour was odd, and it didn’t satisfy their hunger. They felt weakened and sad, some even passed over to another project. “A curse has been placed upon this town”, they cried, “the Requirements Master is a Witch!”  The town’s folk lit lanterns to guide the lost souls home to the land of abandoned engineering.

Well, that’s certainly one way to do design and engineering! Whilst it is often the case that many ideas are ‘thrown into the melting pot’, it should be used as a tool elicit idea, and not to ‘hopefully solve’ the problem. A more complex mix isn’t necessarily successful. As the tale told, losing sight of the requirements is a dangerous thing. Managing the project by a whiff of success is unlikely to be accurate.

So, don’t fall under the spell of those that don’t know how to engineer, and let Cradle light your way!

Social Media

Still to Come this Month

This course is a 1 day course split over 2 half days. It provides the following modules:

  • Introduction to Risk Management
  • Setting up a Risk Item Type
  • Managing Risks
  • Reporting Risks
  • Example Usage Demo

Your Highlights

If you have any company news or achievements that you would like 3SL to share in any of our newsletters then please let us know.

Controlling PDUIDs in Import and Export

This is the fourth and last in a short series of posts that explain Project Database Unique IDs (PDUIDs). This post explains how PDUIDs can be controlled when importing information into Cradle.

Exchanging Information

The primary method of moving data into or out of Cradle databases is import/export. Regardless of the form of the data files used, there are some basic characteristics of import operations that affect the handling of PDUIDs and which can be controlled by the user when importing. These choices can be saved with other import options in an import format file. Such formats can be used for later imports, and specified for command-line based imports using the c_io utility. Using import format files is recommended as it ensures consistency between imports.

Default Behaviour

When importing information:

  • Every item imported will have a PDUID when it is saved, even if the import data does not contain a PDUID
  • The DID in the PDUID of all imported items will be set to the DID of the current Cradle system. For data that is being loaded from other Cradle systems, this means that the PDUIDs of the items in the original and imported databases will always be different. Even if their PUIDs are the same, their DIDs will be different.
  • If an item being imported does not exist in the PDUID lookup table, then a new entry will be created in the table for the item. This new entry will have a PDUID. This PDUID will either be newly generated (the default), or if the import data contains a PDUID and the user has chosen to force the import of PDUIDs, then the PDUID from the import data will be used.
  • If an item being imported exists in the PDUID lookup table and its table entry is marked deleted, then this table entry will be reinstated. If the user has specified to use the PDUID from the import file, the PDUID in the table entry will be replaced with the PDUID from the import file, else the table entry will be reinstated and the imported item will have the original PDUID from the lookup table.
  • If an item being imported has a PDUID that is already used for a different item in the database, then the PDUID in the import file will not be used and the imported item’s PDUID will be replaced, regardless of any import options to the contrary
  • All instances of an item have the same PDUID. Therefore, the PDUID of an item in the database will only be changed if all instances of the item can be changed. If there is any reason why all instances of an item cannot have their PDUIDs changed, then none of the instances will have their PDUIDs changed. As an example, if a user tries to import items with Overwrite set On and wants the PDUIDs in the import file to be used in the database, then the user must have RW access to all instances of the item in the database and the import data must update all of these instances.

Force Use of Existing PDUIDs

When importing data, you can choose to ignore any PDUIDs in the import/export file and instead keep the PDUIDs already in the database. To do this, de-select the checkbox Import PDUIDs from file (do not generate them)

This means that:

  • If an item in the import data does not contain a PDUID, a PDUID will be generated for it as it is imported
  • If an item in the import data does not exist in the database, then PDUIDs will be generated for them
  • If the item in the import data does exist in the database, then the items will still have their original PDUIDs after the import and any PDUIDs in the import data will be ignored

Force Use of Import File PDUIDs

When importing data, you can choose to use PDUIDs in the import/export file and replace the PDUIDs already in the database. To do this, select the checkbox Import PDUIDs from file (do not generate them)

This means that:

  • If the item in the import data does not contain PDUIDs, then PDUIDs will be generated for items as they are imported
  • If the item in the import data does not exist in the database, then the PDUID in the import data will be used provided that it does not already exist in the PDUID lookup table and if it does exist in the table then if that table entry is active then a PDUID will be generated and if the table entry is not active then the PDUID in the import data will be used and the table entry will be replaced
  • If the item in the import data does exist in the database, then:
    • If the PDUID in the import data does not already exist in the PDUID lookup table then:
      • The PDUID in the import data will be used
    • Else if the lookup table entry is active then:
      • If the lookup table entry is for a different item then:
        • A PDUID will be generated and the PDUID in the import data will not be used
      • Else if the user has RW access to all instances of the item and all instances of the item are to be updated by the import then:
        • The PDUID in the import data will be used
      • Else
        • The PDUID already in the lookup table entry and the database items will not be changed
    • Else the lookup table entry is inactive so:
      • The PDUID in the import data will be used

Force PID Change

Whenever an item in an import file is to be imported as a new item in a database (not overwriting an existing item) then the PDUID for that new item will either come from the import data (if it contains PDUIDs) or a new PDUID will be generated. The PID in such PDUIDs will be either PID of the current database, or you can force a specific PID.

This can be useful if, you want to distinguish the data being imported with a specific PID, but the import data does not have that PID. For example, if you are importing into a single database data from multiple other databases then you might want to force the PIDs in the PDUIDs of items imported from database “A” to have one value and for the PIDs in the PDUIDs of items imported from database “B” to have a different value.

If you did this then, for instance, the PDUID facilities in queries could be used to distinguish between these sets of imported data.

Cradle Modules – SWE

Cradle-SWE Module

The Cradle SWE module provides reverse engineering and code generation to maintain consistency between a detailed system design and its software implementation.

Cradle SWE Module
Cradle Software Engineering SWE Module

Software Engineering

There are many contexts for software engineering, each using its own methods and languages. This module is intended for groups using functional methods to build software in C, Ada or Pascal.

Detailed software designs are represented using Structure Charts (STCs) with 3SL extensions to support:

  • Hierarchical descriptions of software into systems
  • Programs
  • Subsystems
  • Modules and source files
  • Representation of functions
  • Representation of basic data types

Software designs are described with diagrams, data definitions and module specifications that hold the pseudo code, descriptions or source code. This software design is cross referenced to architecture, design/analysis models, to requirements/test cases, and to all other data.

The initial design can be code generated to:

  • C, Ada and Pascal type definition header files (built from the model’s data definitions)
  • Source files that contain the call hierarchy from the STCs
  • Call arguments and local variable declarations
  • Content of the STC’s module specifications’ pseudo code or detailed design material.

Once algorithmic content is added to the generated code, the resulting completed source files can be reverse engineered back into the Cradle database, to update its design diagrams, and both the data definitions and module specifications of these diagrams’ symbols.

Reverse Engineering

Reverse engineering merges the actual source code into the design definitions and specifications. Each source file is subdivided into the individual routines. The component parts are then stored into separate frames in the module specification and data definition items in the database. Every line in each source file is stored in a frame of one of these items in the database.

The Code Generator can be run on the results of the reverse engineering to reconstruct the source files, either as they were, or including any changes made in the design model. In this case, the source code is generated using call interfaces built from the (possibly modified) STCs and the routines’ bodies are created from either the STC call hierarchy or the source code from the previous reverse engineer operation.

The process can start by reverse engineering legacy source code into an initial design model, recovering designs in situations where only the implementation currently exists.

As reverse engineering loads all source files into the database, the source files could be deleted, and instead configuration managed through the Cradle Configuration Management System as part of the design.

The diagrams, specifications and data definitions can contain any number of attributes, including URLs to reference the source code in a source code control system, such as Git or Subversion.

Format of Generated Code

The format of all generated code can be tailored to match your coding standards. Data definitions can be marked to be standard data types and generated into the source code. Header files can be produced from the composition specifications inside the data definitions to create record and variant structure declarations.

Support

The reverse engineering tool supports any compiler programs and conditional compilation directives. It can distinguish application code, application libraries and standard library or operating system / runtime routines, and render the design diagrams accordingly. This uses any combination of regular expressions, and Cradle-supplied or user-defined library routine lists.

Reverse engineering can process one or more source files in one run, creating a hierarchy of design diagrams to represent the code structure beyond individual source files.

Full Traceability

Using the reverse engineering tool creates full traceability across the entire system lifecycle, from user needs to system requirements to analysis, architecture and design models, to test procedures, specifications and test cases, to the source code. Cradle’s transitive cross reference view facilities allow users to directly see the user requirements and acceptance criteria associated with each source code module, and vice versa.

Feature Summary

Feature Summary - SWE
Feature Summary – SWE

Please contact 3SL for further information about adding a Cradle SWE module to your existing system.