Category Archives: Clarion.Net

News from CIDC 2017

We are back from the 2017 Clarion International Developers Conference, held in Orlando Florida this year.  I know it’s not possible for everyone in the community to attend the conference, so this post will cover topics that Diego and I presented.

Starting with Clarion 10 – we have a new build just about ready for release within a few days. It’s a significant build with over 150+ fixes/changes and new features.  I’ll post a link to the readme as soon as it’s finalized. Some of the new features were requests for new functionality in the H5 stack. Diego presented H5 in-depth, and quite a few developers were convinced that H5 has a place in their future.

On to H5 – H5 is now code complete. The combination of the AppBroker and your App on the server side, and Bootstrap+jQuery+HTML5 on the client, gives you the simplest path to deploy your App to phones/tablets almost instantly. You re-use 100% of your existing business logic, you customize the UI using CSS themes. And just by a copy/paste of Javascript code snippets you can extend your app to all kinds of new possibilities. Things like signature capture, geolocation, data graphing can be added for free. If you haven’t tried H5 yet, take 15 minutes and give it a try.

On to Clarion 11 – here’s a screenshot of a slide I showed during the keynote

C11 is the biggest update to the Clarion codebase since moving from DOS to Windows – the new internal classes are the base for the evolution of Clarion for many years ahead. I’ll do a separate post covering C11 with more details on what is coming. We think we’ll have C11 into alpha testing within a couple weeks!

On to Clarion.Net 4.0 – it’s been in use within the IDE since the first release of C10. And we released it to several developers who needed to update their production programs to support .Net 4. We plan on making a general release before the year end, and it’s likely that when we release C11 we’ll update it to .Net 4.5. We are supporting a new feature in the next release, during the compilation of the Clarion code we’ll generate C# code and project file (into a separate folder) that provides the exact same functionality as your Clarion code. That means for those who want to work with WPF or share code with a C# project, you can easily bring the code into VS.

On to mobile dev – over the last 2 years we experimented with just about every approach to mobile dev available. From pure native code solutions, to cross-platform C#, to hybrid apps using free frameworks like Apache Cordova or PhoneGap, and more.

Using the native code approach means you can’t develop for iOS without access to a Mac, period. And of course it means learning Objective-C or Swift, and Apple’s Xcode IDE. To support Android with native code you need to write code in either Java or Kotlin, and learn Google’s Android Studio IDE.

With a hybrid mobile approach you can code in a single language (Javascript) for both iOS and Android. But it has several drawbacks; while you can achieve a nice looking UI using HTML, you can never achieve a native look and feel for either platform. And as your app grows in size and complexity, it’s very likely you’ll run into performance problems.

When we set out our goals for mobile dev with Clarion these are a few factors we felt were critical:

  • Provide a (scalable) solution to deploy to mobile/tablets
  • Re-use unique Clarion knowledge/skills
  • Provide access to your database to any modern client app (Mobile/web)
  • Deliver real-time data updates for both the client-side and the back office (your Clarion Win32 app(s))

All of the approaches mentioned so far have a few things in common:
You need to learn either a platform specific language (or two languages if you develop for iOS and Android) or a specific framework and its tools (Ionic, Cordova, etc.) And you need to write a LOT of code.

That’s why we decided to use Native React. React Native is the next generation of React – a Javascript code library developed by Facebook and Instagram, which was released on Github in 2013.

With React Native, you don’t build a “mobile web app”, an “HTML5 app”, or a “hybrid app”. You build a real mobile app that’s indistinguishable from an app built using Objective-C or Java. React Native uses the same platform level UI building blocks as native iOS and Android apps. You just put those building blocks together using JavaScript and React.

Some of the Benefits:
You write JavaScript with React Native but the components/controls are rendered as native platform widgets. Performance is nearly identical to native code apps as long as you understand the nuances of how React Native works. You share the vast majority of your code between both platforms (iOS and Android). You get the benefits of the entire React Native ecosystem. And it looks like in the future we’ll have code sharing with Web apps.

What about the database? If we can generate a great looking, highly performant mobile client, how do we attain real-time data sharing between the Clarion back office applications, and the mobile client apps?

