Stephen Smith's Blog

Musings on Machine Learning…

Posts Tagged ‘javascript

Error Reporting in Sage 300 ERP

with 18 comments

Introduction

A very important aspect of all applications is how they handle errors and how they inform the end user about these errors. When everything is entered properly and people take what is called the “happy path” through the program then there is no issue. But end users will stray from the “happy path” and other circumstances can conspire to cause the need for informing the user of unusual circumstances.

In our previous blog postings on using the .Net API we have been deferring our discussion of error reporting, but now we are going to tackle it and add error reporting to the ASP.Net MVC sample program we started last week. In doing so we will introduce some new concepts including starting to use JQuery and Microsoft’s Unobtrusive Ajax.

Errors

Generally when we refer to errors in this articles we will also mean warnings and informational messages. Often you hit save on a form and if something is wrong then you get a message box telling you what was wrong (and maybe even what to do about it). However this is bit of an oversimplification. Sage 300 ERP is a three tier client server application. Many of the errors originate in the business logic or the database server. These may be running as Windows services and have no way of doing any user interaction. They can’t simply popup a message box. The error message must be transmitted to where ever the UI is running (say in a web browser somewhere on the Internet) and displayed there in a nice form that fits in with the general design of the form.

Further there may be more than one error. It is certainly annoying to have error messages popup one at a time to be answered and it is also very annoying to Save have one error message appear and correct the thing wrong, hit save again and then have a further thing wrong and so on.

To solve these problems we collect errors, warnings and messages up into a collection which is maintained during processing and forwarded up to the higher levels when processing is complete. We see this in the .Net API with the Errors collection on the Session object. As processing proceeds any business logic component can add messages to this collection. This collection can then be processed by the UI and cleared after it has reported the errors.

All the actual error messages referenced from the business logic are stored in Windows resource files and one of these is provided for each language. So the API used by the Business Logic will access the correct language resource file for the language of the Sage 300 user associated with the session object.

Inside the collection, each error has a priority such as Severe Error, Error, Security, Warning or Message. This way we can decide further how to display the error. Perhaps have the error dialog title bar red for errors, blue for warnings and green for messages.

Exceptions

Inside our .Net API we will return a return code for simple things that should be handled by the program. For instance if we go to read a record, we return false if it doesn’t exist, true if it does. But for more abnormal things we will throw an exception. You should always catch these exceptions, since even if you are debugging a program, these messages can be very helpful.

Just because an exception is thrown, doesn’t mean there is an error on the error stack. The exception might be because of some other exception, say from the .Net runtime. Because of this you will see in our exception handler, that if there is no error from Sage 300 then we display the error that is part of the exception (perhaps from .Net).

Sample Program

To add error reporting to our ASP.Net MVC sample programming we are going to start introducing how to program richer functionality in the browser. As we left off you just hit submit, the processing was done and the page was refreshed completely. This is rather old school web programming and a bit better user interaction is expected these days. Now I’ve updated the sample ARInvEntry sample (located here) to do an Ajax request rather than a page submit request. As a result the page isn’t completely redrawn and we can do a bit more processing. In this case we will use JQuery to put up a dialog box with any messages, warnings or errors that were encountered. Normally when you save an Invoice there is no success message displayed, but here we will put up a success message as well.

First off now that we are programming in JavaScript in the Browser, this is an interpreted environment which means there is no compiler to catch dumb programming mistakes and typos. One thing is to watch the syntax highlighting in the editor and use intelli-sense to avoid some typos. The other things is that we are passing data structures from C# on the server to JavaScript on the client. Which means there is no validation that C# and JavaScript have the same understanding of the object. Further JavaScript tends to silently ignore errors and keep on going, so you can be rather mystified when things don’t work. Some good tools to look for errors are Firebug and Fiddler. Trying different browsers can help also.

