800.366.3472 Support

Get Support

Documentation

Resource Center

Synergex

Synergex Blog

Big Code

By , Posted on April 13, 2018 at 7:13 am

If you have large (and I mean LARGE) blocks of code in single source files – and by large I mean 20k lines plus – then you may be having compiler issue with “SEGBIG” errors: “Segment too big”. This issue arises because your code segment is just too big for the compiler to handle and is usually the result of many man years of development to a single routine that has just grown over time.

If you encounter SEGBIG issues, as a customer I have recently worked with did, then this quick blog will give you some practical ideas of how to manage the issue and modify the code to allow for future development and expansion, without having to rewrite the world.

First off, it’s not the physical number of lines of code in the source file that’s the issue, it’s the lines of code and data definitions within each routine block: subroutine or function. Developers have encountered the problem for many years and the resolution has previously been to chop out a section of code, make it into a subroutine or function, and somehow pass all the appropriate data to it – usually by large numbers of arguments or common/global data blocks.

The “today” way is not too dissimilar but is a little more refined: turn the code block into a class. The first major advantage is class-based data. This removes the need to create subroutines or functions that accept large numbers of arguments, or to create large common or global data blocks. As an example:

subroutine BigRoutine

endparams

.include ‘AppCommonData.inc’

record localData

localRoutineData ,a10

endrecord

proc

call doSomeLogic

call doOtherLogic

xreturn

doSomeLogic,

return

doOtherLogic,

return

end

Obviously this code will not give us a SEGBIG issue, but its an example of the structure of the code. The routine has a common data include and private data. In the routine body we make multiple local label calls. When there is too much data and too many lines of code added we will encounter a SEGBIG error.

So to address this, in the same source file, we can create a class with class-level data (the routine level data) and methods for the local call labels. So, for example:

namespace CompanyName

public class BigRoutineClass

private record localData

localRoutineData ,a10

endrecord

public method Execute, void

endparams

proc

doSomeLogic()

doOtherLogic()

mreturn

endmethod

method doSomeLogic, void

.include ‘AppCommonData.inc’

proc

mreturn

endmethod

method doOtherLogic, void

.include ‘AppCommonData.inc’

proc

mreturn

endmethod

endclass

endnamespace

In this code, the Execute method becomes the entry point. All the existing code that made the label calls is moved into this routine and the calls changed to method invocations;

doSomeLogic()

doOtherLogic()

Then we can change the existing BigRoutine code;

subroutine BigRoutine

endparams

record

routineInstance ,@CompanyName.BigRoutineClass

endrecord

proc

routineInstance = new BigRoutineClass()

routineInstance.Execute()

xreturn

end

Simple!

Although the code changes I’ve described here sound monumental, if you use Visual Studio to develop your Traditional Synergy code the process is actually quite simple. Once you have created the scaffolding routine and defined the base class with class level data (which really is a case of cutting and pasting the data definition code), there are a few simple regex commands we can use that will basically do the work for us.

To change all the call references to class method invocations you can use:

Find: ([\t ]+)(call )([\w\d]+)

Replace: $1$3()

To change the actual labels into class methods, simply use the following regex:

Find: ^([\t ]+)([a-zA-z0-9_]+)[,]

Replace: $1endmethod\n$1method $2, void\n$1proc

And to change the return statements to method returns, use:

Find: \breturn

Replace: mreturn

These simple steps will allow you to take your large code routines and make manageable classes from them which can be extended as required.

If you have any questions or would like assistance in addressing your SEGBIG issues, please let me know.

Permalink • Leave a comment (2 comments)

“D” is for Developer

By , Posted on September 20, 2017 at 6:55 am

Development of your traditional Synergy code in Microsoft’s Visual Studio was introduced at the DevPartner conference back in 2016. Using an integrated development environment (IDE) like Visual Studio not only promotes better code development practices and team development but shows prospective new hires that your tooling is the latest and greatest.

The next release of Synergy—10.3.3d—includes all the capabilities now required to fully develop and build your traditional Synergy–based applications in Visual Studio. During a recent engagement I worked with a team of developers to migrate their existing Synergy Workbench development to Visual Studio with great results. Although there are a few steps to complete, the results of developing in Visual Studio more than outweigh the effort taken to get there. And if you think developing in Synergy Workbench is great and productive, just wait until you are using Visual Studio—there will be no turning back! Here are the high-level steps you can take to get your traditional Synergy development to Visual Studio.

First place to start is the Synergy Repository. We all have (or should have) one. Synergy now provides a Repository project that will allow you to build your repository files from one or multiple schema files. If you have multiple schema files you can use the new pre-build capability to run your existing command scripts to create the single, ordered schema file or load the repository your way—simple. So why have the Repository project? Because you can load all your individual schema files into it, and if any change, your repository will be rebuilt automatically.

