Phone800.366.3472 SupportGet Support DocumentationDocumentation Resource CenterResource Center
search
close
Open Menu

Synergex Blog


Announcing Synergy/DE 11.1.1e

By Steve Ives, Posted on July 14, 2020 at 2:04 pm

Steve Ives

Due to the discovery of a potentially serious issue in the 11.1.1d release of Synergy/DE, we have decided to withdraw that release on Windows and UNIX platforms and replace it with 11.1.1e, which is now available.

To understand the issue, it is first necessary to understand that enabling compression on a data file can, in rare cases, result in a small increase in the size of some records! This can only occur if the data in a record is not compressible, yet the compression itself adds a small overhead.

It was found that when reading records from a compressed file, by RFA, any records exhibiting this “negative compression” would have one byte of bad data returned at the end of the record.

11.1.1e includes new versions of Synergy/DE 32-bit and 64-bit for Windows and Unix platforms, and Synergy DBL Integration for Visual Studio (build #2769).

We strongly recommend that anyone who has updated to Synergy/DE 11.1.1d on the affected platforms should immediately upgrade to 11.1.1e.

As we needed to release a new version to address the READ by RFA issue, we decided to also include several other quality improvements that had already been completed.

Synergy/DE Runtime

(Windows) In 11.1.1d, when using SYN_RESIZE_SCALE or having a monitor DPI change, some .NET controls would fail to repaint if the application moved between monitors of different DPI or scaling.

Traditional Synergy Compiler

A global structure with the same name as a subroutine no longer causes a segmentation fault when loading prototype files when there are different prototype files for the global structure and the subroutine.

Synergy Configuration Program

We addressed an issue in rsynd that was causing the SynConfig utility to fail with a “Could not complete services import” error when specifying a user account during service import.

Synergy DBMS

We enhanced the isutl utility when recovering change tracking files with bad change tracking links, and the utility no longer crashes if certain wildcard file operations are attempted.

Visual Studio Build System

We fixed an issue in the incremental build feature in SDI 11.1.1d-2749 through 11.1.1d-2763 that caused full project builds to occur when only partial builds were necessary for projects using common.props and with non-Synergy references.

We fixed an issue that prevented low-level libraries in Synergy .NET Core solutions from automatically rebuilding when an output file was missing.

Visual Studio Property Pages

We fixed an issue that prevented Visual Studio settings imported from a file from working until a Synergy DBL option page (Tools > Options > Text Editor > Synergy DBL > …) was opened.

We fixed an issue with Synergy .NET Core and .NET Standard projects that prevented SDI from resolving known MSBuild properties used for pre-build and post-build events.

For additional information and tracker numbers associated with each of these items, please refer to the release notes.


Announcing SDI 11.1.1d-2763

By Steve Ives, Posted on July 2, 2020 at 1:01 pm

Steve Ives

Shortly after the recent release of SDI build 2755 we discovered an issue that we wanted to address as soon as possible, so today we are announcing the release of build 2763, which we recommend for everyone using Visual Studio for Synergy development.

We are not aware of any customers being affected by the issue, and we have removed the download link for the previous build.

For additional information please refer to the release notes.


No More SDI “Developer” Builds – Just Releases

By Steve Ives, Posted on June 29, 2020 at 3:12 pm

Steve Ives

I wanted to make you aware of a small change that we have recently made to the way that we refer to “interim” releases of the SDI (Synergy DBL Integration for Visual Studio) product.

A few years ago, it became clear that we needed to be able to release our Visual Studio Integration tools on a more frequent cadence than the main Synergy/DE product. So we started doing interim releases that we referred to as “Developer Builds.” Each developer build was identified both by a version number and a build number.

Initially, these builds were often not subject to the same levels of stringent testing that a build for a full release would be, and we made that clear to customers. But now, thanks to considerable improvements in our automated testing processes, these interim builds are now subject to the same levels of inspection and testing as a build for a full release, and it is no longer necessary to discriminate between developer- and full-builds.

For this reason, we have decided to stop referring to these releases as “Developer Builds,” they are now all just “SDI Releases,” which will continue to occur on a much more frequent cadence than Synergy/DE.



xfBBQ: Full-Stack Web Development with Harmony Core

By Steve Ives, Posted on June 15, 2020 at 9:00 am

Steve Ives

On Thursday, June 18th we will launch a new series of webinars called the xfBBQ Webinars, and I’m guessing this may require some explanation. So here goes:

What is xfBBQ?
xfBBQ is a browser-based application, designed and created by Johnson Luong, Synergex Software Developer, (with minor input from Jeff Greene, Harmony Core Technical Lead, and Synergex Principal Engineer) to help us plan for our regular company BBQs. The ones that we are NOT currently enjoying because of the COVID-19 pandemic! Generally though, we host around six BBQs outside our office at lunchtime during the summer season, but most of you won’t care about that because you’re not invited 😉!

Who is Johnson Luong?
Johnson is a valuable member of our development team who, since joining Synergex in 2014, has worked on many different parts of the Synergy/DE toolset. Recently he has played a major role in the creation of our Windows installations using the WiX Toolset, while at the same time having made significant personal contributions to the development of the entire Harmony Core framework.

What does xfBBQ do?
The app allows customers (employees) to register for access, then informs them when BBQs are scheduled, and allows them to select from, and customize, various menu selections for each BBQ. For example, for a given BBQ, I might use the app to express my preference for a “medium rare cheeseburger with hot peppers and a well-done dog.” I could even opt for two burgers, or two dogs, or both … but in doing so I may risk the wrath of Samantha, our wellness coordinator! Johnson assures me she doesn’t have a special “back door” into the data, but I’m not convinced!

Anyhoo, the app collates the orders, presenting the BBQ officials (all who lavish in Synergex VIP status, and rightly so) with the required lists of requirements and ingredients for each BBQ event. Yada, yada, yada.

Why did we do this?
Because having developed an awesome (our words, but we’re confident) web-services framework called Harmony Core, customers were asking for real-world examples of how it might be used. And … we had a real-world problem to solve, namely that we really needed to control the amount of burger patties and sausages that we were purchasing from Costco!

Why xf?
Just for fun! Johnson believes that he has now defined the actual meaning of “xf”, but trust me, he has no clue! Until it’s been ratified by Marketing it means nothing, and that process could take years!

But seriously, this webinar series presents to you an end-to-end view of how a modern browser-based application is developed. You will see how the Harmony Core back-end is built, but you have seen that in previous webinars. What is much more important here is the focus on the development of the front-end application that interacts with the Harmony Core service.

This will be a series of four webinars, as follows:

Thursday June 18 @ 9 am PDT
Creating a Harmony Core solution and hooking it up to a new React app.
Register for part one here.

Thursday June 25 @ 9 am PDT
POSTing data in React, and an introduction to Redux.
Register for part two here.

Wednesday July 1@ 9 am PDT
Captchas, batch processing, and other CRUD.
Register for part three here.

Wednesday July 8@ 9 am PDT
User authentication, styling with Bootstrap, and making a React production build.
Register for part four here.

xfBBQ is a browser-based app. It is a single page application, developed using React and Redux, and using appropriate sprinkles of HTML and JavaScript along the way.

We are completely excited that over the last few months we have built up a marvelous following for our Harmony Core webinars, but I’ll be honest, there won’t be much DBL code to see here! Regardless, I encourage all of you to join us for this webinar series, and to stick with it to the end.

If you’re a DBL dev you may not learn much about your own part of the puzzle that is building a modern distributed application. But I promise you, by the end of the process you will have learned a lot about what it takes to pull together all the other pieces of that puzzle. Building a modern, distributed application requires skills in many different areas, and this webinar series touches on many of them.

It is most important that we get your non-Synergy developers to participate in these webinars. Your web devs will be right at home here, but if you don’t have web devs then invite your Windows devs, your iOS and Android devs, and your MacOS devs.

Web services are accessed via HTTP, and pretty much every development language can do that! The perfect target audience for these webinars is anyone that is involved in developing your next-generation apps. It’s not about any one part of the process, it’s about the entire process, end-to-end, and that will require devs with many different skill sets get together, and to work together to create success!


Unit Testing in Traditional Synergy

By Steve Ives, Posted on June 12, 2020 at 9:00 am

Steve Ives

One of the most significant new features introduced in Synergy/DE 11.1.1d is a unit testing framework for traditional Synergy. The framework is based on the MSTest framework that we have supported in Synergy .NET for some time and is delivered as a component of our Synergy DBL Integration for Visual Studio product.

Introduction

Unit testing is a method of testing software at a low level, usually at the level of individual subroutines, functions, and methods. Unit tests are frequently written by the same software developers that write the code being tested, and sometimes, in the case of test-driven development, even before the actual code being tested.

The idea is to exercise each routine in as many different scenarios as you can think of, passing various combinations of parameters, both correct and incorrect, and perhaps by altering the execution environment. The goal is to prove that the routine responds correctly in all cases when used correctly, and also to prove that it fails appropriately in all cases when it should fail.

Unit tests are generally small and fast to run individually, but numerous. It is not uncommon to have hundreds or even thousands of unit tests, and, ideally, those tests execute quickly enough to make it feasible to run them frequently.

In some environments, unit tests are configured to run each time the developer builds a new version. In other environments, tests might run as part of a “continuous integration / continuous deployment (CI/CD) pipeline that runs each time developers attempt to check code into a central repository, and the failure of a unit test might cause the check-in of the code to fail.

Adding Unit Tests to a Solution

To make adding unit tests easy, we have provided a new Visual Studio project template named “Unit Test (Traditional).” It adds a traditional Synergy ELB project to your solution, and that project contains some sample unit test code.

Adding Test Classes and Test Methods

Unit test projects contain unit test classes, and a unit test class is simply a class that is decorated with a {TestClass} attribute. Here is an example:

Unit Test Class

A unit test project can include any number of unit test classes. Generally, a test class groups together a related set of tests. In the case of the code above, notice the name of the class is CustomerApiTests. Presumably, tests that exercise a Customer API are to be added later.

Each test class contains one or more test methods, which are, once again, decorated with an attribute. In this case the {TestMetod} attribute. Here is an example of a test class containing several test methods:

Unit Test Methods

The code above declares three test methods, each of which tests a particular piece of functionality of the API. But this is just a simple example. In an actual test class, there may be several test methods to test each of the API functions in different ways. The number of test methods per function is typically determined by how complicated the function is, how many parameters it has, how many different things it can do based on those parameters, etc.

Coding Test Methods

Each test method typically contains a small amount of code, sufficient to test a particular scenario. The operating environment must be the same each time a particular test runs; we’ll talk more about that later. Here is an example of a test method that contains some simple code.

Unit Test Code Example

When writing unit tests, many developers follow what is known as the “AAA Pattern,” which stands for “Arrange, Act and Assert.” First, you arrange (or prepare) whatever is needed to execute the test, then you “Act” by executing the test, and finally, you “Assert” the result of the test. The name of this final phase is interesting because, in MSTest, Assert is the name of the actual class used to notify the framework of the results of a test.

In the example above, the arrange phase involves creating a new instance of the CustomerAPI to use for the test. The Act phase then uses that object to make a call to the API function to be tested. And in the Assert phase, the code checks that the expected customer record was returned.

The Assert Class

The Assert class has many different static methods used to signal success or failure based on various scenarios. The method you choose to use depends on the nature of the tests that you need to execute to determine the success or failure of the test. Some examples of Assert methods are:

Assert.AreEqual(expectedObj, actualObj)
Assert.AreNotEqual(notExpectedObj, actualObj)
Assert.AreSame(expectedObj, actualObj)
Assert.AreNotSame(notExpectedObj, actualObj)
Assert.Fail()
Assert.Inconclusive()
Assert.IsTrue(condition)
Assert.IsFalse(condition)
Assert.IsNull(object)
Assert.IsNotNull(object)

Most of these methods also have several overloads with different combinations of parameters. For example, most also have a variant that allows an error message to be recorded in the case of a failing test, and more. In traditional Synergy, the Assert class is located in the Synergex.TestFramework namespace, along with the various attributes mentioned earlier.

By the way, I should mention that if any test method fails with an error, or throws an exception, then the test framework catches those errors and exceptions and reports them as test failures in the Test Explorer window.

Building Tests

When you build a solution that includes a unit test project, that project builds just like any other traditional Synergy ELB. It is likely that the code being tested by your unit tests exists in one or more other projects in your solution, so to give your unit tests access to that code, you simply add references to the other projects. Also, if you are using a Synergy repository project, and your unit tests require repository data definitions, then also add a reference to the repository project in the usual way. And like other Synergy projects in Visual Studio, if your development environment and code rely on the values of environment variables that are defined using the “Common Properties” method, you may need to opt- into those common properties via the project properties dialog in the usual way.

The Test Explorer Window

Visual Studio includes a piece of UI called the Test Explorer. If you don’t see it already displayed, you can display it by using the menu commands Test> Test Explorer.

Empty Test Explorer

When the Test Explorer window it first displayed, it often starts out empty, but notice the instructions that are displayed in the window, which says, “Build your solution to discover available tests.”

Once you build a project that contains unit test classes and methods, the Test Explorer window will discover and display your tests:

Discovered Tests

By default, your tests are displayed in a hierarchy based on your project name, namespace, and class, and then the individual methods are displayed below each class.

Notice the two green buttons to the left side of the Test Explorer toolbar. These are the Run All Tests and Run Test buttons. In my sample scenario, only one of the tests contains any code; the other two test methods are configured to throw an exception that says “Not implemented.” Here’s what happens when the Run All button is clicked:

Test Results

As you can see, Test Explorer is presenting a summary of what happened when it attempted to run each of the three methods. One test passed, and two failed. Notice the color-coded icons, green is good, red is bad, and notice that all of the parent folders are also red. For a parent folder to show a green icon, all tests below must pass.

Also, notice how the Group Summary pane is displaying a summary of the pass/fail information. This is because we have a folder node selected in the tree. If we select an individual test, then the pane displays the details of the result of that specific test:

Individual Test Results

In addition to executing all tests or a single test, you can also select a number of tests, and use the right-click menu to execute just that set of tests:

Selected Tests Run

In the above screenshot, you can see that the third test was not executed, which is indicated by the light color of its icons background.

Debugging Tests and Tested Code

In addition to merely running tests, it is also possible to use the Test Explorer to launch debugging sessions for specific tests. To do so, right-click on the test and select Debug. A debugger session will start, and the debugger will break in the test method. You can debug the test method, and as long as you have the source code available, you can also step through into the underlying code being tested.

Organizing Tests

As the number of tests in your environment grows, it is likely that the sorting and filtering methods provided by the Test Explorer may not be enough to allow you to work efficiently. For this reason, it is also possible for you to apply custom categorizations to your tests in code.

This is done by decorating your test methods with an additional attribute named {TestCategory}. Here is an example:

Categorizing Test Methods

And having done so, there are options in the Test Explorer toolbar to modify the display hierarchy to include “Traits,” which are the custom attributes that you have applied to your test methods. Here is an example of that:

Test Explorer Traits View

Environment Initialization and Cleanup

As you start to really get into writing unit tests, you will quickly realize that a big part of the road to success lies with your ability to always run your tests in a consistent and known state. For example, if your tests are reading and writing data files, those data files need to be in a known good state.

To help with that, the framework provides some special functionality that can be used to establish and reset the environment, if necessary. In MSTest, there are six such mechanisms; in traditional Synergy, we currently support four of them. These are:

  • ClassInitialize – runs once, BEFORE any test in the class runs
  • TestInitialize – runs BEFORE EVERY TEST in the class
  • TestCleanup – runs AFTER EVERY TEST in the class
  • ClassCleanup – runs once, AFTER all tests have completed

You can optionally add methods to your test class to provide each of the functions that you require. To do so, you simply add public void methods, decorated with an appropriate attribute, like this:

Special Test Class Methods

For example, if you are testing an API, and that API is completely stateless, then instead of creating an instance of the API in each method, then using it and discarding it, you could use a ClassInitialize method to create an instance of the API, code all of your test methods to use that same instance, then delete the instance in the ClassCleanup method.

If your API is not stateless and you do require a new instance for each test, you could simplify the code in each test by defining the code to instantiate the API in a TestInitialize method and discard it in a TestCleanup method. The runtime overhead is the same, but you only have to code the APU creation one time instead of potentially hundreds of times.

In MSTest, there is a third level of Initialization and Cleanup that happens at the “Assembly” (ELB in this case) level. This is implemented the exact same way, via the attributes {AssemblyInitialize} and {AssemblyCleanup}. We do plan to add that support; it just didn’t make it into the initial release.

Summing Up

This post is not intended to be a complete guide to the subject of unit testing in Traditional Synergy, and indeed there are other features that have not been discussed here. Instead, the intention was to provide enough information to pique your interest, and hopefully, that goal was achieved.

I encourage you to refer to the Synergy documentation for additional information, and we are looking forward to receiving your feedback on this important new technology for traditional Synergy.


Announcing a New Product Downloads Site

By Steve Ives, Posted on June 9, 2020 at 6:49 pm

Steve Ives

We are introducing a new download experience for all version 11 products. As we continue to migrate functionality from the Original Resource Center to the New Resource Center, product downloads are the latest functionality to move across. To access downloads for version 11 products, first, go to the Products page, and, if not already logged in, then do so.

New Products Page

 

As you can see, the products page now includes a new Downloads option, which, takes you to a new, improved, and simplified download experience. We have tried to make the experience as simple as possible for most people, with all of the most frequently downloaded products being available with a single click.

New Main Downloads Page

The most popular downloads for the latest released version are available via a single-click on one of the prominent blue buttons. But if you need downloads for ancillary products, such as xfNetLink .NET, or different platforms, or older v11 versions of the products, then the text links under “Downloads for all Supported Platforms” take you to pages where everything is available. For example, here’s the downloads page for the IBM AIX platform:

New Platform Downloads Page

The downloads for the latest version of products for the platform are once again directly downloadable via a single click.

Also, notice the “Select Version” drop-down control, which allows you to pick from earlier versions of the product for the selected platform. Currently, we have moved the downloads for all of the version 11 products, so that includes the following versions:

  • 11.1.1
  • 11.1.1a
  • 11.1.1b
  • 11.1.1c
  • 11.1.1d

This represents a significant change from the previous download site. Previously, for any given release, say 11.1, you would only be able to download the latest patch version of any product. When we published a patch for a product, we removed all earlier versions of that release. From now on, when we publish any download for a product, that download remains available for use at any time in the future.

The only exception to this rule is in the improbable scenario that we discover a severe flaw in an installer or in the product, which requires us to replace a download with a subsequent version and remove the previous version to guarantee that nobody else downloads it.

The downloads for all of the previous product versions are still available in the Original Resource Center. We do plan to move those downloads across to the new site, version by version, starting with version 10 and working back from there. We hope to migrate the version 10 downloads across somewhere in the June time-frame, but we have not committed to a specific date yet.

By the way, if you scroll down a little on the platform download pages, you can access various important information and notes, and view a release log showing the timeline of the current and previous releases.

If you attempt to access the new downloads site and find that you can’t see it, the most likely reason is that individual users must be granted downloads access within the resource center. This was also the case in the original resource center, and we believe that we have migrated the permissions to the new site. But if you think you should be able to see downloads and can’t, try contacting your resource center admin (each company has one or more nominated admins), or contact the Synergex Customer Services team for assistance.

We hope that you like the new downloads experience, and we look forward to receiving your feedback.

 


Announcing Synergy/DE 11.1.1d

By Steve Ives, Posted on at 6:49 pm

Steve Ives

More resilient ISAM files, exciting new developer tools, and much more.

A new Synergy/DE patch release is now available to download for all platforms. All customers are encouraged to update to 11.1.1d for access to new features and quality improvements.

Highlighted New Features

The 11.1.1d release introduces many new features across the product set. These are some of the more significant enhancements:

Global I/O hooks

A new “global I/O hooks” mechanism enables you to add I/O hooks to channels within an application without making any changes to existing code. Add an external subroutine named SYN_GLOBALHOOKS_OPEN to your environment, and it gets called during every successful OPEN statement. Add code to the routine to add I/O hooks to the channel as required.

Among many other use cases, this allows you to add data replication to an application with absolutely no changes to the existing code. The feature is available on Windows (in both traditional Synergy and Synergy .NET) and Unix systems. Unfortunately, it was not possible to add support on OpenVMS.

FULLRESILIENT ISAM Files

We have extended the “Resilient ISAM” capabilities introduced in earlier 11.1.1 releases by adding a new ISAM feature called FULLRESILIENT. This new option provides similar capabilities to the existing RESILIENT option, except that for all writes (STORE, WRITE, or DELETE), data is written directly to disk using the OPEN mode FILE_FLAG_WRITE_THROUGH on Windows or O_DSYNC on Unix.

The FULLRESILIENT option can be enabled when using the ISAMC subroutine, the bldism and isutl -p utilities, and when using the ISAM definition language in XDL files.

Support for MYSQL 8

We added support for MySQL 8 in the SQL Connection API on Windows and Linux 64-bit systems. There are some platform restrictions because MySQL 8 requires OpenSSL 1.1.1, which may not be available on some Linux systems. Refer to the release notes for additional information.

Unit Testing for Traditional Synergy

We added a unit testing framework for traditional Synergy, based on the capabilities of the MSTest framework that we already support in Synergy .NET. It is shipped as part of our Synergy DBL Integration for Visual Studio product, although you can also execute tests outside of Visual Studio.

It is easy to get started because we provide a new Visual Studio project template to add a unit tests project to your existing solutions. You can execute tests both from inside Visual Studio, with full Test Explorer UI support, as well as outside of Visual Studio via the VSTest.Console.exe application and .runsettings files.

If you have ever written unit tests for MSTest, this will feel like a familiar environment. You write test classes containing test methods; you decorate those classes and methods with various unit testing attributes. Test classes are decorated with a {TestClass} attribute and test methods with a {TestMethod} attribute. Other attributes facilitate grouping tests by trait, and just like in MSTest, there are a range of options for both preparing a test environment (via {ClassInitialize} and {TestInitialize} methods) as well as cleaning up the environment after tests have run (via {TestCleanup} and {ClassCleanup} methods).

The framework also provides a new Assert class containing a large number of static methods that are used to indicate test method completion status to the test framework.

We know that this does not represent complete MSTest compatibility; in particular, we still need to implement an equivalent of {AssemblyInitialize} and {AssemblyCleanup} methods, which we’ll be working on next.

For now, simply because this new capability has not had much exposure to customers, we are considering this to be a pre-release of the feature, and the release of the 11.1.1d version of Synergy DBL Integration for Visual Studio may trail the main release by a few days. We very much look forward to receiving your feedback on this significant new feature.

Traditional Synergy Debugger Rewritten

We have rewritten the traditional Synergy debugger to improve performance and add many new capabilities, primarily in the area of OO, examining objects, etc. The new implementation yields significant improvements when debugging traditional Synergy code using the Visual Studio IDE’s integrated debugging tools.

As part of the debugger rewrite, we were able to incorporate several new features, all of which improve the debugging experience generally, but in particular, improve the experience when debugging traditional Synergy code in the Visual Studio IDE.

We improved the TRAP ON environment, which now causes a break at the actual line where the error or exception occurred. Previously, the break occurred at the line following any ONERROR or CATCH processing. We also introduced support for evaluating multiple levels of casts, such as “((c2)((c1)a.b).c).d”. And we made it possible to evaluate objects that can vary at runtime (e.g., @* and collection elements) by making it possible to dereference based on their runtime contents. Individually, these improvements are small, but together they result in a marked improvement in the overall experience when debugging in Visual Studio in terms of better hover-over support and improved information in the Locals window.

Other Enhancements

In addition to the highlighted new features mentioned above, this release also includes many more minor enhancements, some of which are listed here:

Add RESILIENT Features to Exiting ISAM Files

We enhanced the isutl utility so that the -p option can now add the RESILIENT option to an existing REV6 or higher file, or to a lower revision file that is being patched to REV6. To enable this option, use the new -qfile=resilient option. Refer to the release notes for additional information.

Enhanced .NET Assembly API Exception Handling

On Windows, we have improved exception handling behavior within the .NET assembly API, used to execute .NET code within a traditional Synergy application. Previously, a .NET exception caught in traditional Synergy exposed the .NET portion of the stack trace in the Message property and the Synergy portion of the stack trace in the StackTrace property. In the new release, the Message property now exposes the exception message, and the StackTrace property reveals the complete stack trace.

UI Toolkit High DPI Improvements

We have made further UI Toolkit enhancements related to improving the overall look and feel on Windows high-DPI displays. Specifically, we improved scaling for buttons and in windows non-client areas (title and menu bar), and we improved the sizing of buttons when the SYN_RESIZE_SCALE option is enabled. In the fonts section of synergy.ini, we added the ability to specify a font specifically for buttons. We also switched to using the Consolas font for the status bar unless a “status” font is specified. We also made some improvements when the monitors’ DPI settings are changed.

REV11 Licensing Upgrade Package Installer Improvements

We made a minor change to the REV11 Licensing Upgrade Package to support installations that are in a non-default location.

Performance Improvements

In addition to new features, we continually search out places that we can enhance performance, in both our tools and your running applications. Here are some of the performance enhancements in the 11.1.1d release:

Mitigation for Intel JCC Erratum Slowdown

We have changed how we build the compilers and runtime by enabling an MSVC compiler option to mitigate the performance impact caused by the Intel “Jump Conditional Code” (JCC) erratum microcode update.

Briefly, Intel released a microcode update for all Intel Gen6 and later processors, correcting an issue that caused “unpredictable behavior” in some circumstances. A side effect of the update is a 2% to 30% performance degradation of affected processors.

Microsoft recently added a new MSVC compiler option, which alters the code to mitigate the JCC Erratum performance degradation. It is essential to be aware of this change because Gen 6 processors have been shipping since 2015 and are likely in a large number of the systems we run today. While 2% of degradation isn’t that important, 30% of degradation could be devastating.

If you are affected by this situation and want a resolution, your solution is to upgrade to Synergy 11.1.1d. For additional information, read Mitigations for JCC Erratum (Intel) and JCC Erratum Mitigation in MSVC (Microsoft).

Select Class Speed Improvement

We have improved the Select class performance when using “sorted” OrderBy (and READ by RFA) over large ISAM files.

Unload to Unsorted File

We have added a new input file option to the fconvert utility on Windows and Unix systems, making it possible to perform file unload operations more quickly.

The new -k  option causes fconvert to use the /nonkey_sequential OPEN option to unload directly from the data file, without the use of any index, resulting in faster unload times but at the cost of the data in the output file being completely unordered.

Also, we have automatically enabled this option if both the input and output files are ISAM files, exclusive access is available, and the key being unloaded does not allow duplicates.

Improved Isutl Performance with Very Large Files

On Windows and Unix, we have improved the isutl utility’s performance when processing extremely large ISAM files (~800 million records or more).

Speed Boost for .NET I/O Code

In .NET, and when targeting the V11 runtime, we have improved the performance of all routines that use I/O statements by reducing object creation for every I/O statement executed to just one object for all I/O statements executed for the routine.

UI Toolkit Window Creation Speed

In Windows UI Toolkit, we have improved window creation performance to help mitigate slowdowns in Microsoft code in later Windows 10 releases.

Highlighted Quality Improvements

Of course, every release also includes quality improvements, many of which are directly related to customer issues. Generally, you would go to the release notes for detailed information about quality improvements, but here we call out a few of the more important ones that we feel customers need to know about:

Fixed “Class Handle Released” Runtime Failure

We fixed an issue that could occur in versions 11.1.1 through 11.1.1c, in which an internal runtime failure “Class handle released” occurred randomly, mostly in .NET interop code.

Corrected FCONVERT Random Freeze

We fixed an issue that occurred from 11.1.1 to 11.1.1c, in which fconvert randomly froze up in some instances where the ISAM file had multiple keys and the system had multiple CPU cores.

Addressed Debugger Hangs

We fixed an issue in the traditional Synergy compiler that could occur in versions 10.1.1 to 11.1.1c, where examining an unused variable in a module compiled -debug (rather than debug=full) caused the debugger to hang.

We also fixed an issue in the traditional Synergy compiler that could occur in versions 10.3.3 to 11.1.1c, where a step into a line accessing the get() routine of a simple one-line property caused the debugger to hang.

Visual Studio Builds Blocked

We corrected a situation that could occur when building solutions in the 11.1.1c SDI builds, where a thread-locking performance problem could cause Visual Studio build operations to be blocked, behind background IntelliSense load operations. As a side benefit, this fix should noticeably improve load performance for large solutions, especially those with Synergy Repository projects and C# projects.

SQL Connection Licensing Error

On Windows, we addressed an issue that could occur in versions 11.1.1 through 11.1.1c when using a network connection to a remote SQL OpenNet Server:  an “Exceeded Maximum User” licensing error could happen in some cases.

Erroneous xfServer Key Not Same Errors

On Windows and Unix, we corrected an error in 11.1.1 through 11.1.1c that occurred when using xfServer to access a file on a remote system: in some cases, a READ by numeric key could incorrectly report a “Key not same” error.

New Downloads Site

We have also introduced a new downloads site, which is currently live for all Synergy/DE 11 products. For more information on this please refer to Announcing our New Product Downloads Site.

 

As always, for a complete list of changes, please refer to the release notes, and Synergy/DE documentation for complete information.


Codegen 5.5.5 is Released

By Steve Ives, Posted on June 5, 2020 at 6:07 pm

Steve Ives

We are pleased to announce the release of a new version of CodeGen.

The primary reason for this release is that we realized that the installations for the last several releases were incorrectly signed, resulting in Windows SmartScreen reporting the installation as risky, and doing its level best to discourage you from proceeding.

The affected versions of the installer were versions V5.5.1 to V5.5.4. But apparently people don’t pay too much attention to Windows SmartScreen warnings, because I know there have been lots of CodeGen installations of the affected versions, and not a single person reported the issue! That’s pretty scary, and as software developers, we really should know better! With one exception (Jeff Greene), I don’t know who you are, but YOU know who you are!

The issue turned out to be related to the fact that we have been working from home for the last three months, thanks to COVID-19, and the code-signing process on my home development system was silently selecting the wrong signing certificate! Sorry about that! But rest assured, we restored normality with the 5.5.5 installer, which is, once again, signed with the correct code-signing certificate.

Oh, and if you are looking for new features, we also made all method loop expansion tokens available in parameter loops.

This version of CodeGen is built with Synergy/DE 11.1.1c, needs a minimum of version 10.1.1 to operate, and can be downloaded here.


Changes Are Afoot for OpenVMS Customers

By Steve Ives, Posted on May 29, 2020 at 4:28 pm

Steve Ives

If you are running OpenVMS within your organization, you should be aware that changes are happening at the end of 2020, which may affect your OpenVMS server environments.

The changes are happening at Hewlett Packard Enterprise (HPE).

Standard support for OpenVMS V8.4 ends on December 31, 2020.

If you currently have OpenVMS support from HPE, you need to switch that support to VMS Software, Inc. (or a third-party provider) by the end of the year. If you are running a recent HPE version of OpenVMS, you won’t need to upgrade your operating system to a VSI version of OpenVMS, but if you are running an older HPE version, you may need to do so. I’m not going to get into specifics; there are far too many system types and version combinations. You should contact VSI for more detailed information.

Final orders for Itanium i6 servers must be placed by December 31, 2020.

HPE Itanium i6 servers are the only systems currently supported by OpenVMS that you can purchase new. If you need to replace your hardware with new equipment before VSI releases OpenVMS 9.2 with support for the x86-based platform, you must order those new systems before the end of this year.

Your decision-making process should take into account that Synergex has not yet committed to porting OpenVMS Synergy to the x86 platform. That decision has both technical and commercial aspects. We are currently waiting on VSI to make an Early Adopters Kit and various tools like compilers that we require to build Synergy on OpenVMS available to us for testing. As soon as we have more information about this critical decision, we’ll post it here.

VSI’s current roadmap shows OpenVMS 9.2 being released late in 2021, but as these things are subject to change, there is potential for that date to slip. The x86 port is picking up momentum, for sure, but I would not be surprised if the OpenVMS 9.2 release is delayed.

Of course, another option is to purchase servers on the used market, where there is a significant supply of both Alpha and Integrity-based servers.

If you are running OpenVMS, I encourage you to talk to your Synergex account rep and let them know your plans. And if you are interested in migrating to OpenVMS on the x86 platform, either on physical hardware or in a virtualized environment, I encourage you to contact me directly . The more customers that register an interest, the better the business case for porting to the new platform.


Improved Visual Studio Developer Tools – Available Now!

By Steve Ives, Posted on April 29, 2020 at 5:29 pm

Steve Ives

We are delighted to announce the immediate availability of a new Synergy DBL Integration for Visual Studio Developer Build and to recommend it for use by all Synergy developers. This new release is versioned 11.1.1c-2714, and it can be downloaded from the Synergy Resource Center now.

For the last few development sprints, we decided to focus on addressing quality issues, some reported by customers, and this new release represents the culmination of a lot of hard work on the part of our dedicated developers, testers, and many others.

There are many improvements and enhancements included in this release, but for now, I’ll highlight just two that are of particular importance to customers, and will significantly enhance developer experience and satisfaction overall:

  • We resolved an issue with deep dependency checking that would cause files from built dependencies to not get correctly copied to referencing projects. This mostly impacted .NET.
  • We resolved an issue that was causing debugger “DataTips” for class fields and properties to not show up.

The release includes many more improvements and enhancements, both in the Visual Studio Integration product, as well as both the Traditional Synergy and Synergy .NET compilers that ship with SDI. For complete information I will refer you to the release notes, you will find a link right next to the download link in the resource center.

If you are already using Visual Studio for your Synergy development then upgrade today, and if not, it’s time to give it a try. The developer experience and productivity in the Visual Studio environment really is second-to-none, and remember, you can always use the runtime version targeting features if you need to produce software that will run with older versions of the Synergy runtime on your customer sites.


CodeGen 5.5.2 Released

By Steve Ives, Posted on March 19, 2020 at 12:47 am

Steve Ives

Apologies for being only a few days after the last CodeGen release, but we’ve been hard at work and have added some really cool new features, and we wanted to share them with you as soon as possible. We have added support for complex expressions, which allow you to use AND, OR and NOT within expression tokens, and also allows you to use parentheses to explicitly define precedence. Here are some examples:

<IF expression_1 AND expression_2>
[code]
</IF>

<IF expression_1 OR expression_2>
[code]
</IF>

<IF NOT expression_1>
[code]
</IF>

<IF NOT expression_1 AND expression_2>
[code]
</IF>

<IF expression_1 AND(expression_2 OR expression_3)>
[code]
</IF>

<IF expression_1 OR expression_2>
[code]
<ELSE expression_3 AND expression_4>
[code]
<ELSE>
[code]
</IF>

We hope you’re as excited as we are about these significant new capabilities.


CodeGen 5.5.1 Released

By Steve Ives, Posted on March 16, 2020 at 10:04 pm

Steve Ives

We are pleased to announce a new CodeGen release that includes a significant new feature named Complex ELSE Clauses. We have some big plans to further enhance IF/ELSE expressions, but for now this initial new feature can be used to simplify complex template file expressions. Here are the full release notes for the new version, which can be downloaded from https://github.com/Synergex/CodeGen/releases.

  • We added support for Complex ELSE Clauses within expressions, which allow multiple expressions of the same type to be evaluated within a single template file construct. We have future plans to extend the capabilities of expressions even further, but for now this new capability can be used to simplify template file code.
  • We improved the error checking that occurs when a processing a Harmony Core Customization File.
  • When using the CodeGen API we have added the ability to specify lists of file overrides at the TaskSet level.
  • We corrected an error that was causing the <HARMONYCORE_BRIDGE_PARAMETER_TYPE> custom expansion token to return incorrect values for structure parameters.
  • This version of CodeGen was built with Synergy/DE 11.1.1c and requires a minimum of version 10.1.1 to operate.

Call to Action for Windows UI Toolkit Developers

By Steve Ives, Posted on February 25, 2020 at 5:06 pm

Steve Ives

In recent months several customers have reported significant slow-downs in their Windows UI Toolkit applications when upgrading to Windows 10 or Windows Server 2016. We’ve been researching this issue, and we believe that much of the slow down resulted from alterations that Microsoft made in the operating system to mitigate the Windows Spectre-Meltdown issues.

In an attempt to mitigate these performance changes, and working in conjunction with one customer that had reported the issue to us, we have been working on various performance optimizations in the Synergy runtime related to low-level window creation, and for the Toolkit file-stack routines when using large lists. The new runtime also has UI improvements related to scaling of fonts on high-DPI monitors, most notably when moving a toolkit application between monitors with different DPI settings in Windows 10. This work is now complete, and we believe it has resulted in significant improvements in performance, which we hope will largely restore previous levels of performance.

We have performed as much internal testing as possible, and the customer we have been working with has also reported good results when testing the new runtime. We would like to be able to ship these improvements in the next Synergy release in the May timeframe, but before we can do that, we need to have several other Windows UI Toolkit developers validate that the changes do not cause any other unforeseen issues in their applications.

What we are asking you to do is to install your application onto a Windows 10 or Windows Server 2016 (or higher) that has Synergy 11.1.1c installed, apply a special runtime patch that we will provide, and test your application. There is no need to re-compile your code; just run your application in the patched 11.1.1c environment and look for any UI issues. You would be looking for any visual anomalies in the UI Toolkit user interface, regions not being painted or cleared correctly, etc.

We believe that our recent runtime changes can deliver significant runtime performance improvements for a lot of users, but because of the significant nature of the internal changes, we need help validating those changes in real user scenarios.

Can you help? If so please contact us as soon as possible, either via Developer Support or through your Synergex Account Representative.


SDI Developer Build 2704 Now Available

By Steve Ives, Posted on February 21, 2020 at 2:04 pm

Steve Ives

We are continually working on improvements to our Synergy DBL Integration for Visual Studio (SDI) product, and we are pleased to announce the release of a new developer build #2704, which is available for immediate download.

This release contains some important improvements in the debugging environment, and also contains some enhancements to IntelliSense related to indexed groups and indexer properties. We also made some improvements in the category options in the new project dialog in  Visual Studio 2019.

If you are running an earlier version 11 release of SDI then we recommend you upgrade immediately to take advantage of these improvements, and if not then you should consider doing so, at least for your development tools. Remember that you can use runtime version targeting to produce binary software for older runtime versions if you’re not ready to upgrade your customer or production systems yet.


Don't miss a post!

Enter your email address to subscribe to this blog and receive notifications of new posts by email.

Recent Posts Categories Tag Cloud Archives


Interested in OpenVMS on the x86 Platform?


Complete this brief form and we will contact you soon to discuss your needs.







captcha