www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - Re: C++ vs Lisp

reply bearophile <bearophileHUGS lycos.com> writes:
Walter Bright:

 An oldie, but some very thought provoking observations on what makes a 
 language productive:
 http://faculty.cs.byu.edu/~irenelg/courses/330/CTM/Resources/C++-vs-Lisp.txt



Dear Walter, take a look at my libs, they are much better than the EasySTL he
talks about:
http://www.fantascienza.net/leonardo/so/libs_d.zip

This was my version of that code, written when I was a D newbie (there are
things I have to learn still), 26 lines long:
http://www.digitalmars.com/webnews/newsgroups.php?art_group=digitalmars.D&article_id=57497
With my libs it becomes even shorter/simpler.

Bye,
bearophile
May 17 2008
parent reply Dee Girl <deegirl noreply.com> writes:
bearophile Wrote:


 Walter Bright:

 An oldie, but some very thought provoking observations on what makes a 
 language productive:
 http://faculty.cs.byu.edu/~irenelg/courses/330/CTM/Resources/C++-vs-Lisp.txt



 Dear Walter, take a look at my libs, they are much better than the EasySTL he
talks about:
 http://www.fantascienza.net/leonardo/so/libs_d.zip



You have send these libraries earlier to me. Thank you for that! It looks
interesting. But one problem is you use delegates. They are much slower than
alias. I measured 3 - 5 times slower depending on task.

Another problem is simpler. The documentation is hard. Why you put a zip file
on web and inside it has html files? It should be inverse. It would be good to
put html pages on the web. Also there is no link in the html files. It is hard
to understand what library is doing. I am sure the library is good. But package
looks bad ^_^ Thank you, Dee Girl
May 17 2008
next sibling parent reply bearophile <bearophileHUGS lycos.com> writes:
Dee Girl:

 Thank you for that! It looks interesting.



My pleasure.



But one problem is you use delegates. They are much slower than alias.
I measured 3 - 5 times slower depending on task.



From my benchmarks they behave well enough, you probably talk about unusual
tasks. My libs are designed for the (large!) parts of the code where you don't
need max running speed. To improve the situation you may need compiler support
for list comphrensions, etc and/or macros.



 The documentation is hard. Why you put a zip file on web and inside it has
html 
 files? It should be inverse. It would be good to put html pages on the web.



I see, you are right, and I can fix this problem.



 Also there is no link in the html files. It is hard to understand what library
is doing.



What do you mean?
(If you spot bugs please tell me)

Bye and thank you,
bearophile
May 17 2008
parent reply Dee Girl <deegirl noreply.com> writes:
bearophile Wrote:


 Dee Girl:

 Thank you for that! It looks interesting.



 My pleasure.
 
 

But one problem is you use delegates. They are much slower than alias.
I measured 3 - 5 times slower depending on task.



 From my benchmarks they behave well enough, you probably talk about unusual
tasks. My libs are designed for the (large!) parts of the code where you don't
need max running speed. To improve the situation you may need compiler support
for list comphrensions, etc and/or macros.



Simplest task was increment a value many times. On my computer is 3 times slow.
Then tried simple functions like counting zeros in array of it. It was more 4
times slower. If I like this slow I code python ^_^

If there is different tradeoff to choose then I agree your argument is good.
But with alias approach you have both static and dynamic. The support is
already, no need for more. Why choose the bad way instead of good way?


 The documentation is hard. Why you put a zip file on web and inside it has
html 
 files? It should be inverse. It would be good to put html pages on the web.



 I see, you are right, and I can fix this problem.
 
 

 Also there is no link in the html files. It is hard to understand what library
is doing.



 What do you mean?
 (If you spot bugs please tell me)



It is only that there is no central page. Or I can not find it. No description
of all library. No links between one document and other documents. I get bored
^_^ In phobos I can easy jump from algorithm to conv or functional. Thank you,
Dee Girl
May 17 2008
parent bearophile <bearophileHUGS lycos.com> writes:
Dee Girl:

 Simplest task was increment a value many times. On my computer is 3 times
slow. Then tried simple functions like counting zeros in array of it. It was
more 4 times slower. If I like this slow I code python ^_^