Next create your library projects. These are either executable (recommended) or object libraries. Ensure you reference the Repository project using “Add Reference…”. You no longer define the Repository environment variables “RPSMFIL” and “RPSTFIL”. This step ensures that if your Repository project is rebuilt, any projects referencing it will be as well. Next add the source files for the routines that make up your library, and build. You may have a few build issues to resolve—the 10.3.3d compiler is a little stricter, and unresolved references will need to be resolved. Any environment variables required to build your software should be set in the project common properties page or if they are library specific in the project environment page.

Finally, your main line programs. Create the required project with single or multiple main line programs. The multiple main line project allows you to have all the programs in one place, and you can easily specify the program to run.

Now you can build and run your traditional Synergy code from Visual studio—and even better, you can debug through the code using the powerful Visual Studio debugger.

Using UI Toolkit? Keep a look out for a future blog post showing how to easily incorporate window script file builds into your development process.

Building for UNIX? Not a problem. A future post will show the simple steps to target the UNIX platform from within Visual Studio.

We are here to help! Synergex can help with every aspect of getting your traditional Synergy development environment inside Visual Studio. Just ask your account manager or contact me directly.

Permalink • Leave a comment (no comments)

Wheel, Scroll, Oops.

By , Posted on October 14, 2016 at 6:45 am

If you answer “yes” to the following questions, then please read on: Do you have a Synergy UI Toolkit application? Do you use standard (not ActiveX) list processing with a load method? Do you run your software on Microsoft Windows 10?

Windows 10 offers a new feature that allows you to mouse over a list and use the mouse wheel to scroll the list, without the list actually getting focus. It’s a great feature, but if you have a standard list displayed in your UI Toolkit application which uses a load method – then that mouse-over scroll operation will attempt to “process” the list and cause the list load method to execute. Does not sound too bad – but if you have method data being passed through from the l_select() or l_input() routines then this data will not be passed to your load method, because you are not actually in l_select() or l_input(). Also, because the list has not gained focus you have potentially not been through your “my list is gaining focus so set up the load parameters” logic, which again means when your load method executes it’s in an unknown state.

When your load method executes in this “unknown” state and you try to access method data or your uninitialized load data then a segmentation fault may occur. The user uses the Wheel, the list attempts to Scroll and Oops your application crashes.

Thankfully, the Synergex team have found the issue and resolved it – and the fix will be in the upcoming 10.3.3b patch. If you are experiencing this issue today and need a resolution now, you can contact support who can provide you with a hotfix.

Permalink • Leave a comment (no comments)

DevPartner 2015 – WOW!

By , Posted on May 15, 2015 at 6:37 pm

That was the week that was the DevPartner 2015 conference in Philadelphia. Ok, so I’m biased but I really have to say this was one of the best conference weeks I’ve had the pleasure to be part of for many years. There were some really great sessions: The HBS customer demonstration rocked! They came to a conference a couple of years ago, did a tutorial on xfServerPlus and with this new found knowledge (and some PSG guidance) created a cool web bolt-on to their existing Synergy app.

We saw some fresh new faces from Synergex: Marty blasted through the Workbench and visual Studio development environments we provide and showed some really great tools and techniques. Phil gave us a 101 introduction to many of the “must know” features and capabilities of Synergy SDBMS – and of course was able to address mine and Jeff’s performance issues – you had to be there:). Roger demonstrated his wizardry to enlighten everyone as to the issues you need to consider when transferring your data within local and wide area networks – I was the bad router!

Bill Mooney set the whole tone of the conference with a great opening presentation showing just how committed Synergex are to empowering our customers with the best software development capabilities available.

My first day’s session followed and gave me the opportunity to demonstrate how you actually can bring all our great tools together to create true single-source, cross-platform applications which run on platforms as diverse as OpenVMS, UNIX and Microsoft Windows and onto a Sony watch running Google Wear!

Steve Ives went 3D holographic with videos from his recent trip to the Microsoft Build conference that showed just how amazing the Microsoft platform is becoming – and we aim to continue to be a first class player in that arena.

So many of our products are reaching a level of maturity that blows the competition away. Gary Hoffman from TechAnalysts presented a session showing how to use CodeGen and Symphony in the real world and showed just what you can achieve today in Synergy.

Jeff Greene (Senior .NET engineer @ Synergex) and I presented a rather informal (read written the night before) presentation showing the performance and analysis tools in Visual Studio 2015 that you can use to identify problem area and memory leaks in your application. Within minutes Brad from Automated System forwarded me an email he’d just sent to his team:

