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

Synergex Blog


CodeGen 5.7.3 Released

By Steve Ives, Posted on July 9, 2021 at 6:47 pm

Steve Ives

There’s a new version of CodeGen out there, so if you’re using it, here’s what’s changed in this version:

  • We added a new special structure expression token <STRUCTURE_HAS_FIELD_name> that allows you to detect the presence or absence of a named field within the structure.
  • We improved the logic used when processing unique key loops and unique alternate key loops and made a slight change to the way that the unique alternate key loops operate. Previously the loop would not compare alternate key segments with the primary key, but now it does. So the loop now processes any alternate keys that do not have identical key segments to the primary key or any previous alternate keys.
  • We fixed a problem with the implementation of the -pa command line option that would cause CodeGen to fail when used with an input file containing multiple structures.
  • We fixed a problem with the implementation of the -tweaks option which could result in a null reference exception in some rare circumstances.
  • We reviewed and updated all sample templates that ship with CodeGen to ensure they use the latest capabilities such as taking advantage of complex expressions to simplify template complexity resulting from nested expressions.
  • This version of CodeGen was built with Synergy/DE 11.1.1g and requires a minimum of version 10.1.1 to operate.

As always, this new release is backward compatible with earlier releases, so we recommend that everyone download the new version as soon as possible.


Another RESTful web service story

By Cindy Limburg, Posted on May 27, 2021 at 12:26 pm

Cindy Limburg

I hope you had a chance to attend some of the recent Synergy DevPartner Conference virtual sessions. There were many opportunities to learn about the latest Synergex technologies and how customers are taking advantage of them. One of the conference themes was the importance of creating RESTful web services with your legacy applications, and the sessions included some examples of customers doing this with our Harmony Core open-source product. We also just published a new customer success story, which describes how our customer RCC used Harmony Core to create a RESTful web service and provide its customer Legacy Vacation Resorts (LVR) with a new web portal.

Used by vacation property owners, the RCC Resort Management Solution offers features such as a central reservations system, contract management, and sales analysis. LVR offers travel experiences across Florida, Colorado, New Jersey, and Nevada. When COVID hit, LVR wanted to make their resorts safer and more comfortable for their guests. They decided to move their check-in process to the web so guests could minimize the time required to interact with LVR’s front desk agents.

RCC and LVR already had a web access solution, but it used Synergex’s proprietary xfServerPlus product, and they both wanted a more standards-based solution. This was a great opportunity for RCC to modernize their solution and provide a foundation for meeting future demands for access.

RCC started with the data/logic access routines they already had for xfServerPlus, expanded them to meet the needs of the new web service and web UI, and then added new OData controllers and a Harmony Core feature called “adapters” to expose the data and logic as OData resources. Code for the adapters and controllers was generated using Synergex’s CodeGen tool and RCC’s Synergy repository.

RCC and LVR were able to meet the project goals, and both are excited to move forward with their new web services solution. See the full success story for details (and some beautiful resort photos).

Mike Amundsen, the Synergy DevPartner Conference’s keynote speaker, said that when you’re getting started with web services and trying to figure out scope and boundaries, you should look for the smallest problem you have, fix that and learn from it, and then move on to the next smallest problem. In the “Leveraging Web Services for UI” conference session, customer Forward Computers had a similar message: start with a well-defined function. (They also advised making sure it’s not too simple, as you’ll want to evaluate performance.) The new customer success story describes how RCC and LVR got started with LVR’s self-check-in function. What function will you start with?

To learn more about web services and Harmony Core, refer to our web services training videos and our documentation.


Updated Visual Studio Development Tools Update

By Steve Ives, Posted on March 29, 2021 at 10:44 am

Steve Ives

Synergex is pleased to announce the immediate availability of a new release of the Synergy DBL Integration for Visual Studio, Version 11.1.1g-3045.

As always, this latest release contains improvements across the board, but in particular, the focus was placed on these specific areas:

  • Improving the development experience in both the editing and debugging of .NET Core code.
  • Improvements in working with Repository projects in various scenarios.

