RSS Feed
News
Jul
11
Case Study: Real-time Android Charts for Medical Industry
Posted by Andrew on 11 July 2016 11:00 AM

About a year and a half ago, IMT AG (Information Management Technology) approached us to ask about porting SciChart Realtime Charts on the Android operating system. At the time we only supported Windows Presentation Foundation, but thanks to their encouragement, and their sponsorship by committing to pre-order SciChart Android licenses for their team, we were able to embark on the port, and have now released SciChart’s Android Chart with record real-time performance.

mguntli

Michael Guntli from IMT AG at Droidcon Berlin

Over the past year or so, IMT have worked alongside us providing valuable feedback as we developed the worlds fastest real-time Android Chart Control, which uses a mixture of Java, C++ with the Android NDK and OpenGL ES2.0 to achieve record performance for an Android Chart. We were able to squeeze the most out of a low powered device by porting our already proven drawing and resampling algorithms from Windows to Android, and implementing them in this new chart control.

This year in June 2016, Michael Guntli from IMT AG presented at Droidcon Berlin to talk about their project. Michael’s presentation ANDROID INDUSTRIAL: REAL-TIME DATA VISUALISATION can now be viewed online and a full video can be seen below.

Antutu-Benchmark-imx6

Benchmark of the Freescale iMX6 hardware. A fraction of the speed of high-end Android devices.

Michael and his team at IMT have built a prototype device for the medical industry running on a dual-core Freescale iMX-6 hardware which uses SciChart’s Android Chart library for the real-time charting. The Freescale iMX-6 is low power ARM processor (dual core, 800MHz) that has about half the computing power of the lowest of the low cost $50 Android Smart phone, and a fraction of the speed of a high-end Nexus smartphone, yet thanks to the engineering of the IMT team and the performance of SciChart for Android, it still runs data-acquisition, processing, UI updates and of course realtime charts at a smooth 30 FPS.

The presentation content is very valuable from an engineers perspective as it goes into great detail about how to develop a truly real-time medical or industrial software with Android as an embedded operating system while running on low power ARM hardware. Some of the challenges faced by IMT are the same as our own: garbage collection, performance of the Java runtime and Android views have all required some inventive workarounds.

SciChartApp-NoProductName

View the IMT Prototype UI running SciChart Android Charts on a Freescale iMX6

Such an application demonstrates the ability of SciChart’s Android Chart component in Industrial and Medical usage where the Android operating system is used in a low-power embedded system. It also shows the amazing performance of SciChart’s Android Chart! If we can draw smooth charts on hardware that is low power, with a low CPU clock speed, then imagine what it can do on the latest smartphones or tablets!

The full presentation slides are available online, as well as a youtube video of the presentation below. There’s a little bit about SciChart at the end, and we really appreciate Michael taking the time to promote us in this way. We hope their project is a great success and we look forward to continuing to work with IMT in the future.


The post Case Study: Real-time Android Charts for Medical Industry appeared first on WPF Charts, iOS and Android Charts | SciChart.


Read more »



Jul
11
Case Study: Real-time Android Charts for Medical Industry
Posted by Andrew on 11 July 2016 11:00 AM

About a year and a half ago, IMT AG (Information Management Technology) approached us to ask about porting SciChart Realtime Charts on the Android operating system. At the time we only supported Windows Presentation Foundation, but thanks to their encouragement, and their sponsorship by committing to pre-order SciChart Android licenses for their team, we were able to embark on the port, and have now released SciChart’s Android Chart with record real-time performance.

mguntli

Michael Guntli from IMT AG at Droidcon Berlin

Over the past year or so, IMT have worked alongside us providing valuable feedback as we developed the worlds fastest real-time Android Chart Control, which uses a mixture of Java, C++ with the Android NDK and OpenGL ES2.0 to achieve record performance for an Android Chart. We were able to squeeze the most out of a low powered device by porting our already proven drawing and resampling algorithms from Windows to Android, and implementing them in this new chart control.

This year in June 2016, Michael Guntli from IMT AG presented at Droidcon Berlin to talk about their project. Michael’s presentation ANDROID INDUSTRIAL: REAL-TIME DATA VISUALISATION can now be viewed online and a full video can be seen below.