And we have an answer for that with the new Clarion REST server. It’s a full web server that can deliver regular web pages, along with processing JSON requests for data. It delivers real-time data updates for both the client-side and the back office (your Clarion win32 app(s)). It’s 100% Template driven, (so it re-uses your Clarion skills and knowledge) to create a custom REST server without writing any code (based on your Data Dictionary using any of the Clarion database drivers). That means you can securely open up your database to any modern client app that can consume JSON data.

And the Clarion REST server is simple to create using the templates and your Clarion skills. You won’t need intensive training classes or weekly webinars to understand it. Its model is similar (in a way) to the IP Server model, where you create a custom Data dll with templates and any embedded code as needed.

This has become a long post so I’ll end here – there’s a lot to look forward to in Clarion’s future.


The options to provide access to your Clarion program on non-PC devices now range from using RDP products, creating pure Web apps, or with @Thin or ClarioNet. And we’re going to be offering some more options for Clarion9 and Clarion.Net.


Today I’m writing about a new product (internally named H5 Builder). H5 is a blend of the best features of Internet Connect (IC) and Web Builder (WB), joined with the jQuery family and HTML5/CSS. Both IC and WB were products ahead of their time. As an example IC was using an async data packet methodology to refresh client side pages before technologies like Ajax were on the drawing board. With the addition of a global template both IC and WB allowed Clarion apps to run over the internet without (hardly) any work at all from the developer.  Drop in the template, remake the app, and deploy. However, they both had the same limitations; difficult (or impossible) to work with the web UI presentation to fit within existing web sites, and they required IIS experience.  They also weren’t positioned properly.  Developers who tried to use either product to create a “web site”, or create a web app that needed to scale to 100’s-1000’s of simultaneous users found neither could meet their requirements.

Flash forward to today and H5.  The intended use for H5 is not to create a “web site”, nor to create a highly scalable web app.  Instead H5 is positioned to make it dirt simple to make your app available as a private web app for a given business/enterprise via a web browser, whether that’s on a PC or on a smartphone/tablet. And it’s built upon today’s standards for the web; HTML5, CSS3, and JavaScript. These standards are open, secure, and efficient, and they allow developers and web designers to create apps that look modern, can fit into existing sites (sharing CSS styles) and can run on modern devices like phones and tablets.

H5 apps use the jQuery library, either jQuery UI or jQuery Mobile (UI), and JSON for updating client side data without a full page refresh.  They run under the AppBroker SE, so you just install the service and deploy — no IIS knowledge required.

The use of the jQuery family of technologies will be shared with Clarion.Net.  So becoming proficient with one group of technology will lead to being able to create web apps, mobile apps, native apps and hybrid apps.

News (short version)

I was working on a much longer post when I was alerted that if I didn’t post something (anything) real soon, then some heads were going to explode 🙂 —
so here is the shortest version I could quickly come up with, and I’ll follow with several small-ish posts.

On the Win32 side:
Expect a new release of Clarion8 out this week – possibly later today if all goes according to plan. Clarion9 is getting close to where we’ll release it to
an initial group of alpha testers, that being a precursor to widespread beta and official release.

On the .Net side
Clarion.Net is being updated to .Net 4.x compatibility, while still maintaining support for earlier .Net versions. It seems most of our developers are strongly interested in more capabilities to share code between .Net and Win32, and we’re working on further improvements in that area (we already support a builtin system for exposing .Net assemblies to Win32). With the push towards mobile and tablets, we’re working on templates that can address that very real need.

As we all know MS has an established history of pushing a new technology as the next “big thing” and then sweeping it under the rug a few years later. We don’t know if Microsoft will back off its Windows 8 strategy in the near future, or a few years down the road (like Zune and Silverlight). But after following MS down the path of WebForms, WinForms and Compact Forms only to have them mostly killed by MS, we’re avidly avoiding the MS trail of dead technology.

So in closing I want to suggest that jQuery, jQuery UI and jQuery Mobile(touch-optimized version of the jQuery framework) for smartphones and tablets will allow you to create a single app that can run on all popular smartphone and tablet devices (and desktop platforms). jQuery supports iOs, Android, Windows Phone, BlackBerry, Symbian, Palm webOS and other devices. So how does that fit into Clarion.Net and Clarion Win32? Well I’ll have to explain that in a separate post.

New functionality challenges new release