Some of the improvements in this release were actually in the Synergy .NET Compiler, so in addition to updating the SDI installation, developers working on .NET Core projects (including any Harmony Core projects) should upgrade the version of the Synergex.SynergyDE.Build NuGet package used in the projects to version 11.1.1070.3045 also.

We encourage everyone undertaking any type of Synergy development in Visual Studio to upgrade to this new release as soon as possible. And remember, if you are not ready to upgrade the runtime versions on your production systems yet, you can use runtime version targeting to give you access to the latest-and-greatest development tools while continuing to support older runtime installations.

Head on over to the Resource Center Downloads page to download the new release now.


9 Windows Tips and Tricks You Should Know

By Jerry Fawcett, Posted on February 23, 2021 at 1:45 pm

Avatar

Over many years of being immersed in Microsoft Windows, I’ve come across a few tidbits I think are worthy of sharing. Some of these you may know about, but I hope you find something new here.

1. Opening a command prompt in File Explorer

So, you’re in File Explorer and you want to open a command prompt in the current location. The easiest way is to simply type “cmd” (without the quotes) in the address bar, and there you go: a command window opens to that location. You can also run other commands the same way. Go ahead: type “notepad” into the address bar of File Explorer for yourself. Conversely, you can use a command prompt to open File Explorer in the current location. To do so, issue either of the following commands in the command prompt: “start.” or “explorer .”.

2. Auto inserting the date and time in Notepad

I use Notepad all the time for taking quick notes. Try pressing F5 when you’re in Notepad. This will enter the time and date, which is useful for marking when an entry was made.

3. Changing configuration settings with MSConfig

Many already know about this utility, but it’s worth mentioning for those who don’t. MSConfig.exe is a built-in Windows tool for controlling such things as the manner the next startup boot will occur (normal, diagnostic, or selective), which services will run, and a list of other built-in tools. It’s very powerful, so use it with care. You can find more information here.

4. Understanding system errors

A quick way (yes, quicker than Googling) to look up a Windows system error is to use the command “net helpmsg errornumber”. For example, if you want to know what system error 5 means, enter this at a command prompt:

     C:\>net helpmsg 5

     Access is denied.

5. Activating speech recognition

Tired of typing? No problem: Windows has a built-in solution that allows you to talk to your computer and give your hands a break. To enable this tool, start by pressing the Windows key +H.  This will prompt you with a link to Settings to enable speech recognition. Toggle it on, and the next time a text field is in focus, you can turn listening mode on with Windows key + H. When you start talking, your computer will start typing for you. You’ll find handy documentation on how to use this feature at Windows Speech Recognition commands.

6. Organizing windows

Say you want to re-arrange the windows on your screen. Pressing the Windows key and the right or left arrow will snap a window to either the right or left side of the screen. But what if you have four windows and you want one in each corner of the screen? Well, that’s easy: just grab a window, drag it to the corner of the screen until you see the outline of the window, and then release it. Repeat this for each corner.

7. Accessing control settings with Windows Master Control Panel

There is something called Windows Master Control Panel, aka the God Mode folder. (Don’t blame me; I didn’t name it.) It’s a folder with shortcuts to many different Windows administrative/management settings and Control Panel tools in a single location. To create it, one must be logged in as Administrator (of course), and then simply create a new folder and give it the name 

     SomeName.{ED7BA470-8E54-465E-825C-99712043E01C}

For example,

     GodMode.{ED7BA470-8E54-465E-825C-99712043E01C}

8. Deleting files

It is well known that when a file is deleted it is not truly deleted, but the space the file consumed is now marked as available. However, if you want to make sure a deleted file is actually deleted and not recoverable (by freely available tools), then the space the file consumed needs to be overwritten. There are plenty of third-party tools that will do this, but why bother getting one when Windows has a built-in tool? To overwrite free space in a particular directory or even a drive so the deleted files are not recoverable, use the cipher command. For example, to overwrite free space in the folder C:\Temp, issue the command

     cipher /w:c:\Temp