“At the Synergex conference just this morning, they just showed fantastic new diagnostics tools in Visual Studio 2015. I just put the Team on the trail of potential memory issues with these new tools in a Virtual PC environment so we don’t alter our current developer stations. This could both reduce the memory footprint and improve performance.” – You can’t beat such instant feedback!

The tutorial time gives attendees the opportunity to play with the latest tools on a pre-configured virtual machine – plug in and code! And we continued the hands-on theme with Friday’s post conference workshop – where we built the DevPartner 2015 App from the ground up!

Thanks to everyone for coming and making the conference such a great success. It’s our 30^th conference next year so keep your eyes and ears open for dates and details – it will be a conference not to miss!

Permalink • Leave a comment (no comments)

Build your own CLR

By , Posted on March 26, 2015 at 1:54 pm

Open source code is all the rage these days, everyone is doing it, even Synergex. For some years now CodeGen and Symphony Framework have been open source. They are both available on www.codeplex.com. What this gives you is the ability to see inside the classes and programs to see, if you are interested, exactly how they are doing what they do. Even Microsoft are joining the open source band wagon – the .NET Framework is open source and the CLR is following! Where PSG lead, others will follow (LOL – I think that means laugh out loud, so my kids tell me).

Does this mean you are going to grab all the code, build your own CLR and tweak it to make the blue windows green? No, not at all. What it does mean is that people can now see what’s happening inside the ocne “black box” and move this code to other platforms. And this obviously helps us Synergy .NET developers. We can already take advantage of other platforms because of the availability of the .NET framework and CLR components on non-windows platforms. It’s how we can deploy your next application to that fancy new Android or iOS phone. It’s how you can take your good received code you wrote 10 years ago, bundle it up into a tablet application with signature capture and have real time “proof of delivery” built into your systems.

Aside from the conference topics there was an interesting question on the Synergy-l list last night. The request was to display multiple coloured boxes on the screen. Sounds simple – and using Synergy.Net inside Visual Studio it was! 20 minute later….

All the UI elements (colour, values, images) come from a data bound repository based structure so you could load the contents directly from your ISAM files. The actual colours and images are selected through switches inside the XAML code based on the values of your synergy data. I don’t think I’ll be demonstrating this simple example at the DevPartner 2015 conference, but there will be lots of great examples to see, and of course tutorials to step you through how it’s done. It’s the last day of DevWeek tomorrow which means I’ll be driving my car around the M25 car park trying to get out of central London for hours. So I’ll make this my last blog from the conference. As always the conference has been enlightening.

Permalink • Leave a comment (no comments)

Colour my World

By , Posted on March 25, 2015 at 3:28 pm

Apparently UI design is more than just picking colours for you controls – who would have guessed it. Now if the Senior Director of Design @ Infragistics is telling you this then I guess it’s time to listen. I’m all for a good UI design – but in our world sometimes it’s just too easy to take the “take what we have and make do” approach. If you have a cell-based or even a UI Toolkit screen cluttered with fields, drop-downs, lists etc. then surely that’s what the users want to see in your shiny new app right? Well maybe, but then you struggle with new prospects because your UI looks, well, wrong. The functionality of the application beats the competition hands-down, but often it’s not good enough to even get your foot in the door. And for all you in-house developers who don’t have a system to “sell” – don’t look away now as your users are just as important to keep happy as the next sales prospect. Imagine if you had to write that cool new app using “notepad” – no intellisence, drag and drop didn’t exist, only one edit buffer available, the list is endless – but in a nutshell you’d leave and go program somewhere where they provided the best tools for you to do your job. And so it is the same for your users – give them the tools to perform at their best.

And then we come back to the age old problem – ten-key. You just can’t beat data entry on a cell based system. While this is generally accepted as true, there are ways to improve the process. Reduce or in many cases eliminate the chrome around the application (I think the cool term today is “flatten”). Does every other field have to be a comb-box – why not let the user enter the “known only to them” code and provide the newbies with a clickable button to “find” the one they want – you’ll soon find them entering the code! Choose a colour scheme that matches the environment. If you application is for office based people then make the screen light and bright – it’s easier on the eyes in a bright open office. Or maybe your application is being used in a dark control room – no windows or natural sunlight, so make the application darker and milder to reflect this. Align your controls, prompts and buttons to a gird like structure. Don’t overdo the font types and sizes. And of course there is the 1.617 rule!

It’s interesting that many of the sessions this year are more about making your apps look right and not actually making you aps.

Permalink • Leave a comment (no comments)

Conference Time

By , Posted on March 23, 2015 at 2:26 pm

Day one and a 9:30 start, which is quite early for a Monday morning – and I have just hustled my way through the London underground commuter traffic! Front row seat for the Xamarin multi-targeting apps workshop, and the presenter is a fellow “Evangelist” so things are looking good.