Antutu-Benchmark-imx6

Benchmark of the Freescale iMX6 hardware. A fraction of the speed of high-end Android devices.

Michael and his team at IMT have built a prototype device for the medical industry running on a dual-core Freescale iMX-6 hardware which uses SciChart’s Android Chart library for the real-time charting. The Freescale iMX-6 is low power ARM processor (dual core, 800MHz) that has about half the computing power of the lowest of the low cost $50 Android Smart phone, and a fraction of the speed of a high-end Nexus smartphone, yet thanks to the engineering of the IMT team and the performance of SciChart for Android, it still runs data-acquisition, processing, UI updates and of course realtime charts at a smooth 30 FPS.

The presentation content is very valuable from an engineers perspective as it goes into great detail about how to develop a truly real-time medical or industrial software with Android as an embedded operating system while running on low power ARM hardware. Some of the challenges faced by IMT are the same as our own: garbage collection, performance of the Java runtime and Android views have all required some inventive workarounds.

SciChartApp-NoProductName

View the IMT Prototype UI running SciChart Android Charts on a Freescale iMX6

Such an application demonstrates the ability of SciChart’s Android Chart component in Industrial and Medical usage where the Android operating system is used in a low-power embedded system. It also shows the amazing performance of SciChart’s Android Chart! If we can draw smooth charts on hardware that is low power, with a low CPU clock speed, then imagine what it can do on the latest smartphones or tablets!

The full presentation slides are available online, as well as a youtube video of the presentation below. There’s a little bit about SciChart at the end, and we really appreciate Michael taking the time to promote us in this way. We hope their project is a great success and we look forward to continuing to work with IMT in the future.


The post Case Study: Real-time Android Charts for Medical Industry appeared first on WPF Charts, iOS and Android Charts | SciChart.


Read more »



Oct
14
A letter from the CEO: SciChart Needs You!
Posted by Andrew on 14 October 2015 01:45 PM

We’re planning some pretty huge changes to SciChart in the next couple of months and I need to personally call on you, our customers, to help us.

abt_jbt_edged128

I’ve known for some time that there is literally a huge wealth of knowledge, time, investment, workarounds and pure genius in the applications that you have built with SciChart. Much of it we simply don’t know about! Also, our customers and new sales prospects don’t know about it either.

I’ve personally seen some of your work and some of it is stunning. I don’t share work unless I have permission as I respect your confidence. However, it’s time to call on you and hopefully call on some of that good-will we’ve built up in our user-base to get some feedback about what you’ve done with SciChart. By helping us out, you can help us to make SciChart become the best graphics & visualisation component in the world.

We need you! We need your feedback to make the SciChart experience better for everyone. If you could take some time to help us it would be greatly appreciated

– Andrew / CEO of ABT Software and SciChart Tech Lead (and son)

So if you have time to help us out, here are the sorts of things we’re looking for. There are some incentives below so don’t close the browser just yet!

Testimonials

We already have a bank of testimonials but many of them are a year or two old. If you love what we do, please give us a sound byte that we can quote on our website.

Extra credit! If you can give us a picture too (e.g. from your linked in profile or twitter profile) it helps build user trust. We want to have testimonials looking like this. We can (optionally) link to your Linked-In, Twitter account or company page.

We would like our testimonials to be short, snappy and with a picture + company name if possible!

We would like our testimonials to be short, snappy and with a picture + company name if possible!

Screenshots for our Showcase Gallery / Case Studies

Guess what, in three and a half years of building SciChart we only have one published customer case study which is a real shame, as I have personally seen such amazing examples from some of you.

BlueShift-One_1

If you can give us a screenshot of your application, with or without what it is and who you are, we would greatly appreciate it. Make sure you get permission to share it. 

If you want to do a full-blown case study to showcase what you’ve built with SciChart and get it published on our site, then please contact-us.

Logos

We literally have 100 blue-chip or easily recognisable companies using SciChart and over 2,000 licenses sold worldwide, and goodness knows how many end-users, but we can’t put  logos on our homepage without permission (what a drag!).

SC-Logos

