UniqueSoft offers more than legacy modernization: we have extensive experience delivering new applications on-time and under budget to our clients. UniqueSoft specializes in large, complex, long-lived embedded software products where modeling and code generation technologies offer substantial quality, time and cost advantages over traditional hand coding techniques.

UniqueSoft has delivered tens of millions of lines of code to a variety of industries, and its domain expertise ranges from telecom to transportation to information systems. UniqueSoft is confident it can offer a solution to fit your needs.

UniqueSoft Maintenance & Support

Based on the extensive experience of our Executive Team in long-lived telecommunications software products, the UniqueSoft process and tools were designed to provide superior and more cost-effective methods for maintaining and enhancing software after its release.

One Year Warranty: Providing high quality, defect-free software is our goal, and we achieve defect rates that are 10-50x lower than traditional software development techniques. To this goal, UniqueSoft offers a one year warranty on its software: any defect found during that time is repaired free of charge. For support beyond the first year, Uniquesoft also offers inexpensive extended maintenance plans.

Anytime Handoff: After one year – or at any time before then – UniqueSoft can hand off maintenance to a client. The client has three options to maintain the code themselves:

  • By hand, using the set of superior, highly visual documentation to assist them;
  • By exporting the UniqueSoft models to a format readable by other commercial tools;
  • By licensing part or all of the UniqueSoft tool suite

Easy Addition of New Features: The use of modeling, feature-driven development and autocode generation technology makes the addition of new features fast and inexpensive. As demonstrated in an embedded case study (please see Industries to download), UniqueSoft added features and changes which required modifying over 20% of the code base in a 34,000 lines of code product in one week.

Continuing Synchronization of Documentation and Source Code: A common problem with traditional hand-coded software is the increasing difficulty in maintaining it after it has been released. Poorly documented patches and additions to the code accumulate, resulting in out-of-date documentation which no longer accurately reflects the product code base. The result: cost of maintenance rises, and new features become increasingly difficult and expensive to add.

UniqueSoft uses a methodology which generates code from models, which are themselves derived from the higher level architecture and design, ensuring that there is continued synchronization between the supporting documentation and the existing code base. As new features are added, these modified designs and models are then used to generate new, fresh code which ensures that UniqueSoft code does not evolve into poorly understood ‘legacy software’.

Easy Porting to New Platforms, Languages: UniqueSoft develops its software in a platform-independent manner, with automatic targeting to platforms and languages handled by the code generation technology. As languages and platforms become obsolete, porting existing UniqueSoft software to a new language or platform is as easy as re-running the code generator with the new targeting information.

Maintenance and Support

Services FAQs

Why not just program in Java / C#?

If your program is small, modeling and code generation may not offer much benefit. However, there are other, more important factors than "How fast can I crank out code?", such as:

  • Efficiency gains from using a domain-specific language (Java, C#, C++, C, etc., are general-purpose languages)
  • Quality gains from automatic code generation
  • Ability to retarget code to new platforms, frameworks, and languages
  • Ability to experiment with and change to different architectures, including automatic handling of multicore and multi-threading
  • Consistently and universally applied coding standards and guidelines
  • Avoiding "patchiness" of code as it is maintained and enhanced over its life
  • Architecture and design documents that are guaranteed to be correct and up-to-date
  • Ability to derive comprehensive test suites from requirements
  • Added resilience to changes in personnel and teams over the life of the product
  • Clear separation of features and platform details to enable product lines

What type of application is the "sweet spot" for UniqueSoft's development methodology?

Indicators for a good fit include:

  • State-based systems
  • Reactive systems (get an input, process it, send a response)
  • Protocol stackss
  • Large, complex systems
  • Product-line development
  • IT systems
  • Safety-critical systems
  • Systems which may be migrated to new languages, frameworks, or platforms
  • Performance-critical systems
  • Systems that have a central processing step, reading multiple inputs in various formats, interfacing with various other systems, and producing outputs in various formats, especially if the list of interfaces is growing
  • Reverse engineering of current systems, including targeting to new languages and platforms

Counter-indicators for a good fit:

  • Low-level, firmware-based code (DSP, FPGA, ...)
  • GUI development (there are good tools out there for this, and we use them, too)
  • Small, simple, one-off,or end-of-life code
  • Small, scattered changes to an existing code base

For larger projects which might involve these kinds of software development, UniqueSoft would partner or perform the work itself, though without the same model-driven development advantages.

Are UniqueSoft tools and notations proprietary?

The core tools are proprietary, although parts are based on open standard frameworks such as Eclipse. We do license our tools, though.

The main modeling notation is TDL, which is a profile for UML. This notation is standardized as ITU-T Z.109. We also use ASN.1 (ITU-T X.680) as a notation for protocols, and Use Case Maps (ITU-T Z.151) and MSCs (ITU-T Z.120) for requirements.

If desired, models could be exported to other industry-standard notations that can be maintained and modified using widely available industry-standard tools.

How do we work together?

We can work with a company no matter what life cycle they are using. We encourage the project to be done as a partnership between UniqueSoft and the customer. That is, we discourage a "throw it over the wall and come back when you are done" view. We can take requirements in any form and in any state of completeness. For example, we have worked on various projects that have requirements as:

  • A few marketing-level PowerPoint slides
  • Unstructured text documents
  • Numbered, organized, detailed requirements
  • Standards documents
  • Spreadsheets
  • Tables of Protocol Data Unit specifications

From the requirements known at the start of the project, a Statement of Work is created which includes, among other information, a summary, technical assumptions, deliverables, the schedule, acceptance criteria, equipment needs, and management and administrative details.

See also the answers to more specific questions in this section.

Does UniqueSoft have to have all the requirements known up front?

No, complete requirements are not needed at the start. We often engage early with a customer to help finalize and formalize the requirements. A requirements document is typically created as part of a project. The amount of detail in that document depends on how well the requirements are known up front. For example, if a project is to implement a system based on a standards document, the project requirements document may reference the standard and list which optional parts will be done, any exceptions or additions to the standard, etc.

Note, also, that it is common in an Agile process to have only high-level requirements completed at the beginning of a project, and for the detailed requirements to be completed as part of the sprints. The same is true for projects with a GUI component, where it is hard to specify the look and feel of the application up front. These projects often go through several planned iterations. UniqueSoft can accommodate projects using any of these styles.

Can you have engineers on site?

Yes. Depending on the specifics of the project, there are several times when an engineer may be on site:

  • At specific collaboration points, such as requirements review, deliverable integrations, on-site testing, etc.
  • For project development
  • Numbered, organized, detailed requirements
  • Maintenance activities

This on-site work is specified as part of the Statement of Work for a project.

What happens if we no longer have a working relationship?

Customers can take over maintenance of the code themselves at any point. They get all the artifacts and documentation, including up-to-date requirements, architecture, design, code, and test cases.

How do you debug the generated code?

Debugging the generated code is done the same way as one would debug hand-written code. However, this is only done as a last resort. The typical debugging cycle is:

  • Take the test case that triggers the defect and run it in the modeling tool. Standard source-level debugging tools are available in the modeling tool, such as breakpoints, single-stepping, variable inspection, etc.
  • If the defect shows up in the model, fix the model (along with the related requirements, if necessary), regenerate the code, and run the regression test suite.
  • If the defect does not show up in the model, then the problem is with the code generator, with the hand-written code, or with library interfaces.
  • Enable tracing in the generated code to isolate when the defect is introduced. This tracing can be enabled at runtime.
  • If additional debugging is needed, standard tools such as source-level tracers, gdb, etc., can be used just as with hand-written code.