First I changed the page submit call to an Ajax call using Microsoft’s unobtrusive JavaScript library.

        @using (Ajax.BeginForm("CreateInvoice", "Home", null,
             new AjaxOptions { OnSuccess = "showResult" }))

Now the request will be made with Ajax and any returned data will be passed to the showResult JavaScript function. Pretty easy change, but there is one major missing piece. We must include the JavaScript library for this. The JavaScript file for any library needs to be added to the Scripts section of the project and then an entry needs to be added to BundleConfig.cs. Here we added jquery.unobtrsive-ajax.js to the jquery bundle.

     bundles.Add(new ScriptBundle("~/bundles/jquery").Include(
         "~/Scripts/jquery-{version}.js",
         "~/Scripts/jquery-ui-{version}.js",
         "~/Scripts/jquery.unobtrusive-ajax.js"));

We also added the jquery-ui-{version}.js. The framework will figure out which version to fill in from the js files in the scripts folder. This way we can update these without having to change any C# code. If we didn’t add the unobtrusive library then nothing would happen and we wouldn’t get any errors because nothing would be hooked up to fail. When having trouble with JavaScript always check you have the correct libraries added. Similarly we have added the css and images for JQuery to the project. You could put these in script tags in your HTML, but the bundles help with eventual deployment as we’ll see in a later article. These bundles are referenced in the cshtml files to actually include them in the generated HTML and one gotcha is that sometimes the order of including them matters due to namespace conflicts, for instance the bootstrap bundle must be placed before the jQuery bundle or something in JQuery won’t work due to some naming conflicts.

Now we add the showResult function and what it calls.

function showResult(data)
{
    $.fn.showMessageDialog(data.Warnings, data.Errors, data.Messages);
}
(function ($) {
    $.fn.showMessageDialog = function (warnings, errors, messages) {
        $("#infoWarningsBlock").hide();
        $("#infoSuccess").hide();

        if ((warnings != null && warnings.length > 0) ||
            (errors != null && errors.length > 0) ||
            (messages != null && messages.length > 0)) {

            var text = "";
            var i;
            if (messages != null && messages.length > 0) {
                $("#infoSuccess").show();
                for (i = 0; i < messages.length; i++) {
                    text = text + "<li>" + messages[i] + "</li>";
                }
            }
            $("#infoSuccess").html(text);
            text = "";
            if (errors != null && errors.length > 0) {
                $("#infoWarningsBlock").show();
                for (i = 0; i < errors.length; i++) {
                    text = text + "<li>" + errors[i] + "</li>";
                }
            }
            if (warnings != null && warnings.length > 0) {
                $("#infoWarningsBlock").show();
                for (i = 0; i < warnings.length; i++) {
                    text = text + "<li>" + warnings[i] + "</li>";
                }
            }
            $("#infoWarnings").html(text);

            $("#informationDialog").dialog({
                title: "Information",
                modal: true,
                buttons: {
                    Ok: function () {
                        $(this).dialog("close");
                        $(this).dialog("destroy");
                    }
                }
            });
        }
    }

}(jQuery));

Besides setting up the HTML to display, this code mostly relies on the JQuery dialog function to display a nice message/error/warning dialog type box in the Browser using an iFrame.

This routine requires a bit of supporting HTML which we put in _Layout.cshtml file so it can be shared.

    <div id="informationDialog" style="display: none;">
        <ul id="infoSuccess" style="display: none;"></ul>
        <div id="infoWarningsBlock" style="display: none;">
            <div id="infoWarningsHeader">
                <h4>Warnings/Errors</h4>
            </div>
            <ul id="infoWarnings"></ul>
        </div>
    </div>

Notice it has display set to none so it is hidden on the main page.