Please please please, if you can, give us permission to use your company logo. If you’re {Big Bank / Big Pharma / Big Scientific} *cough* then you are going to be more valuable to us than smaller companies but anyone is welcome here.

Logos help to build trust and new customers that see hundreds of logos on the SciChart homepage are going to spend less time considering whether SciChart is the right choice for them. That means we have more revenue to invest and more to support you guys! Our success, is your success.

Your workarounds / genius hacks

You know we saw one {big Process Management company} take SciChart Annotations and create a scheduling control out of it?

We saw a {big Gaming company} take our DirectX-accelerated RenderSurface API and use it in creating tools for real-time node-based graphs and diagrams?

We’ve even see a {big Oil & Gas company} take our charts and produce something unrecognisably complex using multiple vertical charts and then print it out of a plotter.

The sorts of things you achieve with SciChart are way beyond what we can achieve with our limited examples and show-case just how powerful and flexible the toolkit is.

Incentives!

We realise that many of you are busy (well, you should be…) and many of you will need to seek permission from managers, even higher levels of corporate to get permission to share any information. We also realise this is going to take you time. So how about some incentives?

  • Are you up for renewal soon? How about a discount off renewal? Or, an extension to your support-expiry date for free?
  • Are you a SciChart WPF Pro customer? How about a discounted upgrade to Source-code?
  • Do you need to add new licenses to your team? How about a discount off those?
  • Or, you could just do it for the love :)

Call us to negotiate what it will cost you in terms of your time to prepare this information and we can negotiate a discount or store credit to compensate you. Be fair, and so will we!

Guys, finally, our success is your success. It is my dream to transform SciChart way beyond just a chart control, and as you continue to invest in us, so we will continue to invest in you.

Have a good day and thanks for your time! Please contact me if you want to help. My email is andrew [at] abtsoftware [dot] co [dot] uk.

Best regards,
Andrew

 

The post A letter from the CEO: SciChart Needs You! appeared first on SciChart.


Read more »



Jul
26
DirectX Scatter Chart Performance Fixed!
Posted by Andrew on 26 July 2015 06:46 PM

Just a quick update from our weekend warriors working hard to make SciChart the best High Performance WPF charting platform:

You may have seen we mentioned that DirectX Scatter chart performance is worse than software.

For background information, see

You’ll be pleased to know we’ve done some extreme optimization and managed to get a near 50x performance increase for 1,000,000 points scatter chart with DirectX. See the animated gif below:

v3.4_vs_Trunk_D3D

This will be available as part of the SciChart v4 SDK later in the year. Until then, you can always get high-performance scatter charts using the parallel rendering trick we presented here!

Best regards,
[SciChart HQ]

The post DirectX Scatter Chart Performance Fixed! appeared first on SciChart.


Read more »



Jul
23
Insane WPF Scatter Chart performance with Parallel Rendering
Posted by Andrew on 23 July 2015 09:42 PM

Today one of our first ever customers (dan danna naah!) contacted us after 3-years and asked about our Scatter Chart performance. They are still using v1.x of SciChart and wanted to know if it was possible with the latest version to draw a million points in a scatter chart at interactive framerates, and what performance improvements we had achieved over the years.

This was a chance for us to show off, I thought!! :-)

Well, over the major versions we have focused on performance (see our article How Fast is SciChart WPF Chart). SciChart has gotten faster over the major versions as you can see below and in the article above:

ScatterPerformance

Scatter performance in our tests has improved from about 1.8 FPS for 250k points in v1.7 to 12FPS in v3.2, about a 6x speed improvement. This is good, but not quite good enough, the customer would like to draw 1,000,000 points in a scatter chart ….

Parallel Rendering for Scatter Charts

An old FAQ on the SciChart forums show a quick hack to enable multi-threaded rendering for the EllipsePointMarker type. This gives a decent boost in scatter chart performance on dual and quad core machines.

Unfortunately the sample no longer compiles, it only works with SciChart v3.1. So we took this as a starting point and re-worked it for SciChart v3.4.

A small update to the SciChart BasePointMarker API

We needed to add a small enhancement (backward compatible) to the BasePointMarker type. This has been added to v3.4.2.6726 and above which you can get from our NuGet feed. This allows us to be notified in the pointmarker when a batch begins and ends and do some caching.