The new functionality I mentioned in the previous post took a bite out of our planned release timeline.  The functionality in question is the .Net implementation of our Win32 BrowseBox Behavior implementation.  We had aimed to have the support implemented across platforms (desktop/web) and across the data access models (ADO,Linq,FileDrivers).   This is what we have for the web side:

BrowseBox Behavior for the web


as you can see its very similar to what we have on the Win32 side of things.  For ASP.Net there are some new properties that are needed.  In particular we have to account for the stateless environment – each page access occurs as if it were the first time it has ever happened.   Hence the options for where the page will get its range limit value (as shown in the dropdown – and sure to expand shortly).

The BrowseBox Behavior implementation will bring a lot of code-free functionality to your web and desktop apps.  We’ll wrap this up tomorrow and release with whatever functionality exists (check the readme for the release state).

Another area where you’ll notice a huge improvement is the processing of the T4 template registry – it is now about 90% faster!

And we also have some nice news for the upcoming Win32 release but I’ll post about that tomorrow.

What’s coming up

We’re currently working on updates for both Clarion 8 and Clarion.Net.  On the C8 side we’re focusing on the first maintenance release for 2012 – lots of bug fixes and some popular feature requests.  On the .Net side we’re working on the next iteration of the 3-tier templates for both desktop and ASP.Net apps.  Additionally we’re adding the option to use the Clarion LINQ provider as the data model, bringing in ABC-like FILE access to your TPS (and other ISAM) tables.  We’ve simplified the steps needed to create the 3-tier app such that running the wizard creates both the model and the base application – and attaches all required extensions automatically.  End result – you won’t have to do much more than just select your Dictionary and then select the data model.  And if you choose the Clarion.Linq model there is no ADO.Net connection to configure.

We expect to release C8 next week to external testers, and a general release to follow the week after.  We’ll be ready to release the updated T4 templates around the same timeline, and once we’ve firmed up the changes we’ll schedule a webinar on ClarionLive.  The webinar will focus on how to use the templates (as opposed to how to write T4 templates).


Clarion.Net update

An update for Clarion.Net is out today.  It has a good number of fixes and delivers the previously described feature that automatically exposes Procedures you select so that they are visible to Clarion Win32 Apps.  I wrote about this a while ago, so I’ll refresh you on it (this is straight from the Help file):

1) In the Clarion# Program’s GLOBAL MAP, add both the NAME and PUBLIC attributes to the PROCEDURE prototype

For example in your Clarion# global Map:


! Procedures exposed for Win32 access must have both the NAME and PUBLIC attributes
SayHello                     PROCEDURE(),NAME(‘SayHello’),PUBLIC
SayTheName            PROCEDURE(string theName),NAME(‘SayTheName’),PUBLIC


2) On the Clarion# Project properties dialog, turn on the checkbox: Export Global named procedures and create Clarion Win32 LIB file

This step causes a .LIB file to be created, its location is set according to your RED file, or you can specify the output path in the Project

3) Copy both the .LIB and the Clarion# DLL to your Win32 project folder.  You also must copy any assemblies (DLLs) that your Clarion# DLL references, for the minimum you need:



4) In the Clarion Win32 program prototype the Procedure(s), and add the PASCAL and DLL attributes. If you need to pass a string value by address also add the RAW attribute.



! Calling Clarion# Procedures, you must use the PASCAL Attribute and set DLL(true)
SayHello            PROCEDURE(),NAME(‘SayHello’),PASCAL,DLL(TRUE)
SayTheName   PROCEDURE(*cstring theName),NAME(‘SayTheName’),PASCAL,RAW,DLL(TRUE)




In the initial implementation (its already changed internally),  you might run into a “gotcha” when you get to step 2.  In order to expose the Procedures for use in a Win32 program the binary Clarion# DLL file has to be disassembled back to IL code, the IL code is then modified, and then the IL code has to be assembled back to a binary (PE format) file.  To do this there are two programs from the .Net SDK that have to be found; Ilasm and Ildasm.  In the current implementation the location for those files is stored in an external .config file, and if they are not found (Ilasm and Ildasm), you’ll get an error message telling you to edit the path stored in Dllexport.exe.config.  In the next release we’ll have an improved implementation that finds these automatically on all OS’s (32 or 64 bit).

You’ll find an easy to understand example showing how this works in the .SamplesWin32toDotNet folder.