To overwrite all the free space on the D: drive, issue the command

     cipher /w:d

And of course, a tool named “cipher” can also encrypt files or directories.

9. Checking battery status

Want to know the state of your laptop’s battery? No problem. Use the powercfg command to learn everything about your battery’s current state. Note: Powercfg must be run in an Administrator command window. While powercfg has many options, the two I find most informative are /batteryreport and /energy. When powercfg is run with /batteryreport, it will create an HTML file named battery-report.html with pretty much all there is to know about your battery’s usage and history statistics.  When run with /energy, powercfg will create an HTML file named energy-report.html with a “Power Efficiency Diagnostics Report” that contains all kinds of information on the battery’s current status. For more information about powercfg, visit Powercfg command-line options.

This is only a drop in the (bit) bucket of Windows tips and tricks, so please share the ones you’ve discovered.


10 Tips for Faster Synergy Development in Visual Studio

By Phil Bratt, Posted on January 21, 2021 at 2:12 pm

Avatar

Visual Studio is consistently one of the highest trending IDEs on the market. It has powerful features to increase code productivity. Because of this, Synergex brought traditional Synergy coding into Visual Studio. But how do you use it? I would like to focus on some of the hotkeys and organizational features available inside Visual Studio that will help developers navigate their code.

Editing Code

  1. Easy commenting: While testing code, there are times when you want to disable large sections of code so that you can run alternative code to see the differences. In Visual Studio, you can highlight the code you want to comment out and press CTRL K + C to comment out the lines. You can press this key combination multiple times to add a ‘;’ to the front of each line or CTRL K + U to remove a comment character from each line. The toolbar also contains buttons to comment and uncomment lines:
  2. Multiple line edits: One of my favorite features in Visual Studio that I’m surprised hasn’t made its way into other Microsoft products is the ability to edit multiple lines at once. If you press ALT + SHIFT and (while still holding them) push the UP or DOWN arrow keys, you can expand the cursor to multiple lines. This means that when you press a key, it will edit all of those lines with that key stroke. For example, let’s say you have multiple WRITES statements in your code:
    writes(chnout, rec_1)     
    writes(chnout, " ")
    writes(chnout, rec_2)
  3. Now you want to add an error list to handle record locking on each line. Well, you can use ALT + SHIFT to add the identical error list to each line, which beats copying and pasting to each line.

    writes(chnout, rec_1)       [$ERR_LOCKED=errloc]     
    writes(chnout, " ")         [$ERR_LOCKED=errloc]
    writes(chnout, rec_2)       [$ERR_LOCKED=errloc]
  1. Simple duplication: Speaking of copy and paste, how annoying is it to click, then hold SHIFT, then END, then CRTL C, then click, and then CTRL V? That’s tedious. It was tedious to write it out. If you want to copy the line you are on, you can duplicate the line of code with CTRL D.

Collapsing and expanding code

You may have noticed that when you create a main routine, subroutine, or function, a “-“ appears to the left of the editor. This allows you to collapse that code section to make it easier to edit large pieces of code.

  1. Collapsible labels: You will also notice that internal subroutines/labels are not naturally collapsible. But what if you wanted to make a label collapsible because you have so many of them? You would surround the code with .REGION/.ENDREGION along with a title for the region. (I usually stick with the name of the label.) For example:
    .region "erroloc"
    errloc,
    repeat
    begin
    ...
    .endregion

With .REGION/.ENDREGION in place, you will now get the “-“ around that section that you can collapse.

  1. Hotkeys: A number of hotkeys can be used to collapse and expand these sections:

Toggle outlining expansion – CTRL M + M
Toggle all outlining – CRTL M + L
Stop outlining – CRTL M + P
Stop hiding current – CRTL M + U
Collapse to definitions – CTRL M + O

Navigating code

There are also a few features that can be used to navigate your code that I find extremely helpful:

  1. If you are on a BEGIN or END in code and want to go to the matching END or BEGIN, while the cursor is on the BEGIN or END, press CRTL ] to move the cursor to its pairing statement.
  2. If you are on a variable or subroutine and want to jump to where it is defined in the code, you can either press F12 or right-click and select “Go to definition.”
  3. With this jumping around, you can also push CTRL – to go back to where you were or CTRL + to go forward.