A new ParallelEllipsePointMarker type

With our new slightly modified API, we can create a new ParallelEllipsePointMarker type that takes advantage of the Begin/End batching.

public class ParallelEllipsePointMarker : BasePointMarker
{
    private float _width;
    private float _height;
    private readonly List<Point> _points = new List<Point>();
    private IPen2D _pen;
    private IBrush2D _brush;

    /// <summary>
    /// When overridden in a derived class, draws the point markers at specified collection of <see cref="Point" /> centers
    /// </summary>
    /// <param name="context">The RenderContext to draw with</param>
    /// <param name="centers">The Centres of the point markers</param>
    /// <param name="pen">The default Stroke pen (if current pen is not set)</param>
    /// <param name="brush">The default Fill brush (if current brush is not set)</param>
    /// <seealso cref="IRenderContext2D" />
    ///   <seealso cref="IPen2D" />
    ///   <seealso cref="IBrush2D" />
    protected override void DrawInternal(IRenderContext2D context, IEnumerable<Point> centers, IPen2D pen, IBrush2D brush)
    {
        Action<Point> drawOp = (center) =>
        {
            context.DrawEllipse(pen, brush, center, _width, _height);
        };

        // This will only work for some drawing functions, like DrawEllipse. Consider this experimental
        Parallel.ForEach(centers, drawOp);
    }

    protected override void DrawInternal(IRenderContext2D context, double x, double y, IPen2D pen, IBrush2D brush)
    {
        _pen = pen;
        _brush = brush;
        _points.Add(new Point(x, y));
    }

    public override void Begin(IRenderContext2D context, IPen2D defaultPen, IBrush2D defaultBrush)
    {
        base.Begin(context, defaultPen, defaultBrush);

        _width = (float) Width;
        _height = (float) Height;
        _points.Clear();
    }

    public override void End(IRenderContext2D context)
    {
        DrawInternal(context, _points, _pen, _brush);
        base.End(context);
    }
}

The above class keeps a List of Points which is cleared on Begin() and drawn on End(). Every call to DrawInternal with a single x,y point is added to the Points. In End() we draw all points using Parallel.ForEach.

Performance of ParallelEllipsePointMarker

The performance of the ParallelEllipsePointMarker is better than the standard EllipsePointMarker. Take a look at the below. While our standard point-marker achieves barely 4.5FPS for 1,000,000 points, the Parallel Ellipse Point Marker is able to push out around 15FPS on an i7 Quad-core workstation.

ParallelEllipsev3.4.2

Overdraw and Contention

This is good but there is some overdraw. Imagine if you had 1,000,000 scatter points drawn all at the same X,Y location. The above implementation would be grossly inefficient. Also, the Parallel.ForEach spawns goodness knows how many threads and context switching between them will start to become an overhead. Having fewer threads active will be a good thing for performance. Ideally, there should be no more threads than there are CPUs.

ClusteredParallelEllipsePointMarker

What about clustering and parallel drawing? … Whoa there! Don’t get too excited!

We had a go at a simple, almost lossless clustered parallel point marker. See the code below:

public class ClusteredParallelEllipsePointMarker : BasePointMarker
{
    private float _width;
    private float _height;
    private IPen2D _pen;
    private IBrush2D _brush;
    private byte[,] _pointsDrawn;
    private int _viewportWidth;
    private int _viewportHeight;

    /// <summary>
    /// When overridden in a derived class, draws the point markers at specified collection of <see cref="Point" /> centers
    /// </summary>
    /// <param name="context">The RenderContext to draw with</param>
    /// <param name="centers">The Centres of the point markers</param>
    /// <param name="pen">The default Stroke pen (if current pen is not set)</param>
    /// <param name="brush">The default Fill brush (if current brush is not set)</param>
    /// <seealso cref="IRenderContext2D" />
    ///   <seealso cref="IPen2D" />
    ///   <seealso cref="IBrush2D" />
    protected override void DrawInternal(IRenderContext2D context, IEnumerable<Point> centers, IPen2D pen, IBrush2D brush)
    {
        // This method is ignored by v3.2 and up...
    }

