Performance - Revision history

Hzwakenberg: Alioth link no longer in existence, removed corresponding paragraph

2022-01-03T12:43:56Z

Alioth link no longer in existence, removed corresponding paragraph

← Older revision		Revision as of 14:43, 3 January 2022
Line 13:		Line 13:

	Good luck to anyone who wants to understand this program in the ''dc'' language, reuse it, improve it or anything else! For the curious, you can run ''dc'' on any UNIX-like system and paste this code; it will print the prime number decomposition of the first value, which is 1000 here. How can you know the principles used here? Does the algorithm search from 2 each time? Does the program stop when the square root has been reached?		Good luck to anyone who wants to understand this program in the ''dc'' language, reuse it, improve it or anything else! For the curious, you can run ''dc'' on any UNIX-like system and paste this code; it will print the prime number decomposition of the first value, which is 1000 here. How can you know the principles used here? Does the algorithm search from 2 each time? Does the program stop when the square root has been reached?
−
−	Now, back to the performance aspect, you can see how Liberty Eiffel behaves on [http://shootout.alioth.debian.org/benchmark.php?test=all&lang=all&calc=Calculate&xfullcpu=1&xmem=1&xloc=&ackermann=1&binarytrees=5&chameneos=5&message=4&fannkuch=3&fasta=3&harmonic=1&knucleotide=5&mandelbrot=4&nbody=3&nsieve=3&nsievebits=2&pidigits=2&random=1&regexdna=4&revcomp=3&spectralnorm=5&hello=0&sumcol=1&takfp=1&tcprequest=4 this site] (where code lines count are ignored because it is not a relevant design aspect, as shown above).
−
−	NOTE: currently alioth.debian.org does not publish any data<br>pertaining to any Eiffel compiler. Perhaps we could take the<br>old SE code, improve on it where possible and re-submit..? /HZ

	Liberty Eiffel generates highly efficient code, doesn't it? In fact, we have many ideas for improving generated code. This means you can choose Liberty Eiffel now and expect your code to run even faster under future releases of the compiler!		Liberty Eiffel generates highly efficient code, doesn't it? In fact, we have many ideas for improving generated code. This means you can choose Liberty Eiffel now and expect your code to run even faster under future releases of the compiler!

−	The main areas for improvement are ~~generated~~ code for dynamic linking, flow analysis and garbage collector. Of course, these projects will be much helped if they were funded!	+	The main areas for improvement are generating code for dynamic linking, flow analysis and garbage collector. Of course, these projects will be much helped if they were funded!

Hzwakenberg: /* Very High Performance Programs */

2018-10-09T17:26:12Z

Very High Performance Programs

← Older revision		Revision as of 19:26, 9 October 2018
Line 4:		Line 4:
	Eiffel is a beautiful method and language, based on strong and elegant principles. But, what interest (except intellectual pleasure) would you have in using a wonderful language with poor performance for writing your programs?		Eiffel is a beautiful method and language, based on strong and elegant principles. But, what interest (except intellectual pleasure) would you have in using a wonderful language with poor performance for writing your programs?

−	~~Hopefully~~, Eiffel has been designed with performance in mind. Furthermore, the Liberty Eiffel compiler and the associated libraries are expressly designed to combine performance with expressivity.	+	Luckily, Eiffel has been designed with performance in mind. Furthermore, the Liberty Eiffel compiler in particular and the associated libraries are expressly designed to combine performance with expressivity.

	In the Eiffel language, expressivity is in the power of concepts. For example multiple inheritance and genericity are very powerful concepts, as are static type and dynamic type. This means that properly designed programs will be made with small code, this is '''global code compactness'''. On the other hand, there is '''no local code compactness'''. The Eiffel spirit is to make your code as legible as possible, because it is written once but is read many, many times (code is designed for change and reuse). So there is no point in using many unreadable abbreviations or symbols in order to save some keystrokes. Of course Eiffel code with its standard formatting rules needs many lines where other languages only need one line. The purpose is to achieve '''legibility''' because that is a prerequisite for code maintenance and reuse.		In the Eiffel language, expressivity is in the power of concepts. For example multiple inheritance and genericity are very powerful concepts, as are static type and dynamic type. This means that properly designed programs will be made with small code, this is '''global code compactness'''. On the other hand, there is '''no local code compactness'''. The Eiffel spirit is to make your code as legible as possible, because it is written once but is read many, many times (code is designed for change and reuse). So there is no point in using many unreadable abbreviations or symbols in order to save some keystrokes. Of course Eiffel code with its standard formatting rules needs many lines where other languages only need one line. The purpose is to achieve '''legibility''' because that is a prerequisite for code maintenance and reuse.

Dkearns: s/LibertyEiffel/Liberty Eiffel/

2016-07-02T10:05:55Z

s/LibertyEiffel/Liberty Eiffel/

← Older revision		Revision as of 12:05, 2 July 2016
Line 4:		Line 4:
	Eiffel is a beautiful method and language, based on strong and elegant principles. But, what interest (except intellectual pleasure) would you have in using a wonderful language with poor performance for writing your programs?		Eiffel is a beautiful method and language, based on strong and elegant principles. But, what interest (except intellectual pleasure) would you have in using a wonderful language with poor performance for writing your programs?

−	Hopefully, Eiffel has been designed with performance in mind. Furthermore, the ~~LibertyEiffel~~ compiler and the associated libraries are expressly designed to combine performance with expressivity.	+	Hopefully, Eiffel has been designed with performance in mind. Furthermore, the Liberty Eiffel compiler and the associated libraries are expressly designed to combine performance with expressivity.

	In the Eiffel language, expressivity is in the power of concepts. For example multiple inheritance and genericity are very powerful concepts, as are static type and dynamic type. This means that properly designed programs will be made with small code, this is '''global code compactness'''. On the other hand, there is '''no local code compactness'''. The Eiffel spirit is to make your code as legible as possible, because it is written once but is read many, many times (code is designed for change and reuse). So there is no point in using many unreadable abbreviations or symbols in order to save some keystrokes. Of course Eiffel code with its standard formatting rules needs many lines where other languages only need one line. The purpose is to achieve '''legibility''' because that is a prerequisite for code maintenance and reuse.		In the Eiffel language, expressivity is in the power of concepts. For example multiple inheritance and genericity are very powerful concepts, as are static type and dynamic type. This means that properly designed programs will be made with small code, this is '''global code compactness'''. On the other hand, there is '''no local code compactness'''. The Eiffel spirit is to make your code as legible as possible, because it is written once but is read many, many times (code is designed for change and reuse). So there is no point in using many unreadable abbreviations or symbols in order to save some keystrokes. Of course Eiffel code with its standard formatting rules needs many lines where other languages only need one line. The purpose is to achieve '''legibility''' because that is a prerequisite for code maintenance and reuse.
Line 14:		Line 14:
	Good luck to anyone who wants to understand this program in the ''dc'' language, reuse it, improve it or anything else! For the curious, you can run ''dc'' on any UNIX-like system and paste this code; it will print the prime number decomposition of the first value, which is 1000 here. How can you know the principles used here? Does the algorithm search from 2 each time? Does the program stop when the square root has been reached?		Good luck to anyone who wants to understand this program in the ''dc'' language, reuse it, improve it or anything else! For the curious, you can run ''dc'' on any UNIX-like system and paste this code; it will print the prime number decomposition of the first value, which is 1000 here. How can you know the principles used here? Does the algorithm search from 2 each time? Does the program stop when the square root has been reached?

−	Now, back to the performance aspect, you can see how ~~LibertyEiffel~~ behaves on [http://shootout.alioth.debian.org/benchmark.php?test=all&lang=all&calc=Calculate&xfullcpu=1&xmem=1&xloc=&ackermann=1&binarytrees=5&chameneos=5&message=4&fannkuch=3&fasta=3&harmonic=1&knucleotide=5&mandelbrot=4&nbody=3&nsieve=3&nsievebits=2&pidigits=2&random=1&regexdna=4&revcomp=3&spectralnorm=5&hello=0&sumcol=1&takfp=1&tcprequest=4 this site] (where code lines count are ignored because it is not a relevant design aspect, as shown above).	+	Now, back to the performance aspect, you can see how Liberty Eiffel behaves on [http://shootout.alioth.debian.org/benchmark.php?test=all&lang=all&calc=Calculate&xfullcpu=1&xmem=1&xloc=&ackermann=1&binarytrees=5&chameneos=5&message=4&fannkuch=3&fasta=3&harmonic=1&knucleotide=5&mandelbrot=4&nbody=3&nsieve=3&nsievebits=2&pidigits=2&random=1&regexdna=4&revcomp=3&spectralnorm=5&hello=0&sumcol=1&takfp=1&tcprequest=4 this site] (where code lines count are ignored because it is not a relevant design aspect, as shown above).

	NOTE: currently alioth.debian.org does not publish any data<br>pertaining to any Eiffel compiler. Perhaps we could take the<br>old SE code, improve on it where possible and re-submit..? /HZ		NOTE: currently alioth.debian.org does not publish any data<br>pertaining to any Eiffel compiler. Perhaps we could take the<br>old SE code, improve on it where possible and re-submit..? /HZ

−	~~LibertyEiffel~~ generates highly efficient code, doesn't it? In fact, we have many ideas for improving generated code. This means you can choose ~~LibertyEiffel~~ now and expect your code to run even faster under future releases of the compiler!	+	Liberty Eiffel generates highly efficient code, doesn't it? In fact, we have many ideas for improving generated code. This means you can choose Liberty Eiffel now and expect your code to run even faster under future releases of the compiler!

	The main areas for improvement are generated code for dynamic linking, flow analysis and garbage collector. Of course, these projects will be much helped if they were funded!		The main areas for improvement are generated code for dynamic linking, flow analysis and garbage collector. Of course, these projects will be much helped if they were funded!

Hzwakenberg: /* Very High Performance Programs */

2014-09-07T13:50:33Z

Very High Performance Programs

← Older revision		Revision as of 15:50, 7 September 2014
Line 20:		Line 20:
	LibertyEiffel generates highly efficient code, doesn't it? In fact, we have many ideas for improving generated code. This means you can choose LibertyEiffel now and expect your code to run even faster under future releases of the compiler!		LibertyEiffel generates highly efficient code, doesn't it? In fact, we have many ideas for improving generated code. This means you can choose LibertyEiffel now and expect your code to run even faster under future releases of the compiler!

−	The main areas for improvement are generated code for dynamic linking, flow analysis and garbage collector. Of course, these projects will be much helped if they ~~are~~ ~~[[Donations\|~~funded]]!	+	The main areas for improvement are generated code for dynamic linking, flow analysis and garbage collector. Of course, these projects will be much helped if they were funded!

Hzwakenberg: /* Very High Performance Programs */

2014-09-07T13:49:06Z

Very High Performance Programs

← Older revision		Revision as of 15:49, 7 September 2014
Line 1:		Line 1:
		+	[[Category: Performance]]
	==Very High Performance Programs==		==Very High Performance Programs==

	Eiffel is a beautiful method and language, based on strong and elegant principles. But, what interest (except intellectual pleasure) would you have in using a wonderful language with poor performance for writing your programs?		Eiffel is a beautiful method and language, based on strong and elegant principles. But, what interest (except intellectual pleasure) would you have in using a wonderful language with poor performance for writing your programs?

−	Hopefully, Eiffel has been designed with performance in mind. Furthermore, the LibertyEiffel compiler and the associated libraries are expressly designed to ~~associate~~ performance ~~and~~ expressivity.	+	Hopefully, Eiffel has been designed with performance in mind. Furthermore, the LibertyEiffel compiler and the associated libraries are expressly designed to combine performance with expressivity.

−	In Eiffel language, expressivity is in the power of concepts. For example multiple inheritance and genericity are very powerful concepts, as are static type and dynamic type. This means that properly designed programs will be made with small code, this is '''global code compactness'''. On the other hand, there is '''no local code compactness'''. The Eiffel spirit is to make your code as legible as possible, because it is written once but is read many, many times (code is designed for change and reuse). So there is no point in using many unreadable abbreviations or symbols in order to save some keystrokes. Of course Eiffel code with its standard formatting rules needs many lines where other languages only need one line. The purpose is to achieve '''legibility''' because that is a prerequisite for code maintenance and reuse.	+	In the Eiffel language, expressivity is in the power of concepts. For example multiple inheritance and genericity are very powerful concepts, as are static type and dynamic type. This means that properly designed programs will be made with small code, this is '''global code compactness'''. On the other hand, there is '''no local code compactness'''. The Eiffel spirit is to make your code as legible as possible, because it is written once but is read many, many times (code is designed for change and reuse). So there is no point in using many unreadable abbreviations or symbols in order to save some keystrokes. Of course Eiffel code with its standard formatting rules needs many lines where other languages only need one line. The purpose is to achieve '''legibility''' because that is a prerequisite for code maintenance and reuse.

	To convince you, I'll just give one example:		To convince you, I'll just give one example:
Line 14:		Line 15:

	Now, back to the performance aspect, you can see how LibertyEiffel behaves on [http://shootout.alioth.debian.org/benchmark.php?test=all&lang=all&calc=Calculate&xfullcpu=1&xmem=1&xloc=&ackermann=1&binarytrees=5&chameneos=5&message=4&fannkuch=3&fasta=3&harmonic=1&knucleotide=5&mandelbrot=4&nbody=3&nsieve=3&nsievebits=2&pidigits=2&random=1&regexdna=4&revcomp=3&spectralnorm=5&hello=0&sumcol=1&takfp=1&tcprequest=4 this site] (where code lines count are ignored because it is not a relevant design aspect, as shown above).		Now, back to the performance aspect, you can see how LibertyEiffel behaves on [http://shootout.alioth.debian.org/benchmark.php?test=all&lang=all&calc=Calculate&xfullcpu=1&xmem=1&xloc=&ackermann=1&binarytrees=5&chameneos=5&message=4&fannkuch=3&fasta=3&harmonic=1&knucleotide=5&mandelbrot=4&nbody=3&nsieve=3&nsievebits=2&pidigits=2&random=1&regexdna=4&revcomp=3&spectralnorm=5&hello=0&sumcol=1&takfp=1&tcprequest=4 this site] (where code lines count are ignored because it is not a relevant design aspect, as shown above).
		+
		+	NOTE: currently alioth.debian.org does not publish any data<br>pertaining to any Eiffel compiler. Perhaps we could take the<br>old SE code, improve on it where possible and re-submit..? /HZ

	LibertyEiffel generates highly efficient code, doesn't it? In fact, we have many ideas for improving generated code. This means you can choose LibertyEiffel now and expect your code to run even faster under future releases of the compiler!		LibertyEiffel generates highly efficient code, doesn't it? In fact, we have many ideas for improving generated code. This means you can choose LibertyEiffel now and expect your code to run even faster under future releases of the compiler!

Hzwakenberg at 18:15, 5 September 2014

2014-09-05T18:15:27Z

← Older revision		Revision as of 20:15, 5 September 2014
Line 1:		Line 1:
−	[[Category:Smarteiffel]]
	==Very High Performance Programs==		==Very High Performance Programs==

	Eiffel is a beautiful method and language, based on strong and elegant principles. But, what interest (except intellectual pleasure) would you have in using a wonderful language with poor performance for writing your programs?		Eiffel is a beautiful method and language, based on strong and elegant principles. But, what interest (except intellectual pleasure) would you have in using a wonderful language with poor performance for writing your programs?

−	Hopefully, Eiffel has been designed with performance in mind. Furthermore, the ~~SmartEiffel~~ compiler and the associated libraries are expressly designed to associate performance and expressivity.	+	Hopefully, Eiffel has been designed with performance in mind. Furthermore, the LibertyEiffel compiler and the associated libraries are expressly designed to associate performance and expressivity.

	In Eiffel language, expressivity is in the power of concepts. For example multiple inheritance and genericity are very powerful concepts, as are static type and dynamic type. This means that properly designed programs will be made with small code, this is '''global code compactness'''. On the other hand, there is '''no local code compactness'''. The Eiffel spirit is to make your code as legible as possible, because it is written once but is read many, many times (code is designed for change and reuse). So there is no point in using many unreadable abbreviations or symbols in order to save some keystrokes. Of course Eiffel code with its standard formatting rules needs many lines where other languages only need one line. The purpose is to achieve '''legibility''' because that is a prerequisite for code maintenance and reuse.		In Eiffel language, expressivity is in the power of concepts. For example multiple inheritance and genericity are very powerful concepts, as are static type and dynamic type. This means that properly designed programs will be made with small code, this is '''global code compactness'''. On the other hand, there is '''no local code compactness'''. The Eiffel spirit is to make your code as legible as possible, because it is written once but is read many, many times (code is designed for change and reuse). So there is no point in using many unreadable abbreviations or symbols in order to save some keystrokes. Of course Eiffel code with its standard formatting rules needs many lines where other languages only need one line. The purpose is to achieve '''legibility''' because that is a prerequisite for code maintenance and reuse.
Line 14:		Line 13:
	Good luck to anyone who wants to understand this program in the ''dc'' language, reuse it, improve it or anything else! For the curious, you can run ''dc'' on any UNIX-like system and paste this code; it will print the prime number decomposition of the first value, which is 1000 here. How can you know the principles used here? Does the algorithm search from 2 each time? Does the program stop when the square root has been reached?		Good luck to anyone who wants to understand this program in the ''dc'' language, reuse it, improve it or anything else! For the curious, you can run ''dc'' on any UNIX-like system and paste this code; it will print the prime number decomposition of the first value, which is 1000 here. How can you know the principles used here? Does the algorithm search from 2 each time? Does the program stop when the square root has been reached?

−	Now, back to the performance aspect, you can see how ~~SmartEiffel~~ behaves on [http://shootout.alioth.debian.org/benchmark.php?test=all&lang=all&calc=Calculate&xfullcpu=1&xmem=1&xloc=&ackermann=1&binarytrees=5&chameneos=5&message=4&fannkuch=3&fasta=3&harmonic=1&knucleotide=5&mandelbrot=4&nbody=3&nsieve=3&nsievebits=2&pidigits=2&random=1&regexdna=4&revcomp=3&spectralnorm=5&hello=0&sumcol=1&takfp=1&tcprequest=4 this site] (where code lines count are ignored because it is not a relevant design aspect, as shown above).	+	Now, back to the performance aspect, you can see how LibertyEiffel behaves on [http://shootout.alioth.debian.org/benchmark.php?test=all&lang=all&calc=Calculate&xfullcpu=1&xmem=1&xloc=&ackermann=1&binarytrees=5&chameneos=5&message=4&fannkuch=3&fasta=3&harmonic=1&knucleotide=5&mandelbrot=4&nbody=3&nsieve=3&nsievebits=2&pidigits=2&random=1&regexdna=4&revcomp=3&spectralnorm=5&hello=0&sumcol=1&takfp=1&tcprequest=4 this site] (where code lines count are ignored because it is not a relevant design aspect, as shown above).

−	~~SmartEiffel~~ generates highly efficient code, doesn't it? In fact, we have many ideas for improving generated code. This means you can choose ~~SmartEiffel~~ now and expect your code to run even faster under future releases of the compiler!	+	LibertyEiffel generates highly efficient code, doesn't it? In fact, we have many ideas for improving generated code. This means you can choose LibertyEiffel now and expect your code to run even faster under future releases of the compiler!

	The main areas for improvement are generated code for dynamic linking, flow analysis and garbage collector. Of course, these projects will be much helped if they are [[Donations\|funded]]!		The main areas for improvement are generated code for dynamic linking, flow analysis and garbage collector. Of course, these projects will be much helped if they are [[Donations\|funded]]!

Ramack at 21:15, 4 March 2013

2013-03-04T21:15:32Z

← Older revision		Revision as of 23:15, 4 March 2013
Line 1:		Line 1:
−	[[Category:~~Book~~]]	+	[[Category:Smarteiffel]]
	==Very High Performance Programs==		==Very High Performance Programs==

Ramack: 6 revisions: initial import from SamrtEiffel Wiki - The Grand SmartEiffel Book

2013-03-03T21:46:26Z

6 revisions: initial import from SamrtEiffel Wiki - The Grand SmartEiffel Book

New page

[[Category:Book]]
==Very High Performance Programs==

Eiffel is a beautiful method and language, based on strong and elegant principles. But, what interest (except intellectual pleasure) would you have in using a wonderful language with poor performance for writing your programs?

Hopefully, Eiffel has been designed with performance in mind. Furthermore, the SmartEiffel compiler and the associated libraries are expressly designed to associate performance and expressivity.

In Eiffel language, expressivity is in the power of concepts. For example multiple inheritance and genericity are very powerful concepts, as are static type and dynamic type. This means that properly designed programs will be made with small code, this is '''global code compactness'''. On the other hand, there is '''no local code compactness'''. The Eiffel spirit is to make your code as legible as possible, because it is written once but is read many, many times (code is designed for change and reuse). So there is no point in using many unreadable abbreviations or symbols in order to save some keystrokes. Of course Eiffel code with its standard formatting rules needs many lines where other languages only need one line. The purpose is to achieve '''legibility''' because that is a prerequisite for code maintenance and reuse.

To convince you, I'll just give one example:

1000[p]s2[lip/dli%0=1dvsr]s12sid2%0=13sidvsr[dli%0=1lrli2+dsi!>.]ds.xd1<2

Good luck to anyone who wants to understand this program in the ''dc'' language, reuse it, improve it or anything else! For the curious, you can run ''dc'' on any UNIX-like system and paste this code; it will print the prime number decomposition of the first value, which is 1000 here. How can you know the principles used here? Does the algorithm search from 2 each time? Does the program stop when the square root has been reached?

Now, back to the performance aspect, you can see how SmartEiffel behaves on [http://shootout.alioth.debian.org/benchmark.php?test=all&lang=all&calc=Calculate&xfullcpu=1&xmem=1&xloc=&ackermann=1&binarytrees=5&chameneos=5&message=4&fannkuch=3&fasta=3&harmonic=1&knucleotide=5&mandelbrot=4&nbody=3&nsieve=3&nsievebits=2&pidigits=2&random=1&regexdna=4&revcomp=3&spectralnorm=5&hello=0&sumcol=1&takfp=1&tcprequest=4 this site] (where code lines count are ignored because it is not a relevant design aspect, as shown above).

SmartEiffel generates highly efficient code, doesn't it? In fact, we have many ideas for improving generated code. This means you can choose SmartEiffel now and expect your code to run even faster under future releases of the compiler!

The main areas for improvement are generated code for dynamic linking, flow analysis and garbage collector. Of course, these projects will be much helped if they are [[Donations|funded]]!

Cadrian: Category: Book

2005-11-22T10:06:49Z

Category: Book

← Older revision		Revision as of 12:06, 22 November 2005
Line 1:		Line 1:
		+	[[Category:Book]]
	==Very High Performance Programs==		==Very High Performance Programs==

Cadrian: mainly typos

2005-11-21T09:10:46Z

mainly typos

New page

==Very High Performance Programs==

Eiffel is a beautiful method and language, based on strong and elegant principles. But, which interest (except intellectual pleasure) could you find in using a wonderful language with poor performance on programs you can write?

Hopefully, Eiffel has been designed with performance in mind. Furthermore, the SmartEiffel compiler and the associated libraries are designed with strong thoughts in order to associate performance and expressivity.

In Eiffel language, expressivity is in the power of concepts. For example multiple inheritance and genericity are very powerful concepts, as are static type and dynamic type. This means that properly designed programs will be made with small code, this is '''global code compacity'''. On the opposite, there is '''no local code compacity'''. Eiffel spirit is to put as much legibility as possible in your code, because it is written once but is read many, many times (code is designed for changes and reuse). So there is no interest in using many unreadable abreviations or symbols in order to save some keystrokes. Of course Eiffel code with standard formatting rules needs many lines where other languages only need one line. The purpose is just '''legibility''' because it's a prerequisite for code maintenance and reuse.

To convince you, I'll just give one example:

1000[p]s2[lip/dli%0=1dvsr]s12sid2%0=13sidvsr[dli%0=1lrli2+dsi!>.]ds.xd1<2

I wish good luck to anyone who wants to understand this program in the ''dc'' language, reuse it, improve it or anything else. For the curious, you can run ''dc'' on any UNIX-like system and paste this code, this will print the prime number decomposition of the first value which is 1000 here. How to know the principles used here? Does the algorithm search from 2 each time? Does the program stop when the square root has been reached?

Now, back on the performance aspect, you can see how SmartEiffel behaves on [http://shootout.alioth.debian.org/benchmark.php?test=all&lang=all&calc=Calculate&xfullcpu=1&xmem=1&xloc=&ackermann=1&binarytrees=5&chameneos=5&message=4&fannkuch=3&fasta=3&harmonic=1&knucleotide=5&mandelbrot=4&nbody=3&nsieve=3&nsievebits=2&pidigits=2&random=1&regexdna=4&revcomp=3&spectralnorm=5&hello=0&sumcol=1&takfp=1&tcprequest=4 this site] (where code lines count are ignored because it's not a relevant design aspect as shown above).

SmartEiffel generates highly efficient code, isn't it? In fact, we have many ideas for improving generated code. This means you can choose SmartEiffel now and expect even better speed of your code using future releases of the compiler!

The main improvements areas are generated code for dynamic linking, flow analysis and garbage collector. Of course, these projects will be much helped if they are [[Donations|funds based]].