Turing speed - Revision history

JaroslavTulach: /* One VM to Rule them All! */

JaroslavTulach — Thu, 15 Mar 2018 11:32:31 GMT

One VM to Rule them All!

←Older revision		Revision as of 11:32, 15 March 2018
Line 13:		Line 13:
	As far as I can tell we are on the right track, as our [[Ruby]] implementation is [[RubySpeed\|ten times faster than any other]] implementation. Other [[language]] implementations ([[FastR]], [[Python]], etc.) are on par with such speed.		As far as I can tell we are on the right track, as our [[Ruby]] implementation is [[RubySpeed\|ten times faster than any other]] implementation. Other [[language]] implementations ([[FastR]], [[Python]], etc.) are on par with such speed.

-	Default [[R]] is probably slower than [[Python]] when it comes to [[Turing speed]], but with [[OracleLabs]]’ [[GraalVM]]it is no longer true - both the [[language]]s become as fast as native code can be!	+	Default [[R]] is probably slower than [[Python]] when it comes to [[Turing speed]], but with [[OracleLabs]]’ [[GraalVM]] it is no longer true - both the [[language]]s become as fast as native code can be!

JaroslavTulach: /* One VM to Rule them All! */

JaroslavTulach — Fri, 09 Mar 2018 08:07:05 GMT

One VM to Rule them All!

←Older revision		Revision as of 08:07, 9 March 2018
Line 9:		Line 9:
	== One VM to Rule them All! ==		== One VM to Rule them All! ==