DevCon, Clarion8, Clarion.Net and more

I did a short talk at the start of today’s ClarionLive session. John and Arnold had posted that I’d be there and the room filled up really fast. In case you missed it, here is what I covered:

1. SoftVelocity and ClarionLive are co-organizing the next Clarion DevCon, which will be held in Denver Colorado, (same location as the last ClarionLive conference) for November 11-13, 2011. It’s sure to be a great event! I’ve heard the venue is incredible, and I know the content will be even better. In the weeks ahead we’ll be announcing the details on the session topics.

2. The initial early release of Clarion8 is going out today!
A few notes on the C8 release:
– You’ll get your chance to try out all the new UI features, like the Gradient support on Toolbar controls, the new Slider control, the 3-state Checkbox control, the vastly improved look for disabled images and icons, PROP:NoThemed support to allow transparent SHEET when the application is using a manifest, and much more.
– All told there are already over 65 new features and improvements, as well as about 150 fixes and changes.

– You’ll have some long sought after improvements in the IDE; like remembering the last edited EMBED point, and the ability to edit data as Text. But you’ll have to delve into the readme for the complete list. A lot of hard work has gone into this release, and we hope you will love it.

– What to expect after the install:

  • Clarion8 inherits all Clarion versions set up in Clarion 7, so you can start using the Clarion8 IDE right away
  • You should check with the 3rd party vendors that you use – but if you copy your .ClarionAccessory folder from your Clarion7.3 install folder into your Clarion8 folder most of your add-on tools should be ready to use as-is in a C8 App. The exceptions are those that have explicit checks for the Clarion version number, unless they use a greater than or equal condition. Also any tools that ship local link LIBs should be rebuilt just as a matter of routine sanity/safety.
  • The Dictionary format was updated in Clarion8, so expect an upgrade message upon open of the Dct or App

And that’s about it, this update should be absolutely painless, and it brings some very nice new features that your end-users can see, and some big productivity gains.

Back to the announcements:

3. Next week we’ll release an update for Clarion.Net – no AppGen.Net yet, but it will deliver the bridging technology that allows you to very easily call .Net procedures from your Clarion Win32 programs without the use of COM or C++ wrappers.

4. I’ll be doing short talks on ClarionLive at least twice per month in order to share the latest news on what we’re up to, and in general what’s happening with Clarion. I can’t thank John and Arnold enough times for the incredible resource they have created for the entire Clarion community!

Clarion.Net update

The AppGen for Clarion.Net is making steady progress (despite a few wild rumors to the contrary).  It’s a given that the progress is much slower than we would like, and in moment I’ll explain why that is the case. The core of Clarion.Net just like Clarion Win32, is not the AppGen, but is the Clarion language and Clarion runtime function library.  For those who are willing and capable of writing their own code (as opposed to generating it), Clarion.Net has long been both productive and complete. Let’s take stock on what we have now.

Well first and foremost we have the Clarion language, extended to be able to take full advantage of the .Net Framework while maintaining compatibility with Clarion syntax and language features. Let’s not underestimate the importance of this. I know there are those developers who claim they don’t care what the language is, but they are the minority. For most of us, the language we read and write to build our applications has great significance.

Next we have the Clarion Runtime, every function we have in Clarion Win32 we also have in Clarion.Net. The entire runtime has been ported to 100% verifiable .Net code with the exception being Window structures and the corresponding Accept loop and its related functions. So we lost Window structures, but did we gain anything in the trade? Yes we did, we gained the ability to seamlessly work with any add-on UI component library available. As you know Window structures are constrained to the core set of controls that we have had since the introduction of the Clarion for Windows product. Not so for Clarion.Net, the world of add-on controls is now wide open. And when we talk about the Clarion runtime let’s not overlook that this support encompasses the Clarion Driver technology. Driver support is bread and butter for most of us.

Is there anything else? Can we ignore what might well be the most important reason for some? Clarion.Net enables you to use you existing Clarion knowledge to build and deploy .Net applications for all of the platforms supported by .Net (Desktop, Web, and Mobile). Of course you could pick up a new language, and in a few years be a master of it. But your knowledge of the Clarion language shouldn’t be taken lightly, it’s a valuable asset.