For those very simple operations numpy is probably faster than anything you can
do in D... (you probably need assembler to go a bit faster).
But compared to Python and Psyco my D libs are generally faster or much faster
:-)
My libs are designed to be flexible, despite not being as fast as normal D
code. In the usually very limited spots where you need max speed you can use
normal D code. delegates/functions are quite more flexible than the things you
talk about. And closures even more.



 It is only that there is no central page. Or I can not find it. No description
of all library. No links between one document and other documents. I get bored
^_^ In phobos I can easy jump from algorithm to conv or functional. Thank you,
Dee Girl



I see, and you are right, I can fix this too (currently the "central page" is
the one of the 'func' module, it introduces to the whole lib).

Bye and thank you,
bearophile
May 17 2008
prev sibling parent reply "Nick Sabalausky" <a a.a> writes:
"Dee Girl" <deegirl noreply.com> wrote in message 
news:g0nfdd$1c2m$1 digitalmars.com...

 bearophile Wrote:


 Walter Bright:

 An oldie, but some very thought provoking observations on what makes a
 language productive:
 http://faculty.cs.byu.edu/~irenelg/courses/330/CTM/Resources/C++-vs-Lisp.txt



 Dear Walter, take a look at my libs, they are much better than the 
 EasySTL he talks about:
 http://www.fantascienza.net/leonardo/so/libs_d.zip



 You have send these libraries earlier to me. Thank you for that! It looks 
 interesting. But one problem is you use delegates. They are much slower 
 than alias. I measured 3 - 5 times slower depending on task.



Can you give an example of what you mean by using alias instead of 
delegates?
May 17 2008
parent reply Dee Girl <deegirl noreply.com> writes:
Nick Sabalausky Wrote:


 "Dee Girl" <deegirl noreply.com> wrote in message 
 news:g0nfdd$1c2m$1 digitalmars.com...

 bearophile Wrote:


 Walter Bright:

 An oldie, but some very thought provoking observations on what makes a
 language productive:
 http://faculty.cs.byu.edu/~irenelg/courses/330/CTM/Resources/C++-vs-Lisp.txt



 Dear Walter, take a look at my libs, they are much better than the 
 EasySTL he talks about:
 http://www.fantascienza.net/leonardo/so/libs_d.zip



 You have send these libraries earlier to me. Thank you for that! It looks 
 interesting. But one problem is you use delegates. They are much slower 
 than alias. I measured 3 - 5 times slower depending on task.



 Can you give an example of what you mean by using alias instead of 
 delegates? 



There was long discussion here. Maybe you did not read.

void slowbad(delegate void() f)
{
    f();
}

void fastgood(alias f)()
{
    f();
}

void main() 
{
    void f() { }
    slowbad(&f);
    fastgood!(f);
}

Syntax is different but power is very different. std.algorithm uses alias
always. Everybody else uses slowbad ^_^ Dee Girl
May 17 2008
next sibling parent bearophile <bearophileHUGS lycos.com> writes:
Dee Girl:

 Syntax is different but power is very different. std.algorithm uses alias
always. Everybody else uses slowbad ^_^ Dee Girl



D supports simple function pointers too, and just only delegates, but I see
your point. I'll think about it...

Bye,
bearophile
May 17 2008
prev sibling parent reply "Nick Sabalausky" <a a.a> writes:
"Dee Girl" <deegirl noreply.com> wrote in message 
news:g0noqa$2rpf$1 digitalmars.com...

 There was long discussion here. Maybe you did not read.



Didn't see it, must have been on a different thread.


 void slowbad(delegate void() f)
 {
    f();
 }

 void fastgood(alias f)()
 {
    f();
 }

 void main()
 {
    void f() { }
    slowbad(&f);
    fastgood!(f);
 }

 Syntax is different but power is very different. std.algorithm uses alias 
 always. Everybody else uses slowbad ^_^ Dee Girl



Isn't that akin to forcing a function to be inlined? It sounds to me like, 
just as with normal function inlining, there are cases where that could 
backfire because of things like increased cache misses or increased register 
consumption (or are those outdated problems with inlining?).
May 17 2008
parent reply janderson <askme me.com> writes:
Nick Sabalausky wrote:

 "Dee Girl" <deegirl noreply.com> wrote in message 
 news:g0noqa$2rpf$1 digitalmars.com...

 There was long discussion here. Maybe you did not read.



 Didn't see it, must have been on a different thread.
 

 void slowbad(delegate void() f)
 {
    f();
 }

 void fastgood(alias f)()
 {
    f();
 }

 void main()
 {
    void f() { }
    slowbad(&f);
    fastgood!(f);
 }

 Syntax is different but power is very different. std.algorithm uses alias 
 always. Everybody else uses slowbad ^_^ Dee Girl



 Isn't that akin to forcing a function to be inlined? It sounds to me like, 
 just as with normal function inlining, there are cases where that could 
 backfire because of things like increased cache misses or increased register 
 consumption (or are those outdated problems with inlining?). 
 
 