-	In addition to that I am helping with ~~OracleLabs’~~ Graal/Truffle project ~~(https://graalvm.github.io)~~ that aims to implement the fastest virtual machine on the Planet. The project offers various ~~languages~~ with boosted performance: Ruby, R, Python, JavaScript, etc. with the vision to make them all really fast from the point of Turing speed.	+	In addition to that I am helping with [[OracleLabs]]’ Graal/[[Truffle]] project that aims to implement the fastest virtual machine on the Planet. The project offers implementations of various [[language]]s with boosted performance: [[Ruby]], [[R]], [[Python]], [[JavaScript]], etc. with the vision to make them all really fast from the point of [[Turing speed]].

-	As far as I can tell we are on the right track, as our Ruby implementation is ten times faster than any other implementation. Other ~~languages~~ are on par with it.	+	As far as I can tell we are on the right track, as our [[Ruby]] implementation is [[RubySpeed\|ten times faster than any other]] implementation. Other [[language]] implementations ([[FastR]], [[Python]], etc.) are on par with such speed.
-	Default R is probably slower than Python when it comes to Turing speed, but with ~~OracleLabs’~~ GraalVM ~~(http://www.oracle.com/technetwork/oracle-labs/program-languages/overview/index.html)~~ it is no longer true - both the ~~languages~~ become as fast as native can be!	+
		+	Default [[R]] is probably slower than [[Python]] when it comes to [[Turing speed]], but with [[OracleLabs]]’ [[GraalVM]]it is no longer true - both the [[language]]s become as fast as native code can be!

JaroslavTulach: /* The Real Speed */

JaroslavTulach — Fri, 09 Mar 2018 08:03:27 GMT

The Real Speed

←Older revision		Revision as of 08:03, 9 March 2018
Line 5:		Line 5:
	On the other hand, each programming language shall be [[Turing complete]] (e.g. support general programming with '''if''', '''while''', '''for''' statements). Thus I propose to compare speed of [[language]]s on so called [[Turing speed]]: ''measure how fast the [[language]] can be when performing a generic computation'' (preferably without any intrinsic built-ins).		On the other hand, each programming language shall be [[Turing complete]] (e.g. support general programming with '''if''', '''while''', '''for''' statements). Thus I propose to compare speed of [[language]]s on so called [[Turing speed]]: ''measure how fast the [[language]] can be when performing a generic computation'' (preferably without any intrinsic built-ins).

-	I am running such experiment with my [[polyglot]] [[Sieve of Eratosthenes]~~] [https://github.com/jtulach/sieve/ project~~] - I am trying to implement simple, long running algorithm in many different ~~languages~~ and compare their speed. See my ~~sieve project (~~https://github.com/jtulach/sieve/) for the actual results.	+	I am running such experiment with my [[polyglot]] [[Sieve of Eratosthenes]] - I am trying to implement simple, long running algorithm in many different [[language]]s and compare their speed. See my [https://github.com/jtulach/sieve/ sieve project] for the actual results.
		+
		+	== One VM to Rule them All! ==
		+
	In addition to that I am helping with OracleLabs’ Graal/Truffle project (https://graalvm.github.io) that aims to implement the fastest virtual machine on the Planet. The project offers various languages with boosted performance: Ruby, R, Python, JavaScript, etc. with the vision to make them all really fast from the point of Turing speed.		In addition to that I am helping with OracleLabs’ Graal/Truffle project (https://graalvm.github.io) that aims to implement the fastest virtual machine on the Planet. The project offers various languages with boosted performance: Ruby, R, Python, JavaScript, etc. with the vision to make them all really fast from the point of Turing speed.

	As far as I can tell we are on the right track, as our Ruby implementation is ten times faster than any other implementation. Other languages are on par with it.		As far as I can tell we are on the right track, as our Ruby implementation is ten times faster than any other implementation. Other languages are on par with it.
	Default R is probably slower than Python when it comes to Turing speed, but with OracleLabs’ GraalVM (http://www.oracle.com/technetwork/oracle-labs/program-languages/overview/index.html) it is no longer true - both the languages become as fast as native can be!		Default R is probably slower than Python when it comes to Turing speed, but with OracleLabs’ GraalVM (http://www.oracle.com/technetwork/oracle-labs/program-languages/overview/index.html) it is no longer true - both the languages become as fast as native can be!

JaroslavTulach: /* The Real Speed */

JaroslavTulach — Fri, 09 Mar 2018 08:02:11 GMT

The Real Speed

←Older revision		Revision as of 08:02, 9 March 2018
Line 3:		Line 3:
	== The Real Speed ==		== The Real Speed ==

-	On the other hand, each programming language shall be [[Turing complete]] (e.g. support general programming with if, while, for statements). Thus I propose to compare speed of ~~languages~~ on so called [[Turing speed]]: ''measure how fast the [[language]] is when performing generic computation'' (preferably without any intrinsic built-ins).	+	On the other hand, each programming language shall be [[Turing complete]] (e.g. support general programming with '''if''', '''while''', '''for''' statements). Thus I propose to compare speed of [[language]]s on so called [[Turing speed]]: ''measure how fast the [[language]] can be when performing a generic computation'' (preferably without any intrinsic built-ins).

-	I am running such experiment with my polyglot ~~sieve~~ of Eratosthenes (https://github.com/jtulach/sieve/) - I am trying to implement simple, long running algorithm in many different languages and compare their speed. See my sieve project (https://github.com/jtulach/sieve/) for the actual results.	+	I am running such experiment with my [[polyglot]] [[Sieve of Eratosthenes]] [https://github.com/jtulach/sieve/ project] - I am trying to implement simple, long running algorithm in many different languages and compare their speed. See my sieve project (https://github.com/jtulach/sieve/) for the actual results.
	In addition to that I am helping with OracleLabs’ Graal/Truffle project (https://graalvm.github.io) that aims to implement the fastest virtual machine on the Planet. The project offers various languages with boosted performance: Ruby, R, Python, JavaScript, etc. with the vision to make them all really fast from the point of Turing speed.		In addition to that I am helping with OracleLabs’ Graal/Truffle project (https://graalvm.github.io) that aims to implement the fastest virtual machine on the Planet. The project offers various languages with boosted performance: Ruby, R, Python, JavaScript, etc. with the vision to make them all really fast from the point of Turing speed.

	As far as I can tell we are on the right track, as our Ruby implementation is ten times faster than any other implementation. Other languages are on par with it.		As far as I can tell we are on the right track, as our Ruby implementation is ten times faster than any other implementation. Other languages are on par with it.
	Default R is probably slower than Python when it comes to Turing speed, but with OracleLabs’ GraalVM (http://www.oracle.com/technetwork/oracle-labs/program-languages/overview/index.html) it is no longer true - both the languages become as fast as native can be!		Default R is probably slower than Python when it comes to Turing speed, but with OracleLabs’ GraalVM (http://www.oracle.com/technetwork/oracle-labs/program-languages/overview/index.html) it is no longer true - both the languages become as fast as native can be!

JaroslavTulach at 08:00, 9 March 2018

JaroslavTulach — Fri, 09 Mar 2018 08:00:14 GMT

←Older revision		Revision as of 08:00, 9 March 2018
Line 1:		Line 1:
-	Measuring speed of a [[language]] is a biased task. Every language comes with certain built-ins suitable for tasks the language is optimized for. Authors of the language usually spend enormous amount of time to optimize these parts and thus comparing languages on their (different) built-ins makes little sense.	+	Measuring speed of a [[language]] is a biased task. Every language comes with certain built-ins suitable for tasks the [[language]] is optimized for. Authors of the [[language]] usually spend enormous amount of time to optimize these parts and thus comparing languages on their (different) built-ins makes little sense.

	== The Real Speed ==		== The Real Speed ==

JaroslavTulach at 07:54, 9 March 2018

JaroslavTulach — Fri, 09 Mar 2018 07:54:50 GMT

←Older revision		Revision as of 07:54, 9 March 2018
Line 1:		Line 1:
	Measuring speed of a [[language]] is a biased task. Every language comes with certain built-ins suitable for tasks the language is optimized for. Authors of the language usually spend enormous amount of time to optimize these parts and thus comparing languages on their (different) built-ins makes little sense.		Measuring speed of a [[language]] is a biased task. Every language comes with certain built-ins suitable for tasks the language is optimized for. Authors of the language usually spend enormous amount of time to optimize these parts and thus comparing languages on their (different) built-ins makes little sense.

		+	== The Real Speed ==

	On the other hand, each programming language shall be [[Turing complete]] (e.g. support general programming with if, while, for statements). Thus I propose to compare speed of languages on so called [[Turing speed]]: ''measure how fast the [[language]] is when performing generic computation'' (preferably without any intrinsic built-ins).		On the other hand, each programming language shall be [[Turing complete]] (e.g. support general programming with if, while, for statements). Thus I propose to compare speed of languages on so called [[Turing speed]]: ''measure how fast the [[language]] is when performing generic computation'' (preferably without any intrinsic built-ins).

JaroslavTulach at 07:47, 9 March 2018

JaroslavTulach — Fri, 09 Mar 2018 07:47:51 GMT

←Older revision		Revision as of 07:47, 9 March 2018
Line 1:		Line 1:
-	Measuring speed of a language is a biased task. Every language comes with certain built-ins suitable for tasks the language is optimized for. Authors of the language usually spend enormous amount of time to optimize these parts and thus comparing languages on their (different) built-ins makes little sense.	+	Measuring speed of a [[language]] is a biased task. Every language comes with certain built-ins suitable for tasks the language is optimized for. Authors of the language usually spend enormous amount of time to optimize these parts and thus comparing languages on their (different) built-ins makes little sense.

-	On the other hand, each programming language shall be Turing complete (e.g. support general programming with if, while, for statements). Thus I propose to compare speed of languages on so called [[Turing speed]]: measure how fast it is when performing generic computation (preferably without any intrinsic built-ins).	+
		+	On the other hand, each programming language shall be [[Turing complete]] (e.g. support general programming with if, while, for statements). Thus I propose to compare speed of languages on so called [[Turing speed]]: ''measure how fast the [[language]] is when performing generic computation'' (preferably without any intrinsic built-ins).

	I am running such experiment with my polyglot sieve of Eratosthenes (https://github.com/jtulach/sieve/) - I am trying to implement simple, long running algorithm in many different languages and compare their speed. See my sieve project (https://github.com/jtulach/sieve/) for the actual results.		I am running such experiment with my polyglot sieve of Eratosthenes (https://github.com/jtulach/sieve/) - I am trying to implement simple, long running algorithm in many different languages and compare their speed. See my sieve project (https://github.com/jtulach/sieve/) for the actual results.

JaroslavTulach at 06:59, 9 March 2018

JaroslavTulach — Fri, 09 Mar 2018 06:59:36 GMT

←Older revision		Revision as of 06:59, 9 March 2018
Line 1:		Line 1:
	Measuring speed of a language is a biased task. Every language comes with certain built-ins suitable for tasks the language is optimized for. Authors of the language usually spend enormous amount of time to optimize these parts and thus comparing languages on their (different) built-ins makes little sense.		Measuring speed of a language is a biased task. Every language comes with certain built-ins suitable for tasks the language is optimized for. Authors of the language usually spend enormous amount of time to optimize these parts and thus comparing languages on their (different) built-ins makes little sense.

-	On the other hand, each programming language shall be Turing complete (e.g. support general programming with if, while, for ~~statement~~). Thus I propose to compare speed of languages on so called Turing speed: measure how fast it is when performing generic computation (preferably without any intrinsic built-ins).	+	On the other hand, each programming language shall be Turing complete (e.g. support general programming with if, while, for statements). Thus I propose to compare speed of languages on so called [[Turing speed]]: measure how fast it is when performing generic computation (preferably without any intrinsic built-ins).

	I am running such experiment with my polyglot sieve of Eratosthenes (https://github.com/jtulach/sieve/) - I am trying to implement simple, long running algorithm in many different languages and compare their speed. See my sieve project (https://github.com/jtulach/sieve/) for the actual results.		I am running such experiment with my polyglot sieve of Eratosthenes (https://github.com/jtulach/sieve/) - I am trying to implement simple, long running algorithm in many different languages and compare their speed. See my sieve project (https://github.com/jtulach/sieve/) for the actual results.

JaroslavTulach: New page: Measuring speed of a language is a biased task. Every language comes with certain built-ins suitable for tasks the language is optimized for. Authors of the language usually spend enormous...

JaroslavTulach — Fri, 09 Mar 2018 06:57:48 GMT

New page: Measuring speed of a language is a biased task. Every language comes with certain built-ins suitable for tasks the language is optimized for. Authors of the language usually spend enormous...

New page

Measuring speed of a language is a biased task. Every language comes with certain built-ins suitable for tasks the language is optimized for. Authors of the language usually spend enormous amount of time to optimize these parts and thus comparing languages on their (different) built-ins makes little sense.

On the other hand, each programming language shall be Turing complete (e.g. support general programming with **if**, **while, for **statement). Thus I propose to compare speed of languages on so called Turing speed: measure how fast it is when performing generic computation (preferably without any intrinsic built-ins).

I am running such experiment with my polyglot sieve of Eratosthenes (https://github.com/jtulach/sieve/) - I am trying to implement simple, long running algorithm in many different languages and compare their speed. See my sieve project (https://github.com/jtulach/sieve/) for the actual results.
In addition to that I am helping with OracleLabs’ Graal/Truffle project (https://graalvm.github.io) that aims to implement the fastest virtual machine on the Planet. The project offers various languages with boosted performance: **Ruby**, **R**, **Python**, **JavaScript**, etc. with the vision to make them all really fast from the point of Turing speed.

As far as I can tell we are on the right track, as our **Ruby** implementation is ten times faster than any other implementation. Other languages are on par with it.
Default R is probably slower than Python when it comes to Turing speed, but with OracleLabs’ GraalVM (http://www.oracle.com/technetwork/oracle-labs/program-languages/overview/index.html) it is no longer true - both the languages become as fast as native can be!