JS++

<h2 id="history">History</h2>
<p>JS++ first appeared on October 8, 2011.<a class="footnote-ref" id="fnref:1" href="#fn:1"><sup>1</sup></a><a class="footnote-ref" id="fnref:2" href="#fn:2"><sup>2</sup></a><a class="footnote-ref" id="fnref:3" href="#fn:3"><sup>3</sup></a> The modern implementation was announced at DeveloperWeek 2016<a class="footnote-ref" id="fnref:4" href="#fn:4"><sup>4</sup></a> and released on May 31, 2016.<a class="footnote-ref" id="fnref:5" href="#fn:5"><sup>5</sup></a><a class="footnote-ref" id="fnref:6" href="#fn:6"><sup>6</sup></a><a class="footnote-ref" id="fnref:7" href="#fn:7"><sup>7</sup></a><a class="footnote-ref" id="fnref:8" href="#fn:8"><sup>8</sup></a> The language is designed by Roger Poon and Anton Rapetov.
</p>
<h2 id="features">Features</h2>
<h3>Sound gradual type system</h3>
<p>Since JS++ is a superset of JavaScript, declaring <a href="/facts/Data_type/fcx5hgVL">data types</a> for variables is optional. However, when types are declared, the types are enforced at both compile time and runtime.
</p><p><a href="/facts/Type_signature/psEPS0UW">Type annotations</a> in JS++ use the traditional <a href="/facts/C_(programming_language)/Ky2No763">C</a> syntax:
</p>
int x = 1;
var y = 2;
bool z = true;

<p>Notably, this differs from <a href="/facts/TypeScript/A6XNmrTd">TypeScript</a> and <a href="/facts/ActionScript/xtDQb0wR">ActionScript</a>, which use a more verbose style:
</p>
var x : number = 1;
var y : any = 2;
var z : boolean = true;

<p>The type system in JS++ is <a href="/facts/Soundness/ndpamd2A">sound</a> for <a href="/facts/ECMAScript/M7nDHsB5">ECMAScript</a> and <a href="/facts/Document_Object_Model/GglE6jGx">DOM</a> API corner cases, including host objects, dynamic key-value pairs, <a href="/facts/Comet_(programming)/kLGmy68t">Comet</a>, <a href="/facts/JScript/HyuCUU2D">JScript</a> conditional compilation, dynamic return types, <a href="/facts/ActiveX/xJb7t7Eh">ActiveX</a>, <a href="/facts/ECMAScript_for_XML/351rfHeK">ECMAScript for XML</a>, <a href="/facts/Web_browser/2pfyymLs">web browser</a> <a href="/facts/Garbage_collection_(computer_science)/j2vlIu7g">garbage collector</a> and <a href="/facts/Cycle_graph/bYhnPDHc">cyclic</a> <a href="/facts/Reference_counting/jbPcXuXe">reference counting</a> bugs, conditional logic, and other corner cases.<a class="footnote-ref" id="fnref:9" href="#fn:9"><sup>9</sup></a><a class="footnote-ref" id="fnref:10" href="#fn:10"><sup>10</sup></a> This differs from other <a href="/facts/JavaScript/XhhIIEsl">JavaScript</a> <a href="/facts/Superset/gLcqWjd2">supersets</a> where types are optional and discarded at runtime via <a href="/facts/Type_erasure/uap24s8y">type erasure</a>, such as in <a href="/facts/TypeScript/A6XNmrTd">TypeScript</a>.<a class="footnote-ref" id="fnref:11" href="#fn:11"><sup>11</sup></a><a class="footnote-ref" id="fnref:12" href="#fn:12"><sup>12</sup></a>
</p>
<h3>Importing JavaScript libraries</h3>
<p>JS++ can use JavaScript libraries using the one-line external statement as in the following example from the homepage of JS++:
</p>
import System;
// Import JavaScript libraries in one line of code
external jQuery, $;

class Example {
    public Example() {
        // Nearly NO learning curve
        // You can keep writing regular JavaScript
        var a = 0, random = Math.random();
        // Integer types and other primitives
        // ... enable fast (optimized) and clear code
        byte[] rgbColors = [ 0xFF, 0xFA, 0xFF ];
    }

public void showMessage(int id, string text) {
        // 100% compatible with regular JavaScript
        jQuery("#msgbox").show();
        $("#msgbox").text(id.toString() + text);
    }
}