Only if the compiler decided to inline the contents of f function. 
Even then if the compiler can inline f's contents, its probably going to 
beable to reduce the size of the program size somewhat.  Normally the 
compiler is going to get it right with inlining.  The above template 
will boil down to:

void main()
{
    void f() { }
    slowbad(&f);  //May or maynot be inlined
    f();
}

As you can see f() is one function call less then slowbad and doesn't 
have to do any of the other stuff slowbad would.

-Joel
May 17 2008
parent reply "Nick Sabalausky" <a a.a> writes:
"janderson" <askme me.com> wrote in message 
news:g0o03o$k01$1 digitalmars.com...

 Nick Sabalausky wrote:

 "Dee Girl" <deegirl noreply.com> wrote in message 
 news:g0noqa$2rpf$1 digitalmars.com...

 There was long discussion here. Maybe you did not read.



 Didn't see it, must have been on a different thread.


 void slowbad(delegate void() f)
 {
    f();
 }

 void fastgood(alias f)()
 {
    f();
 }

 void main()
 {
    void f() { }
    slowbad(&f);
    fastgood!(f);
 }

 Syntax is different but power is very different. std.algorithm uses 
 alias always. Everybody else uses slowbad ^_^ Dee Girl



 Isn't that akin to forcing a function to be inlined? It sounds to me 
 like, just as with normal function inlining, there are cases where that 
 could backfire because of things like increased cache misses or increased 
 register consumption (or are those outdated problems with inlining?).



 Only if the compiler decided to inline the contents of f function. Even 
 then if the compiler can inline f's contents, its probably going to beable 
 to reduce the size of the program size somewhat.  Normally the compiler is 
 going to get it right with inlining.  The above template will boil down 
 to:

 void main()
 {
    void f() { }
    slowbad(&f);  //May or maynot be inlined
    f();
 }

 As you can see f() is one function call less then slowbad and doesn't have 
 to do any of the other stuff slowbad would.



But fastgood() is always inlined, right?
May 18 2008
parent reply janderson <askme me.com> writes:
Nick Sabalausky wrote:

 "janderson" <askme me.com> wrote in message 
 news:g0o03o$k01$1 digitalmars.com...

 Nick Sabalausky wrote:

 "Dee Girl" <deegirl noreply.com> wrote in message 
 news:g0noqa$2rpf$1 digitalmars.com...

 There was long discussion here. Maybe you did not read.





 void slowbad(delegate void() f)
 {
    f();
 }

 void fastgood(alias f)()
 {
    f();
 }

 void main()
 {
    void f() { }
    slowbad(&f);
    fastgood!(f);
 }

 Syntax is different but power is very different. std.algorithm uses 
 alias always. Everybody else uses slowbad ^_^ Dee Girl



 like, just as with normal function inlining, there are cases where that 
 could backfire because of things like increased cache misses or increased 
 register consumption (or are those outdated problems with inlining?).



 then if the compiler can inline f's contents, its probably going to beable 
 to reduce the size of the program size somewhat.  Normally the compiler is 
 going to get it right with inlining.  The above template will boil down 
 to:

 void main()
 {
    void f() { }
    slowbad(&f);  //May or maynot be inlined
    f();
 }

 As you can see f() is one function call less then slowbad and doesn't have 
 to do any of the other stuff slowbad would.



 But fastgood() is always inlined, right? 
 
 



You'd have to get Walters for the final word however I can't see why the 
compiler would generate another function for fastgood other then to 
speed up compiler performance for duplicate templates.  If your worried 
about a long fastgood function being inlined, then I suggest that that 
template has been made to long.  Also pre-premature optimisation is not 
a good thing.  Do what works for you then optimize later.