My goal for today is to squeeze as much knowledge from James, the Developer Evangelist from Xamarin, to ensure everything we are doing at Synergex is going to take us down the multi-targeting utopia highway.

DevWeek in London is an annual conference I try to attend because over the years it’s given me many thought provoking ideas that have made their way into Synergy, Symphony and the applications I write and assist on. I’m especially looking forward to this year because everything is no longer just about C#, it’s now about multi-platform targeted development – you know, just like what we have been doing with Synergy for 30 years!!

Today it’s a pre-conference Xamarin workshop showing how to provide true native applications on android, iOS and Windows without compromising the UI or having to duplicate your application code across multiple development projects. The trick is Portable Class Libraries (PCL’s) – once you have these you can plug them into your chosen UI project (Android, Windows, iOS). Of course Synergy allows for the creation of these PCL’s so out-of-the-box your development team have the tools to “go mobile”.

Many years ago Synergex developed the UI Toolkit – and I know many people reading this will still have applications running using it. It provided a single source for UI design that targeted multiple platforms. You could write your UI pieces into a script file which would be “compiled” on the target platforms and the same Synergy code would run and display according to the host environment – OpenVMS and UNIX was “green screen”, Microsoft Windows was just that, native Microsoft Windows.

Today’s multi-targeting tools come from Xamarin and are built into Microsoft Visual Studio and Utilise the Microsoft .Net Framework – just like Synergy. It provides developers with the ability to write-once-deploy-many across all the latest must-have devices including iOS, Android and Windows Phone and Store. And did I mention Google Wear?

As a Synergy developer you are perfectly placed to take full advantage of these opportunities. As well as being able to build new applications from Synergy templates, built into Visual Studio for Android and iOS, you can also plug in your Synergy Portable Class Libraries directly into Windows Phone and Store applications. You could even be sending push notifications to the latest Google Watch technology on your wrist, if that’s what your application needs.

We will be showing you just how easy it is to create great cross-device apps using Synergy and the latest Xamarin tools at this year’s DevPartner 2015 conference.

And if you want to get right up to speed on all things Synergy don’t forget to sign-up for the pre and post conference workshops. These workshops will take you from zero to hero when it comes to building great Synergy applications using all the latest tools and techniques, and understanding what all the buzz words and jargon mean.

Permalink • Leave a comment (no comments)

Symphony Framework Basics: Control Styling

By , Posted on September 6, 2013 at 5:05 am

In my previous article (Symphony Framework Basics: Data Binding) I demonstrated how to perform simple data binding between your XAML UI controls and your Data Objects. This article demonstrates how to build powerful styles to define and control your user interface and provide automated data binding to your Data Objects.

Before we look at styles, let’s recap how we do data binding. Consider the following simple repository structure;

Record group_record

GROUP_ID ,A20 ; (1,20) group id

DESCRIPTION ,A100 ; (21,120) description

When created as a Data Object this creates two properties;

public property Group_id, a20

public property Description, a100

In the XAML code we can data bind the properties exposed by the Data Object to standard UI controls;

There are a number of issues here, and not all of them are obvious. Although we have performed the data binding, there is no code in the XAML to prevent the user typing more characters than the underlying data allows. The Group_id property for example only allows up to twenty characters, so we need to add code to prevent more being entered. In the repository we’ve defined the field to only contain uppercase characters and again the XAML is not honouring this requirement. When a field is in error, for example a required field that is blank, the underlying Data Object exposes this information, but we are not utilising it here. Also, controlling if the field is read-only, if entry is disabled, etc. All these setting and more can be configured against the field in the Synergy Repository.

Using CodeGen and the correct Symphony templates we can generate styles that define exactly how we require field entry to be controlled.

Generating the style files is very simple. The syntax to execute CodeGen with is;

codegen -s GROUP -t Symphony_Style -n GroupMaint -ut ASSEMBLYNAME=GroupMaint -cw 16

One interesting item on the CodeGen command line is the “-cw 16”. This simply defines the standard width as 16 pixels for each character and is used when defining the size of a control.

The generated style file contains individual styles for each field in the repository structure, as well as a style for the prompt. Here is an example of a prompt style;

<Setter.Value>

<Label

Content=”Group ID”

IsEnabled=”{Binding Path=Group_idIsEnabled}”>

</Label>

</ControlTemplate>

</Setter.Value>

</Setter>

</Style>

And a field style;

<Setter.Value>

<TextBox Name=”ctlGroup_Group_id”

Text=”{Binding Path=Group_id, Converter={StaticResource alphaConverter},

UpdateSourceTrigger=PropertyChanged,

ValidatesOnDataErrors=True}”

Validation.ErrorTemplate=”{StaticResource validationTemplate}”