    protected override void DrawInternal(IRenderContext2D context, double x, double y, IPen2D pen, IBrush2D brush)
    {
        _pen = pen;
        _brush = brush;
        int ix = (int)x;
        int iy = (int)y;

        // If out of bounds, skip
        if (ix < 0 || iy < 0 || ix >= _viewportWidth || iy >= _viewportHeight)
            return;            

        // If pixel already marked as ignored, skip
        if (_pointsDrawn[ix, iy] == 0xFF)
            return;

        // Set pixel as marked to draw
        _pointsDrawn[ix, iy] = 0x1;

        // Below here
        //
        // This introduces a very very slight loss by also marking the surrounding pixels to a Point-Marker as
        // ignored (using 0xFF). We will prevent drawing to these pixels as well
        // Comment out this section below if you wish to have a true lossless clustered parallel pointmarker
        // 

        // Set surrounding pixels as marked to ignore
        if (ix < 1 || iy < 1 || ix >= _viewportWidth-1 || iy >= _viewportHeight-1)
            return;   

        _pointsDrawn[ix - 1, iy - 1] = 0xFF; // x x x
        _pointsDrawn[ix - 1, iy]     = 0xFF; // x o x
        _pointsDrawn[ix - 1, iy + 1] = 0xFF; // x x x
        _pointsDrawn[ix,     iy - 1] = 0xFF;
        _pointsDrawn[ix,     iy + 1] = 0xFF; // when a point is drawn at o, do not allow any points to be drawn at x
        _pointsDrawn[ix + 1, iy - 1] = 0xFF;
        _pointsDrawn[ix + 1, iy]     = 0xFF;
        _pointsDrawn[ix + 1, iy + 1] = 0xFF;
    }

    public override void Begin(IRenderContext2D context, IPen2D defaultPen, IBrush2D defaultBrush)
    {
        base.Begin(context, defaultPen, defaultBrush);

        _viewportWidth = (int)context.ViewportSize.Width;
        _viewportHeight = (int)context.ViewportSize.Height;

        if (_pointsDrawn == null || _pointsDrawn.GetLength(0) != _viewportWidth ||
            _pointsDrawn.GetLength(1) != _viewportHeight)
        {
            _pointsDrawn = new byte[_viewportWidth, _viewportHeight];
        }
        else
        {
            Array.Clear(_pointsDrawn, 0, _pointsDrawn.Length);
        }
        _width = (float)Width;
        _height = (float)Height;
    }

    public override void End(IRenderContext2D context)
    {
        Parallel.For(0, _viewportHeight, y =>
        {
            for (int x = 0; x < _viewportWidth; x++)
            {
                if (_pointsDrawn[x, y] == 0x1)
                {
                    context.DrawEllipse(_pen, _brush, new Point(x,y),  _width, _height);
                }
            }
        });

        base.End(context);
    }
}

So how does it work?

On Begin() we declare a Byte array the same size as the viewport. This byte array, any point-marker to draw we set a byte to 0x1. Any point-marker to ignore will remain 0x0.

For extra credit, we can optionally set points surrounding an 0x1 (point to draw) with 0xFF: a point to ignore. This means that if two or more scatter points are to be drawn within a 1-pixel distance of each other, only one scatter point will be drawn, reducing overdraw.

Second, because we’re using a Byte array and not a List of points, we’re avoiding memory creation on each pass. The Byte array is only recreated if the viewport is resized.

Finally, we use Parallel.For to iterate over rows of the byte array. Sure there is some cache missing here as we’re reading from all over the byte array, but at least we have a maximum of one Task or thread per row, not one per pixel :)

Performance of the ClusteredParallelEllipsePointMarker

The performance is pretty insane. Take a look at the below. While our standard EllipsePointMarker achieves barely 4.5FPS for 1,000,000 points, the ClusteredParallelEllipsePointMarker above is able to push out a whopping ~30FPS on an i7 Quad-core workstation.

ClusteredParallelEllipsev3.4.2

A note about DirectX

The attached sample allows you to compare HighSpeed (CPU) vs. DirectX scatter performance. If you run it, you’ll probably be disappointed that DirectX is considerably slower than a parallel enabled CPU rendering. We’ve done some analysis and can see some low-hanging fruit to vastly improve the DirectX rendering of scatter charts. Note that DirectX is considerably faster for line charts however.