<h3>Object-oriented programming</h3>
<p>While classes in <a href="/facts/JavaScript/XhhIIEsl">JavaScript</a> (<a href="/facts/ECMAScript_6/M7nDHsB5">ECMAScript 6</a>) are <a href="/facts/Syntactic_sugar/FYkNSdTI">syntactic sugar</a> for <a href="/facts/Prototype-based_programming/x9oNIYPG">prototypes</a> under the hood,<a class="footnote-ref" id="fnref:13" href="#fn:13"><sup>13</sup></a> JS++ <a href="/facts/Class_(computer_programming)/zvzkSAtE">classes</a> resemble the classes found in classical <a href="/facts/Programming_language/cWTYbgWa">programming languages</a> such as <a href="/facts/C%252B%252B/Et0F2qn9">C++</a>, <a href="/facts/Java_(programming_language)/9ScgFyAL">Java</a>, and <a href="/facts/C_Sharp_(programming_language)/UC2gxeyb">C#</a> in terms of memory layout, performance, and semantics. For example, private methods are private at both compile time and runtime, and external JavaScript objects cannot access private JS++ fields or methods.
</p>
<h4>Example: object-oriented sorting</h4>
<p>The following source code illustrates object-oriented sorting in JS++ using the <a href="https://docs.onux.com/en-US/Developers/JavaScript-PP/Standard-Library/System/IComparable">IComparable<T> interface</a> and <a href="https://docs.onux.com/en-US/Developers/JavaScript-PP/Standard-Library/System/Comparison">Comparison enumeration</a> for type-safe and readable comparisons.<a class="footnote-ref" id="fnref:14" href="#fn:14"><sup>14</sup></a> The custom sorting logic is one line of code in the <a href="/facts/Method_overriding/B1AwBgUF">overridden</a> compare method below:
</p>
import System;
 
class Employee : IComparable<Employee>
{
    private string firstName;
    private string lastName;
 
    public Employee(string firstName, string lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }
 
    public override Comparison compare(Employee that) {
        // Sort by employee surname
        return this.lastName.compare(that.lastName);
    }
 
    public override string toString() {
        return this.firstName + " " + this.lastName;
    }
}

Employee zig  = new Employee("Zig", "Ziglar");
Employee john = new Employee("John", "Smith");
Employee abe  = new Employee("Abe", "Lincoln");

Employee[] employees = [ zig, john, abe ];
employees.sort();
Console.log(employees.join(", "));

// Output:
// Abe Lincoln, John Smith, Zig Ziglar

<p>Thus, in the code above, the custom sorting logic provided is:
</p>
return this.lastName.compare(that.lastName);

<p>Likewise, to call the sort:
</p>
employees.sort();

<p>For printing the sorted results:
</p>
Console.log(employees.join(", "));

<p>The join method will call the overridden toString method on each individual object, which <a href="/facts/Concatenation/1npYg6rc">concatenates</a> the employee's first and last names.
</p>
<h4>Example: encapsulation by default</h4>
<p>JS++ provides <a href="/facts/Encapsulation_(computer_programming)/kzDnbHPe">encapsulation</a> by default. In the following example, the fields x and y are private by default, even if no access modifier is specified. The methods getX() and getY() are public by default. This enables a more concise class definition syntax, as illustrated in the Point class below:<a class="footnote-ref" id="fnref:15" href="#fn:15"><sup>15</sup></a>
</p>
class Point
{
    int x, y;
 
    Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
 
    int getX() { return this.x; }
    int getY() { return this.y; }
}

<h3>Out-of-bounds analysis</h3>
<p>An out-of-bounds access usually occurs with <a href="/facts/Array_(data_structure)/BKGvF8AM">arrays</a>. For example, when we access the 100th element of a 3-element array, we have an out-of-bounds access:
</p>
int[] arr = [ 1, 2, 3 ];
Console.log(arr[100]); // out-of-bounds access, 'arr' does not have an element at index 100