In my experience things like using delegates over templates rarely 
matter.  That is because the size of the rest of the code dwarfs the 
runtime spent there.  People will run benchmarks on the specific piece 
of code and get some impressive benchmarks but they don't try running it 
in real world code.  Many times optimisation works against 
maintainability and flexibility, yet having highly flexible code is the 
key to being able to focus optimizations on the code that matters.

Having said that, its nice to have these optimizations in the standard 
libraries because I figure that with 1000's of users, someones/everyones 
code is going to benefit from it.

It is also true that heavy use of templates can slow down code speed 
just as heavy use of delegates.  I think its up to the engineer to make 
the correct judgment call, particularly after they've run the profiler.


-Joel
May 18 2008
parent reply Dee Girl <deegirl noreply.com> writes:
janderson Wrote:

 You'd have to get Walters for the final word however I can't see why the 
 compiler would generate another function for fastgood other then to 
 speed up compiler performance for duplicate templates.  If your worried 
 about a long fastgood function being inlined, then I suggest that that 
 template has been made to long.  Also pre-premature optimisation is not 
 a good thing.  Do what works for you then optimize later.



It is not about inlining. I think this is confusion again, same made in
discussion with title safer casts. It is about template instantiation. Which
can affect inlining but is very different thing.


 In my experience things like using delegates over templates rarely 
 matter.  That is because the size of the rest of the code dwarfs the 
 runtime spent there.  People will run benchmarks on the specific piece 
 of code and get some impressive benchmarks but they don't try running it 
 in real world code. 



If you see 4 times faster in a function then all program will not be 4 times
faster. Of course. But many programs have little core operation. For example wc
has at its core reading file, character comparison and loop. If core has 4
times slower function maybe the cost is much.


 Many times optimisation works against 
 maintainability and flexibility, yet having highly flexible code is the 
 key to being able to focus optimizations on the code that matters.



General observation is correct. But phobos algorithm and compose are good but
not inflexible. 


 Having said that, its nice to have these optimizations in the standard 
 libraries because I figure that with 1000's of users, someones/everyones 
 code is going to benefit from it.
 It is also true that heavy use of templates can slow down code speed 
 just as heavy use of delegates.  I think its up to the engineer to make 
 the correct judgment call, particularly after they've run the profiler.



If you have many template instantiation code is big. Big makes code slow
because cache effect. But with template you can limit size because you can
write slowbad to use fastgood. Then only one fastgood is instantiated. But if
you start with slowbad is nothing you can do. Thank you, Dee Girl
May 18 2008
parent janderson <askme me.com> writes:
Dee Girl wrote:

 janderson Wrote:

 You'd have to get Walters for the final word however I can't see why the 
 compiler would generate another function for fastgood other then to 
 speed up compiler performance for duplicate templates.  If your worried 
 about a long fastgood function being inlined, then I suggest that that 
 template has been made to long.  Also pre-premature optimisation is not 
 a good thing.  Do what works for you then optimize later.



 It is not about inlining. I think this is confusion again, same made in
discussion with title safer casts. It is about template instantiation. Which
can affect inlining but is very different thing.



This was in regards to Nicks question.


 

 In my experience things like using delegates over templates rarely 
 matter.  That is because the size of the rest of the code dwarfs the 
 runtime spent there.  People will run benchmarks on the specific piece 
 of code and get some impressive benchmarks but they don't try running it 
 in real world code. 



 If you see 4 times faster in a function then all program will not be 4 times
faster. Of course. But many programs have little core operation. For example wc
has at its core reading file, character comparison and loop. If core has 4
times slower function maybe the cost is much.



I agree. Read the last paragraph. This is taken out of context.


 

 Many times optimisation works against 
 maintainability and flexibility, yet having highly flexible code is the 
 key to being able to focus optimizations on the code that matters.



 General observation is correct. But phobos algorithm and compose are good but
not inflexible.



I agree.


 

 Having said that, its nice to have these optimizations in the standard 
 libraries because I figure that with 1000's of users, someones/everyones 
 code is going to benefit from it.
 It is also true that heavy use of templates can slow down code speed 
 just as heavy use of delegates.  I think its up to the engineer to make 
 the correct judgment call, particularly after they've run the profiler.



 If you have many template instantiation code is big. Big makes code slow
because cache effect. But with template you can limit size because you can
write slowbad to use fastgood. Then only one fastgood is instantiated. But if
you start with slowbad is nothing you can do. Thank you, Dee Girl



I agree. Read first paragraph.
May 18 2008