Also note that Parallel-enabled point markers are only compatible with the HighSpeed (CPU) renderer. The other renderers are not suitable to parallelise on the CPU, although DirectX by its very nature is highly parallel and we will be working to improve it.

Conclusion

If ClusteredParallelEllipsePointMarker was able to achieve near 30FPS at 1,000,000 points, but our previous speed test clocked SciChart v3.2’s EllipsePointMarker at 4.5FPS points and SciChart v1.7’s point-marker at 1.8FPS for 250k points then our solution is approx ~60x faster at drawing scatter charts than SciChart v1.x.

So, how did we do? 
						<br />
						<a class=Read more »




Mar
17
SciChart – the Value of Priority Support!
Posted by Andrew on 17 March 2015 02:18 PM

Recently in October 2014 we introduced a new support policy, where we decided to give priority support tickets to SciChart WPF/SL Professional and Source-code customers. SciChart WPF Basic and trial users would still receive support, but via the forums. This is part of an ongoing process of continually improving and refinining the tech support we provide, as we feel it is such a critical part of our business.

This article is just some feedback of what we’ve learned from this experience and also to demonstrate the value-add of priority support to our customers!

Why is Tech Support so Important?

Have you ever bought a component from a vendor, and they might have a great 200 page document on how to use it, but for some reason it just doesn’t make sense to you? There’s a learning curve to climb when purchasing a new component and nothing is more frustrating than having a problem, and a deadline / angry boss / impatient customer <delete as applicable>, writing an email to their support and getting nothing back … Have you ever been there?

Since introducing the support desk at http://support.scichart.com one year ago, we have resolved over 1,300 support requests, 700 sales requests with an average feedback rating of 4.6/5.0! 

I personally have, and it’s disappointing… There is nothing that leaves a bad taste in your mouth more than a company that takes your money, but doesn’t respond when you need help.

We personally try to model ourselves on Telerik. Yes! I said a competitor name! I know … not a good idea.. but I believe we’re non-overlapping competitors with Telerik and personally, having used their docking components in 2008-2009 when working as a WPF Developer I realized they did something really well – tech support.

I noticed from using Telerik components that if you had a problem:

  • You posted it on the forums
  • You got an answer within a day or two from somebody competent
  • Usually you had to provide a solution to reproduce … which was annoying but …
  • … when they had information to reproduce the problem, they fixed it, or offered a workaround pretty quickly.

In other words, I could get my job done and continue on with my day. That is a Value-Add

This is a model we have emulated and it has paid dividends to us. Most of our business comes from referrals! Enough said …

How Many Support Requests do we get?

Since introducing the support desk at http://support.scichart.com one year ago, we have resolved 1,360 support requests, 616 sales requests with an average feedback rating of 4.6/5.0!

SciChart Support - Total Ticket Count by Department

SciChart Support – Total Ticket Count by Department

SciChart Support - Average Replies to Resolved

SciChart Support – Average Replies before Ticket Resolved

Each ticket has an average of 5 replies before the ticket is considered resolved, so in a year we’ve basically sent and received over 10,000 emails related to tech-support. That’s a pretty incredible rate and the feedback score and is consistent over the year. We are proud of how much tech-support we’ve handled and how we’ve delivered it, but more importantly, we’re really pleased to see how much value tech-support adds to our business. It’s taught us a lot …

How Quickly do we Respond to Support Requests?

We’re quick, and we really care.

We advertise that we respond to support requests sub-day, e.g. 24 hours to first response. This does not mean that we can resolve all problems in this timeframe, nor do we gaurantee to respond within this time but we aim to respond and at least make some progress to resolving within one business day. Over the past year this is what our support-desk says about our response time:

SciChart Support - Average Time to First Response

SciChart Support – Average Time to First Response

SciChart Support - Maximum Time to First Response

SciChart Support – Maximum Time to First Response

  • Average time to first response (per staff member, per month) was always less than one-day
  • In some cases average response time was less than one hour!
  • Maximum response time was typically 3-days. Don’t forget we don’t support on weekends (business days only), but this report includes Monday-Sunday
  • Our record lowest response & resolution was 4 minutes