MaxLength=”20″

Width=”320″

CharacterCasing=”Upper”

IsEnabled=”{Binding Path=Group_idIsEnabled}”

IsReadOnly=”{Binding Path=Group_idIsReadOnly}”

VerticalAlignment=”Center”

HorizontalAlignment=”Left”

ToolTip=”{Binding RelativeSource={RelativeSource Self},Path=(Validation.Errors), Converter={StaticResource errorConveter}}”>

<TextBox.Style>

<Style>

<Style.Triggers>

<Setter Property=”FocusManager.FocusedElement”

Value=”{Binding ElementName=ctlGroup_Group_id}”></Setter>

</DataTrigger>

<Setter.Value>

<LinearGradientBrush.GradientStops>

</LinearGradientBrush.GradientStops>

</LinearGradientBrush>

</Setter.Value>

</Setter>

</DataTrigger>

</Style.Triggers>

</Style>

</TextBox.Style>

</TextBox>

</ControlTemplate>

</Setter.Value>

</Setter>

</Style>

This code may look a little verbose but enables a number of capabilities, including;

Data binds the underlying UI control to the Data Object property
Control features like field length, character casing, read-only, etc.
The Tooltip is used to display any error information if the field is in error.
The control background colour is made red if the field is in error.

Once you have created your styles and added them to your Visual Studio project you can then reference and use them in your UI design. To reference the style;

Each style is based on a control in the Symphony Framework called “FieldControl” which can be found in the Symphony.Conductor.Controls namespace. You must add a reference to this namespace in your XAML code;

xmlns:symphonyControls=”clr-namespace:Symphony.Conductor.Controls;assembly=SymphonyConductor”

Now you can reference the FieldControl and apply the required style to it;

<symphonyControls:FieldControl DataContext=”{Binding Path=MasterData}”

Style=”{StaticResource Group_Group_id_style}”>

</symphonyControls:FieldControl>

And to add the prompt, or label style use;

<Label Style=”{StaticResource Group_Group_id_prompt}”

DataContext=”{Binding Path=MasterData}” />

Because the styles are linked to the same property in the same Data Object when your code disables the input control the prompt will be greyed out as well.

The code snippets here are just part of the overall solution. To see the full details you can watch a short video at http://youtu.be/FqWpMRrSb4w. This article convers styling of the user interface. The next article will demonstrate using all of the difference Synergy fields types and utilizing controls like date pickers, check boxes, etc.

Permalink • Leave a comment (no comments)

Beauty and the Beast

By , Posted on June 22, 2012 at 2:28 am

With every advancing version of Synergy/DE we are better armed to tame the beast! For me one of the biggest beasts in a commercial application is a record lock. This beast will appear without warning, leave no trace of its being, and always instils rage in the innocent users of the system who encounter it.

Although locking records is a fundamental requirement of any application it is always difficult to explain to a user who has been sat there for ten minutes with a “record locked” message flashing on the screen that “the system is functioning correctly”. All they want to do is move forward and finish the task in hand.

So who has that rouge record locked? Which line of code is actually causing the lock? Is the lock valid? How long has the lock been there? If we could answer these questions then life would be so much easier. So how can we tame the record lock beast? With Synergy 9.5.3b of course!

If you attended the DevPartner conference in either Chicago or York then you would have seen my presentation “Hooked Line & Sinker”. During the session I presented the new (and extremely cool) IO Hooks class that allows you to hook methods to the various events that occur around SDBMS data access. For example you can register methods that are executed every time a record is read, stored, updated or deleted. And given this capability I demonstrated the beautiful Synergy DBMS Lock Viewer. By assigning my LockRecorder class to every file opened in update mode (a single line code change to my standard file open routine) I was able to record lock information in a central “lock manager” control file. The Synergy DBMS Lock Viewer program I wrote then reads this file and displays lock information.

And the real beauty was just today. Having modified a customer’s application to utilise the LockRecorder class I was able to run the Lock Viewer:

And immediately identify who was locking which records in which programs and how long the locks had been there. It’s beautiful to just sit and watch the lock information appear and then clear – and when they don’t clear we call the culpritJ. The usual response was “I just nipped out to get a cuppa”. Maybe not the users fault, but now I know where to look in the program to see if I can prevent the lock being required.

If you are interested in the example code you can use the “Knock Knock Who’s Locked” tutorial which steps you through the whole process of creating the LockRecorder class and monitoring the lock manager control file. The tutorial, along with all conference tutorials, can be downloaded from http://tutorials.synergex.com/.

Permalink • Leave a comment (no comments)

DevPartner 2012, Chicago style.

By , Posted on May 28, 2012 at 1:20 am