From the C# code on the server here is the error handler:

        //
        // Simple generic error handler.
        //
        private void MyErrorHandler(Exception e)
        {
            if (session.Errors == null)
            {
                Errors.Add(e.Message);
                Console.WriteLine(e.Message);
            }
            else
            {
                if (session.Errors.Count == 0)
                {
                    Errors.Add(e.Message);
                    Console.WriteLine(e.Message);
                }
                else
                {
                    copyErrors();
                }
            }
        }

        private void copyErrors()
        {
            int iIndex;

            for (iIndex = 0; iIndex < session.Errors.Count; iIndex++)
            {
                switch (session.Errors[iIndex].Priority)
                {
                    case ErrorPriority.Error:
                    case ErrorPriority.SevereError:
                    case ErrorPriority.Security:
                    default:
                        Errors.Add(session.Errors[iIndex].Message);
                        break;
                    case ErrorPriority.Warning:
                        Warnings.Add(session.Errors[iIndex].Message);
                        break;
                    case ErrorPriority.Message:
                        Messages.Add(session.Errors[iIndex].Message);
                        break;

                }
                Console.WriteLine(session.Errors[iIndex].Message);
            }
            session.Errors.Clear();
        }

It separates the errors, warnings and messages. Also the copyErrors method was separated out so it can be called in the case of success, in case there are any warnings or other messages that should be communicated.

The controller now just passes the variables from the model back to the web browser.

        public JsonResult CreateInvoice(Models.CreateInvoice crInvObj)
        {
            ResultInfo results = new ResultInfo();

            results.Messages = crInvObj.Messages;
            results.Errors = crInvObj.Errors;
            results.Warnings = crInvObj.Warnings;

            crInvObj.DoCreateInvoice();

            return Json(results);      
        }

All the work here is done by the Json method which translates all the C# objects into Json objects. It even translates the C# list collections into JavaScript arrays of strings. So for the most part this handles the communication back to the Browser and the JavaScript world.

error2

Summary

We discussed the Sage 300 ERP error reporting architecture and saw how to integrate that into our ASP.Net MVC sample program. Since this was our first use of Ajax and JQuery, we had a bit of extra work to do to set all that up to operate. Still we didn’t have to write much JavaScript and the framework handled all the ugly details of Ajax communications and translating data between what the server understands and what the browser understands.

Update 2015/01/29: Sometimes View calls will return a non-zero return code for special informational purposes. These will cause the API to throw an exception. To handle these you need to catch the exception, check the View’s LastReturnCode property to see what it is and then continue processing. Perhaps a bit of a pain to do this, but it is the exception rather than the rule.

Advertisements

Frustrations in Developing Mobile Applications

with 14 comments

Introduction

Recently I’ve been talking to many people about various techniques to develop portable mobile applications. In the good old days of the 90s with the Wintel monopoly usually you could just develop for Windows and you would reach 99% of the market. The main challenge was just adapting to new versions of Windows where you would get things like UAC thrown at you.

Now suddenly we are developing for various Windows devices, various Apple devices and various Android/Linux devices. Plus we have some other contenders like Blackberry clamoring for our attention. The market is now highly fragmented and all of these have considerable market share.

I develop business applications and the functionality I’m most interested in has to do with ERP and CRM workflows. This means I’m not writing games, although it would be fun to produce a game like “Angry Accountants” or “ERPville”.

I know I’ve blogged about mobile development a few times like here and here; but my thinking on this keeps changing and I’m still not happy with the whole situation. There are many mobile frameworks and I’m only touching on a couple of representative ones here. I’ve got to think there will be a better solution, but until then I feel like ranting.

mobile device frustration

Going Native

There is an appeal to going native. The native development environments are really excellent. I’ve been playing with Apple’s XCode development tools for OS/X and iOS development and they are really amazing. They’ve progressed a lot since I last saw them over 20 years ago when I worked for a company that did NeXTStep development for the NeXT cube. Similarly Visual Studio 2012 for Windows 8 development is really quite good and so are all the Android tools.

If I only needed to development for one of these, I would be happy with any one of them. But keeping several in my brain at once really hurts.

