Prototyping to Final product

So I was going over Andy Carle's presentation on "Hardware Prototyping for Software Developers" talk. He makes a good case for the ease of moving from prototype hardware (Kinoma Create) to Custom hardware using Marvell ARM.

However, one thing that he didn't go over was what happens on the software side. I mean while the Javascript code would work well for many IoT applications, is it going to be robust enough to be left in shipping products requiring sub micro-second level latencies?

I am averse to developing a solution in JavaScript and create custom hardware afterwards only to have to rewrite everything in other languages to extract the most out of the Custom Marvell ARM hardware.

Am I not seeing things correctly here? What have other folks who have gone from Prototype to shipping products experienced?

Comments

  • We don't recommend JavaScript for sub-microsecond latencies. It isn't designed for that. But, using our XS6 JavaScript engine works well for products that need low latency, high performance execution. XS6 has a bridge to C (called "XS in C") to allow scripts to call C code and C code to call into scripts. We use this interface to implement performance critical code in C. We usually start with code in script to get started quickly, and then move the few performance bottlenecks over to C later. Of course, if you know the code has device specific performance dependencies, start in C. The overall product / device / application is written in JavaScript, from prototype on through production.

    While today's JavaScript is not designed for low latency (sub-microsecond) operations, that looks to be changing. The work on asm.js allows a strict sub-set of JavaScript to be directly translated to native code. it is, more or less, a way to write C code using JavaScript syntax. We're following the development of asm.js with interest.

    Finally, I believe Andy's presentation pre-dates our open source release of XS6. You can now use XS6 on any hardware platform you like. The code is C-only (no C++). We've successfully run it on a variety of microprocessor architectures, compilers, and operating systems.

  • Thank you, phoddie.

    I haven't looked at the XS6 JS engine. Where would you recommend I start off on XS6?

  • Our XS6 repository has all the code, so it is the ultimate reference. It is part of the KinomaJS repository: https://github.com/Kinoma/kinomajs/tree/master/xs6.

    The documentation is still in the original XS folder, here https://github.com/Kinoma/kinomajs/tree/master/xs/doc. The "XS in C" document is the most relevant to your questions, as it explains the interface between the C and JavaScript layers.

    The ReadMe.md file on GitHub contains instructions to build XS6 (as well as KinomaJS) for a variety of platforms. That will get you our command line tools. https://github.com/Kinoma/kinomajs/blob/master/README.md

    In my blog post introducing our open source release, there is an introduction to XS (which applies equally well to XS6) in the section "XS Virtual Machine"

    We have a web page that explains our results with the ES6 Compatibility Table project. That includes a simple example of using our xsr6 command line tool to run script files (e.g. .js) files. http://kinoma.com/develop/documentation/js6/

    Happy reading.

  • Thank you!

Sign In or Register to comment.