Having just completed the three day conference in Chicago I felt the urge to write about the event. Fun is most certainly a word I would use! It’s a real blast. That’s not to take away from the information exchange, education and general idea stimulation that occurred not only during the conference times but throughout the informal evening receptions, which always stimulate great debate.

This year’s agenda is a mix of technical presentations and self-paced tutorials – a total of sixteen brand new tutorials to test and tax your brain and to expand your knowledge of just what Synergy can do today! Although all the tutorials use Visual studio or Workbench as the development environment, many of them introduce capabilities which are cross platform, as you would expect with Synergy! And the presentations themselves cover many subjects including the upcoming Windows 8 operating system from Microsoft – will your software be ready?

Tuesday starts the conference with a detailed review of everything Synergy – and I bet there are quite a few enhancements and new features you never knew existed. Then we move into unchartered territory for the Professional Services Group – Open Source. We will show you two great new Open Source projects that we have created, and invite you to join the community and collaborate together to build some great tools and frameworks. So come and join the orchestra and help us all to take full advantage of Synergy and Synergy .NET. And that’s not all, we’ll have you all hooked up by lunch!

Wednesday kicks off with the development team presenting future thoughts and Synergy opportunities. And of course their unique take on the issues that will affect you – even before you’ve thought of them! Watch out for the pesky new disk drives, they will hurt you if you are not ready! And what do you store on a disk drive – data of course. Wednesday is data day so you can be as selective as you like with the information you receive, but be sure to update those brain cells you’ll need to remember it all.

Thursday starts with the Synergy brain strain – pitching your knowledge and skills against my grey matter manipulating questions. We’ll blow away those early morning cobwebs ready for the final day of presentations and tutorials. Hold onto your input windows as we show you how utilize Synergy .NET and tweak your UI toolkit programs. And we’ll get all %NM$N%REFrrF$%£GRT&FSD£$FSD– that’s encrypted so you’ll need to attend the presentation to know what I said. Get ready to jump on the metro and take a tour of the Windows 8 OS – you’ll be amazed, but is it right for your customers?

Throughout the conference the sessions are informative and thought provoking. Being described by one customer as a cross between Monty Python and Austin Powers one wonders how educational the event really was – but I was assured they’d learnt a whole lot of new things about Synergy and our amazing Synergy .NET environment.

And so the DevPartner 2012 conference hits the road and will be rolling up to York, England, on the 12^th June. Do you think you have the knowledge to take on the Thursday morning Synergy brain strain quiz? You’ll only know by signing up and being there. There really is just too much information and opportunity to miss and I hope to see you there!

Permalink • Leave a comment (no comments)

Windows 8 First Impressions.

By , Posted on March 27, 2012 at 1:41 pm

Although I’ve seen the latest offerings from Microsoft in the Windows OS stakes, I must say it’s a real eye opener to see it presented – and by non-Microsoft people! It is conference time again for me, both preparing my sessions for the upcoming DevPartner Conferences in Chicago and York, and attending Dev Week in London. This is my third year at this conference and I use the presentations here to spring board ideas into my conference sessions.

Anyone keeping abreast of the OS news from Microsoft will no doubt know there is a new OS on the block – Windows 8. The new OS has, of course, a new UI. First impressions are that it is a combination Windows Mobile and Xbox! Thankfully there is also a standard desktop environment as well, which for those of us without touch screen enabled laptops (note to boss, need new slate device :)) is good news. Don’t get me wrong, the new interface is great, but as I’m swiping along and hunting for the back button I have a tendency to be up on my feet waving my hands erratically – well that’s what I have to do to get my Kinect to respond, and I did say it’s like the Xbox!

Joking aside (why?) it’s rather important to understand that Windows 8 has a new interface, and not a single application you have running under Windows (7/XP, etc.) will run under this new environment. Now before you all start to panic, I did say there is a Windows desktop environment, and it’s under this that all your Synergy based applications will run. Panic over then. All you need to do is install and go – click the start button and you are away. So where has the program “start” button gone? Disappeared, it is no longer, vanished! All your programs will start from the new Windows 8 swishing tile start page. If you have a lot of programs hanging off start button sub-menus then these will all appear as individual tiles on your new start page, which may be an installation consideration. The desktop appears to work just nicely, and it’s where all of the traditional style applications are executed within, complete with all their associated Chrome (the windows, ribbon menus, buttons, etc.) There are, of course, new or updated programs that utilise the new design architecture, Metro. Metro is a new style of program UX (user experience). Metro takes a while to get used to, but if you’ve been swishing through Xbox programs like LoveFilm, or the new BBC iPlayer app, you’ll be well versed in the navigation techniques of Metro styled programs.

It’s interesting that even the Microsoft people at his conference have no idea (or are not able to say) when Windows 8 will be officially released, but it’s most likely no time soon.