You get the best results for the given platform with any one of these, but you don’t really get anything reusable except the basic design. All the platforms use a different object oriented extension of C (namely Objective C, Java and C#). All the platforms have different operating system functions and different separations between what you do in the application versus have as a service.

C Reborn

One surprising thing I found from talking to people was that the idea of writing as much as you could in C. All the main platforms use extensions of C and all support compiling and running C code. This reminds me of the old days where you tried to write a portable application for Mac, Windows and Linux by isolating the operating system dependent parts and then writing as much code as possible in good old portable C. Funny how what was old can be new again. But then it was a good idea back then, why wouldn’t it be a good idea now?

Air

Much maligned Adobe always seems to have a proprietary solution in the game. With Flash being booted from most platforms, Air seems to have followers in some areas. Some people really like Adobe development tools, I’ve always found them strange. Like with Flash, uses ActionScript which is a nice object oriented extension to JavaScript, but then that makes it all non-standard. Then strangely you have to structure Flash projects as a movie which I’ve never liked. Air seems to claim to follow standards but then keeps dragging in Flash technologies. My own bias is that if you go down this route, you may as well stick with using JavaScript which is then more standard and more cross platform.

The other problem with Adobe is that they are the leading vendor in producing software with giant security flaws. This means they are more likely to be blocked or dropped from platforms. It is also a big risk for app development since your app could be tarred by Adobe’s problems.

Xamarin

Xamarin takes the Mono project and ports it to mobile devices like iOS and Android. The goal then is that you can develop a C# Windows application that will also run on iOS and Android. We tried Mono as a way to move some .Net projects to Linux, but just ran into too many problems and had to give up. As a result Mono has left a bad taste in my mouth so I’m inclined to avoid this. I also wonder how much code you will have putting the .Net runtime on top of the native iOS or Android operating systems. Is this just going to have too many layers and is it just going to be too fat and bloated?

If they can pull it off with high quality and compatibility there is potential here, but I suspect, like Air, you will just get a big non-standard mess.

JavaScript/HTML5/CSS

Ever since the first Netscape browser we’ve been promised that the web will standardize all programming. Then came a proliferation of web standards and incompatible browsers. Now things are coming back together in the web world. We have good standardization on HTML5, JavaScript and CSS. We have a number of browsers with good support for these and they run on pretty much all PCs, laptops, tablets and phones. So you would think you can just develop once as a web application and run happily everywhere.

Unfortunately all the vendors have a vested interest in their app stores (like iTunes). Vendors like Apple, Google and Microsoft make 30% off all software sold through their stores. They make nothing on people running web applications from browsers. As a consequence quite a few native platform functionalities are held back deliberately from the web. Then they market hard that for the best experience you must use a native app form their store or you are getting a second rate experience. Strangely the reverse is often the case where the app is just providing a subset of some web site and you lose abilities like being able to zoom.

In the current market/environment it’s very hard to compete against native apps with web apps which is really too bad. I think at some point the app store monopoly will fall apart, but that is today’s reality.

Phonegap

Phonegap is an open source library to try to bridge the gap between HTML/JavaScript apps and native apps. It adds a hardware API for JavaScript apps and allows them to be packaged for distribution via app stores. Phonegap was recently purchased by Adobe which really worried me. So far Adobe hasn’t done anything bad (that I’ve seen) and hopefully it will survive as a good open source solutions.

The main risks with Phonegap is that it usually lags the native apps in adoption of new operating system features, Apple may at some point start rejecting apps made with Phonegap and Adobe may start adding proprietary Flash like technology.

Beside these drawbacks the other problem is that your app is still made out of Browser controls and not the UI widgets that are part of the underlying operating system. You can style away a lot of differences but discerning users will be able to tell the difference.

Phonegap is a great technology which does really help JavaScript/HTML apps be more native and is really worth considering if you go down this road.

Summary

I’m still frustrated. I’m not really happy with the quality of apps produced by the cross platform technologies and I don’t like developing the same thing multiple times using the native SDKs.

I also find it a bit monotonous to develop the same program over and over again for iOS, Android, Blackberry and Windows.

Written by smist08

February 23, 2013 at 11:34 pm

The Argos SDK Part 2

with one comment

Introduction

Last week I introduced a sample of how to develop mobile apps for Sage 300 ERP using the Argos SDK. In that article I covered where to get the sample and how to get it working. This week, we’ll start to look at how it is put together and how it works.

Sign On

The first thing you need to do is sign-on or authenticate. There is a standard method of authentication built into SData which is explained on the SData website here. Usually you would want to create a sign-on dialog and then feed the results into the SData access layer. This is all done in the sample application.

Basically the file src\Application.js is responsible for orchestrating the running of the application. When it starts running, it calls handleAuthentication() which usually calls navigateToLoginView() to run the login screen. This is done in src\views\login.js. This file displays the UI and gets the data entered. We’ll talk more about how UIs work next. It basically sets up the credentials data structure, calls authenticateuser to save these for the SData layer and then navigates to the initial screen.

Anatomy of a View

For Sage 300 ERP developers this is going to be confusing, because in the Sage 300 ERP world, business logic objects are called Views. But here in the Argos SDK world, Views are UI screens. Basically you provide a data structure (JavaScript object described in JSON notation) with all the fields you want and an HTML template on how you want them displayed, and then Argos has base classes to display these. The Argos SDK uses object oriented JavaScript, so it’s often worth going into the SDK and browsing the base classes to see what things are derived from. This gives you a good idea of what is done for you and what behavior you can override.

The most basic such View is src\views\VendorGroups. This is used as a finder when adding new Vendors. The code is:

define('Mobile/Sage300/Views/VendorGroup/List', [
     'dojo/_base/declare',
     'dojo/string',
     'Sage/Platform/Mobile/List'
 ], function(
     declare,
     string,
     List
 ) {
     dojo.declare('Mobile.Sage300.Views.VendorGroup.List', [List], {
         //Templates
         itemTemplate: new Simplate([
             '<h3>{%: $.DESCRIPTN %}</h3>',
             '<h4>{%: "Code: " + $.GROUPID + " Active: " + $.ACTIVESW %}</h4>'
         ]),
        //Localization
         titleText: 'Vendor Groups',
        //View Properties
         icon: 'content/images/Accounts_24x24.gif',
         id: 'vendorgroup_list',
         security: 'Entities/VendorGroup/View',
         queryOrderBy: 'GROUPID',
         querySelect: [
             'GROUPID',
             'DESCRIPTN',
             'ACTIVESW'
         ],
         resourceKind: 'apVendorGroupsFinder',

         onRequestDataFailure: function(response, o) { 
               alert( Mobile.Sage300.Environment.parseErrors(response.responseText) );
               Sage.Platform.Mobile.ErrorManager.addError(response, o, this.options,
                   'failure');
               dojo.removeClass(this.domNode, 'list-loading');
         },      
         formatSearchQuery: function(query) {
             return dojo.string.substitute('upper(DESCRIPTN) like "%${0}%"',
                 [this.escapeSearchQuery(query.toUpperCase())]);
         }
     });
 });

This is basically the JSON definition for this View object. This one fairly simple and bare bones, the main points are to define the SData feed in the resourceKind: property, along with the query fields we need. Notice the simplate which  is used to format and display each entry in the list, these are described in the next section. Then there is an error handler and a function to perform searches. The rest is done in the base class for this View. For more complicated objects, you will need to override more functions and provide more input (like more details about fields for editing).

Simplate

Simplate is a small templating engine for JavaScript. We use the templates to dynamically combine HTML and data in our views.

The Simplate syntax is a mix of markup, tags and JavaScript code. These are the most common syntax items you’ll see:

  • {%= … %}: Output the result of the inner JavaScript
  • {: … %}: Output the HTML encoded result of the inner JavaScript
  • $: References the data object (in our case, the JSON entry retrieved via Sdata)
  • $$: References the data object container (in our case, the view)

You can check out the code and some examples here:

https://github.com/mmorton/simplate

Debugging

When developing you run into lots of bugs, so how to solve them? The nice thing about JavaScript is you just update your files, save them and then hit refresh on the browser to run. But since JavaScript is interpreted and not compiled, you only find out about syntax errors when you run. If the syntax error is bad then it can stop the whole program from running (extra or missing brackets are bad for this), simpler errors will just stop the program when it hits that line of code. Also beware that if you misspell variables, JavaScript will just happily keep going using an undefined value, so be careful.

I like to run in both Firefox and Chrome. Firefox (with Firebug) is good at pointing out syntax errors, so they are easy to fix. Chrome has an excellent JavaScript source code debugger built in that is great for setting breakpoints and tracing through code. Another tool I really like is Fiddler which spies on all the SData server calls being made. From here you can look in depth at what is going on with the SData server.

Since the Argos SDK along with any other libraries it uses are all open source JavaScript projects that means you can examine any of the source code in the Argos SDK and debug into it to see what is happening there as well as what is happening in your own code.

Also remember the SalesLogix and Sage 300 sample applications, chances are you can find an example of what you are trying to do in one of these programs.

Summary

The Argos SDK is a powerful mobile development platform that combines SData with the Dojo JavaScript framework to give quite a deep method to quickly develop mobile applications for various Sage SData enabled products.

Written by smist08

July 28, 2012 at 5:03 pm

Sage ERP Accpac 6 Competitive Advantages

with 3 comments

Introduction

A key goal of the Sage ERP Accpac 6.x series is to completely revamp the Accpac User Interface technology. The goal is to transform Accpac into a technologically leading product again. We want to ensure that through this technology transformation we make Accpac an extremely competitive market leading product. This blog post will look at the technologies being incorporated into the Accpac 6.x platform and compares them to other technologies to highlight a few of the differentiators that set Accpac apart. We will also examine what we will be able to do with the building blocks being put in place.

This blog posting talks about the technologies being incorporated to make Accpac more competitive. However there is much more to competitiveness than the technology platform being used. We are also making changes to business models, marketing, product features, integrations, migrations, verticals, etc. All of these have just as big an impact on competitiveness as technology. All of these reflect that Accpac isn’t sitting still, but that all departments are moving ahead at a rapid pace to stay ahead of the constant change that we see in the market today. But I’ll leave those topics to other people’s blogs.

Usability

Besides advancing to more modern technologies and providing a platform for future development, we are taking the opportunity of a User Interface rewrite to give the product a usability rework in the process. The goal is to greatly improve the learnability of the product, and to greatly increase the productivity of customers. This is from performing extensive end user testing and from applying modern user interface design techniques. Typically applying advanced usability to an ERP product has been the domain of small business products like Simply Accounting or Peachtree. We are looking to bring the ease of use of a small business product to the mid-market space and to develop this into another competitive advantage. We are also looking to greatly improve our user assistance, for more see: https://smist08.wordpress.com/2010/06/19/sage-erp-accpac-6-user-assistance/.

Technology Direction

The general trend in technology is to go Web. The question isn’t whether, but how and when. A key trend driving this is that people just don’t want to install software anymore. It’s a pain. They want to just browse to a web site, possibly sign up, log on and work. People have many devices whether a PC or Mac, iPad, iPhone or Android. Ideally they would like to do their work from any of these and not have any hassles of downloading and installing applications. This trend on the front end is well underway without any resistance to adoption. On the back end many people are asking the same questions, why do we need to maintain all this server and network infrastructure? How do we reduce these costs and just have our applications work. This is driving SaaS (http://en.wikipedia.org/wiki/Software_as_a_service). This is still underway with many problems still being solved like protection and privacy of data, what happens if you SaaS application goes out of business, control, customizability, etc.

We are fully embracing the new Web based technologies. With our Accpac 5.x platform we were web deployed but relying on ActiveX controls and IE to provide the foundation. These caused problems with security, reliability, ease of use and performance. Learning from this lesson we have gone in the complete opposite direction, writing our new UIs in pure HTML/JavaScript and not relying on any ActiveX controls, Java Applets, Browser Plug-ins or anything else that can cause installation or usage roadblocks. All we require is a modern Browser that runs HTML and JavaScript well.

Many of our competitors continue to develop Windows desktop applications using technologies like .Net WinForms (http://en.wikipedia.org/wiki/Windows_Forms), Java Swing (http://en.wikipedia.org/wiki/Swing_(Java)) or WPF (http://en.wikipedia.org/wiki/Windows_Presentation_Foundation). These applications will only run on Windows, they will not run on mobile devices, Macs or Linux PCs. They are designed exclusively for PC sized monitors and will only run on Intel/AMD hardware. The claim is that they can give a richer user experience than Web based applications, which perhaps true ten years ago, is no longer true today. Currently applications written with HTML4 can easily match the richness while applications embracing HTML5 will exceed this richness of interaction, while remaining open and device/hardware/operating system independent. Typically such applications haven’t reached the ease of use level common in Web applications like Facebook or Gmail.

Many of our competitors still use ActiveX controls (http://en.wikipedia.org/wiki/ActiveX) and Java Applets (http://en.wikipedia.org/wiki/Java_applet). Again requiring special plug-ins or limiting browser and device choices. These are really just ways to start Windows applications from inside the Browser.

Many of our competitors have gone with Adobe Flex/Flash (http://en.wikipedia.org/wiki/Adobe_Flex) to create their Web Based UIs. The problem with these is that you require an Adobe plug-in for your browser for these to operate. This means they do not work on many phones and other devices like the iPad. They also sometimes don’t port to all platforms, so if you have 64-Bit Linux, you are out of luck.

Many of our competitors have embraced Microsoft Silverlight (http://en.wikipedia.org/wiki/Microsoft_Silverlight). This is worse than Flash, in that there are very limited choices for where it runs and you are really limited to only running on Windows PCs in IE or on Microsoft Phones which so far haven’t been very popular.

Again we chose HTML and JavaScript because we get full device and browser independence built on open industry standards. Our competitors will claim that they chose something proprietary to give a richer client experience. This may have been true five years ago, but today even with only HTML4, you can get just as rich an experience as these other technologies. And now with HTML5 and a whole host of newer more powerful Browsers coming to market, we can now exceed the rich client experience of these other technologies without losing TCO or locking in to proprietary platforms.

TCO

Reducing TCO is a key goal of Accpac 6. Initiatives here include requiring only a Server installation, no workstation setup, nothing else that needs to be installed on the individual workstations. Not requiring any special firewall or network setup, having everything use standard HTTP (or HTTPS). Making customizations upgrade safe, allowing you to upgrade and have customized reports and screens just work. For more details see:  https://smist08.wordpress.com/2010/03/12/on-total-cost-of-ownership/.

Customization

As we move forwards we want to provide a more powerful customization model. A powerful customization model and robust SDK has always been one of Accpac’s competitive advantages, and we want to extend that. Studying what people customize currently and seeing if we can incorporate this into the product as part of the UCD review process to eliminate the need for customization. But when customizations are required we want to:

  • Make more customizations straight from forms without requiring code.
  • Make customizations upgrade safe.
  • Have many more customizations possible from the UI designer.
  • When code is required, ensure we provide the power to do more than we can currently.

For more on customizations see: https://smist08.wordpress.com/2010/02/05/sage-erp-accpac-6-customization/.

Openness

With everything we do, we are trying to be more open. Using open standards like HTML, JavaScript, SData and XML. Any files that we save are now just XML text files that anyone can manipulate with any of the many XML tools out there (including notepad). We want to follow industry standards and best practices. We want to avoid single vendor lock in. We want to make sure we can play when the next disruptive technology comes along. We are avoiding binary file formats and binary network protocols. We are avoiding proprietary technologies developed by a single vendor. We are ensuring we can be as adaptable and open as possible. This also reduces TCO since we can leverage open source technologies like Apache Tomcat (http://en.wikipedia.org/wiki/Apache_Tomcat) and Eclipse (http://en.wikipedia.org/wiki/Eclipse_(software)) which are freely re-distributable.

Future Foundations

Many of the technology choices and architecture we chose was to provide a foundation for future innovations including:

  • Browser Independence: Due to time constraints the first version will fully support only IE 7 and 8. But everything we have done is set to support Firefox, Safari and Chrome as well. This would include desktop and mobile versions of these Browsers.
  • 64-Bit – All the new technologies are fully 64-bit compliant. You can run the 64-bit versions of the browsers.  Now we are set to compile our Views for 64 bit and to produce a 64 bit version of Accpac when needed. As we scale we will be able to take advantage of huge 64-Bit memory spaces.
  • SaaS – Although we are shipping as an on-premise install to start, we have architected the system for SaaS deployment at a later version.
  • Advanced end to end integrations enabled through SData. As other Sage applications like SageCRM move to the same platform, we have the opportunity to integrate much more closely. With common UI components and a common SData Web Services layer, we can provide much more cross application functionality in UIs, Reports and Workflows. For instance see: https://smist08.wordpress.com/2010/05/07/on-the-sage-gcrm-contract/.
  • Performance/Scalability – With the adoption of SData Restful Web Services we can use advanced Web performance tools to test and expand the scalability/performance of Accpac from where it is today. See https://smist08.wordpress.com/2010/02/26/sage-erp-accpac-6-performance-testing/.
  • Server Independence – All the technologies involved in the Accpac 6 platform are server operating system independent. So we can produce a Linux Web Server version easily if we choose to do so.
  • Full Unicode Support – All the new technologies fully support Unicode, so this sets the stage for creating a full Unicode version of Accpac.
  • Mobile – All the new screens are pure HTML/JavaScript and can run on iPhone, Android and Blackberry phones. Plus tablet devices like the iPad. See: https://smist08.wordpress.com/2010/06/25/accpac-on-the-iphone-and-android/.
  • HTML5 – For our first version we are only using HTML4 features, but since we are built on the Google Web Toolkit (GWT) and Google is aggressively pursuing HTML5 we will automatically be getting HTML5 features as they become available in the various Browsers.
  • Connected Cloud – As a Web Based application, built from the ground up on RESTful Web Services, we are ideally situated to integrate with other Web Based applications based on Web Services whether these are locally installed or cloud based. This can include common ERP services like sales tax calculation or government reporting, but also integration to other services like Social Networks or Web Based Office applications (like Google Docs). Our technology platform is ideal for both consuming and producing such services.

Summary

With the Sage ERP Accpac 6.0A platform we want to ensure that Accpac is a leader in Web Technologies, Usability, Customizability and TCO. Expect to see a progression of exciting releases kicking off with 6.0A later this year.

Update 2010/10/10: Forgot to mention competing against Web 1.0 companies. Many of our competitors went to the web early with technologies like ASP.Net. These are all Web 1.0 applications meaning that they aren’t a very rich user experience and often result in fairly major page refreshes as you work. These companies may claim to be Web 2.0, but usually they have only patched in a few specific cases for show and you soon realize it isn’t used in most of the product. Many of these companies were start ups and are still fleshing out full ERP functionality and so don’t have time to go back and do a major refactoring of their UIs. Accpac’s new Web interfaces are fully Web 2.0 which use Ajax everywhere. All server calls are asynchronous and we only update individual DOM elements, never doing a page refresh. Since Accpac has full ERP business functionality already, we aren’t still filling in missing pieces.

Written by smist08

October 9, 2010 at 4:18 pm