800.366.3472 Support

Documentation

Resource Center

Synergex

Synergex Blog

Announcing Synergy/DE 11.1.1e

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

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.

Permalink • Leave a comment (no comments)

Announcing SDI 11.1.1d-2763

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

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.

Permalink • Leave a comment (no comments)

No More SDI “Developer” Builds – Just Releases

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

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.

Permalink • Leave a comment (no comments)

Announcing SDI 11.1.1d-2755

By Steve Ives, Posted on June 24, 2020 at 4:00 pm

I am pleased to announce that a new release of the Synergy DBL Integration for Visual Studio product is available for immediate download from the new Downloads Center. The release includes several quality enhancements and is recommended for everyone using Visual Studio for Synergy development. For additional information please refer to the release notes.

Permalink • Leave a comment (no comments)

xfBBQ: Full-Stack Web Development with Harmony Core

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

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!

Permalink • Leave a comment (no comments)

Unit Testing in Traditional Synergy

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

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:

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:

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.

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.

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:

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:

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:

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:

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:

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:

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:

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.

Permalink • Leave a comment (no comments)
Tags: Visual Studio

Announcing a New Product Downloads Site

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

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.

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.

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:

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.

Permalink • Leave a comment (no comments)

Announcing Synergy/DE 11.1.1d

By Steve Ives, Posted on at 6:49 pm

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.

Permalink • Leave a comment (no comments)

Codegen 5.5.5 is Released

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

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.

Permalink • Leave a comment (no comments)

Changes Are Afoot for OpenVMS Customers

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

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.

Permalink • Leave a comment (no comments)

Improved Visual Studio Developer Tools – Available Now!

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

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.

Permalink • Leave a comment (no comments)
Tags: Visual Studio

7 UI Design Trends to Make Your Software Stand Out

By Kristen Vogler, Posted on April 16, 2020 at 5:48 am

Create a useful, beautiful, and easy-to-use system

What approach did you take when creating your application? Did you focus solely on functionality and figure you’d worry about the user interface and experience later? Did later never come? Because developers often need to develop or add additional functionality to products quickly, the role design plays in the creation of applications is often forgotten. Don’t make the same mistake. The visual appeal of your application is your first opportunity to make a lasting impact on your users. Let’s take a look at some of the user interface design trends that will allow you to make the most of that first impression and stand out from other applications.

1. Microinteractions

While overlooked by many, microinteractions play an essential role in a user’s experience and are the perfect proof that details really do make the design. You’ll notice these interactions in almost every major app and website you visit. Facebook’s “Like” feature is a great example. Hovering over the Like button will display animated versions of the different types of a “like” a user can give. Microinteractions are subtle and you may not notice them, but if they’re removed, you’ll feel like something important is missing.

2. Skeuomorphic Design

Skeuomorphic design refers to the creation of elements in a realistic style. While this type of design was put to rest years ago, the popularity of VR/AR technology is welcoming it back, albeit with a modern twist. When done correctly, the results are absolutely stunning, but you should consider the time, effort, and incredible focus on details needed before diving head first into this trend. The excessive amount of work can make the style not worth it for an application that is constantly changing and evolving.

Skeuomorph investing app dashboard — Jordan Hughes

3. Asymmetrical Layouts

It’s time to release your grip on those perfectly tidy and traditional grid layouts and say hello to overlapping elements. Asymmetrical doesn’t mean random; rather it means you’ve placed your elements in an unusual way that is still aesthetically pleasing. Choose images, text, and other elements that your users will respond to and place them in a way that guides users through your design. You’ll also want to include a generous amount of white space to be successful.

4. Simplicity

Minimalism comes and goes in the design world, but right now it’s in. While not exactly a trend and more of a group of principles to follow, the focus of a simple design is functionality. In this style, you’ll notice bold typography, minimal color palettes, and plenty of white space. Simplicity requires a thoughtful and deliberate approach. Because of the style, there won’t be many, if any, places to hide a design mistake. However, the results are worth it, offering an elegant and high-quality feeling that can be hard to match.

