As incredible as it may sound, some Synergy developers (myself included) have aged, no matured to the point where we can often be found looking back fondly on the days before computers had a fancy GUI. All we had to work with was the good old TUI which, by the way, we very much enjoyed working with because it represented a huge step up from running mag-stripe cards and punched paper tape, or typing instructions at a console printer. Yes, kids, back in the day some printers used to have keyboards! And no, believe it or not, there were no smart phones (or even cell phones) back then either!
By the way, if you’re not familiar with the term TUI (which I wasn’t until recently but now it’s one of my favorite terms) refers to a Text User Interface. I like the term in part because it’s a TLA, and in this industry we do love our TLA’s, but mostly because it just sounds so much more exciting than “character-based” or “cell-based”.
As a total aside, have you seen the management UI of Microsoft’s new Server product Windows Nano Server 2016?
This beautiful piece of TUI is what you encounter having completed an equally TUI-based login. There are a couple of other screens where core networking features can be configured, but that’s the entire UI of the whole server OS. They do say “what goes around comes around”! Of course that’s the entire point of Nano Server; everything is stripped down to the bare minimum so that you can install only the components that you need in order to host your application; making server instances lean and fast. But now … I am totally off track and really need to get back to what I am supposed to be talking about today. So what was the point of all of this? Well this article is about the editors that we chose to use in the day-to-day development of our code.
Back in the day all we had, depending on our chosen platform, were TUI editors such as EDT, TPU, VI and other such tools. While these tools did allow us to achieve our primary goal, editing our code, they really offered little assistance with that task. Everything was down to us.
If we wanted to layout and indent the code in a certain way then we would spend time with our friends the SPACE, TAB and ENTER keys. If we wanted to ensure the correct parameters were specified to a statement or subroutine call, we had better know what the correct parameters were (that’s one of the reasons that prototyping code can be hard today; we would frequently get that wrong!), and if we wanted to add comments to our code we could do so by typing a semi-colon followed by arbitrary text (that’s called “documenting your code” by the way, some of you might want to Google that!). If we did document our code the editor would display the comments in green, assuming you were using a terminal with a green screen, or orange, or white; basically the same color as all of the other text on the screen. The point is that these were editors, not Integrated Development Environments.
An integrated development environment has, at its core, an editor, but an IDE provides so much more than an editor. An IDE surrounds developers with the tools and technologies that make it easier to get their job done. It actively assists developers by automating common tasks, by providing relevant information right when it is needed, by making code more readable and providing a myriad of ways to move around in the code, understand how and from where code is used, and even helps developers write new code. It’s really quite simple; developers working in an IDE are always significantly more productive than developers working in an editor, and usually spend significantly less time fixing errors and more time enhancing or writing new code.
Of course Synergy developers have been able to take advantage of the Workbench IDE since the introduction of version 7.1 which, in the context of the earlier discussion was fairly recently, in 1999! But seriously, Workbench did take Synergy development to a whole new level, and has been widely adopted throughout the developer community. Since its introduction Workbench has been continually updated and enhanced, and continues to be an important tool for many. But what if there were an even better option?
Here’s another little (excuse the IDE pun) “snippet” of historical information for you; in October of 2010 we released Synergy/DE 9.5, and in doing so embarked on the next phase of the “Editor to IDE” journey. The 9.5 release introduced Synergy .NET, along with its inherent support for Synergy development in Microsoft’s Visual Studio IDE.
Visual Studio is widely considered to be the absolute state-of-the-art when it comes to IDEs and, as developers who embraced the early releases of Synergy .NET will attest, once again took the Synergy development experience to a whole new level.
But at that time, and since that time, there has been somewhat of a divide; and we at Synergex don’t like that. We like it when developers are able to leverage one set of tools, to write one application, and then be able to deploy that application in a wide range of scenarios across a wide range of hardware and software environments. After all, that’s why we first wrote DBL all those years ago, and it’s the primary reason why all of the Synergy products exist. It’s always been about the return on investment that our customers can achieve, based on the portability, scalability and forward and backward compatibility of our tools, and of the applications that they help developers produce.
So now we had two IDE’s, Workbench and Visual Studio. Workbench for traditional Synergy development, and Visual Studio for Synergy .NET development. Both do similar things, one may do something slightly different to or better than the other, but both have a lot in common. But on balance even the most fervent of Workbench supporters would agree that the capabilities of Visual Studio when working with Synergy .NET far exceed the capabilities of Workbench.
Wouldn’t it be great, we thought, if we were able to leverage the considerable capabilities of Visual Studio while developing traditional Synergy applications? Wouldn’t it be great if our developers and customers could use a single best of breed IDE, regardless of what type of application they were developing? Wouldn’t it be great if developers could develop their traditional Synergy application with its OLB’s, ELB’s and DBR’s, right alongside their new Synergy .NET WPF application, and alongside their Synergy .NET RESTful Web API services that power their ASP.NET MVC Web applications that are written in C#? And, not only all in the same IDE, but in the same solution! How great would that be?
Well, as many of you already know (because we announced Experimental support at the DevPartner conference in Washington DC back in May) doing just that IS now possible and now, with the release of Synergy 10.3.3b, is presented in a fully supported form. This is really exciting news, and several of the developers here at Synergex who have worked on the project are to be commended; the ability to develop traditional Synergy code in the Microsoft Visual Studio IDE, alongside other Synergy and non-Synergy applications of any type supported by Visual Studio, and to be able to do so in such a tightly integrated environment is, well, simply awesome!
So what are the initial capabilities of this new environment? Well, in addition to everything that Visual Studio with the Synergy .NET tools can already do, you can now create projects that:
- Combine one or more DBL source files to produce an object library (OLB)
- Combine one or more DBL source files to produce an executable library (ELB)
- Combine one or more DBL source files to produce a program (DBR)
- Compile multiple DBL source files to produce multiple programs
We have also introduced a new mechanism that allows environment settings to be defined across multiple projects within a solution, making complex environmental configuration within the IDE possible for the first time.
Of course the traditional Synergy environment includes all of the usual IDE features that you would expect, including but not limited to:
- Project and new item templates
- Code snippets
- Advanced code formatting
- Color coding
- Code beautifier
- Advanced code navigation features (go to definition, find references, etc.)
- Fully integrated build system
- Fully integrated debugging experience
Clearly some of these are things that have been supported in Workbench for many years, but Visual Studio does them so much better! For example, in Workbench you could pick one of four pre-defined code formatting styles and as you entered code, Workbench would do its best to format your code based on your choice of style. Visual Studio does the same thing, but you have a much finer level of control over how code is formatted, and you also have access to the code beautifier (from Synergy .NET) that allows you to re-flow existing code to match your currently defined formatting rules.
Perhaps the largest single enhancement in this new environment is the experience with the debugger. Visual Studio users have always enjoyed a debugging experience that is fully integrated with the source code of the application being debugged, and now we bring those capabilities along to the traditional Synergy world. The ability to visually step through code, set breakpoints, hover over variables to see values, and the many other advanced features of the debugger are again, simply awesome!
Oh, did I mention that we have also provided a migration tool that can significantly simplify the setup process for many of you? If you already have a Workbench development environment that uses the Workbench build system (the ability to add source code to Workbench projects and then use the built in “Build” command”) then this tool will parse your existing Workbench workspace and projects, and will create an equivalent Visual Studio solution and projects. It doesn’t always produce a 100% working environment, but in many cases it gets pretty close to that.
Once you have your libraries and applications configured in Visual Studio you will also be able to benefit from the way that Visual Studio knows how to build your code. Included is a comprehensive dependency-based build environment built atop of Microsoft’s MSBUILD tools. Visual Studio is able to understand your project and source code hierarchies, figure out what depends on what, automatically build things in the correct sequence, and automatically know what needs to be rebuilt when something changes. Again, we’re talking whole new levels of functionality here.
By the way, in the interest of full disclosure I should mention that there are two basic requirements that you must meet in order to be able to successfully build your code in this new Visual Studio environment.
- The code must prototype cleanly on Windows
- The code must compile cleanly on Windows
If you have never prototyped your code before then this is likely to be where the work is, but thanks to features in Visual Studio itself, and thanks to the introduction of several new compiler options designed specifically to assist with that process, making code prototype correctly is much easier than it used to be.
I could continue for a long time, but this article is already getting a little long. We’ll likely write more about this exciting new feature here in the weeks and months to come, but for now I’ll just point you to some video and other resources to check out:
From the 2016 DevPartner conference:
- Traditional Synergy Development in Visual Studio
- Traditional Synergy in Visual Studio & Migrating from Workbench
From an October 2016 webinar:
Synergy web documentation:
Don’t get me wrong, when I joined this industry in the early 1980’s I learned my trade on various PDP-11, VAX/VMS and UNIX systems and I still love EDT. But if you’re working on Windows or Linux then IMHO this is a no brainer; you should consider getting onto the latest version of Synergy and then building out your development environment in Visual Studio. Even if you ultimately deploy to one of the other supported platforms (UNIX, IBM AIX, HP-UX, Solaris or OpenVMS) there may still be significant opportunities to enhance your developer experience and productivity through the use of the Visual Studio IDE.