Is that all? You have access to the entire.NET Framework and all of its classes and methods, including XML Web service classes. You have painless interoperation with both COM and native code Libraries. Clarion.Net programs and code can be integrated seamlessly with any other .Net languages; inheriting from classes created in other languages, invoking and being invoked by methods written in other languages, in other words you can use any library written in any .Net language, the same as if it were written in Clarion.Net. And the reverse is true.

So that’s what we have now, but what we’re missing is the code generation that separates Clarion from all competitors. As you may know the template language used in the new AppGen.Net is a complete departure from the syntax used by the templates in our Win32 Application Generator.  In place of the Clarion template language we use an extended set of T4 template directives. The extended set of T4 template directives include equivalents for our #PROCEDURE, #CODE, #GROUP, #CONTROL, #EMBED and #AT and #EXTENSION directives as found in our Win32 template system. And there is the root cause of the delay. The T4 engine has many advantages for generation of .Net code – but it’s primarily capability by design is for generation of individual classes and code snippets. The base premise of Clarion code generation is one of round-trip code generation, embedded code within the generated code block, generation of entire applications, and at the core, an Application tree that represents the structure and relationships of procedures within the application.  We very badly underestimated the complexities of imposing this required functionality onto the T4 engine, and it cost many more man-hours than we projected in our most generous estimations. We apologize for that, as we know a lot of Clarion users are purely AppGen developers, and are not going to be productive without the code generation functionality. But on the plus side, we now have the prerequisite functionality working, almost completely. And our stated plan to make the templates available on a public subversion repository so that users have instant access to updates and fixes, and have the ability to contribute new features and fixes (or even new templates and template sets) remains central to our plans (both for .Net and Win32).

The long-term goals remain unchanged; to create a code generation environment that opens the doors to WinForms, WebForms. Compact Forms, WPF and Silverlight. And in fact beyond those platforms, the new AppGen will open a path to Android and iOS. In order to get it into your hands faster, the initial templates will scale back on some of the optional features like the option to generate test cases (nUnit) for aspects of the APP. That can added later, by us, or by the community.

In the interim before the release of the AppGen for .Net we’ll be releasing an update to Clarion.Net that has a number of fixes and delivers the new technology that allows you to easily expose Clarion.Net methods to your Win32 Clarion applications.

Happy Holidays from SoftVelocity

From all of us at SoftVelocity, we would like to take this opportunity to wish you and your families a very Merry Christmas and a Happy and Prosperous New Year.

Here is our Holiday hours of operation for the next few days:

12/24 – Closed at Noon (EST)
12/25 – 12/27 – Closed
12/28-12/30 – Open for business, normal hours.
12/31 – Closed

Of course, our support newsgroups are always open 24/7, and you can always purchase our products online anytime at

A more detailed blog on Clarion versions 7.3, 8 (Beta), and Clarion.NET will follow here very soon.

All the best! We appreciate your business and support, and thank you!

Upcoming releases and news from Denver

The Clarion User conference was a great success. I presented the keynote remotely, and in this post I’ll cover the highlights of the presentation.

First on the Clarion for Windows Win32 side – I mentioned that the next release for Clarion 7 will be version 7.3, and in that release we’ll deliver several key RTL bug fixes and additional fixes for ReportWriter and the IDE. The 7.3 release will be ready to go out around mid-month.  I also did a brief demo of Clarion8, I only touched upon some of the new features already implemented, such as the new “edit as text” mode for the Data pad, and the new locators added to every list in the Dictionary editor (and added to the Data pad as well).  I also announced that we’ll be making an early access release for Clarion8 available to everyone with a subscription, and that will be ready by the end of this month.

On the .Net side I showed a short preview of the .Net Application Generator UI, and Pierre did further demonstrations during the conference. I explained that we are busy writing the .Net templates – and that the process of writing and testing the templates leads to bug fixes in the code generation engine.  With lots of hard work, and a bit of luck, we hope you’ll see a beta release in December.  I also mentioned that we’ll be putting all the templates (.Net and Win32) into a repository that will be open to the community. Doing this will allow Clarion developers instant access to the latest templates, and any template fixes or changes, and it will also allow Clarion developers to contribute their own templates and to participate in extending and refining existing templates. Later this week I’ll post another blog with some screenshots of the AppGen.Net UI – and as always we look forward to your feedback.