Travel App Home Screen UI Design — Gleb Kuznetsov

5. Responsive Colors

Your branding is important. I’m sure you have a list of fonts, sizes, colors, and ways to handle your logo and other image assets. This isn’t a new trend, but brands are now adopting it more and more. Instead of owning a single color for your brand, allow the color to change in the context of what part of your brand it represents. Try putting together a number of predefined colors that can be assigned to different parts of your environment.

6. Typography

Large text makes a statement. And an interesting change in user interface design is the gradual return of serif fonts. Previously, screen resolution was so low that a font with serifs was considered too difficult to read. With screen resolution improving year after year, that excuse is out the window, opening the door to use thousands of beautiful new typefaces.

Design & Life – Oprah House — Daniel Mcleay

7. Dark Themes

No, not ominous undertones—we’re talking color palette. These themes have been around for years, but when Apple recently added one in their Mojave update, the style took off. The key to designing a successful dark theme? Don’t start with a full black background and white text. Begin with darker grays in the background and lighter grays for text, saving white for something that really needs to pop. A side bonus for this style is that with less bright white to stare at, a dark theme can lessen eye strain for your users.

Sales Manager Dashboard — Fireart Studio

The best UI trends are not only fun to look at, they also improve the overall experience and usefulness of a product. As more and more brands adopt these trends, they shift from being a trend to a design standard. Take a look at your applications today to see which of these trends you can apply—and then take your interfaces to the next level.

If you want to modernize your UI, Synergex has tools and other resources to help you get there. Learn more about our open-source Harmony Core solution, or contact an account executive to find out how our software development consultants with our Professional Services Group can assist you.

Permalink • Leave a comment (no comments)
Tags: ui design

Who Invited the Dog? Tips for Business Meetings While Sheltering in Place

By Jacklin Garcia, Posted on April 7, 2020 at 10:19 am

Many of us now find ourselves unexpectedly working from home. Maybe you’ve always worked remotely, like my spouse who has recently lost 50% of his home office space to me. We’re all living in a state of some uncertainty, with conferences postponed and opportunities to connect fewer and farther between—yet work still needs to get done. Are you, like us, now attending or hosting more video calls and webinars? It’s wonderful that we have the technology to help bridge the distance between ourselves and our coworkers or customers while we are all remote. In fact, we’ve found that our meetings start and end on time more often now that they’re all remote! But this new normal comes with its own set of challenges and different etiquette than face-to-face meetings, so here are a few tips to make you a virtual-meeting pro!

What (equipment)

There are so many different brands of virtual-meeting software. In fact, Synergex uses more than one to meet our needs as a company. Most have generally the same features, but if you aren’t familiar with what your company uses, you should take the application(s) for a test drive. At the very least, learn how to properly adjust your webcam and microphone settings and use the mute and screen share options (more on all these later). Pro tip for working from home: Depending on how your network is set up, you will likely want to use this software outside of your company’s VPN!

If you can, make sure you have a decent camera and microphone. A good headset seems to be the preferred way for many webinar pros to mic up, but a lot of us are just making do with what’s built into our loaner laptops for now, and that’s OK too! Pro tip for working from home: Sometimes using a phone line or the software’s mobile app to dial into the meeting might be a better option for your audio.

Where (setting up the meeting space)

In an office setting, you might have a choice of meeting rooms that are already equipped with the technology you’ll need. At home, you may not have that luxury. Find a space with the fewest distractions for you and in your background. I think we are all getting used to seeing a cat or dog (or even a small toddler in my case) walk by in the background of a meeting by now, but to whatever extent possible, try to minimize this for the duration of your meeting. This may be tough if your workspace is in a common area. Pro tip for working from home: Try setting expectations with your partners, kids, or roommates about when you will be in meetings so they know to make themselves scarce during those times.

How