One great bit of news is that Metro is built on XAML – just like the WPF desktop developments I’ve been promoting for some years now. Also, for those utilising my single page Visual State Managed design then this is the same approach used by Metro – well done MicrosoftJ

Now, I wonder if there will be any fancy data driven, Metro styled, slate device based, live & interactive demos at this year’s DevPartner conference – see “note to boss” above. Check out the conference agenda (http://conference.synergex.com/) and make sure you have your seat booked to find out!

Permalink • Leave a comment (no comments)

All Hooked Up. (Circa 1957, Elvis Presley)

By , Posted on July 19, 2011 at 9:25 am

Back in the day, Elvis Presley shook up a bit of a stir when his gyrating hips and dulcet tones came over the airways onto our little black and white TVs (so I was told, I’m not old enough!). Today, Synergex is defining a development that will shake the Synergy world when it’s released with an upcoming version! And it’s a development that we’ll all be hooked on.

In the specification phase at the moment is the ability to “hook” user definable logic against operations within the SDBMS file IO system. This proposal offers the ability to perform logic when any operations on any SDMBS file (index or relative) are executed.

For example, you can hook up a Synergy method that will be called “before” a record is read from a file, or before a record is stored into a file. A method can be hooked up and executed when a record lock is encountered, records deleted or updated.

The possibilities are truly endless. You could use this capability to debug your applications. For example, you may have a system that occasionally encounters corrupt data – and you have no idea when the data got corrupted. By implementing pre-store and pre-write event hooks you could validate the data and log to a file if it’s not valid. Because it’s a Synergy method, in the calling stack, you can use routines like MODNAME to record the full stack trace and pinpoint the problem.

Implementing hooks for the pre-store and pre-update events can allow you to ensure that default data is correctly set.

Hooking up post-events could allow you to record modifications to your SDBMS data that you wish to replicate somewhere – in a third party relational database for example. Or you could actually record the data being sent to a file for transaction/logging purposes.

All hooks will be on a per-channel basis, so if you currently have a generic file open routine you’ll be well placed to begin to implement this new exciting capability. If you don’t, now’s the time to start thinking of adding one!

One thing to remember, performance! Once you have bound a hook to an event then every operation of that type will cause your logic to be executed, so keep the code concise, specific and efficient!!

This development, for me, is on a par with the .NET API – it’ll open up a whole new world of possibilities. I can’t wait to get hold of the alpha release so I can blog about it, and watch out for the early videos showing you the full power of this great new development. And the best bit is that it’ll be supported on ALL platforms, so you won’t have to be a .NET guru to take full advantage! I can already feel an SPC session in the making.

I’m hooked, line a sinker!

Permalink • Leave a comment (2 comments)
Tags: IO Hooks, Synergy 9.5

The Final Chapter

By , Posted on December 17, 2010 at 6:00 am

Using Synergy in all aspects of a new WPF based development is really quite exciting. But when you start to bring in code that was written many years ago you really begin to see the power of a truly cross platform capable development environment.

The task I started while working with White Knight was to create a simple application that managed the communications with their customer base – basically a very simple CRM system. The brief was to have a great looking windows desktop application and write it in Synergy – oh, and use all their existing library routines, data layout include files and database files.

And the solution, if you’ve followed my earlier blogs, was to utilise the new 9.5 release of Synergy. With Synergy 9.5 we have the Visual Studio Integration which, in a nut shell, is Synergy language inside the powerful Visual Studio development environment. Using this environment we can craft our user interface utilising WPF controls and Synergy language to bind to our data classes. So, that’s the UI sorted.

Using the Synergy .NET API I can continue to use my existing Synergy language routines to load my new WPF UI Library, and manage the data communication between my program and the UI controls using WPF’s powerful data binding techniques. So that’s the existing program logic and data access sorted.

And the results:

A fully functional UI, all written in Synergy and XAML (the WPF portion of the UI) managing our SDBMS data and Synergy business and validation logic.

So what about your application? If it’s in need of a bit of a user interface upgrade, download the latest 9.5 release of Synergy and let your imagination run wild. You’ll be surprised just how much you can do in a short space of time.

As we head towards the end of 2010 we’ve already started our plans for SPC2011 – watch this space for details! I’m really excited about the prospect of presenting these great new capabilities that Synergy offers. I can’t believe how quickly this year has gone by. I hope you all have a great holiday season and here’s to a bright WPF New Year!

Permalink • Leave a comment (no comments)
Tags: .NET, SPC, Synergy 9.5, WPF

The .NET Rollercoaster

By , Posted on November 24, 2010 at 1:28 pm

Sometimes my job feels like I’m on a rollercoaster with some great highs and some scary lows, and the adrenaline rushes between the two. Version 9.5, complete with the Visual Studio integration with Synergy, was officially released yesterday. I’m sure I was not the first one, but I was straight to the resource centre at www.synergex.com to download and install 9.5. The installation went without issue and we were ready to begin to build our CRM application.

The first task was to rebuild our existing Synergy routines using the Synergy 9.5 DBL compiler. This new version has tightened things up even more and the compiler found another subscripting error which was duly fixed! Things were looking great – the rollercoaster car was slowly making its assent.

The next step was to build our Visual Studio projects and run the new CRM application. The builds completed and the car was teetering on the brink. But what goes up must come down. With that stomach in the mouth feeling the car came spiralling down from the dizzy heights. Our CRM didn’t run quite as we’d hoped. Now don’t get me wrong. I’m extremely impressed with the release of 9.5 and the integration with Visual Studio. Just the ability to build code written when Bill Gates was a lad in this environment is testimony to the strength of Synergy. But this is a brand new release and I’m pushing it to the limit. This is no “Hello World” development!

Now the customer wants a new CRM, and I’m determined to complete the job using Synergy. And so a new plan was hatched. Why can’t we use Synergy/DE and Workbench to build the program to host our new UI? We can use the .NET API to achieve this, and we know all the existing routines work because they have been executing the code for years. So straight away we have half of the application in Synergy, written and working. Given that the problems we were having with the Visual Studio side of 9.5 centred on arrayed fields, changes that have been made to the way error trapping works, and the debugger, why not build our WPF UI using Synergy. And this side of the Visual Studio integration worked for us all day without issue. Building simple class files to expose our Synergy data as .NET types was a breeze with the code snippets available. Some of this code could, I guess, be code generated, but to be honest generating code can strangle the flair of the developer. Plus we only wanted to expose selected fields and manipulate the format of the data to suit our needs.

We soon had our data classes built and the application was returning data ready to expose to our new WPF UI. And this is our task for tomorrow. The car is well and truly back on track and heading for the exciting twisty section of the ride. And I’m still only programming in Synergy. There is not a single line of C# or VB.NET!

So, should you wait before you try 9.5? Certainly not! Download it, install it, and start to build not only your code but your dreams of that new slick looking application – and all in Synergy. I’ll post the results of all our hard work at the end of the week. Please keep all hands and feet within the car and hold on tight to the hand rail. You’re going to love the ride!

Permalink • Leave a comment (2 comments)
Tags: Synergy 9.5, Synergy.NET

.NET is a blast

By , Posted on November 23, 2010 at 3:19 pm

One great aspect about my job is not only helping people utilise Synergy to the full, but to see the results of their hard work. And there is no better place to do this than “at the coal face”. Today’s coal face is, of course, on the shop floor at White Knight laundry. I was given a guided tour after lunch to see just how the Synergy system tracks items through the process.

The washing machines are huge, several feet taller than me. I shudder to think just how many pairs of socks you can wash within one of them, and they have several, all lined up together. It’s no wonder they have to tag every single item. Once items are cleaned they are dried in large driers and then the cool automation happens. Sheets are taken out of the dryers and each is laid out in turn at one end of a machine. If you are quick enough and sprint around to the other side of these large machines out pop a beautifully pressed and folded sheet. The shirt press is a blast, literally. It’s a two stage operation. Firstly the collar and cuffs are placed onto a machine and pressed. Then the shirt is placed over a frame, then it’s whisked off and steam blasted through it, and out comes a perfectly pressed shirt fit for a king.

And so to our CRM development. Our first task was to build the White Knight core routines into a native .NET assembly, which is the equivalent of an executable library. This task was achieved within a couple of hours. After all, it’s the same Synergy Language just a new compiler. The current system runs under Synergy version 8.3 and this code, I would say, hasn’t changed much since version 5.9 days. It’s testament to the power of Synergy to be able to take this code and build it under a brand spanking new development environment called Visual Studio 2010! To successfully build the new assembly required a few code changes. The compiler caught parameter mismatch declarations and some over subscripting. All the modifications we made improved the stability of the code.

We are now ready to begin to integrate our tried and tested logic with our new WPF UI. But there is a little more work to do first. Our data is a little shy and we need to gently coax it from the dark depths of our SDBMS files. Remember, some of this data was written away to the file a long time ago and those little single alpha character chaps that store our Y or N values work just fine in Synergy land, but for WPF we need to coerce these values to native types. So we are writing some very simple classes that take our Synergy records and expose only the fields our UI will be interested in as native .NET types.

Now we are building the WPF interface and binding to our new Synergy classes, exposing our existing Synergy data…

Permalink • Leave a comment (no comments)
Tags: .NET, OO Programming