<p>In <a href="/facts/Java_(programming_language)/9ScgFyAL">Java</a> and <a href="/facts/C_Sharp_(programming_language)/UC2gxeyb">C#</a>, this can result in an exception and program termination. In <a href="/facts/C_(programming_language)/Ky2No763">C</a>, this can result in <a href="/facts/Buffer_overflow/uMFduL4B">buffer overflows</a> or <a href="/facts/Segmentation_fault/MvAqaWzT">segmentation faults</a>. <a href="/facts/C%252B%252B/Et0F2qn9">C++</a> has varying semantics, such as default initialization, exceptions, segmentation faults, or buffer overflows.<a class="footnote-ref" id="fnref:16" href="#fn:16"><sup>16</sup></a><a class="footnote-ref" id="fnref:17" href="#fn:17"><sup>17</sup></a>
</p><p>JS++ can efficiently analyze <a href="/facts/Bounds_checking/vnAjD4Lp">out-of-bounds errors</a> at <a href="/facts/Compile_time/yCdI3oqn">compile time</a>.<a class="footnote-ref" id="fnref:18" href="#fn:18"><sup>18</sup></a><a class="footnote-ref" id="fnref:19" href="#fn:19"><sup>19</sup></a><a class="footnote-ref" id="fnref:20" href="#fn:20"><sup>20</sup></a>
</p><p>JavaScript has the notion of null and undefined values, where null means a value is present but it's an empty value, and undefined means there isn't a value there at all. JS++ extends this intuition further to differentiate between empty values and out-of-bounds accesses.<a class="footnote-ref" id="fnref:21" href="#fn:21"><sup>21</sup></a>
</p><p>Consider the following code, with a nullable int type represented with int?:
</p>
int[] a = [ 1, 2 ];
int? value1 = a[2];
if (value1 == null) {
    Console.log("Definitely out of bounds");
}
 
int?[] b = [ 1, null ];
int? value2 = b[2];
if (value2 == null) {
    Console.log("Might be out of bounds, might just be an access of a null element");
}

<p>While <a href="/facts/Nullable_type/0jI1MoNq">nullable types</a> can represent an out-of-bounds access, it falls apart when the array might contain nullable values as illustrated above. Instead, JS++ introduces an <i>additional</i> concept in addition to null values: undefined values. Recall that JS++ extends the JavaScript notion that null means a value is present but is an empty value, while an undefined value means a value does not exist at all. JS++ uses the concept of "a value does not exist at all" to mean an out-of-bounds access has occurred, and this concept is known in JS++ as "existent types."<a class="footnote-ref" id="fnref:22" href="#fn:22"><sup>22</sup></a>
</p><p>Therefore, the previous example can be amended. The existent type int+ means "int or out of bounds" and int?+ means "int, null, or out of bounds":
</p>
int[] a = [ 1, 2 ];
int? value1 = a[2];
if (value1 == undefined) {
    Console.log("Definitely out of bounds");
}

int?[] b = [ 1, null ];
int?+ value2 = b[2];
if (value2 == undefined) {
    Console.log("Definitely out of bounds");
}

<p>Intuitively, this means existent types cannot be used as the underlying type for array elements. JS++ enforces this at compile time:
</p>
int+[] arr = []; // ERROR