Share your camera. Communication is more than 50% non-verbal, so being able to see those you are meeting with or enabling them to see you while you’re making a point is hugely important. Try to check out what your camera will pick up before sharing with the audience. You can usually do this through the meeting software itself, but some computers also have a built-in camera app that you can use to do the same. If possible, make sure your camera is at about eye level. Pro tip for working from home: It’s ok if you don’t have a pretty way to raise your laptop to get the camera to eye level. We won’t see the pile of books propping it up. Another working from home pro tip: Network issues seem to come up more at home where we don’t have an IT department to manage them. Go ahead and turn off the cameras if anyone in the meeting is experiencing audio/video delays or choppiness. We’ve found that seems to stop most issues.

Not all of us have ideal backdrops in our makeshift home offices. I know I can’t be the only one with a pile of clean laundry lurking just out of view, but these things can be distracting to our audience. If you can’t physically hide the distractions, try changing the angle of the camera slightly. Pro tip for working from home: It’s totally acceptable to use the blur or background image options to hide distractions digitally.

*If you want to go above and beyond, you can set up a greenscreen like Marty and pretend you are back at the office.*

While meeting from your computer can have its perks, it can also be fraught with distractions. Close any email, chat, or other unnecessary applications that have notifications. Many of these applications have both auditory and visual cues that can be disruptive to the meeting, especially if you’re sharing your screen. Pro tip for working from home: Many of us are using personal computers, so be even more vigilant about tidying your desktop so nothing shows that you may not want to share with others if you need to share your screen.

Use the mute button when appropriate. I was in a meeting a few days ago, and I could clearly hear a lawn mower in the background. Life happens and we can’t control everything around us, but if you have ambient noise and you aren’t currently leading the meeting, it’s OK to use mute until your turn to speak.

Have an agenda. This should be true for all meetings, but it’s especially important for remote ones.

Bonus tips: Remote presentations

If you were planning on making a presentation in person but are now trying to translate it to the digital realm, there are a few things to keep in mind.

You need to engage with your audience in a different way than if you were meeting in person. Experts suggest that you engage the audience every four minutes! That’s at least seven times in a 30-minute presentation. How do you fit all of that in such a short time period? Throw out calls to action for the audience and use whatever tools are available to you, such as polls, hand raising, chat, or a question box.

Use more slides with fewer words than you would for an in-person presentation. The audience can read what is on the screen quickly. They don’t want you to read it to them. If you do, they will likely put your presentation in the background and start to browse email. So, keep the slides light on content and keep them moving to ensure your audience stays attentive.

Staying connected

While many in-person gatherings have been cancelled or postponed for the foreseeable future, Synergex is still here for you! We’re offering several webinars throughout this year on topics ranging from web services to unit testing to debugging. We’ll also continue to host our regular OpenVMS remote customer meetup and our Harmony Core office hours. Keep an eye on your inbox for upcoming invitations.

We invite you to comment on this post to share any additional tips you may have for remote meetings and presentations. You can also join in on the conversation about general working from home tips in Community.

We hope to see many of you in person in Sacramento in May 2021 for the DevPartner conference, but in the meantime stay home and stay healthy!

Permalink • Leave a comment (1 comment)

CodeGen 5.5.2 Released

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

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.

Permalink • Leave a comment (no comments)

CodeGen 5.5.1 Released

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

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.

Permalink • Leave a comment (no comments)

Don't miss a post! Recent Posts

Introduction

Adding Unit Tests to a Solution

Adding Test Classes and Test Methods

Coding Test Methods

The Assert Class

Building Tests

The Test Explorer Window

Debugging Tests and Tested Code

Organizing Tests

Environment Initialization and Cleanup

Summing Up

Highlighted New Features

Other Enhancements

Performance Improvements

Highlighted Quality Improvements

New Downloads Site

1. Microinteractions

2. Skeuomorphic Design

3. Asymmetrical Layouts

4. Simplicity

5. Responsive Colors

6. Typography

7. Dark Themes

Interested in OpenVMS on the x86 Platform?