For a recent project I’ve worked with a customer who wished to provide their users with an engaging desktop application that would allow management of product formulations. They had a Synergy UI Toolkit version and also elements of the required application in a third-party system. However, neither met the needs of the users. After a review and discussions about their requirements we agreed on a Synergy .NET Windows Presentation Foundation based application using Infragistics tooling for the User Experience.
The basic requirements of the application where to allow the creation and maintenance of formulations. A formulation contains the components required to make a finished product. For this customer the final product is an aerosol.
Let’s take a look
The basic interface is built using the Infragistics control to handle navigation (Ribbon menu control), listing and selection of data (powerful DataGrid), hierarchical representation of the formulation components (TreeView) and management of finished product details (Property Grid);
Of course, using the Infragistics DockManager allows the user to drag and reposition all the available windows to their liking.
There are powerful searching facilities, or QBE (Query By Example) controls. These allow the user to provide snippets of information and the application will query the Synergy DBMS database using Symphony Harmony and the Synergex.SynergyDE.Select class;
The top line of the QBE controls allow the user to enter the data in the columns they wish to search for and so only select the data they require and not have to filter through a list of thousands of formulations.
Because the application is written in Synergy, the existing printing capabilities from the original UI Toolkit application have been retained without change;
The whole application is written in Synergy .NET and utilises the Symphony Framework for controlling the data access and presentation. If you would like more details, or would like to know how you can build modern applications with Synergy .NET please drop me an email.
The Synergex Resource Center Community site has a number of great features including the Answers and Ideas portals. Ideas is the place to post your ideas for improving Synergy and related products. You can vote for ideas and provide comment and feedback to help the whole community be more successful. The Synergex community site had an idea posted recently:
The Synergy DBMS Manager allows you to query and manage data in your Synergy data files using Symphony Data Objects.
Code generating Symphony Data Objects for your files is a simple process. Ensure you have your Synergy Repository configured. You need to define the structure and associated file definition for each file you wish to be able to manage using the utility. There are full instructions at the Symphony Framework page which walk you through the few simple steps to building your data object assembly in Synergy .Net. Not sure how to build Synergy .NET assemblies – then send me your repository and I’ll do it for you!
To query data you simply issue the required select command and define the response data object;
Simple, and you can scroll through the results. The idea posted was to be able to then export the selected data to Microsoft Excel so that further review and analysis can be performed.
A new toolbar button has been added and the GemBox Spread assembly used to easily create the Excel document. Now you can export all the selected rows to an Excel document:
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.
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 30th conference next year so keep your eyes and ears open for dates and details – it will be a conference not to miss!
Back in 1979 Ian Dury and the Blockheads wrote a song about all the things that made them cheerful. Titled “Reasons to be cheerful, part 3” it’s a quick fire list of things in his life that not only made him cheerful, but what he believed made everyone feel cheerful. As 2014 draws to a close we have our own reasons to the cheerful – the release of Synergy version 10.3.1.
Reasons to be cheerful – One, two, three.
Now you are able to take you Synergy code, build it in Visual Studio and deploy to any Android device – that’s your phone or tablet. Using XAML to define your UI can even enable you to write once and deploy to many different device options including iOS – which is being released in beta mode with 10.3.1.
Improved Developer Experience
Both Workbench and Visual Studio Integration continue to exceed expectations when we talk “developer experience”. Even better IntelliSence and seamless access to .NET capabilities like LinQ. Build powerful Portable Class Libraries (PCLs) that can be used to deploy your Synergy logic and data access code on multiple target platforms.
In Visual Studio you can now install the latest Synergy Language Integration and target an older runtime version, for example install SDI 10.3.1 and target runtime 10.1.1. This keeps you using the latest tools without the need to immediately update your target platform.
Programmatically Track File Changes
Using the new ChangeTracking class you can now access file snapshots and change tracking information directly from Synergy.
xfServer between Windows client and server can now be configured to recover from a network interruption and auto-reconnect. This development continues to strengthen the robust quality of xfServer.
Controlling who’s using your applications is important and Synergex recognises this with the ability to utilise device licensing for your Android and iOS (future release of Synergy) apps as well as your Windows store and desktop programs.
To complement the release of Synergy 10.3.1 the Symphony team has developed a new server component called Symphony Bridge. Symphony Bridge allows you to communicate via HTTP and HTTPS to a server that is exposing your application logic and data. Bridge utilises Symphony Harmony which is an SQL command interpreter layer that accepts SQL based commands (selection, store procedure execution, etc.) and performs the required tasks on the remote server. There will be more about Harmony and Bridge in a future blog post.
For now, let’s sing along with Ian and have “Reasons to be cheerful” with the release of 10.3.
For many years we have had the ability to expose Synergy data and logic through xfServerPlus which can be consumed, processed and displayed by cool Windows programs. But for me there has always been the “single thread” bottleneck. I’ve wanted my Windows applications to respond when the user drags the mouse, clicks a button, sorts a grid, at the time the event happens, and not when the program has caught up doing its background actions. Calling a remote method generally “hangs” the program until that operation has completed and this is because it’s being performed on the UI thread. And while the UI thread is busy calling into your xfServerPlus libraries and waiting for a response it blocks any user interaction so your application becomes unresponsive.
The answer is to utilize threads. Threads are separate processing channels that can run simultaneously. Your application always has at least one thread – the UI thread. But if you have a language that can allow multithreading then utilising this to perform background tasks on other threads frees your UI thread to continue being response to the user – its job really!
Welcome to Synergy.NET! Totally written in Synergy.NET and utilising the Symphony Framework I’ve written a fully functional interactive dashboard:
The user can fully define the record selection criteria and then issue the “Select” of the data. This selection is performed on a background thread. This means as the results are being returned from the remote Synergy DBMS file via xfServer the list is populated and the user can begin navigating the items within it. While the list is loading, the user can select an item even if the list load is not complete. At this point a number of background threads become active – each one loading data from different files via xfServer. The various lists are populated “in real time” and the application remains responsive – all the lists can be “loading” at the same time.
If the user clicks another item in the list the executing threads are instructed to “stop” and then the selection process restarts based on the newly selected master record.
Using the Symphony Framework and building my Synergy Repository based Data Objects using CodeGen I was able to quickly build the core components used in the Dashboard including the thread based selection code.
All this functionality is available in the latest V10.1 release of Synergy. To find out more details and to see multithreaded processing in action book your place at the upcoming DevPartner Conference at http://conference.synergex.com.
By Steve Ives, Posted on August 1, 2012 at 4:20 pm
Richard Morris and I have just returned from a seven-day consulting engagement with a customer, and I wanted to share with you some information about our achievements during the visit. The customer we visited with is one of our larger ISV’s and has an extensive Synergy application, much of which is implemented using the Synergy/DE UI Toolkit. As with many applications, life started out on cell-based systems many years ago, but for many years now it has been deployed exclusively on Windows systems.
The customer in question had listened to us talking about Symphony Framework and CodeGen at the Chicago DevPartner conference, and was interested in how they might be able to leverage them to accelerate the process of updating the look and feel of their applications by replacing their existing UI Toolkit user interface with a Windows Presentation Foundation (WPF) user interface. Needless to say we were eager to help, because we believe we have a great story to tell, and some great tools to share!
Most in the industry would agree that WPF represents the current “state of the art” when it comes to implementing user interfaces for Windows Desktop applications. We have had our eyes on WPF for some time now, and have been learning about it’s capabilities. We have also been encouraging customers to consider WPF as a great way of updating the UI of their existing applications, or implementing the UI of new applications. And thanks to new features in Synergy/DE 9.3 and 9.5 there are a couple of great ways of doing just that.
For existing applications the Synergy/DE .NET Assembly API can be used to embed WPF directly into existing applications. Of course one of the main benefits of doing so is that the application can be enhanced screen-by-screen, without the need for extensive re-writes and long development cycles. Of course for new development Synergy .NET can be used to build all-new applications with a WPF user interface. There is also a realistic migration path between the two; you can chose to start off by enhancing screens in an existing application via the .NET Assembly API today, and then ultimately migrate the entire application to a native Synergy .NET solution. All very “doable”.
Before I get into the specifics of our tools and what was achieved, there is one more thing that I should mention. Just as most industry pundits would agree that WPF is the way to go for Windows Desktop applications, most would also tell you that there is a specific WAY that WPF applications should be implemented; it’s called the “Model-View-ViewModel Design Pattern”, which is often abbreviated as MVVM.
A design pattern describes a methodology for implementing a software solution to a certain problem. The MVVM design pattern sets out a way of designing software such that there are clear lines of demarcation between code that deals with different parts of an application. Specifically it prescribes how the “Model” (code which implements an applications data definitions and business logic) should be separated from the “View” (code which implements the applications user interface), and how these two entities should be joined by the “ViewModel”. We’ve talked quite extensively about MVVM in the past, and there are lots of great resources available on line, so I don’t intend to go into more detail here. Suffice it to say that adhering to the MVVM design pattern is strongly recommended when implementing WPF applications.
I mentioned earlier that we have been focusing on WPF for some time now, and also on MVVM. But as well as just learning about the technologies and patterns, Richard Morris has been “beavering away” at his home office in England pondering the question “how can we help our customers to easily use WPF and MVVM in the context of their existing Synergy applications?”. Once he’d finished pondering the question, he then started coding the answer … and the Symphony Framework was born.
So just what is the Symphony Framework and how can it help you? Well in a nutshell, Symphony Framework is an MVVM Framework (library) which can be leveraged by Synergy developers to significantly simplify the process of implementing WPF user interfaces in their Synergy applications, while at the same time adhering to the best practices prescribed by the MVVM design pattern. Symphony Framework can be used to incrementally add WPF UI to existing applications in conjunction with the .NET Assembly API, and it can be used to implement all-new Synergy .NET applications with a WPF UI.
Some areas of Symphony Framework are designed to specifically address the somewhat unique challenges associated with migrating UI Toolkit applications, but the framework is in no way limited to working only with UI Toolkit applications. To cut a long story short, if you have an existing Synergy application and want to “spiff it up” with a fabulous new WPF UI, then Symphony Framework might just become your new best friend!
I’m not going to go into a huge amount of detail about HOW this all takes place, but I do want to briefly describe some of the common steps. For the purpose of this illustration I’ll ask you to imagine an existing UI Toolkit application (but remember, it doesn’t have to be Toolkit), and imagine that I want to do a gradual screen-by screen migration to a WPF UI, initially driven by the existing application (via the .NET assembly API). What might the steps be? Well, for each screen (or window) we might:
Create a “Model” class that describes and exposes the underlying data to be worked with. Model classes inherit a lot of functionality from base classes in the Symphony Framework.
Create a “View” using WPF.
Create a “ViewModel” that exposes the information in the model to the view, and provides the functionality needed to service the requirements of the view. ViewModel classes also inherit a lot of functionality (in some cases all of the required functionality) from base classes in the Symphony framework.
The code for all of the steps described above would be implemented in Synergy .NET and would be compiled into a .NET assembly.
Use the .NET assembly APIs “GENNET” tool to create Traditional Synergy “wrapper” classes that allow these various components to be accessed and manipulated from the existing Traditional Synergy application.
Create a “Manager” class (we’re still trying to figure out what to call this bit!) which contains the bulk of the code required to instantiate and drive the underlying .NET code.
Modify the existing application to present the new WPF UI instead of the existing UI, primarily by accessing functionality exposed by the “Manager” class.
You might be tempted to see this last bullet point and think “there is is, modify our existing code, that’s the hard and time consuming part”! But don’t let this thought put you off, believe it or not the changes that typically need to be made to the existing code are relatively small and painless. This is due in no small part to the things that the Symphony Framework is doing for you!
During our visit with our customer we initially worked on what it would take to replace existing “lookup” routines with new WPF implementations. In a UI Toolkit application a lookup routine is often accessed via a “drill method” associated with an input field, and often uses a combination of input processing to allow the user to define search criteria, and list processing to present matching results. When the user picks an item the associated value is returned into the input field. We managed to get this process down to a fine art. and this is where CodeGen comes in.
We were able to create CodeGen templates which allowed us to generate most of the code that was required to “switch out” a UI Toolkit lookup for a WPF lookup. We were able to code generate 100% of the Model class, 100% of the View class, 100% of the ViewModel class, and 100% of the “Manager” class. All that remained was to modify the existing application to utilize the new code instead of the existing UI Toolkit UI. Figuring out how to do the first lookup probably took in the order of half a day, but with the process and CodeGen templates in place, the next four lookups probably took around 20 minutes each to implement. We left it at that, because we were confident that we had the process down at that point.
Then we moved on to other areas, attacking a “maintenance” type program. The process is actually remarkably similar, and actually not that much more complex, again because much of the base functionality required is inherited from the Symphony Framework. By the end of our engagement we pretty much had that process down also, and again much of the required new code was being code generated, leaving only relatively minor changes to the existing application to be made.
Of course not all aspects of an application are as simple to deal with as the scenarios that I just described, some parts of an application and its UI get pretty complex, and it isn’t always possible to code generate all of the required components, and it isn’t always possible for the Symphony Framework to provide all of the required functionality in the form of base classes. Programmers still have a role to play, and thank goodness for that! But I do believe that the tools that Richard and I have developed can play a significant role in projects of this type, and it’s not just theory, we just proved it!
Actually that’s probably not a totally fair statement for me to make, as there are several other customers who have already used the Symphony Framework with great effect. Just as there are many customers who already use CodeGen to generate many different types of code to address various application needs. But Richard and I don’t often get to work together on a project, and this is perhaps the first time that we have really tried to use both of these tools together and push them HARD to see what could be achieved. And I for one am confident that everyone involved, including our customer of course, was pretty impressed with the results.
By the way, if your goal is to build an all-new WPF application directly in Synergy .NET, while retaining and re-using large portions of your existing code, then the steps aren’t that different to those described above. The Models, Views, ViewModels and “Manager” classes would be essentially the same, but would be driven by a Synergy .NET WPF application rather than by a DBR application via the .NET Assembly API. We actually proved this recently while preparing a proof of concept demo for another customer. Having been provided with the code for a small sample application, and some sample data, we migrated the UI of the application to WPF using the steps described above. Once the application was working with a new UI, and armed with the classes that we had just created, we were able to re-purpose those classes without change in a 100% Synergy .NET WPF application. In all the process took about four hours … but probably could have been completed faster had we not been sat at a bar at the time! This really is pretty cool stuff!
Before finish I do want to stress one more time that the Symphony Framework and CodeGen tools are not just about UI Toolkit applications on Windows. Symphony Framework helps you migrate to an ultra-modern WPF UI on Windows, but the starting point could easily be an application that runs on a cell-based platform today. And CodeGen can be and is being used on all systems supported by Synergy.
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/.
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…
Ding dong, “Laundry service”! Now you could be mistaken for thinking that I’m staying in a rather nice hotel, being called upon by the maid for my dirty laundry. Not so, I’m afraid, I’ll be taking my dirty ‘smalls’ home with me. But for one of our customers, this is their calling card. The customer is White Knight, based near London and their business is laundry, run by Synergy.
It’s true. People and many of them are well known celebrities, have their laundry collected every Monday and returned within a few days, cleaned dried and perfectly ironed. Some ten thousand “items” pass through the machines at this site and this is a small site. Their other sites handle in excess of two hundred thousand articles every week.
To manage this workload across all sites is a suite of Synergy programs running on a Linux machine. Traditional character based systems handle all aspects of the process from collection, cleaning through to delivery of the right items to the correct customers.
But things don’t always go right. So when the customers call in and say “you’ve washed the spots off my favourite pair of shorts” it all needs to be recorded and processed. This calls for a CRM (Customer Relations Management) system. And here is where I enter the story. White Knight has invited me down to assist them to begin to write a fully functional CRM system in Synergy. They want a Microsoft Windows desktop application with all the bells and whistles with access to new and existing Synergy data and logic. Easy!
So today we hatched a plan. Graham from White Knight was fully prepared for my visit with a functional specification, data layouts and design utilising xfServerPlus. “But for a desktop application?” I asked. “Why are we not using WPF (Windows Presentation Foundation) and .NET?” Because I’m not strong with C#, I know enough to do my web site!” Graham replied. Well, given the imminent release of Synergy v9.5 and the integration of Synergy Language within Microsoft Visual Studio 2010 it would be a perfect candidate. We’ve created our Visual Studio projects and begun to define our WPF User Interface in XAML. Our existing Synergy routines are being imported into a new class library project and we are crafting Synergy classes to facilitate the communication between our application elements. For those of you at SPC 2010 you’ll recognise this as the Model-View-ViewModel pattern!
And how did we do? Well I’ll update my blog over the next few days of how well we do, writing our first Synergy for .Net application…..
In days of old, carrying your trusted, heavy weight camera around your neck, you’d take the perfect snap. You’d then continue snapping away until the film was full, which, for the impatient among us, meant taking a large number of “I was just finishing off the film darling” type shots. On returning home you’d quickly rewind the film back into its cartridge, unless you had one of those fancy modern “advanced” film cameras of course, where the camera did it for you, and then pop it into your “postage free” envelope. And off you sent it, in the hope that your “once in a life time” shot would be processed and returned to you post haste.
And what of the results? Normally a hazy, slightly out of focus, batch of glossy pictures that really don’t give your artistic prowess justice. After all, the subject must have moved because you’d never intentionally crop the top of the head of the bride, just above the eye line, and why was the gentleman third from the right picking his nose?
If this sounds like your photography experiences, the chances are if you live in the UK the people processing your film were a company called Harrier L L C. You may know them better as “TRUPRINT”. At their peak they were processing 85,000 rolls of film per day! Today, however, they are processing no more than 1,000 films. Not really a great statistic if film processing is your business. But Harrier saw the potential of the digital world and has embraced the processing of the digital image. Today they average over 200,000 prints a day, which can rise to over 1,000,000 prints at times like Christmas. However, although this figure is significantly lower than the prints they were processing in the heyday of film, it’s now a very small part of their product portfolio. The key to success was to diversify. Today, in this digital age, people want more than just a glossy print of their blurred, half-cropped pictures. They want the t-shirt, a coffee mug and of course the family calendar, all donned with their own artistic compositions. Today, with a few clicks of a mouse you can upload your pictures and have them delivered to your door on anything from coffee mugs, placemats to a full size framed canvases. You can even have your prized picture delivered to you in lots of tiny pieces – in the form of a jigsaw!
So where does Synergy fit into their IT strategy? Their OpenVMS based Synergy /DE applications manage the order processing and management of every item they process. Once an order is accepted through the many portals including a host of web sites, major supermarket chains, leading pharmacies, and of course by post, the Synergy application takes control. It manages the processing or the required prints, storybooks or mugs (to name but a few product lines – they have over 500) through to despatch and successful delivery to the customer. The Synergex Professional Services Group is assisting Harrier to evaluate to work needed to migrate their Synergy/DE applications from the OpenVMS platform to Microsoft Windows.