[ ERROR ] JSPPE5204: Existent type `int+' cannot be used as the element type for arrays
<h2 id="development-tools">Development tools</h2>
<h3>Compiler</h3>
<p>The JS++ <a href="/facts/Compiler/WNfCDFJe">compiler</a> is available for <a href="/facts/Windows_(operating_system)/bwhAhuSL">Windows</a>, <a href="/facts/MacOS/Y93vVpTm">macOS</a>, and <a href="/facts/Linux/9FvCKSTq">Linux</a>. It is a <a href="/facts/Source-to-source_compiler/MnSVwoe9">source-to-source compiler</a> which emits JavaScript <a href="/facts/Source_code/o9J6Jv23">source code</a> as an <a href="/facts/Intermediate_representation/s0qRrbfh">intermediate representation</a>.
</p>
<h3>Editor integration</h3>
<p>JS++ integrates with various code editors including <a href="/facts/Visual_Studio_Code/YsBDgKlK">Visual Studio Code</a>, <a href="/facts/Atom_(text_editor)/fHN07lHW">Atom</a>, and <a href="/facts/Sublime_Text/8GzJSGEr">Sublime Text</a>.<a class="footnote-ref" id="fnref:23" href="#fn:23"><sup>23</sup></a><a class="footnote-ref" id="fnref:24" href="#fn:24"><sup>24</sup></a><a class="footnote-ref" id="fnref:25" href="#fn:25"><sup>25</sup></a>
</p>
<h3>Build tools</h3>
<p>JS++ can be integrated with third-party build tools like <a href="/facts/Webpack/XqBk3PQP">Webpack</a>.<a class="footnote-ref" id="fnref:26" href="#fn:26"><sup>26</sup></a>
</p>
<h2 id="release-history">Release history</h2>
<table><tbody><tr><th>Version number</th><th>Release date</th><th>Changes</th></tr><tr><td>0.01</td><td>8 October 2011 (2011-10-08)</td><td>Alpha version, initial release</td></tr><tr><td>0.011</td><td>10 October 2011 (2011-10-10)</td><td>Alpha version</td></tr><tr><td>0.012</td><td>25 October 2011 (2011-10-25)</td><td>Alpha version</td></tr><tr><td>0.013</td><td>29 January 2012 (2012-01-29)</td><td>Alpha version</td></tr><tr><td>0.014.1</td><td>15 August 2012 (2012-08-15)</td><td>Alpha version</td></tr><tr><td>0.4.1</td><td>31 May 2016 (2016-05-31)</td><td>Beta version, array and callback types, character literals, integral suffixes, removed ECMAScript ASI</td></tr><tr><td>0.4.2</td><td>18 October 2016 (2016-10-18)</td><td>Modules, function overloading, dead code elimination, editor integrations</td></tr><tr><td>0.4.2.1</td><td>24 October 2016 (2016-10-24)</td><td>Bug fixes</td></tr><tr><td>0.4.2.2</td><td>17 November 2016 (2016-11-17)</td><td>Source map debugging</td></tr><tr><td>0.4.2.4</td><td>25 December 2016 (2016-12-25)</td><td>Support for Mac OS X, C-style casts, callback and array conversions</td></tr><tr><td>0.5.0</td><td>13 March 2017 (2017-03-13)</td><td>Classes</td></tr><tr><td>0.5.1</td><td>26 March 2017 (2017-03-26)</td><td>'foreach' loops</td></tr><tr><td>0.5.2</td><td>27 July 2017 (2017-07-27)</td><td><a href="/facts/BSD_License/XLtmLp5x">BSD License</a>, Interfaces, Abstract Classes, Virtual Methods, Auto-boxing</td></tr><tr><td>0.7.0</td><td>27 October 2017 (2017-10-27)</td><td>All ECMAScript 3 features via Array<T> and Standard Library</td></tr><tr><td>0.8.0</td><td>15 March 2018 (2018-03-15)</td><td>Generic programming, Dictionary<T>, multi-line strings, .js++ file extension</td></tr><tr><td>0.8.1</td><td>27 March 2018 (2018-03-27)</td><td>auto, catch-all clauses, standard library modules for handling time, bug fixes</td></tr><tr><td>0.8.4</td><td>23 May 2018 (2018-05-23)</td><td>New string functions, advanced generics, bug fixes, standard library expansion</td></tr><tr><td>0.8.5</td><td>2 June 2018 (2018-06-02)</td><td>Bug fixes</td></tr><tr><td>0.8.10</td><td>24 November 2018 (2018-11-24)</td><td>Faster compile times, stacks, queues, <a href="/facts/Unicode/DDu3MfPV">Unicode</a>, <a href="/facts/Base64/xIvVm33q">Base64</a>, generic default constraint rules</td></tr><tr><td>0.9.0</td><td>11 January 2019 (2019-01-11)</td><td>Efficient compile time out-of-bounds error analysis</td></tr><tr><td>0.9.1</td><td>1 July 2019 (2019-07-01)</td><td>Bug fixes</td></tr><tr><td>0.9.2</td><td>18 October 2019 (2019-10-18)</td><td>Final (immutable) variables and default to <a href="/facts/64-bit_computing/AgvkQHkM">64-bit</a> for <a href="/facts/MacOS_Catalina/B2RE5fGd">macOS Catalina</a></td></tr></tbody></table>
<h2 id="see-also">See also</h2>
<ul><li><a href="/facts/TypeScript/A6XNmrTd">TypeScript</a></li>
<li><a href="/facts/PureScript/QMoWGw4y">PureScript</a></li></ul>

<h2 id="references">References</h2>

<ol>
<li id="fn:1"><p>"JavaScript++: New, Powerful Language for Better Web Development". 17 October 2011. Archived from the original on 17 October 2011. <a href="https://web.archive.org/web/20111017221312/http://jspp.javascript.am/" target="_blank">https://web.archive.org/web/20111017221312/http://jspp.javascript.am/</a> <a href="#fnref:1" class="footnote-back-ref">↩</a></p></li>
<li id="fn:2"><p>"C++ et Javascript = Javascript++". La ferme du web. 12 October 2011. Archived from the original on 12 October 2011. <a href="https://web.archive.org/web/20111012143226/http://www.lafermeduweb.net/veille/c-et-javascript-javascript-123284133702156289.html" target="_blank">https://web.archive.org/web/20111012143226/http://www.lafermeduweb.net/veille/c-et-javascript-javascript-123284133702156289.html</a> <a href="#fnref:2" class="footnote-back-ref">↩</a></p></li>
<li id="fn:3"><p>"Index of /downloads". 18 October 2011. Archived from the original on 18 October 2011. <a href="https://web.archive.org/web/20111018172906/http://jspp.javascript.am/downloads/" target="_blank">https://web.archive.org/web/20111018172906/http://jspp.javascript.am/downloads/</a> <a href="#fnref:3" class="footnote-back-ref">↩</a></p></li>
<li id="fn:4"><p>"JavaScript Conference - DeveloperWeek 2016 - February 12–18". 13 February 2016. Archived from the original on 13 February 2016. <a href="https://web.archive.org/web/20160213204925/http://www.developerweek.com/javascript-conference/" target="_blank">https://web.archive.org/web/20160213204925/http://www.developerweek.com/javascript-conference/</a> <a href="#fnref:4" class="footnote-back-ref">↩</a></p></li>
<li id="fn:5"><p>Poon, Roger (May 31, 2016). "JS++ Goes Into Public Beta". Onux.com. <a href="https://www.onux.com/jspp/blog/jspp-goes-into-public-beta/" target="_blank">https://www.onux.com/jspp/blog/jspp-goes-into-public-beta/</a> <a href="#fnref:5" class="footnote-back-ref">↩</a></p></li>
<li id="fn:6"><p>Handy, Alex (June 1, 2016). "Onux seeks to fix JavaScript's lack of type safety". SD Times. <a href="http://sdtimes.com/onux-seeks-fix-javascripts-lack-type-safety/" target="_blank">http://sdtimes.com/onux-seeks-fix-javascripts-lack-type-safety/</a> <a href="#fnref:6" class="footnote-back-ref">↩</a></p></li>
<li id="fn:7"><p>Krill, Paul (June 6, 2016). "New compiler tackles JavaScript's weak typing". InfoWorld. <a href="https://www.infoworld.com/article/3079092/javascript/new-compiler-tackles-javascripts-weak-typing.html" target="_blank">https://www.infoworld.com/article/3079092/javascript/new-compiler-tackles-javascripts-weak-typing.html</a> <a href="#fnref:7" class="footnote-back-ref">↩</a></p></li>
<li id="fn:8"><p>Cimpanu, Catalin (June 9, 2016). "jQuery 3.0 Released and Other JavaScript News". Softpedia. <a href="https://news.softpedia.com/news/jquery-3-0-released-and-other-javascript-news-505064.shtml" target="_blank">https://news.softpedia.com/news/jquery-3-0-released-and-other-javascript-news-505064.shtml</a> <a href="#fnref:8" class="footnote-back-ref">↩</a></p></li>
<li id="fn:9"><p>"The JS++ Type System, Appendix B: Problems (Why was this hard to solve?)". Retrieved 10 February 2020. <a href="https://www.onux.com/jspp/tutorials/type-system#Appendix-B" target="_blank">https://www.onux.com/jspp/tutorials/type-system#Appendix-B</a> <a href="#fnref:9" class="footnote-back-ref">↩</a></p></li>
<li id="fn:10"><p>US patent 10296313, Roger Poon, "Safely consuming dynamically-typed code from a statically-typed programming language", published 2019-05-21
 <a href="http://patft1.uspto.gov/netacgi/nph-Parser?patentnumber=10296313" target="_blank">http://patft1.uspto.gov/netacgi/nph-Parser?patentnumber=10296313</a> <a href="#fnref:10" class="footnote-back-ref">↩</a></p></li>
<li id="fn:11"><p>Bridgwater, Adrian (June 13, 2016). "Onux JS++, an answer to JavaScript 'brittle' type safety?". Computer Weekly. Archived from the original on 2016-07-22. <a href="https://web.archive.org/web/20160722151154/http://www.computerweekly.com/blog/Open-Source-Insider/Onux-JS-an-answer-to-JavaScript-brittle-type-safety" target="_blank">https://web.archive.org/web/20160722151154/http://www.computerweekly.com/blog/Open-Source-Insider/Onux-JS-an-answer-to-JavaScript-brittle-type-safety</a> <a href="#fnref:11" class="footnote-back-ref">↩</a></p></li>
<li id="fn:12"><p>"The JS++ Type System". Onux.com. <a href="https://www.onux.com/jspp/tutorials/type-system" target="_blank">https://www.onux.com/jspp/tutorials/type-system</a> <a href="#fnref:12" class="footnote-back-ref">↩</a></p></li>
<li id="fn:13"><p>"Classes". MDN Web Docs. Retrieved 2025-06-20. <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes" target="_blank">https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes</a> <a href="#fnref:13" class="footnote-back-ref">↩</a></p></li>
<li id="fn:14"><p>Poon, Roger (May 28, 2019). "Tips & Tricks: Object-oriented Sorting in JS++ with IComparable<T>". Retrieved June 20, 2025. <a href="https://www.onux.com/jspp/blog/tips-tricks-object-oriented-sorting-in-jspp-with-icomparable-t/" target="_blank">https://www.onux.com/jspp/blog/tips-tricks-object-oriented-sorting-in-jspp-with-icomparable-t/</a> <a href="#fnref:14" class="footnote-back-ref">↩</a></p></li>
<li id="fn:15"><p>Poon, Roger (June 10, 2018). "Tips & Tricks: Only Fields are 'private' by Default". Retrieved June 20, 2025. <a href="https://www.onux.com/jspp/blog/tips-tricks-only-fields-are-private-by-default/" target="_blank">https://www.onux.com/jspp/blog/tips-tricks-only-fields-are-private-by-default/</a> <a href="#fnref:15" class="footnote-back-ref">↩</a></p></li>
<li id="fn:16"><p>"std::unordered_map<Key,T,Hash,KeyEqual,Allocator>::operator[] - cppreference.com". en.cppreference.com. Retrieved June 20, 2025. <a href="https://en.cppreference.com/w/cpp/container/unordered_map/operator_at.html" target="_blank">https://en.cppreference.com/w/cpp/container/unordered_map/operator_at.html</a> <a href="#fnref:16" class="footnote-back-ref">↩</a></p></li>
<li id="fn:17"><p>"std::unordered_map<Key,T,Hash,KeyEqual,Allocator>::at - cppreference.com". en.cppreference.com. Retrieved June 20, 2025. <a href="https://en.cppreference.com/w/cpp/container/unordered_map/at.html" target="_blank">https://en.cppreference.com/w/cpp/container/unordered_map/at.html</a> <a href="#fnref:17" class="footnote-back-ref">↩</a></p></li>
<li id="fn:18"><p>Díaz, Fabio (January 23, 2019). "JS++, the JavaScript superset, is getting rid of out-of-bounds errors". Akuaroworld. <a href="https://www.akuaroworld.com/js-the-javascript-superset-is-getting-rid-of-out-of-bounds-errors/" target="_blank">https://www.akuaroworld.com/js-the-javascript-superset-is-getting-rid-of-out-of-bounds-errors/</a> <a href="#fnref:18" class="footnote-back-ref">↩</a></p></li>
<li id="fn:19"><p>Cardoza, Christina (January 16, 2019). "JS++ programming language looks to solve out-of-bounds errors". SD Times. <a href="https://sdtimes.com/softwaredev/js-programming-language-looks-to-solve-out-of-bounds-errors/" target="_blank">https://sdtimes.com/softwaredev/js-programming-language-looks-to-solve-out-of-bounds-errors/</a> <a href="#fnref:19" class="footnote-back-ref">↩</a></p></li>
<li id="fn:20"><p>Poon, Roger (January 11, 2019). "JS++ 0.9.0: Efficient Compile Time Analysis of Out-of-Bounds Errors". Onux.com. <a href="https://www.onux.com/jspp/blog/jspp-0-9-0-efficient-compile-time-analysis-of-out-of-bounds-errors/" target="_blank">https://www.onux.com/jspp/blog/jspp-0-9-0-efficient-compile-time-analysis-of-out-of-bounds-errors/</a> <a href="#fnref:20" class="footnote-back-ref">↩</a></p></li>
<li id="fn:21"><p>Poon, Roger (January 11, 2019). "JS++ 0.9.0: Efficient Compile Time Analysis of Out-of-Bounds Errors". Onux.com. <a href="https://www.onux.com/jspp/blog/jspp-0-9-0-efficient-compile-time-analysis-of-out-of-bounds-errors/" target="_blank">https://www.onux.com/jspp/blog/jspp-0-9-0-efficient-compile-time-analysis-of-out-of-bounds-errors/</a> <a href="#fnref:21" class="footnote-back-ref">↩</a></p></li>
<li id="fn:22"><p>Poon, Roger (January 11, 2019). "JS++ 0.9.0: Efficient Compile Time Analysis of Out-of-Bounds Errors". Onux.com. <a href="https://www.onux.com/jspp/blog/jspp-0-9-0-efficient-compile-time-analysis-of-out-of-bounds-errors/" target="_blank">https://www.onux.com/jspp/blog/jspp-0-9-0-efficient-compile-time-analysis-of-out-of-bounds-errors/</a> <a href="#fnref:22" class="footnote-back-ref">↩</a></p></li>
<li id="fn:23"><p>"JavaScript superset JS++ adds dead code elimination and more". Computerworld. October 19, 2016. <a href="http://www.computerworld.com/article/3132920/application-development/javascript-superset-js-adds-dead-code-elimination-and-more.html" target="_blank">http://www.computerworld.com/article/3132920/application-development/javascript-superset-js-adds-dead-code-elimination-and-more.html</a> <a href="#fnref:23" class="footnote-back-ref">↩</a></p></li>
<li id="fn:24"><p>Cardoza, Christina (October 19, 2016). "JS++ 0.4.2 released with code editor integrations, modules and dead code elimination". SD Times. <a href="http://sdtimes.com/js-0-4-2-released-code-editor-integrations-modules-dead-code-elimination/" target="_blank">http://sdtimes.com/js-0-4-2-released-code-editor-integrations-modules-dead-code-elimination/</a> <a href="#fnref:24" class="footnote-back-ref">↩</a></p></li>
<li id="fn:25"><p>Clark, Geneva (October 20, 2016). "JS++ 0.4.2 Release - Upgraded With Modular Design, Dead Code Elimination, and Multiple Code Editors". Zeomag. <a href="https://www.zeolearn.com/magazine/jspp-0.4.2-release-with-upgrades" target="_blank">https://www.zeolearn.com/magazine/jspp-0.4.2-release-with-upgrades</a> <a href="#fnref:25" class="footnote-back-ref">↩</a></p></li>
<li id="fn:26"><p>Phoenix, Ingwie (7 December 2018). "Proof of Concept: Using JS++ with WebPack". GitHub. Ingwie Phoenix. <a href="https://github.com/IngwiePhoenix/jspp-webpack-poc" target="_blank">https://github.com/IngwiePhoenix/jspp-webpack-poc</a> <a href="#fnref:26" class="footnote-back-ref">↩</a></p></li>
</ol>

JS++ open-in-new

JS++