Debugging code

To round off this list, there are a number of function keys that are useful during a debugging session in Visual Studio:

  1. To step into the line of code you are on, so you can see the code run through a subroutine, class, etc., use F11. To step over and go to the next line of the currently executing source code, press F10.
  2. While coding or debugging, pressing F9 will toggle adding or removing a breakpoint on the current line.

Those are my 10 tips for navigating through Visual Studio and making use of its code editing and hotkey features. You can also find our video about Visual Studio hotkeys here. Keep in mind that most of these keys can be changed or customized inside Visual Studio by selecting Options from the Tools drop-down menu. Hope you found some of these helpful.

If you haven’t moved your Synergy development environment to Visual Studio yet, what are you waiting for? Check out our solution for modernizing your development environment and accessing a superior debugging and build experience. You can also reach out to your account executive to discuss how we can help you move to Visual Studio or train your developers to get the most out of their new environment.


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.



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.


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.


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.



Synergy/DE 11.1.1c Released

By Steve Ives, Posted on January 29, 2020 at 6:23 pm

Steve Ives

Important quality improvements for REV11 licensing

A new patch release for Windows and Unix is now available to download on the Synergex website. All customers are encouraged to update to 11.1.1c for important quality improvements.

This update includes new versions of the following products:

  • Synergy/DE (32- and 64-bit)
  • REV11 licensing upgrade package (32- and 64-bit, delivered in one installer on Windows)
  • Synergy DBL Integration for Visual Studio
11.1.1c includes quality improvements for the following issues:
  • IMPORTANT: Previously, in REV11 licensing environments, an expired license error could occur if a license allocated by a program expired while the program was running. Even if new keys had been delivered and installed, if the license server had not been restarted since the new keys were installed, the error could occur.

    It is important that all customers using subscription licensing in a REV11 environment install the 11.1.1c patch (for version 11 systems) or apply the 11.1.1c version of the licensing upgrade package (for version 9 or 10 systems).

    If for any reason you are not able to do so, you should ensure that your license server is restarted as soon as possible after your new subscription keys are delivered. Long-running processes are resilient to a license server restart.

  • In versions 11.1.1a and 11.1.1b, if an attempt to rename a remote file (via xfServer) resulted in an error being generated, in some cases xfServer could fail with a segmentation fault.
  • In versions 11.1.1 through 11.1.1b, using the isutl utility to re-index a large multi-key ISAM file with an index exceeding 4,294,967,295 bytes caused a corrupted index to be created.
  • In versions 11.1.1 through 11.1.1b, when running xfServer in Secure or Trusted mode, a client using the RUSER mechanism to provide login credentials to the server experienced a “Bad username, login rejected” error.
  • In versions 11.1.1 through 11.1.1b, in some circumstances when opening a remote file via xfServer when that server did not already have other files open, the xfServer process could fail.
The patch also includes the following enhancements to Synergy DBL Integration for Visual Studio:
  • We significantly enhanced the Visual Studio build system for Synergy .NET projects by improving the dependency-checking algorithms. Previously, any change in the code of, for example, a class library caused all projects that reference that library to be rebuilt. With these changes in place, dependent projects will only be rebuilt if changes in the dependency library result in the signatures of externally visible items being added, changed, or removed. This will result in a significant reduction in elapsed build times in many cases.

  • We improved the hover-over information (QuickInfo) displayed for type declarations for variables, fields, properties, etc. We added simple colorization and documentation comments (when available), and in some cases, type names are now fully qualified.

See the release notes for a complete list of 11.1.1c changes. See the Synergy/DE 11 page for information about the latest Synergy/DE features.

Visual Studio Adaptive Formatting

By Steve Ives, Posted on January 24, 2020 at 4:32 pm

Steve Ives