We’re quick, and we really care. We want to help you to use our software, because if you can use our software, you get great value out of it, and if you see value in it, you’re more likely to tell other people about us. In other words, our business model is centered around customer service.

What do our Users Say?

Every time a support request is resolved (marked as closed by staff or user) the customer has a chance to give us feedback. Over the past year we’ve collected over 300 feedback responses, with an average rating of 4.6/5. That’s a 90% customer happiness score!

SciChart Priority Support - Average Feedback Rating by Staff Member

SciChart Support – Average Feedback Rating by Staff Member

Some of the comments are really encouraging. When customers give feedback scores & leave a comment it is emailed directly to the team cc the Company Director. Here are a selection of anonymised comments below:

“The ticket was really fast answered. All open items could be closed with customer satisfaction. Thank you again!” (Thomas, 5/5, Feb 2015)

SciChart always provides great feedback and service – A+” (Phillip, 5/5, Jan 2015)

You guys rock… I’ve only just loaded up the source but from what I can see it’s very clean and well organized. I’ll be spending time this weekend working on the modified data series. I’ll report back as I progress… thanks again, you guys are really great to deal with and sciCharts really rocks!” (Geoff, 5/5, Jan 2015)

“Thanks for prompt response and clear explanation. From your advice, I also found that there are useful resources for using sciChart in support page.” (Jack, 5/5, Jan 2015)

SciChart has absolutely excellent customer support. Every time I have contacted you, my questions have been answered and issues resolved quickly and professionally. This time was no exception. No need for any improvement.” (William, 5/5, Dec 2014)

“Bug reports made for problems found. Acceptable workarounds provided. Super support” (Bob, 5/5 Dec 2014)

“Pleased with response. Problem confirmed and fixed within 24 hours” (Ian, 5/5, Dec 2014)

I am very impressed. It appears to be what we need for our application. When zooming in we would prefer exponents with floating point, this appears to be the behavior you implemented. Other customers may prefer linear behavior, it would be nice to give them the option.” (Vincent, 5/5, Sept 2014)

“The response was so fast I would like to give you 6 stars” (Mark, 5/5, Nov 2014)

OH YEAH! Love you guys!

Similarly, we receive negative feedback via the ticket response ratings. If you want to encourage us, or, give us a slap, the ticket survey response is the place to do it. These surveys go straight to the team CC the company director, so we do hear them!

What about the Trial Users / Basic Customers on the Forums?

We also have a public forum at www.scichart.com/questionsHere we aim to respond within 3 business days, but often sooner, depending on our workload. The conversation time is typically a lot shorter, it tends to be question & single answer or at most two or three answers. The good thing about the forums for us is they are google indexed, so if you have a how-to question this is the place to put it. It helps us to build a searchable knowledgebase!

SciChart Support - Public Searchable Forums

SciChart Support – Public Searchable Forums

SciChart Support - Forums are Searchable on Google

SciChart Support – Forums are Searchable!

We encourage you to use the ratings here as voting questions up/down puts them higher or lower in the search results. Also we love to see the public knowledgebase grow as every question asked becomes a search result for someone later

The Value-Add of SciChart Priority Tech Support

In conclusion,

Our goal when introducing the support-policy in October 2014 was three-fold:

  • To reduce our support-load (limit priority support to paid customers, in subscription)
  • To allows us to focus on providing excellent service
  • To increase the value of our higher-end products

These goals have been achieved and more. In fact, we found that by introducing the support-policy our support load has decreased significantly, customer satisfaction has gone up, and importantly for us, sales are still strong. It hasn’t put anyone off excluding trial customers from support tickets, far from it, we are seeing more and more referrals.

We hope this has been useful information to you, and if you’re a competitor and you’ve read this far, we are available to consult to create a state-of-the-art support model for your business. Just joking. We don’t have time for that, we’re focusing on our own customers and product development 
						<br />
						<a class=Read more »





CONTACT US

Not sure where to start? Contact us, we are happy to help!


CONTACT US

SciChart Ltd, 16 Beaufort Court, Admirals Way, Docklands, London, E14 9XL. Email: Legal Company Number: 07430048, VAT Number: 101957725