In Microsoft Visual Studio version 16.4 a new feature was, I was going to say introduced, but snuck in might be more appropriate way of describing things. There was no mention of the new feature in any release notes that we can find, and an internet search for the name of the new feature currently returns no useful matches!

The feature is called Adaptive Formatting and apparently what it does is allows code editor windows to “heuristically determine if the current file should use tabs or spaces for indentation”. Previously this behavior was determined by a language specific setting, and those settings are still present, but if Adaptive Formatting is enabled (which it is by default by the way), then it wins!

So if your code is indented with tabs, and suddenly Visual Studio decides to start using spaces instead (or vice-versa) then it’s probably Adaptive Formatting getting it wrong! Thankfully this new feature can be disabled by going into Tools > Options > Text Editor > Advanced and un-checking the Use adaptive formatting option.

Happy coding everyone!


SQL Replication – Significant New Features

By Steve Ives, Posted on January 16, 2020 at 8:10 pm

Steve Ives

In recent weeks we have been working on making improvements to our SQL Replication environment, which demonstrates how to easily replicate your Synergy data to a SQL Server database. Some of these changes were undertaken in collaboration with a customer that uses the environment extensively, and we thank them for their input and support. Other changes have been on our road-map for some time and we think you’ll be excited about what has been achieved. Here’s a summary of the changes:

  • Synergy 11 introduced a new SQL Connection API capability which calls the ODBC API function SQLDescribeParam behind the scenes to improve performance and avoid excessive cache memory thrashing for SQL statements that have I/O parameters when accessing SQL Server (VTX12_SQLNATIVE). Synergex recommend setting SSQL_PERFORMANCE_SQL to yes (or setting the SQLPERFORMANCESQL environment variable. We have updated the environment to do this, which should result in improved performance when running in Synergy 11 or higher environments.
  • We have added the ability to run multiple instances of the replicator process side-by-side, within a single data set, and to divide up the replication of different files between these multiple replicator instances. Each instance is assigned a unique instance name and has its own associated instruction queue file, the name of which includes the instance name, as does the log file produced by each instance. In a multi-instance environment developers can chose on a file-by-file bases which data files are replicated via which queue file, and therefor via which replicator instance. It is important to understand that in this scenario there is no synchronization of the sequence in which changes are applied to the underlying SQL database between the multiple instances of the replicator.
  • We have added the ability to exclude certain fields in a record from being appearing in and being replicated to the associated SQL Server database table. It is important that fields associated with keys not be excluded, unless those keys are also excluded (see the next item). Generally the fewer fields/columns that are replicated the faster the replication will be.
  • We have added the ability to exclude certain keys from processing, so that matching database indexes will not be created in the associated database tables. Generally the fewer indexes that exist on a table the faster the replication will be.
  • We have added the ability for the replicator to detect some kinds of database failure, caused by network errors, or the database being shut down or otherwise unavailable, and allow it to gracefully disconnect, and then attempt to reconnect, with a configurable number of retries and retry interval. This should make the replicator processes more robust.
  • We have added the ability to change the database datatypes of fields. The main use case envisaged is transforming decimal fields into implied decimal fields (adding decimal places in the database data), but there may be other use cases, such as transforming Y/N fields into Boolean true/false fields, etc.
  • We have also corrected an issue that could occur if replicator encountered an unexpected error and was configured to use BATCH COMMIT mode. Is some circumstances, if there were uncommitted changes at the time on an error any uncommitted changes could be lost because the change records were deleted from the instruction queue one by one before the batch was committed. Now any instructions related to uncommitted changes remain in the queue file until the batch is committed, and are then all deleted. When the replicator is restarted it will then attempt to reply the changes to the database again. This should help prevent the database getting out of sync if there is a replicator failure.

We’re excited about these new features in our SQL Replication offering and looking forward to hearing your feedback. By the way, many of these new features rely on using the latest and greatest version of CodeGen (5.4.8) which was also released today. If you’re already using an earlier version of the SQL Replication environment, or if you are interested in getting started and would like some assistance, don’t hesitate to contact us through your Synergex Account Representative.


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