www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - Let Go, Standard Library From Community

reply Davidl <Davidl 126.com> writes:
Personally, I'm not familiar with tango, but the following is based on the  
thought of
1. one man's effort vs. a team's effort
2. growing D code need only 1 base standard library.

I don't think it's funny to switch from phobos to tango or switch tango  
back to phobos.

I think standard library should be provided by D community, I appreciate  
Walter gave us phobos.
We needed this babysitter. But now D community is growing bigger & bigger.  
I'm wondering if Walter
can put as much effort as he used to put on Phobos to compete with Tango.   
And endless arguing of
Phobos vs. Tango is somewhat meaningless & annoying.
Once tangobos out, I hope standard DMD package would be released by tango  
team & Walter, with Tango
being the base default library. Users can use tangobos for legacy code.
Apr 18 2007
next sibling parent reply Daniel Keep <daniel.keep.lists gmail.com> writes:
Davidl wrote:
 Personally, I'm not familiar with tango, but the following is based on
 the thought of
 1. one man's effort vs. a team's effort
 2. growing D code need only 1 base standard library.
 
 I don't think it's funny to switch from phobos to tango or switch tango
 back to phobos.

If you haven't used Tango, then how can you make this comment?
 I think standard library should be provided by D community, I appreciate
 Walter gave us phobos.
 We needed this babysitter. But now D community is growing bigger &
 bigger. I'm wondering if Walter
 can put as much effort as he used to put on Phobos to compete with
 Tango.  And endless arguing of
 Phobos vs. Tango is somewhat meaningless & annoying.
 Once tangobos out, I hope standard DMD package would be released by
 tango team & Walter, with Tango
 being the base default library. Users can use tangobos for legacy code.

I really don't see the need for this. Phobos is a lovely minimalist library that simply gets the job done with a minimum of fuss. Tango is a nicely structured library full of functionality. They fill different needs. What's more, switching between them is a *total* non-issue. Here's how I compile phobos apps: $ rebuild foo Here's how I compile Tango apps $ rebuild -dcdmd-tango bar Heck, I usually don't even do that; I just dump the switches into a text file and use them as response files. If rebuild grew bud-style +target args, it'd be perfect :) It's not like it's rocket science any more. I honestly can't see a reason why the two can't simply coexist. -- Daniel -- int getRandomNumber() { return 4; // chosen by fair dice roll. // guaranteed to be random. } http://xkcd.com/ v2sw5+8Yhw5ln4+5pr6OFPma8u6+7Lw4Tm6+7l6+7D i28a2Xs3MSr2e4/6+7t4TNSMb6HTOp5en5g6RAHCP http://hackerkey.com/
Apr 18 2007
next sibling parent reply eao197 <eao197 intervale.ru> writes:
On Wed, 18 Apr 2007 11:55:55 +0400, Daniel Keep  
<daniel.keep.lists gmail.com> wrote:

 What's more, switching between them is a *total* non-issue.  Here's how
 I compile phobos apps:

 $ rebuild foo

 Here's how I compile Tango apps

 $ rebuild -dcdmd-tango bar

 Heck, I usually don't even do that; I just dump the switches into a text
 file and use them as response files.  If rebuild grew bud-style +target
 args, it'd be perfect :)

 It's not like it's rocket science any more.  I honestly can't see a
 reason why the two can't simply coexist.

I think problem of Phobos/Tango incompatibility affects not application writers, but libraries writers. If someone writes some application domain library (XML parsing, SOAP support, event-driven framework and so on) then he/she can use Phobos or Tango, but this choice divides users of than library to Phobos-only or Tango-only. An attempt to write big library which can work either with Phobos or Tango would lead to undesirable amount of version statements in code (as in good old C/C++ times with many #if/#else). -- Regards, Yauheni Akhotnikau
Apr 18 2007
next sibling parent reply Daniel Keep <daniel.keep.lists gmail.com> writes:
eao197 wrote:
 On Wed, 18 Apr 2007 11:55:55 +0400, Daniel Keep
 <daniel.keep.lists gmail.com> wrote:
 
 What's more, switching between them is a *total* non-issue.  Here's how
 I compile phobos apps:

 $ rebuild foo

 Here's how I compile Tango apps

 $ rebuild -dcdmd-tango bar

 Heck, I usually don't even do that; I just dump the switches into a text
 file and use them as response files.  If rebuild grew bud-style +target
 args, it'd be perfect :)

 It's not like it's rocket science any more.  I honestly can't see a
 reason why the two can't simply coexist.

I think problem of Phobos/Tango incompatibility affects not application writers, but libraries writers. If someone writes some application domain library (XML parsing, SOAP support, event-driven framework and so on) then he/she can use Phobos or Tango, but this choice divides users of than library to Phobos-only or Tango-only. An attempt to write big library which can work either with Phobos or Tango would lead to undesirable amount of version statements in code (as in good old C/C++ times with many #if/#else). --Regards, Yauheni Akhotnikau

I've been writing an XML SAX parser based on Expat, and it supports both Phobos and Tango; it wasn't much work at all. A few aliases and version statements, and I'm good. Also, this seems a bit like the difference between writing a library for just the standard C++ libraries and, say, MFC or wxWidgets. I still think it's a little early to be shoving Phobos out the door into the cold, dark night with nary more than a "thanks, it's been great but I'm seeing someone else now" based on what we think might happen at some indeterminable point in the future. I think it would be better to wait until Tango hits 1.0, and a few large libraries have actually been written so we can get a feel for how this is all panning out. Besides, I quite like Phobos :) -- Daniel "There, there, Phobos. *I* still <3 you..." -- int getRandomNumber() { return 4; // chosen by fair dice roll. // guaranteed to be random. } http://xkcd.com/ v2sw5+8Yhw5ln4+5pr6OFPma8u6+7Lw4Tm6+7l6+7D i28a2Xs3MSr2e4/6+7t4TNSMb6HTOp5en5g6RAHCP http://hackerkey.com/
Apr 18 2007
parent eao197 <eao197 intervale.ru> writes:
On Wed, 18 Apr 2007 14:27:10 +0400, Daniel Keep  
<daniel.keep.lists gmail.com> wrote:

 I think problem of Phobos/Tango incompatibility affects not application
 writers, but libraries writers. If someone writes some application
 domain library (XML parsing, SOAP support, event-driven framework and so
 on) then he/she can use Phobos or Tango, but this choice divides users
 of than library to Phobos-only or Tango-only. An attempt to write big
 library which can work either with Phobos or Tango would lead to
 undesirable amount of version statements in code (as in good old C/C++
 times with many #if/#else).

 --Regards,
 Yauheni Akhotnikau

I've been writing an XML SAX parser based on Expat, and it supports both Phobos and Tango; it wasn't much work at all. A few aliases and version statements, and I'm good.

I said not about D-wrappers around existing C/C++ libraries but about 'native' D libraries. For example, to use D on my work I need to make D-port of (at least) 3 our C++ libraries (for configuration files, data serialization, event-oriented programming). Because the existing C++ libraries heavy use C++templates it isn't possible to make D wrapper around existing code.
 Also, this seems a bit like the difference between writing a library for
 just the standard C++ libraries and, say, MFC or wxWidgets.  I still
 think it's a little early to be shoving Phobos out the door into the
 cold, dark night with nary more than a "thanks, it's been great but I'm
 seeing someone else now" based on what we think might happen at some
 indeterminable point in the future.

I didn't speak about throwing Phobos away. Phobos is a good library. And it should be here because D is a multiparadigm language, so in some circumstances C-like Phobos library much more appopriate then fully object-oriented Tango library. But it is a sad situation when some application can't be link against Phobos-based and Tango-based libraries at the same time. I hope that Walter and the Tango team find the solution for that problem. -- Regards, Yauheni Akhotnikau
Apr 18 2007
prev sibling parent Mike Parker <aldacron71 yahoo.com> writes:
eao197 wrote:

 
 I think problem of Phobos/Tango incompatibility affects not application 
 writers, but libraries writers. If someone writes some application 
 domain library (XML parsing, SOAP support, event-driven framework and so 
 on) then he/she can use Phobos or Tango, but this choice divides users 
 of than library to Phobos-only or Tango-only. An attempt to write big 
 library which can work either with Phobos or Tango would lead to 
 undesirable amount of version statements in code (as in good old C/C++ 
 times with many #if/#else).

Or they can do what I did with Derelict and add a module to the library that wraps Phobos/Tango calls. It only needs to wrap the functions/objects the library actually uses. Admittedly, there is a problem if you use standard library calls extensively, or if you use features of one library that aren't (yet) available in the other (such as the Zlib and ZipArchive modules in Phobos). But in that case, unless your library is intended to make money for you, why worry? And if it is commercial, then you have good incentive to implement missing functionality anyway.
Apr 18 2007
prev sibling next sibling parent reply Davidl <Davidl 126.com> writes:
 Davidl wrote:
 Personally, I'm not familiar with tango, but the following is based on
 the thought of
 1. one man's effort vs. a team's effort
 2. growing D code need only 1 base standard library.

 I don't think it's funny to switch from phobos to tango or switch tango
 back to phobos.

If you haven't used Tango, then how can you make this comment?

on those.
 I think standard library should be provided by D community, I appreciate
 Walter gave us phobos.
 We needed this babysitter. But now D community is growing bigger &
 bigger. I'm wondering if Walter
 can put as much effort as he used to put on Phobos to compete with
 Tango.  And endless arguing of
 Phobos vs. Tango is somewhat meaningless & annoying.
 Once tangobos out, I hope standard DMD package would be released by
 tango team & Walter, with Tango
 being the base default library. Users can use tangobos for legacy code.

I really don't see the need for this. Phobos is a lovely minimalist library that simply gets the job done with a minimum of fuss. Tango is a nicely structured library full of functionality. They fill different needs. What's more, switching between them is a *total* non-issue. Here's how I compile phobos apps: $ rebuild foo Here's how I compile Tango apps $ rebuild -dcdmd-tango bar Heck, I usually don't even do that; I just dump the switches into a text file and use them as response files. If rebuild grew bud-style +target args, it'd be perfect :)

users to choose between 2 base libraries at the very first. And I'm quite sure they would *IN MOST CASE* be misled to phobos without any cosideration even they don't know if phobos is what they want, they just think it comes with the compiler. And I think this brings a *GREAT UNFAIR* in library competition
 It's not like it's rocket science any more.  I honestly can't see a
 reason why the two can't simply coexist.

 	-- Daniel

No, for D's own good, one of them should die peacefully.
Apr 18 2007
parent Sean Kelly <sean f4.ca> writes:
Davidl wrote:

users to choose between 2 base libraries at the very first. And I'm quite sure they would *IN MOST CASE* be misled to phobos without any cosideration even they don't know if phobos is what they want, they just think it comes with the compiler. And I think this brings a *GREAT UNFAIR* in library competition

The Tango binary distribution now includes the compiler as well. Sean
Apr 18 2007
prev sibling parent reply Davidl <Davidl 126.com> writes:
And also learning two completely different APIs ain't that easy.
With the powerful expressive D lang , users already have many things
to learn to use it practical, not to say the base libraries.

I'm not saying Phobos is *BAD*. What I mean is the coexistance of
Phobos and Tango just confuses users.
Apr 18 2007
parent reply Lionello Lunesu <lio lunesu.remove.com> writes:
Davidl wrote:
 And also learning two completely different APIs ain't that easy.
 With the powerful expressive D lang , users already have many things
 to learn to use it practical, not to say the base libraries.
 
 I'm not saying Phobos is *BAD*. What I mean is the coexistance of
 Phobos and Tango just confuses users.

And I agree with you. L.
Apr 18 2007
parent reply Dan <murpsoft hotmail.com> writes:
I just use phobos.  It gets the job done, instead of trying to be everything
and anything the user might possibly want to interact with; like the Java
libraries.

I find the Java libraries are so freakin' huge and multipurpose that they
couldn't possibly be even close to efficient or practical for any one solution.

Likewise I fear for Tango, as it's got that OO gleam in it's eye and is
implementing classes for crypto.. I mean.. crypto!?  What's next, a math class?
 *shudders*
Apr 18 2007
next sibling parent reply Brad Anderson <brad dsource.org> writes:
Dan wrote:
 I just use phobos.  It gets the job done, instead of trying to be
 everything and anything the user might possibly want to interact with; like
 the Java libraries.
 
 I find the Java libraries are so freakin' huge and multipurpose that they
 couldn't possibly be even close to efficient or practical for any one
 solution.
 
 Likewise I fear for Tango, as it's got that OO gleam in it's eye and is
 implementing classes for crypto.. I mean.. crypto!?  What's next, a math
 class?  *shudders*

Oh to be a fly on the wall when the current lib doesn't have a function you need...
Apr 18 2007
parent reply Dan <murpsoft hotmail.com> writes:
Brad Anderson Wrote:
 Oh to be a fly on the wall when the current lib doesn't have a function you
 need...

I can write assembler. I can write D. I can write ECMAScript. If there's something I need that isn't there, I write it. I personally think there's something wrong with someone who claims to be a programmer but *can't* solve a trivial puzzle. Not knowing what address to write directly to the screenbuffer is forgiveable. Look it up. Not being able to implement huffman compression or a quicksort or binary search, or a jump gate after knowing what you need to achieve... well, that means you lost that gleam in your eye you had back in kindergarten. - Dan
Apr 18 2007
next sibling parent Brad Anderson <brad dsource.org> writes:
Dan wrote:
 Brad Anderson Wrote:
 Oh to be a fly on the wall when the current lib doesn't have a function
 you need...

I can write assembler. I can write D. I can write ECMAScript. If there's something I need that isn't there, I write it. I personally think there's something wrong with someone who claims to be a programmer but *can't* solve a trivial puzzle. Not knowing what address to write directly to the screenbuffer is forgiveable. Look it up. Not being able to implement huffman compression or a quicksort or binary search, or a jump gate after knowing what you need to achieve... well, that means you lost that gleam in your eye you had back in kindergarten. - Dan

That's fine. You choose to keep your feet on the ground, as opposed to standing on the shoulders of giants. No biggie. It's just kind of reinventing the wheel. I know it's fun to implement things yourself at times, and a lot of it has to do with what you're trying to accomplish. When time and all the -abilities matter most, I think your approach is wrong. Or rather, not the one I would choose. BA
Apr 18 2007
prev sibling next sibling parent janderson <askme me.com> writes:
Dan wrote:
 Brad Anderson Wrote:
 Oh to be a fly on the wall when the current lib doesn't have a function you
 need...

I can write assembler. I can write D. I can write ECMAScript. If there's something I need that isn't there, I write it. I personally think there's something wrong with someone who claims to be a programmer but *can't* solve a trivial puzzle.

That means a lot of time wasted focusing on writing solutions to problems that have already been solved. It also means when reading someone else's code there's more to learn, rather then there being a standard way of writing something (more time wasted). Furthermore things that have been in some public library (not necessarily standard) generally receive a high level of free testing from the community, that means I save more time. My approach to coding is to try to do as much re-use as is feasible. It means I can focus on the actual problem more, not how I get there.
 Not knowing what address to write directly to the screenbuffer is forgiveable.
 Look it up.  Not being able to implement huffman compression or a quicksort or
binary search, or a jump gate after knowing what you need to achieve... well,
that means you lost that gleam in your eye you had back in kindergarten.

I can, have and believe anyone one on this newsgroup could as well. It doesn't mean I should do it again. Its a time investment, even if it only takes you 5 minutes to write a quicksort. I'm sure Michael Abrash could write a ASM optimized quicksort that could rival anything normal people could write (and sure given time any code monkey(s) could produce something better). Even Michael Abrash is an avoid code reuser. That's an advantage of using code that has been worked on by a community or been available forever. That's this code monkey's view. Humm, although I respect your option: You should know that this is one common interview question. PS - Yes I'm a Michael Abrash fan-boy.
 
 - Dan

Apr 18 2007
prev sibling parent reply Alexander Panek <a.panek brainsware.org> writes:
Dan wrote:
 [...]
 Not knowing what address to write directly to the screenbuffer is forgiveable.
 Look it up.  Not being able to implement huffman compression or a quicksort or
binary search, or a jump gate after knowing what you need to achieve... well,
that means you lost that gleam in your eye you had back in kindergarten.

This is utterly stupid. I am an undergraduate student, claiming to be quite a good programmer. I have never implemented one of those, yet I can produce proper library & application code... why? Oh..seems like someone else solved this already, and I can head forward to the solution of my actual problem, without having to care about the obstacles that might be in my if I haven't had a pre-made solution. Wait.. this is kindergarten? I wonder how you pay your rent and earn money for food...oh well..you wouldn't need to, when you're in kindergarten.. Kind regards, Alex
Apr 18 2007
next sibling parent Alexander Panek <a.panek brainsware.org> writes:
Alexander Panek wrote:
 [...]

..I'm sorry for my harsh response. I didn't mean to let my really-bad-day-mood out like this.. please don't take it personally.
Apr 18 2007
prev sibling parent reply Dan <murpsoft hotmail.com> writes:
Alexander Panek Wrote:

 Dan wrote:
  > [...]
 Not knowing what address to write directly to the screenbuffer is forgiveable.
 Look it up.  Not being able to implement huffman compression or a quicksort or
binary search, or a jump gate after knowing what you need to achieve... well,
that means you lost that gleam in your eye you had back in kindergarten.

This is utterly stupid. I am an undergraduate student, claiming to be quite a good programmer. I have never implemented one of those, yet I can produce proper library & application code... why? Oh..seems like someone else solved this already, and I can head forward to the solution of my actual problem, without having to care about the obstacles that might be in my if I haven't had a pre-made solution. Wait.. this is kindergarten? I wonder how you pay your rent and earn money for food...oh well..you wouldn't need to, when you're in kindergarten..

*sigh* A good programmer needs to be able to do more than simply type down what's blatantly obvious. They need to be able to overcome obstacles as simple as these. That was the point of the message. If you can't overcome something, and be creative - even if your solution isn't a perfect qsort, but maybe you just need to sort, and recreate a decent shellsort instead. If you can't approach a problem and overcome it, you shouldn't be programming, you should be in data entry and speaking Vorgon (for those who've read/seen Hitchhiker's Guide to the Galaxy). You obviously were quite offended by this line of thought.
Apr 18 2007
parent reply Alexander Panek <a.panek brainsware.org> writes:
Dan wrote:
 Alexander Panek Wrote:
 [...]
 You obviously were quite offended by this line of thought.

Might be. The reason for this may lie in the circumstances of my "career" as a programmer. I'm not attending university yet, I am just having my last year's finals at school. This means, problems of academic level are just new to me, but I'm constantly gaining bits of knowledge how to achieve different kinds of goals. However, I love beautifully designed systems in general, solving problems in the most elegant way. This *may* involve implementing a sorting algorithm at times, to achieve the goal of providing an elegant solution for a given problem. Yet, this is not an every-day obstacle. Good programmers are not anymore those, who can write the fastest algorithms with as few lines as possible, using almost no memory.. programming is more than that. In fact, it's not programming alone. I've attended a school for Electrical Engineering the last five years, where I've learned different kinds of ways to solve problems. There are mathematical ways, graphical ways, weirdo-graphical ways (yea.. VBA-like :P), semi-mathematical ways and analog electronic that can achieve what you want. Still, it's not the knowledge in detail alone that makes a good EE, it's the knowledge of what tools and environments are available that makes a good engineer, in general. Apart from that.. I think programmers, and engineers in general are the laziest people you can find, when it comes to solutions, but that doesn't make them bad engineers. Kind regards, Alex
Apr 18 2007
parent reply janderson <askme me.com> writes:
Alexander Panek wrote:
 Dan wrote:
 Alexander Panek Wrote:

of what tools and environments are available that makes a good engineer, in general. Apart from that.. I think programmers, and engineers in general are the laziest people you can find, when it comes to solutions, but that doesn't make them bad engineers. Kind regards, Alex

Agreed, the best engineers are the laziest ones. They normally write the most productive code. -Joel
Apr 18 2007
parent Brad Anderson <brad dsource.org> writes:
janderson wrote:
 Alexander Panek wrote:
 Dan wrote:
 Alexander Panek Wrote:

of what tools and environments are available that makes a good engineer, in general. Apart from that.. I think programmers, and engineers in general are the laziest people you can find, when it comes to solutions, but that doesn't make them bad engineers. Kind regards, Alex

Agreed, the best engineers are the laziest ones. They normally write the most productive code. -Joel

http://www.lazyway.net/sample_chapter_page1.html BA
Apr 18 2007
prev sibling next sibling parent reply Lars Ivar Igesund <larsivar igesund.net> writes:
Dan wrote:

 
 I just use phobos.  It gets the job done, instead of trying to be
 everything and anything the user might possibly want to interact with;
 like the Java libraries.
 
 I find the Java libraries are so freakin' huge and multipurpose that they
 couldn't possibly be even close to efficient or practical for any one
 solution.
 
 Likewise I fear for Tango, as it's got that OO gleam in it's eye and is
 implementing classes for crypto.. I mean.. crypto!?  What's next, a math
 class?  *shudders*

Seriously, classes don't inherently mean in-efficient as you seem to believe. Tango puts it's pride in being an efficient library, and if it is provably slower than other solutions, whether they are OO or procedural, then we would like to know, as it is most likely a bug. Note that the overhead with classes most often are related to the allocation cost. In very many cases, when it makes sense to keep the ojbect a live for a period, keeping state can you help you make many operations more efficient than if they had to be done repeatedly through a free function, quickly overcoming the initial allocation cost. This also often leads to easier overall use. Then you have the cases where the related operations (especially disk IO) are so expensive in itself, that whether classes are used or not, won't be noticed in the grand scheme of things. They may however ease use through encapsulation. As for the String class; Yes, Tango has one, but do also have free functions for the same operations, and in most cases we provide versions that do not induce heap activity. Additionally we try to design the library to be flexible and easy to use, and coherent with itself. We even worry about binary sizes. -- Lars Ivar Igesund blog at http://larsivi.net DSource, #d.tango & #D: larsivi Dancing the Tango
Apr 18 2007
parent reply Dan <murpsoft hotmail.com> writes:
Lars Ivar Igesund Wrote:

 Dan wrote:
 
 
 I just use phobos.  It gets the job done, instead of trying to be
 everything and anything the user might possibly want to interact with;
 like the Java libraries.
 
 I find the Java libraries are so freakin' huge and multipurpose that they
 couldn't possibly be even close to efficient or practical for any one
 solution.
 
 Likewise I fear for Tango, as it's got that OO gleam in it's eye and is
 implementing classes for crypto.. I mean.. crypto!?  What's next, a math
 class?  *shudders*

Seriously, classes don't inherently mean in-efficient as you seem to believe. Tango puts it's pride in being an efficient library, and if it is provably slower than other solutions, whether they are OO or procedural, then we would like to know, as it is most likely a bug. Note that the overhead with classes most often are related to the allocation cost. In very many cases, when it makes sense to keep the ojbect a live for a period, keeping state can you help you make many operations more efficient than if they had to be done repeatedly through a free function, quickly overcoming the initial allocation cost. This also often leads to easier overall use. Then you have the cases where the related operations (especially disk IO) are so expensive in itself, that whether classes are used or not, won't be noticed in the grand scheme of things. They may however ease use through encapsulation. As for the String class; Yes, Tango has one, but do also have free functions for the same operations, and in most cases we provide versions that do not induce heap activity. Additionally we try to design the library to be flexible and easy to use, and coherent with itself. We even worry about binary sizes.

~~ That's respectable. On that note, I think I'll examine the Tango sources. Whomever is working on Tangobos is definitely doing us all a favor. So if I could demonstrate that many (if not all) of these implementations should really be using a struct for strictly performance reasons, for example, would that have any weight? I find that structs tend to be able to do alot in D, with Interfaces being the only remaining thing I miss.
Apr 18 2007
next sibling parent reply Dan <murpsoft hotmail.com> writes:
Dan Wrote:
 On that note, I think I'll examine the Tango sources.  Whomever is working on
Tangobos is definitely doing us all a favor.

Oh my... I went through tango.core.Array and tango.math.Math and personally found several rather junior mistakes like: int abs(int x){ return x > 0? x : -x; // should be: return x &= 0x7FFF_FFFF; } and all sorts of template mess in Array and String just to implement things like find as well as several equivalents to opAssign, opAdd, opCat etc. I spent three minutes quickly trying out a template that could implement find on an array of any type using delegates or functions, as well as trying to remember what an operator overload would be classified as; and to be honest I did find it somewhat disorienting so I can understand that part. I wonder if Phobos is likewise written...
Apr 18 2007
next sibling parent reply Frits van Bommel <fvbommel REMwOVExCAPSs.nl> writes:
Dan wrote:
 
 Oh my...
 
 I went through tango.core.Array and tango.math.Math and personally found
several rather junior mistakes like:
 
 int abs(int x){
   return x > 0? x : -x;
  // should be: return x &= 0x7FFF_FFFF;
 }

... That's *so* wrong... You may want to save yourself some embarrassment by checking code before you post it here: ===== $ cat test.d import std.stdio; int abs(int x) { return x &= 0x7fff_ffff; } void main() { writefln(abs(-2)); } $ dmd -run test.d 2147483646 ===== hint: abs(-2) != 2147483646 :P (Most computers use a representation called "two's complement" to store signed integers. See http://en.wikipedia.org/wiki/Two's_complement for details) Though returning an _unsigned_ integer instead of a signed one would arguably improve the "abs" function. (Try calling the current version with int.min to see what I mean)
Apr 18 2007
parent reply Dan <murpsoft hotmail.com> writes:
Frits van Bommel Wrote:

 Dan wrote:
 
 Oh my...
 
 I went through tango.core.Array and tango.math.Math and personally found
several rather junior mistakes like:
 
 int abs(int x){
   return x > 0? x : -x;
  // should be: return x &= 0x7FFF_FFFF;
 }

... That's *so* wrong... You may want to save yourself some embarrassment by checking code before you post it here:

Bah... you know what I meant. Unpredicted branches on an x86 cost roughly 6 cycles, not including the neg; we assume for both cases that we're inlining the function (no call overhead) What I intended to show was that you could do it better with a touch of bit math. I think the right way is actually to use something like asm's: rol EAX, 1; // 1000_0001 becomes 0000_0011 shr EAX, 1; // 0000_0011 becomes 0000_0001 Of course, I can't test this. I'm at work, not at home with my development box. I may have also used the wrong right shift instruction, or used the rotate that goes through the sign bit in EFLAGS. Surely one of the asm gurus has presented this already? So I looked around a bit. Some further reading: http://www.azillionmonkeys.com/qed/2scomp.html http://graphics.stanford.edu/~seander/bithacks.html#IntegerAbs
Apr 18 2007
parent Don Clugston <dac nospam.com.au> writes:
Dan wrote:
 Frits van Bommel Wrote:
 
 Dan wrote:
 Oh my...

 I went through tango.core.Array and tango.math.Math and personally found
several rather junior mistakes like:

 int abs(int x){
   return x > 0? x : -x;
  // should be: return x &= 0x7FFF_FFFF;
 }

That's *so* wrong... You may want to save yourself some embarrassment by checking code before you post it here:

Bah... you know what I meant. Unpredicted branches on an x86 cost roughly 6 cycles, not including the neg; we assume for both cases that we're inlining the function (no call overhead) What I intended to show was that you could do it better with a touch of bit math. I think the right way is actually to use something like asm's: rol EAX, 1; // 1000_0001 becomes 0000_0011 shr EAX, 1; // 0000_0011 becomes 0000_0001 Of course, I can't test this. I'm at work, not at home with my development box. I may have also used the wrong right shift instruction, or used the rotate that goes through the sign bit in EFLAGS. Surely one of the asm gurus has presented this already? So I looked around a bit. Some further reading: http://www.azillionmonkeys.com/qed/2scomp.html http://graphics.stanford.edu/~seander/bithacks.html#IntegerAbs

BTW I'm mentioned on that second page <g>. Seriously, the emphasis to this point in Tango has been getting the interface and the implementation correct, rather than low-level optimisation (since it can be done later). There's a lot still to be done. Any contributions are very welcome.
Apr 19 2007
prev sibling next sibling parent Sean Kelly <sean f4.ca> writes:
Dan wrote:
 
 I went through tango.core.Array and tango.math.Math and personally found
several rather junior mistakes like:
 
 int abs(int x){
   return x > 0? x : -x;
  // should be: return x &= 0x7FFF_FFFF;
 }
 
 and all sorts of template mess in Array and String just to implement things
like find as well as several equivalents to opAssign, opAdd, opCat etc.
 
 I spent three minutes quickly trying out a template that could implement find
on an array of any type using delegates or functions, as well as trying to
remember what an operator overload would be classified as; and to be honest I
did find it somewhat disorienting so I can understand that part.

You're welcome to submit suggestions if you think the current implementation can be improved. Please note that any array routine must work for array literals, static arrays, and dynamic arrays, that duplicate generated code should be avoided whenever possible, and any default predicate should have its code inlined. Also, predicate support must allow for any callable type, not just delegates and functions. Sean
Apr 18 2007
prev sibling parent reply Derek Parnell <derek psych.ward> writes:
On Wed, 18 Apr 2007 15:09:12 -0400, Dan wrote:

 I went through tango.core.Array and tango.math.Math and personally found
 several rather junior mistakes like:
 
 int abs(int x){
   return x > 0? x : -x;
  // should be: return x &= 0x7FFF_FFFF;
 }

I disagree strongly with your "improvement" on the grounds that it assumes a particular implementation of signed integers. The compiler knows better. If I was to suggest any change it would be return x >= 0 ? x : -x; because that way if zero is supplied, it won't try to evaluate -zero. -- Derek Parnell Melbourne, Australia "Justice for David Hicks!" skype: derek.j.parnell
Apr 18 2007
parent reply Stephen Waits <steve waits.net> writes:
Derek Parnell wrote:
   return x >= 0 ? x : -x;

Or, if we're going to get that picky, and you want to prefer +0 over -0, then you can also eliminate the equality test. return x < 0 ? -x : x; I agree with you.. portability is preferred here, considering the non-existent performance difference. I'd even go as far as saying that using bit twiddling in this specific case is the "junior mistake". Why? Because it assumes that the compiler isn't already taking care of this for you. In C++, my gcc4 already optimizes both -x and x *= -1 into optimal code, similar to the bit-twiddling Dan suggested. I have to assume we can get the same under D, whether it exists today or not. --Steve
Apr 18 2007
parent reply "David B. Held" <dheld codelogicconsulting.com> writes:
Stephen Waits wrote:
 [...]
 I agree with you.. portability is preferred here, considering the 
 non-existent performance difference.
 
 I'd even go as far as saying that using bit twiddling in this specific 
 case is the "junior mistake".
 
 Why?  Because it assumes that the compiler isn't already taking care of 
 this for you.
 [...]

To highlight this point, I interviewed a candidate the other day that agonized over the best way to return a vector from a C++ function in an efficient manner. He considered heap-allocating it and returning a pointer (apparently, he thinks 'new' is fast), passing an out reference, and a few other things. And yet, he didn't once mention the fact that he was passing *in* two vectors *by value*. When I asked him the most efficient way to pass in the input vectors, I asked if he should do it by value, by reference, or by pointer. He said: "By pointer". Oy vai! Apparently, he wasn't familiar with [N]RVO, and was optimizing the wrong thing. 90% of any given program contributes only 10% to its overall performance, typically. That's why C.A.R. Hoare warned against the dangers of premature optimization (and making sure you optimize the *right* thing). Dave
Apr 19 2007
parent reply Daniel Keep <daniel.keep.lists gmail.com> writes:
David B. Held wrote:
 Stephen Waits wrote:
 [...]
 I agree with you.. portability is preferred here, considering the
 non-existent performance difference.

 I'd even go as far as saying that using bit twiddling in this specific
 case is the "junior mistake".

 Why?  Because it assumes that the compiler isn't already taking care
 of this for you.
 [...]

To highlight this point, I interviewed a candidate the other day that agonized over the best way to return a vector from a C++ function in an efficient manner. He considered heap-allocating it and returning a pointer (apparently, he thinks 'new' is fast), passing an out reference, and a few other things. And yet, he didn't once mention the fact that he was passing *in* two vectors *by value*. When I asked him the most efficient way to pass in the input vectors, I asked if he should do it by value, by reference, or by pointer. He said: "By pointer". Oy vai! Apparently, he wasn't familiar with [N]RVO, and was optimizing the wrong thing. 90% of any given program contributes only 10% to its overall performance, typically. That's why C.A.R. Hoare warned against the dangers of premature optimization (and making sure you optimize the *right* thing). Dave

This is one thing I really lament about my uni education thus far. Two topics that basically have *never* been covered in even minimal detail have been optimisation and debugging. To be honest, I wouldn't know the most efficient way to return or pass out a vector because I've never had any kind of grounding in the effects of the various ways of doing it. For instance: at what point does passing by reference become faster than by value? Wish I knew :) -- Daniel -- int getRandomNumber() { return 4; // chosen by fair dice roll. // guaranteed to be random. } http://xkcd.com/ v2sw5+8Yhw5ln4+5pr6OFPma8u6+7Lw4Tm6+7l6+7D i28a2Xs3MSr2e4/6+7t4TNSMb6HTOp5en5g6RAHCP http://hackerkey.com/
Apr 19 2007
next sibling parent reply "David B. Held" <dheld codelogicconsulting.com> writes:
Daniel Keep wrote:
 [...]
 This is one thing I really lament about my uni education thus far.  Two
 topics that basically have *never* been covered in even minimal detail
 have been optimisation and debugging.
 
 To be honest, I wouldn't know the most efficient way to return or pass
 out a vector because I've never had any kind of grounding in the effects
 of the various ways of doing it.  For instance: at what point does
 passing by reference become faster than by value?

This is where it really helps to have some understanding of what a compiler actually does. The "Java Syndrome" helps students treat the compiler like a magical black box where text goes in and executables come out. While this is useful for cranking out thousands of entry-level programmers that assiduously follow design specs, it's not very good for creating engineers who are also artists. If you want to understand pass-by-value vs. pass-by-reference, it helps to understand how C works, and then how assembly works. Only when you get an idea for the actual instructions involved and how much time they take, relatively speaking, does it become practical to estimate these things. You can never be 100% sure what code a compiler is going to generate without looking at the output, but after you learn a few languages, you can make pretty good guesses. For function call performance, you need to understand registers, memory, stacks, call frames, and calling conventions. You also need to understand that references are just pointers that get automagically dereferenced on use. Once you put these things together, it starts to become fairly clear when one is preferred over the other (though there is definitely a gray area where it depends on the actual code generation and hardware characteristics). If you really want to be a good programmer, you need to take your education into your own hands. I would venture to claim that the majority of experts in the world learned most of what they know from self-study, and not from classroom lectures and textbooks. You are particularly lucky to be alive at this point in time because you have ridiculously more free information available to you than I did when I was growing up. I would have killed to have as much of the internet to access as you do. If you are really serious about your education, you will soon find your classes boring, because most of your learning will be self-directed. But you have to be fairly motivated to engage in that kind of learning, and everyone has different personalities. In the end, a diploma only proves that you will jump through hoops for The Man (which is important for getting a job in the corporate world, where docility is rewarded and innovation is discouraged). Dave
Apr 19 2007
next sibling parent Sean Kelly <sean f4.ca> writes:
David B. Held wrote:
 Daniel Keep wrote:
 [...]
 This is one thing I really lament about my uni education thus far.  Two
 topics that basically have *never* been covered in even minimal detail
 have been optimisation and debugging.


I took a university course on software testing a while back and found it to be fairly useful. It opened with proofs of correctness and went from there. Not directly related to debugging, but close enough to bear mentioning.
 If you really want to be a good programmer, you need to take your 
 education into your own hands.  I would venture to claim that the 
 majority of experts in the world learned most of what they know from 
 self-study, and not from classroom lectures and textbooks.

Definitely.
 If you are really serious about your education, you will soon find your 
 classes boring, because most of your learning will be self-directed. But 
 you have to be fairly motivated to engage in that kind of learning, and 
 everyone has different personalities.  In the end, a diploma only proves 
 that you will jump through hoops for The Man (which is important for 
 getting a job in the corporate world, where docility is rewarded and 
 innovation is discouraged).

True enough, but a lot of importance is placed on degrees nevertheless. My advice would be not to go to college until you're ready to take it seriously, because there's no point in paying for a service you're not going to use. But don't look to formal education as the beginning and end of the learning process. In the professional sector, credentials might get you an interview but they won't get you a job. Sean
Apr 20 2007
prev sibling next sibling parent Daniel Keep <daniel.keep.lists gmail.com> writes:
David B. Held wrote:
 Daniel Keep wrote:
 [...]
 This is one thing I really lament about my uni education thus far.  Two
 topics that basically have *never* been covered in even minimal detail
 have been optimisation and debugging.

 To be honest, I wouldn't know the most efficient way to return or pass
 out a vector because I've never had any kind of grounding in the effects
 of the various ways of doing it.  For instance: at what point does
 passing by reference become faster than by value?

This is where it really helps to have some understanding of what a compiler actually does. The "Java Syndrome" helps students treat the compiler like a magical black box where text goes in and executables come out. While this is useful for cranking out thousands of entry-level programmers that assiduously follow design specs, it's not very good for creating engineers who are also artists.

Well, it's a good thing that I loathe Java, then ;)
 If you want to understand pass-by-value vs. pass-by-reference, it helps
 to understand how C works, and then how assembly works.  Only when you
 get an idea for the actual instructions involved and how much time they
 take, relatively speaking, does it become practical to estimate these
 things.  You can never be 100% sure what code a compiler is going to
 generate without looking at the output, but after you learn a few
 languages, you can make pretty good guesses.

I think I've got a fairly good understanding of *how* things work at the instruction level. My current failing is, I believe, the part about understanding their relative speed under different circumstances. The example I gave in my previous posting was in regards to my vector struct; I don't understand the relative speeds of copying the vectors onto the stack and dereferencing pointers to them to be able to comfortably make a decision on which to use.
 For function call performance, you need to understand registers, memory,
 stacks, call frames, and calling conventions.  You also need to
 understand that references are just pointers that get automagically
 dereferenced on use.  Once you put these things together, it starts to
 become fairly clear when one is preferred over the other (though there
 is definitely a gray area where it depends on the actual code generation
 and hardware characteristics).
 
 If you really want to be a good programmer, you need to take your
 education into your own hands.  I would venture to claim that the
 majority of experts in the world learned most of what they know from
 self-study, and not from classroom lectures and textbooks.  You are
 particularly lucky to be alive at this point in time because you have
 ridiculously more free information available to you than I did when I
 was growing up.  I would have killed to have as much of the internet to
 access as you do.
 
 If you are really serious about your education, you will soon find your
 classes boring, because most of your learning will be self-directed. But
 you have to be fairly motivated to engage in that kind of learning, and
 everyone has different personalities.  In the end, a diploma only proves
 that you will jump through hoops for The Man (which is important for
 getting a job in the corporate world, where docility is rewarded and
 innovation is discouraged).
 
 Dave

Well, I basically taught myself to program from books and online tutorials. Sadly, my first languages were all BASICs (GWBASIC, QBASIC and then Visual Basic 5 & 6), although I hope I've made up for that by taking an interest in a wider variety of languages. My comp.sci. degree was boring until about the third year when it finally started to get interesting :) That said, I don't think I'll ever really be able to learn enough... all I can do is continue to read and experiment, hopefully bettering myself in the process. -- Daniel -- int getRandomNumber() { return 4; // chosen by fair dice roll. // guaranteed to be random. } http://xkcd.com/ v2sw5+8Yhw5ln4+5pr6OFPma8u6+7Lw4Tm6+7l6+7D i28a2Xs3MSr2e4/6+7t4TNSMb6HTOp5en5g6RAHCP http://hackerkey.com/
Apr 20 2007
prev sibling parent reply Stephen Waits <steve waits.net> writes:
David B. Held wrote:
 
 compiler actually does.  The "Java Syndrome" helps students treat the 

Ahh, thanks for giving it a name. I'll add that to our vocabulary here. We've been seeing this get worse and worse in the past 5 years. It's to the point now where entry-level candidates we interview, from some high-profile schools, cannot write a basic recursive function (factorial) or demonstrate any knowledge about pointers, memory, or anything to do with bits. That's been my experience anyway. Basically, seems like the students aren't learning much about the machine any more. Were they ever? Or were us "old-timers" (I'm 35, not quite an old timer, but whatever) just so excited about the whole thing that we all spent way too much time learning stuff on our own? (I also quit college so I could learn more) I fear for some of the guys coming through here, that some day they may find themselves inside a paper bag. --Steve
Apr 20 2007
next sibling parent Sean Kelly <sean f4.ca> writes:
Stephen Waits wrote:
 David B. Held wrote:
 compiler actually does.  The "Java Syndrome" helps students treat the 

Ahh, thanks for giving it a name. I'll add that to our vocabulary here. We've been seeing this get worse and worse in the past 5 years. It's to the point now where entry-level candidates we interview, from some high-profile schools, cannot write a basic recursive function (factorial) or demonstrate any knowledge about pointers, memory, or anything to do with bits.

I have had similar problems interviewing new graduates who learned with Java rather than C++. Fortunately, it's not universal. One interviewee I remember was taught using Java but reasoned correctly about the C/C++ questions using their knowledge of architecture. I've never had an interviewee do that before, even the ones who know C/C++.
 Basically, seems like the students aren't learning much about the 
 machine any more.  Were they ever?  Or were us "old-timers" (I'm 35, not 
 quite an old timer, but whatever) just so excited about the whole thing 
 that we all spent way too much time learning stuff on our own?  (I also 
 quit college so I could learn more

Well, I think it is less important what a student is taught than what they learn ;-) But simple exposure to explicit memory management, stack-based vs. dynamic data, etc, makes a noticeable difference. If nothing else, the average graduate taught with C, C++, or Pascal will have some basic concept of what it means for data to be on the stack vs. the heap.
 I fear for some of the guys coming through here, that some day they may 
 find themselves inside a paper bag.

Same here. However, if a field doesn't interest someone enough to inspire them to learn about it on their own time then they are probably in the wrong field. If someone is pursuing CS for the money, they are in for a disappointment. Sean
Apr 20 2007
prev sibling parent reply Walter Bright <newshound1 digitalmars.com> writes:
Stephen Waits wrote:
 Basically, seems like the students aren't learning much about the 
 machine any more.  Were they ever?  Or were us "old-timers" (I'm 35, not 
 quite an old timer, but whatever) just so excited about the whole thing 
 that we all spent way too much time learning stuff on our own?  (I also 
 quit college so I could learn more)

A guy in my dorm in college built a CPU board out of random logic (NAND, NOR gates) just for fun. Those are the kind of guys you want to hire! I think it was Niven who wrote that a real scientist was one who'd fearlessly peer through the gates of hell if he thought he could learn something. It isn't hard to tell the real engineers from the "just a job" folks in a job interview. The real engineers: 1) did weird projects in their spare time, just for fun, not for credit 2) regard getting a degree as incidental, and wind up leaving it forgotten in the bottom of a drawer 3) took the hard classes that weren't required 4) didn't duck the calculus classes 5) can enthusiastically describe their projects 6) can tell you how bright an LED can glow if you file down the housing a bit and stick it in liquid nitrogen The charlatans: 1) did nothing that wasn't required 2) generally complain that their hard work goes unrecognized 3) are much more interested in the salary & benefits rather than what the work is 4) have difficulty describing just what their last project was and what their contribution to it was 5) complain about outsourcing or foreigners taking their jobs 6) never made beersicles from pouring beer into liquid nitrogen
Apr 20 2007
next sibling parent reply Stephen Waits <steve waits.net> writes:
Walter Bright wrote:
 It isn't hard to tell the real engineers from the "just a job" folks in 
 a job interview. The real engineers:
 
 1) did weird projects in their spare time, just for fun, not for credit
 2) regard getting a degree as incidental, and wind up leaving it 
 forgotten in the bottom of a drawer
 3) took the hard classes that weren't required
 4) didn't duck the calculus classes
 5) can enthusiastically describe their projects
 6) can tell you how bright an LED can glow if you file down the housing 
 a bit and stick it in liquid nitrogen
 
 The charlatans:
 
 1) did nothing that wasn't required
 2) generally complain that their hard work goes unrecognized
 3) are much more interested in the salary & benefits rather than what 
 the work is
 4) have difficulty describing just what their last project was and what 
 their contribution to it was
 5) complain about outsourcing or foreigners taking their jobs
 6) never made beersicles from pouring beer into liquid nitrogen

Nicely said. This is basically what we go by too; except, maybe for the liquid nitrogen parts. Sounds like somebody had some fun back in the day... :) --Steve
Apr 20 2007
parent reply Walter Bright <newshound1 digitalmars.com> writes:
Stephen Waits wrote:
 This is basically what we go by too; except, maybe for the liquid 
 nitrogen parts.  Sounds like somebody had some fun back in the day...  :)

There was making a flamethrower out of a lawnmower, too, and the time some friends discovered how a stereo could be used to shake the whole building, and lots of other stuff <g>.
Apr 20 2007
parent reply Dan <murpsoft hotmail.com> writes:
Walter Bright Wrote:

 Stephen Waits wrote:
 This is basically what we go by too; except, maybe for the liquid 
 nitrogen parts.  Sounds like somebody had some fun back in the day...  :)

There was making a flamethrower out of a lawnmower, too, and the time some friends discovered how a stereo could be used to shake the whole building, and lots of other stuff <g>.

Yeah, I enjoyed playing with thermite, and would maim to get my hands on a huge roll of aerogel. Apart from women, it's software and physics that interest me the most; and I'm not much for small talk. : )
Apr 20 2007
parent BCS <BCS pathlink.com> writes:
Dan wrote:
 
 Apart from women, it's software and physics that interest me the most; and I'm
not much for small talk.
 
 : )

"Science is like sex: sometimes something useful comes out, but that is not the reason we are doing it" -- Richard Feynman
Apr 23 2007
prev sibling parent reply Chris Nicholson-Sauls <ibisbasenji gmail.com> writes:
Walter Bright wrote:
 Stephen Waits wrote:
 Basically, seems like the students aren't learning much about the 
 machine any more.  Were they ever?  Or were us "old-timers" (I'm 35, 
 not quite an old timer, but whatever) just so excited about the whole 
 thing that we all spent way too much time learning stuff on our own?  
 (I also quit college so I could learn more)

A guy in my dorm in college built a CPU board out of random logic (NAND, NOR gates) just for fun. Those are the kind of guys you want to hire! I think it was Niven who wrote that a real scientist was one who'd fearlessly peer through the gates of hell if he thought he could learn something. It isn't hard to tell the real engineers from the "just a job" folks in a job interview. The real engineers: 1) did weird projects in their spare time, just for fun, not for credit 2) regard getting a degree as incidental, and wind up leaving it forgotten in the bottom of a drawer 3) took the hard classes that weren't required 4) didn't duck the calculus classes 5) can enthusiastically describe their projects 6) can tell you how bright an LED can glow if you file down the housing a bit and stick it in liquid nitrogen The charlatans: 1) did nothing that wasn't required 2) generally complain that their hard work goes unrecognized 3) are much more interested in the salary & benefits rather than what the work is 4) have difficulty describing just what their last project was and what their contribution to it was 5) complain about outsourcing or foreigners taking their jobs 6) never made beersicles from pouring beer into liquid nitrogen

Ironically, a friend of mine just recently acquired some liquid nitrogen and we've been chattering away at work planning all the things we intend to do with it. Time to add beersicles to the list.. made from home brewed beer no less. ;) Bananas and marshmellows do fun things too... especially if loaded into certain old nerf guns, but I digress. -- Chris Nicholson-Sauls -- who still dreams of cubicle nerf wars gone awry
Apr 20 2007
parent Clay Smith <clayasaurus gmail.com> writes:
Chris Nicholson-Sauls wrote:
 Walter Bright wrote:
 Stephen Waits wrote:
 Basically, seems like the students aren't learning much about the 
 machine any more.  Were they ever?  Or were us "old-timers" (I'm 35, 
 not quite an old timer, but whatever) just so excited about the whole 
 thing that we all spent way too much time learning stuff on our own?  
 (I also quit college so I could learn more)

A guy in my dorm in college built a CPU board out of random logic (NAND, NOR gates) just for fun. Those are the kind of guys you want to hire! I think it was Niven who wrote that a real scientist was one who'd fearlessly peer through the gates of hell if he thought he could learn something. It isn't hard to tell the real engineers from the "just a job" folks in a job interview. The real engineers: 1) did weird projects in their spare time, just for fun, not for credit 2) regard getting a degree as incidental, and wind up leaving it forgotten in the bottom of a drawer 3) took the hard classes that weren't required 4) didn't duck the calculus classes 5) can enthusiastically describe their projects 6) can tell you how bright an LED can glow if you file down the housing a bit and stick it in liquid nitrogen The charlatans: 1) did nothing that wasn't required 2) generally complain that their hard work goes unrecognized 3) are much more interested in the salary & benefits rather than what the work is 4) have difficulty describing just what their last project was and what their contribution to it was 5) complain about outsourcing or foreigners taking their jobs 6) never made beersicles from pouring beer into liquid nitrogen

Ironically, a friend of mine just recently acquired some liquid nitrogen and we've been chattering away at work planning all the things we intend to do with it. Time to add beersicles to the list.. made from home brewed beer no less. ;) Bananas and marshmellows do fun things too... especially if loaded into certain old nerf guns, but I digress. -- Chris Nicholson-Sauls -- who still dreams of cubicle nerf wars gone awry

I heard that ice cream created with liquid nitrogen tastes very good and it is very quick to make as well.
Apr 24 2007
prev sibling next sibling parent reply Stephen Waits <steve waits.net> writes:
Daniel Keep wrote:
 
 To be honest, I wouldn't know the most efficient way to return or pass
 out a vector because I've never had any kind of grounding in the effects
 of the various ways of doing it.  For instance: at what point does
 passing by reference become faster than by value?

10 second lesson on optimization: * Memory access is slow. Both reading and writing. It's generally been that way for a long time, and appears to be staying that way. * Optimize what is slowest. * Know what's slowest by profiling. * The largest gains generally come from larger algorithmic changes. --Steve
Apr 20 2007
next sibling parent Dan <murpsoft hotmail.com> writes:
Stephen Waits Wrote:
 * Memory access is slow.  Both reading and writing.  It's generally been 
 that way for a long time, and appears to be staying that way.
 
 * Optimize what is slowest.

Optimize what consumes the most time when the user needs it most. Having a slow idle process that consumes the cpu time doesn't imply you need to make the idle process more effiicient. : )
 * Know what's slowest by profiling.

This involves more than invoking a program. It involves some heuristics.
 * The largest gains generally come from larger algorithmic changes.

I find trivial things like aligning heavily used structs and using in/out/inout parameters in the right places make a big difference and don't even require significant thought. ~~~ To answer his question; A reference is typically a void**, which essentially means a pair of 32-bit (on a 32 bit system) values stored somewhere. Those values are used as indexes into the massive array that is your program's memory space (a.k.a: pointers). If both pointers are already loaded into cache by virtue of being on the same memory page as previously executed data, then dereferencing can take as few as 4 cycles. In the event of a cache miss, it can take several hundred. Typically they're kept on the stack, so you almost always get towards the low end. Passing by value tends to involve moving the data itself, either through registers or the stack (at 1 mov instruction each 32-bit dword). If the data is less than 128-bits, it tends to be cheaper to pass by value than by reference; and with SSE2, that can be true with data up to 512-bits. Additionally, once the data has been passed by value, you can manipulate it on the spot; using inout parameters for direct manipulation and in parameters when you only want to touch a copy of the data (copies are as cheap as the original, unlike when passed by reference) I may have missed some things. Regardless, those are my thoughts on it atm. Sincerely, Dan
Apr 20 2007
prev sibling next sibling parent Sean Kelly <sean f4.ca> writes:
Stephen Waits wrote:
 Daniel Keep wrote:
 To be honest, I wouldn't know the most efficient way to return or pass
 out a vector because I've never had any kind of grounding in the effects
 of the various ways of doing it.  For instance: at what point does
 passing by reference become faster than by value?

10 second lesson on optimization: * Memory access is slow. Both reading and writing. It's generally been that way for a long time, and appears to be staying that way. * Optimize what is slowest.

Optimizers (within the compiler) put a weird spin on some of these however, because they take care of most fine-grained optimizations automatically. I think these are good things to keep in mind, but they are subordinate to what you mention below:
 * Know what's slowest by profiling.
 
 * The largest gains generally come from larger algorithmic changes.

Sean
Apr 20 2007
prev sibling parent reply Derek Parnell <derek psych.ward> writes:
On Fri, 20 Apr 2007 10:27:14 -0700, Stephen Waits wrote:

 Daniel Keep wrote:
 
 To be honest, I wouldn't know the most efficient way to return or pass
 out a vector because I've never had any kind of grounding in the effects
 of the various ways of doing it.  For instance: at what point does
 passing by reference become faster than by value?

10 second lesson on optimization: * Memory access is slow. Both reading and writing. It's generally been that way for a long time, and appears to be staying that way.

'Slow' compared to Register access rather than Disk access <G> In other words, try to use the data that is in registers rather than get it (again) from RAM, and try to use registers as temporary/intermediate areas.
 * Optimize what is slowest.
 
 * Know what's slowest by profiling.

A concentrate on slow functions that are used frequently rather those that are rarely used. I've seen people spend way to much time on shaving off milliseconds from a program's initialization section rather than deal with other areas that are run thousands of times each time the application is executed.
 * The largest gains generally come from larger algorithmic changes.

YES! Time spent working on getting the best algorithm is always going to pay dividends. Improving the efficiency of a bubble-sort for million-element array is probably a waste of time. -- Derek Parnell Melbourne, Australia "Justice for David Hicks!" skype: derek.j.parnell
Apr 20 2007
parent Stephen Waits <steve waits.net> writes:
Derek Parnell wrote:
 On Fri, 20 Apr 2007 10:27:14 -0700, Stephen Waits wrote:
 * Know what's slowest by profiling.

A concentrate on slow functions that are used frequently rather those that are rarely used. I've seen people spend way to much time on shaving off milliseconds from a program's initialization section rather than deal with other areas that are run thousands of times each time the application is executed.

Yes, exactly what I meant; only said more eloquently. There's only so much I can teach in 10 seconds! --Steve
Apr 20 2007
prev sibling parent reply Walter Bright <newshound1 digitalmars.com> writes:
Daniel Keep wrote:
 This is one thing I really lament about my uni education thus far.  Two
 topics that basically have *never* been covered in even minimal detail
 have been optimisation and debugging.

Most great programmers didn't learn programming from taking college courses. They learned it on their own. Programming has the nice characteristic that it is fairly straightforward to learn on your own. Want to take advantage of what a university can offer? Taking the basic course in each of following will pay you lifelong dividends: 1) Calculus 2) Accounting 3) Physics 4) Chemistry 5) Statistics 6) Electronics
Apr 20 2007
parent reply Dave <Dave_member pathlink.com> writes:
Walter Bright wrote:
 Daniel Keep wrote:
 This is one thing I really lament about my uni education thus far.  Two
 topics that basically have *never* been covered in even minimal detail
 have been optimisation and debugging.

Most great programmers didn't learn programming from taking college courses. They learned it on their own. Programming has the nice characteristic that it is fairly straightforward to learn on your own. Want to take advantage of what a university can offer? Taking the basic course in each of following will pay you lifelong dividends: 1) Calculus 2) Accounting 3) Physics 4) Chemistry 5) Statistics 6) Electronics

I couldn't agree more. Software development is and always has been a craft(*) - part science, part art. Colleges have never been really good at teaching crafts -- no such thing as a "Bachelor of Crafts in Software Development" <g> Personally, the best developers I've ever known (again, personally -- please note the next paragraph) have almost w/o exception been formally trained/educated for something else, and most of the CS majors went into management (but then again maybe they're truly the smart ones <g>). That said, there are *alot* of super-smart CS students and graduates in this group, I gather. If it's truly what you love doing, a CS or related degree can only help because you get to goof-off for 4 years doing what you like and learning too <G> (*) Alan Cooper ("The Father of Visual Basic") for the insight that Software Development is really more of a craft than a science.
Apr 20 2007
parent reply Chris Nicholson-Sauls <ibisbasenji gmail.com> writes:
Dave wrote:
 Walter Bright wrote:
 Daniel Keep wrote:
 This is one thing I really lament about my uni education thus far.  Two
 topics that basically have *never* been covered in even minimal detail
 have been optimisation and debugging.

Most great programmers didn't learn programming from taking college courses. They learned it on their own. Programming has the nice characteristic that it is fairly straightforward to learn on your own. Want to take advantage of what a university can offer? Taking the basic course in each of following will pay you lifelong dividends: 1) Calculus 2) Accounting 3) Physics 4) Chemistry 5) Statistics 6) Electronics

I couldn't agree more. Software development is and always has been a craft(*) - part science, part art. Colleges have never been really good at teaching crafts -- no such thing as a "Bachelor of Crafts in Software Development" <g> Personally, the best developers I've ever known (again, personally -- please note the next paragraph) have almost w/o exception been formally trained/educated for something else, and most of the CS majors went into management (but then again maybe they're truly the smart ones <g>). That said, there are *alot* of super-smart CS students and graduates in this group, I gather. If it's truly what you love doing, a CS or related degree can only help because you get to goof-off for 4 years doing what you like and learning too <G> (*) Alan Cooper ("The Father of Visual Basic") for the insight that Software Development is really more of a craft than a science.

I tend to tell people that all forms of art seemingly arise from some form of science. Programming just happens to be an artform still closely linked to its base science. And our own Walter -- if I recall right -- is a prime example of a major developer whose background is in something else. I'm pretty sure those airplanes didn't require new compilers. -- Chris Nicholson-Sauls
Apr 20 2007
next sibling parent reply Walter Bright <newshound1 digitalmars.com> writes:
Chris Nicholson-Sauls wrote:
 I tend to tell people that all forms of art seemingly arise from some 
 form of science. Programming just happens to be an artform still closely 
 linked to its base science.  And our own Walter -- if I recall right -- 
 is a prime example of a major developer whose background is in something 
 else.  I'm pretty sure those airplanes didn't require new compilers.

My training is as a mechanical engineer, with an emphasis on jet engines. I was fortunate enough to attend a university (Caltech) that thoroughly believed that all their sci/eng majors should be well grounded in a broad range of fields, and as I've gotten older and wiser I see the value in it now. Caltech requires of all its graduates: o 3 years of calculus o 2 years physics o 1 year chemistry among other courses.
Apr 22 2007
parent reply Bill Baxter <dnewsgroup billbaxter.com> writes:
Walter Bright wrote:
 Chris Nicholson-Sauls wrote:
 I tend to tell people that all forms of art seemingly arise from some 
 form of science. Programming just happens to be an artform still 
 closely linked to its base science.  And our own Walter -- if I recall 
 right -- is a prime example of a major developer whose background is 
 in something else.  I'm pretty sure those airplanes didn't require new 
 compilers.

My training is as a mechanical engineer, with an emphasis on jet engines. I was fortunate enough to attend a university (Caltech) that thoroughly believed that all their sci/eng majors should be well grounded in a broad range of fields, and as I've gotten older and wiser I see the value in it now. Caltech requires of all its graduates: o 3 years of calculus o 2 years physics o 1 year chemistry among other courses.

If all you know is CS, then I think you're restricting the kind of work you can do. It's not too tough to figure out how to be a competent programmer coming from a hard science or engineering discipline. But going the other way is pretty much impossible. My tack was to take a lot of CS courses, because they were fun and relatively easy, but go with EE as the major. It was much more difficult, but I'm glad I did it that way. The decent grounding in calculus, linear algebra, Fourier analysis etc that I got from that has allowed me to do things I never would have been able to consider had I just gotten the CS education. I've heard that CS departments at schools these days are suffering from a big drop in the number of majors. But that seems to me to be as it should be. The IT boom brought on a lot of silliness. You really don't need a CS degree to do most IT jobs. Yes, *everybody* needs to know how work with computers these days to varying degrees. Just like everyone needs math to varying degrees. But that doesn't mean there need to be a lot of math majors, or CS majors. Almost everyone takes a class or two from the math department, but very few major in it. Likewise, pretty much everyone these days should have a class or two from the CS dept, but we don't really need that many majors. --bb
Apr 22 2007
next sibling parent reply Walter Bright <newshound1 digitalmars.com> writes:
Bill Baxter wrote:
 If all you know is CS, then I think you're restricting the kind of work 
 you can do.  It's not too tough to figure out how to be a competent 
 programmer coming from a hard science or engineering discipline.  But 
 going the other way is pretty much impossible.  My tack was to take a 
 lot of CS courses, because they were fun and relatively easy, but go 
 with EE as the major.  It was much more difficult, but I'm glad I did it 
 that way.  The decent grounding in calculus, linear algebra, Fourier 
 analysis etc that I got from that has allowed me to do things I never 
 would have been able to consider had I just gotten the CS education.

I agree. When I worked at Boeing, it was in the early days of using computers for engineering analysis. There were problems because the programmers didn't understand engineering, and the engineers didn't understand programming. So there'd be programs that worked great but solved the wrong problem. My lead engineer wryly remarked once that I was the only one he'd worked with who brought back numbers from the computer that weren't garbage. (Things have changed a lot since then, my friends who work there tell me that everything is done on computers now.) I've never seen anyone learn calculus outside of the classroom, but plenty of people who learned programming outside of one.
 I've heard that CS departments at schools these days are suffering from 
 a big drop in the number of majors.  But that seems to me to be as it 
 should be.  The IT boom brought on a lot of silliness.  You really don't 
 need a CS degree to do most IT jobs.  Yes, *everybody* needs to know how 
 work with computers these days to varying degrees.  Just like everyone 
 needs math to varying degrees.  But that doesn't mean there need to be a 
 lot of math majors, or CS majors.   Almost everyone takes a class or two 
 from the math department, but very few major in it.  Likewise, pretty 
 much everyone these days should have a class or two from the CS dept, 
 but we don't really need that many majors.

In defense of CS majors, Andrei has an academic CS background, and he's been a huge help in taking my limited back-of-envelope approach to the next level. I once saw a news program on cheaters in universities. Students would shamelessly state on camera that they cheated whenever they could get away with it. I just find that stunning. Several would justify it with the claim that since they'll never use 97% of what they learn in college, there was no point in learning it, and therefore it was fine to cheat. Just, wow. How pathetic and contemptible. A friend of mine went through MIT, and he told me that after he was there for a while he had an epiphany. MIT wasn't teaching him things. MIT was teaching him how to think. And that's what the calculus, physics, etc., classes will give you. Sure it's hard, but that's what it takes to rewire your brain <g>.
Apr 23 2007
parent reply Bill Baxter <dnewsgroup billbaxter.com> writes:
Walter Bright wrote:
 Bill Baxter wrote:

 I've heard that CS departments at schools these days are suffering 
 from a big drop in the number of majors.  But that seems to me to be 
 as it should be.  The IT boom brought on a lot of silliness.  You 
 really don't need a CS degree to do most IT jobs.  Yes, *everybody* 
 needs to know how work with computers these days to varying degrees.  
 Just like everyone needs math to varying degrees.  But that doesn't 
 mean there need to be a lot of math majors, or CS majors.   Almost 
 everyone takes a class or two from the math department, but very few 
 major in it.  Likewise, pretty much everyone these days should have a 
 class or two from the CS dept, but we don't really need that many majors.

In defense of CS majors, Andrei has an academic CS background, and he's been a huge help in taking my limited back-of-envelope approach to the next level.

Yeh, I'm not saying there's anything inherently wrong with a CS degree. But you may be better off with something else, unless what you really want to do is take fundamental concepts of computing to the next level. Just like you don't major in math just to learn how to use math. You major in math if you're interested in creating *new* math. Or discovering it. Whatever you want to call it. If what you want to do is create advanced new compilers or new languages, or new algorithms, then yeh, the CS degree is a good thing, provided it's done right. --bb
Apr 23 2007
parent reply Sean Kelly <sean f4.ca> writes:
Bill Baxter wrote:
 
 Yeh, I'm not saying there's anything inherently wrong with a CS degree. 
 But you may be better off with something else, unless what you really 
 want to do is take fundamental concepts of computing to the next level. 
  Just like you don't major in math just to learn how to use math.  You 
 major in math if you're interested in creating *new* math.  Or 
 discovering it.  Whatever you want to call it.
 
 If what you want to do is create advanced new compilers or new 
 languages, or new algorithms, then yeh, the CS degree is a good thing, 
 provided it's done right.

If nothing else, a CS background should provide someone with the tools necessary to solve complex problems and prevent too many wheels from being reinvented in the process. An ignorance of basic algorithms and data structures is inexcusable for someone creating software. Sean
Apr 23 2007
parent Dan <murpsoft hotmail.com> writes:
Sean Kelly Wrote:
 being reinvented in the process.  An ignorance of basic algorithms and 
 data structures is inexcusable for someone creating software.

Heh. : D I agree. In fact I was arguing the same point last week and someone was coming down on me for it. That said, I'm guilty of a few cases of ignorance and I learn by reinventing the wheel - I also occassionally invent things that haven't been invented yet... interestingly the process of learning that way has let me become good at (re)invention. I think to myself "self, what would be a really effective way to do this" and then I answer, "well, if I did this it would work" and then two weeks later go "eureka! It really should be this way! I wonder if anyone has done that yet..." : D Well, at least I ask if it's been done before instead of just assuming I invented it. Sincerely, Dan
Apr 23 2007
prev sibling next sibling parent reply Jeff Nowakowski <jeff dilacero.org> writes:
Walter Bright wrote:
 Caltech requires of all its graduates:

 o    3 years of calculus
 o    2 years physics
 o    1 year chemistry


Bill Baxter wrote:
 If all you know is CS, then I think you're restricting the kind of work 
 you can do.

I have a Computer Science degree, and I have never needed calculus, physics, chemistry, etc. in any of my programming jobs. I resent all the time I was forced to waste taking these courses, instead of learning about my trade. Sure, these topics would have been useful if I wanted to get a programming job in a field that made use of it, but I don't want these kinds of jobs, and there are plenty of programming jobs that don't need them. I even wouldn't have minded being exposed to the topics, but I was forced to take the same physics and calculus courses as mechanical engineers. I wasted so much time memorizing formulas and learning how to solve problems that I never touched again. I'm not into heavy math or physics, though I like the concepts at a high level. This doesn't make me a bad coder.
 I've heard that CS departments at schools these days are suffering from 
 a big drop in the number of majors.

My understanding is that there is a greater emphasis on Software Engineering as a degree for those who want to actually code instead of doing academic research. This is a good thing. Too many programmers graduate from college woefully unprepared for working in the industry. -Jeff
Apr 23 2007
next sibling parent reply Walter Bright <newshound1 digitalmars.com> writes:
Jeff Nowakowski wrote:
 Walter Bright wrote:
 Caltech requires of all its graduates:

 o    3 years of calculus
 o    2 years physics
 o    1 year chemistry


Bill Baxter wrote:
 If all you know is CS, then I think you're restricting the kind of 
 work you can do.

I have a Computer Science degree, and I have never needed calculus, physics, chemistry, etc. in any of my programming jobs. I resent all the time I was forced to waste taking these courses, instead of learning about my trade.

I have (such as using physics in game code), and, of course, in the engineering coding I've done. At worst, I simply have the pleasure of knowing the basics in that stuff, and can enjoy things like I once attended a dinner put on by the JPL mission director for a Mars probe, and was able to follow what he was talking about. I can appreciate what the Wright bros did and why they were successful while their contemporaries failed. I can read about technical things happening and be able understand what they're talking about. I know why those 9/11 conspiracy theories are hokum (all the "anomalies" are easily explained if you have even an elementary knowledge of physics and chemistry). It enabled me to correct a severe structural flaw in my house that the architect, structural engineer, and builder failed to notice. I have yet to find a roofer who understands what "galvanic corrosion" is, and I always check what kind of nails they use on the flashing (they're always wrong), saving me a ton of maintenance costs. The downside (if you could call it that) is that knowledge of real physics takes away from enjoying movies that have "Hollywood physics".
 Sure, these topics would have been useful if I wanted to get a 
 programming job in a field that made use of it, but I don't want these 
 kinds of jobs, and there are plenty of programming jobs that don't need 
 them.  I even wouldn't have minded being exposed to the topics, but I 
 was forced to take the same physics and calculus courses as mechanical 
 engineers.  I wasted so much time memorizing formulas and learning how 
 to solve problems that I never touched again.

It's too bad you were made to memorize formulas. To me, that isn't what physics is about, and at Caltech we were never made to memorize/regurgitate formulas. It's about learning how to solve complex problems. That skill comes in very handy with programming. For example, a common programming problem is your program doesn't behave. How do you go about fixing it? It's the same organized way of thinking as solving a physics or calculus problem.
Apr 23 2007
parent Daniel Keep <daniel.keep.lists gmail.com> writes:
Walter Bright wrote:
 Jeff Nowakowski wrote:
 Sure, these topics would have been useful if I wanted to get a
 programming job in a field that made use of it, but I don't want these
 kinds of jobs, and there are plenty of programming jobs that don't
 need them.  I even wouldn't have minded being exposed to the topics,
 but I was forced to take the same physics and calculus courses as
 mechanical engineers.  I wasted so much time memorizing formulas and
 learning how to solve problems that I never touched again.

It's too bad you were made to memorize formulas. To me, that isn't what physics is about, and at Caltech we were never made to memorize/regurgitate formulas. It's about learning how to solve complex problems. That skill comes in very handy with programming.

Maybe that's why I'm stuck with this burning desire to *never* get within a hundred kilometres of any maths course ever again. I know *why* it's useful, but having to sit down and memorise huge numbers of formulae so that I can write down answers for one test and then never look at it again was driving me crazy. But I'm not crazy. He he.
 For example, a common programming problem is your program doesn't
 behave. How do you go about fixing it? It's the same organized way of
 thinking as solving a physics or calculus problem.

Really? I'd always been taught that combining "hit it with a hammer until it sees your way" reasoning and chemistry was A Bad Idea™. And now I find out they were wrong! Cool! Now, if you'll excuse me, I'm gonna go hammer some red phosphorous and potassium chlorate together--what's the worst that could happen?* -- Daniel * Serious obligatory disclaimer: Do not try this. Ever. See the third last paragraph of http://www.theodoregray.com/PeriodicTable/Stories/015.8/index.html -- int getRandomNumber() { return 4; // chosen by fair dice roll. // guaranteed to be random. } http://xkcd.com/ v2sw5+8Yhw5ln4+5pr6OFPma8u6+7Lw4Tm6+7l6+7D i28a2Xs3MSr2e4/6+7t4TNSMb6HTOp5en5g6RAHCP http://hackerkey.com/
Apr 23 2007
prev sibling parent reply Sean Kelly <sean f4.ca> writes:
Jeff Nowakowski wrote:
 
 I have a Computer Science degree, and I have never needed calculus, 
 physics, chemistry, etc. in any of my programming jobs.  I resent all 
 the time I was forced to waste taking these courses, instead of learning 
 about my trade.

But many people do. That aside, science and math courses are invaluable for teaching problem solving skills, which are useful regardless of the problem domain.
 Sure, these topics would have been useful if I wanted to get a 
 programming job in a field that made use of it, but I don't want these 
 kinds of jobs, and there are plenty of programming jobs that don't need 
 them.

I think that's likely true for entry level jobs, but over time I've been surprised at just how useful math and science knowledge has been. Even seemingly straightforward topics like economics and accounting involve a decent bit of calculus.
 I even wouldn't have minded being exposed to the topics, but I
 was forced to take the same physics and calculus courses as mechanical 
 engineers.  I wasted so much time memorizing formulas and learning how 
 to solve problems that I never touched again.

That's more specific to the school than anything. One thing I've found is that the larger state schools seem to favor testing information retention rather than problem solving. One mathematics professor I talked to recently lamented this, saying he had to teach this way because it was what students expected at the school, and not doing so would have generated a lot of complaints. Interestingly, he has also seen a steady decline in his students performance over the years. I would guess this is because students are busier today than in the past, but it's interesting nevertheless.
 My understanding is that there is a greater emphasis on Software 
 Engineering as a degree for those who want to actually code instead of 
 doing academic research.  This is a good thing.  Too many programmers 
 graduate from college woefully unprepared for working in the industry.

Personally, I'm more interested in finding people with solid problem solving skills, good communication skills, and an ability to write clear, maintainable code than a knowledge of UML, a facility with specific tools, etc. The last bit is more related to job-specific knowledge anyway. Sean
Apr 23 2007
parent reply Jeff Nowakowski <jeff dilacero.org> writes:
Sean Kelly wrote:
 But many people do.  That aside, science and math courses are invaluable 
 for teaching problem solving skills, which are useful regardless of the 
 problem domain.

I see this idea mentioned over and over. "you won't need all this baroque knowledge we're feeding you, yet it will help your problem solving skills". Guess what I do when I write programs? Yep, I solve problems. I learned this skill while learning to program, and every time I program it is reinforced.
 I think that's likely true for entry level jobs, but over time I've been 
 surprised at just how useful math and science knowledge has been.

I've been programming in the industry since 1993. Most people just don't need the math, and if you do, find a converted math major or mechanical engineer to help you out (unless they have forgotten all their math skills, as many of them do since they never use this stuff!).
 Personally, I'm more interested in finding people with solid problem 
 solving skills, good communication skills, and an ability to write 
 clear, maintainable code than a knowledge of UML, a facility with 
 specific tools, etc.  The last bit is more related to job-specific 
 knowledge anyway.

You can learn good problem solving skills, communication, etc. while actually learning valuable software engineering techniques. I'm not talking about learning Java or UML. I'm talking about learning how to handle errors (this topic was completely ignored during my education), distributed programming, concurrency, keeping a service up 24/7, testing, source control, project management, etc. Solving physics problems is a waste of time, unless that is something that appeals to you. -Jeff
Apr 23 2007
next sibling parent reply Stephen Waits <steve waits.net> writes:
Jeff Nowakowski wrote:
 Sean Kelly wrote:
 I see this idea mentioned over and over.  "you won't need all this 
 baroque knowledge we're feeding you, yet it will help your problem 
 solving skills".  Guess what I do when I write programs?  Yep, I solve 
 problems.  I learned this skill while learning to program, and every 
 time I program it is reinforced.

In this age of specialization, I can understand how you may not use math in your job. And, while math might help in problem solving, I don't think that's why it should be taught. Math is useful. When you're tasked with implementing the backpropagation algorithm to train neural networks, and you get to the part that says you need to choose an easily differentiable activation function, then you need some Calculus knowledge. This is a trivial example, but the type of thing I run into all the time.
 I've been programming in the industry since 1993.  Most people just 
 don't need the math, and if you do, find a converted math major or 
 mechanical engineer to help you out (unless they have forgotten all 
 their math skills, as many of them do since they never use this stuff!).

Your "most people" is completely different from mine. In my line of work, *every* programmer, at minimum, applies linear algebra *every* day. Many make frequent use of calculus too. You may not have needed it in your job, but if you don't have these skills, don't apply for a job with me. :)
 You can learn good problem solving skills, communication, etc. while 
 actually learning valuable software engineering techniques.  I'm not 

Agree. --Steve
Apr 23 2007
next sibling parent Jeff Nowakowski <jeff dilacero.org> writes:
Stephen Waits wrote:
 Your "most people" is completely different from mine.  In my line of 
 work, *every* programmer, at minimum, applies linear algebra *every* 
 day.  Many make frequent use of calculus too.

Yes, in *your* line of work. There's tons and tons of software written that does not require heavy math skills. There's no reason to train all programmers in linear algebra and calculus. I think they should be exposed to it at a high level, and if they want to go deeper that should be their option.
 You may not have needed it in your job, but if you don't have these 
 skills, don't apply for a job with me.  :)

Indeed, and I never would. Isn't the free market wonderful? -Jeff
Apr 23 2007
prev sibling parent reply Derek Parnell <derek nomail.afraid.org> writes:
On Mon, 23 Apr 2007 15:00:06 -0700, Stephen Waits wrote:

 Jeff Nowakowski wrote:

 In this age of specialization, I can understand how you may not use math 
 in your job.  And, while math might help in problem solving, I don't 
 think that's why it should be taught.
 
 Math is useful.

Absolutely! The most compelling reason to learn maths in college is so that you can one day help your kids with their college homework. <G> -- Derek (skype: derek.j.parnell) Melbourne, Australia "Justice for David Hicks!" 24/04/2007 10:45:47 AM
Apr 23 2007
parent Bill Baxter <dnewsgroup billbaxter.com> writes:
Derek Parnell wrote:
 On Mon, 23 Apr 2007 15:00:06 -0700, Stephen Waits wrote:
 
 Jeff Nowakowski wrote:

 In this age of specialization, I can understand how you may not use math 
 in your job.  And, while math might help in problem solving, I don't 
 think that's why it should be taught.

 Math is useful.

Absolutely! The most compelling reason to learn maths in college is so that you can one day help your kids with their college homework. <G>

Heh heh. That's a similar reason why we need literature majors. Or classics majors. You have to have those majors in order to train new literature and classics professors for the next generation. --bb
Apr 23 2007
prev sibling parent reply Stephen Waits <steve waits.net> writes:
Jeff Nowakowski wrote:
 I see this idea mentioned over and over.  "you won't need all this 
 baroque knowledge we're feeding you, yet it will help your problem 
 solving skills".  Guess what I do when I write programs?  Yep, I solve 
 problems.  I learned this skill while learning to program, and every 
 time I program it is reinforced.

This blog post just hit my radar yesterday. Thought it was appropriate to this conversation. http://ihurl.com/2f --Steve
Apr 24 2007
parent reply Jeff Nowakowski <jeff dilacero.org> writes:
Stephen Waits wrote:
 This blog post just hit my radar yesterday.  Thought it was appropriate 
 to this conversation.
 
   http://ihurl.com/2f

And the full URL (I really dislike hidden URLs): http://steve-yegge.blogspot.com/2006/03/math-for-programmers.html That was a good blog article, thanks for posting it. I agree with a lot of what he says, in particular about the way math is taught. As I have said, I didn't mind the concepts so much as attention to arcane detail. I actually do what he's been doing, that is revisiting math as I need it while running across it in research papers. I still think, however, that the vast majority of programmers can get by with basic algebra, discrete math, and a high level understanding of calculus. -Jeff
Apr 24 2007
parent Sean Kelly <sean f4.ca> writes:
Jeff Nowakowski wrote:
 Stephen Waits wrote:
 This blog post just hit my radar yesterday.  Thought it was 
 appropriate to this conversation.

   http://ihurl.com/2f

And the full URL (I really dislike hidden URLs): http://steve-yegge.blogspot.com/2006/03/math-for-programmers.html That was a good blog article, thanks for posting it. I agree with a lot of what he says, in particular about the way math is taught. As I have said, I didn't mind the concepts so much as attention to arcane detail. I actually do what he's been doing, that is revisiting math as I need it while running across it in research papers.

Donald Knuth has a book called "Concrete Mathematics" that it fairly useful for programmers. It's also very well written, which is rare. Sean
Apr 24 2007
prev sibling next sibling parent reply Lars Ivar Igesund <larsivar igesund.net> writes:
Bill Baxter wrote:
 
 If all you know is CS, then I think you're restricting the kind of work
 you can do.  It's not too tough to figure out how to be a competent
 programmer coming from a hard science or engineering discipline.  But
 going the other way is pretty much impossible.  My tack was to take a
 lot of CS courses, because they were fun and relatively easy, but go
 with EE as the major.  It was much more difficult, but I'm glad I did it
 that way.  The decent grounding in calculus, linear algebra, Fourier
 analysis etc that I got from that has allowed me to do things I never
 would have been able to consider had I just gotten the CS education.

I have a CS master degree myself (is that what you call a major?), and I had all of the subjects you mention above. Over 5 years, I had calculus, linear algebra, the fourier stuff, laplace and friends (this was actually a math course especially for the computer students), statistics, physics, a tad chemistry, discrete mathematics, basic electronics, and some more digital techniques, molecular biology, pencil drawing (!), tree/wood facade project and introductory philosophy. In total, this amounted to almost 2 years, I think. The rest was CS related, the basics (computers, programming, etc), intermediate (software engineering/planning, databases, programming languages, etc) and my chosen subjects/projects (natural languages, algorithms, graphics, and a whole year spent on projects (including the master thesis) for privately held companies). All in all, I think this is as good as it will get at a university. Most of my fellow students ended up as consultants in Accenture and friends, very clever people, but at least a few chose their route more from the career outlooks back when we started, rather than a true interest in computers. Those of us who chose due to the latter, mostly have jobs in other areas, and quite a few have started their own companies.
 I've heard that CS departments at schools these days are suffering from
 a big drop in the number of majors.  But that seems to me to be as it
 should be.  The IT boom brought on a lot of silliness.  You really don't
 need a CS degree to do most IT jobs.  Yes, *everybody* needs to know how
 work with computers these days to varying degrees.  Just like everyone
 needs math to varying degrees.  But that doesn't mean there need to be a
 lot of math majors, or CS majors.   Almost everyone takes a class or two
 from the math department, but very few major in it.  Likewise, pretty
 much everyone these days should have a class or two from the CS dept,
 but we don't really need that many majors.

At my university, they are seeing a little bit lower levels on the incoming students' grades, but they're far away from having empty seats. Norway seems to be in a somewhat special situation these times though, companies sucking up all technical engineers coming out of Norwegian institutions. Also, Trondheim being a small city, and still having major employers like Google, Yahoo, Sun, ARM and Atmel, make CS majors a highly sought after group of employees. -- Lars Ivar Igesund blog at http://larsivi.net DSource, #d.tango & #D: larsivi Dancing the Tango
Apr 23 2007
parent reply Dan <murpsoft hotmail.com> writes:
When I went to university, my first year offered an extensive and exhaustive
examination of what an array is, and where the sign bit can be located.  In
Pascal, and the second course in Java.

Can you see why I didn't continue?

I had been programming since I was 12, and explained the course well enough to
have a friend actually pass after a 20 minute crash course by showing him a
language reference after explaining memory in terms of a giant row of boxes.

That said, if I didn't have to subject myself to that again, I would love to
someday actually learn something.  Until an institution offers learning, rather
than edumacation, I'll stick with reinventing the wheel and asking if someone's
discovered that yet.

I learned D, jump tables, level-order binary search arrays, as well as geodesic
binary search arrays in the past six months that way.

Sincerely,
Dan
Apr 23 2007
parent Lars Ivar Igesund <larsivar igesund.net> writes:
Dan wrote:
 
 That said, if I didn't have to subject myself to that again, I would love
 to someday actually learn something.  Until an institution offers
 learning, rather than edumacation, I'll stick with reinventing the wheel
 and asking if someone's discovered that yet.

I'm uncertain of which technical knowledge I truly gained during my studies, and which I also find useful in my work. There were a couple of reasons for this though, not the least the post dotcom jobmarket, leading me to work quite far from my specialization. I _do_ think that the diversity of the studies helped in going for different jobs, and I know that the team and social skills learned are invaluable where I'm now. -- Lars Ivar Igesund blog at http://larsivi.net DSource, #d.tango & #D: larsivi Dancing the Tango
Apr 23 2007
prev sibling parent reply Jascha Wetzel <"[firstname]" mainia.de> writes:
 You really don't need a CS degree to do most IT jobs

100% agreed i'll have to stand up for the CS majors here, though... ;) i think, these (fairly typical) statements about CS majors are highly dependent on the university. i attended exactly one lecture during the first semester of my CS major that was supposed to teach you something about programming. it was actually more an overview of programming paradigms and languages types. that's it. no more programming taught for the rest of the at least 4.5 years. therefore, argumenting that you can learn programming on your own and don't need to have a CS major doesn't make much sense to me, since you have to learn it on your own even if you do have a CS major. what i've learned instead: - calculus (incl. numerical and differential) - mathematical logic, knowledge representation - designing, analysing and proving correctness of algorithms - loads of algorithms and data structures - linear algebra, 3d geometry (incl. curves and surfaces), rendering, lighting simulation - image analysis, compression, etc. (incl. fourier analysis, btw) - some machine vision, pattern recognition - language theory, compiler construction and optimization - processor and operating system concepts - analog and digital electronics basics i don't regret having spent time with any of this. what i regret not having taken classes in is cryptography. i hope i'll find the time to make up for that... Bill Baxter wrote:
 Walter Bright wrote:
 Chris Nicholson-Sauls wrote:
 I tend to tell people that all forms of art seemingly arise from some
 form of science. Programming just happens to be an artform still
 closely linked to its base science.  And our own Walter -- if I
 recall right -- is a prime example of a major developer whose
 background is in something else.  I'm pretty sure those airplanes
 didn't require new compilers.

My training is as a mechanical engineer, with an emphasis on jet engines. I was fortunate enough to attend a university (Caltech) that thoroughly believed that all their sci/eng majors should be well grounded in a broad range of fields, and as I've gotten older and wiser I see the value in it now. Caltech requires of all its graduates: o 3 years of calculus o 2 years physics o 1 year chemistry among other courses.

If all you know is CS, then I think you're restricting the kind of work you can do. It's not too tough to figure out how to be a competent programmer coming from a hard science or engineering discipline. But going the other way is pretty much impossible. My tack was to take a lot of CS courses, because they were fun and relatively easy, but go with EE as the major. It was much more difficult, but I'm glad I did it that way. The decent grounding in calculus, linear algebra, Fourier analysis etc that I got from that has allowed me to do things I never would have been able to consider had I just gotten the CS education. I've heard that CS departments at schools these days are suffering from a big drop in the number of majors. But that seems to me to be as it should be. The IT boom brought on a lot of silliness. You really don't need a CS degree to do most IT jobs. Yes, *everybody* needs to know how work with computers these days to varying degrees. Just like everyone needs math to varying degrees. But that doesn't mean there need to be a lot of math majors, or CS majors. Almost everyone takes a class or two from the math department, but very few major in it. Likewise, pretty much everyone these days should have a class or two from the CS dept, but we don't really need that many majors. --bb

Apr 23 2007
parent reply Dan <murpsoft hotmail.com> writes:
Jascha Wetzel <[firstname] mainia.de> Wrote:

 You really don't need a CS degree to do most IT jobs

100% agreed

I agree too. I'm not saying "anyone can do it"; I'm saying that a degree doesn't provide as much as it ought in this particular field. I found my experience almost debilitating and I think there are a few reasons why: 1) By the time you're done 4th year, the exactly implementation you were taught starting 2nd year is already obsolete. 2) Professors were taught by their professors were taught by their professors. The teacher typically has never been in the industry, and doesn't really understand programming beyond trivial examples on a theoretical capacity. They're also typically still stuck in the same paradigms and with the same tools as their professor's professor (the 70's). 3) First year professors are really there to study a master's, not to teach. They typically suck at teaching, not being able to frame the paradigm with the right analogies, but merely having acceptable technical knowledge.
 
 i'll have to stand up for the CS majors here, though... ;)
 i think, these (fairly typical) statements about CS majors are highly
 dependent on the university. i attended exactly one lecture during 

For anyone interested, don't go to University of Calgary for CPSC. the
 first semester of my CS major that was supposed to teach you something
 about programming. it was actually more an overview of programming
 paradigms and languages types. that's it. no more programming taught for
 the rest of the at least 4.5 years.
 therefore, argumenting that you can learn programming on your own and
 don't need to have a CS major doesn't make much sense to me, since you
 have to learn it on your own even if you do have a CS major.
 
 what i've learned instead:
 - calculus (incl. numerical and differential)
 - mathematical logic, knowledge representation
 - designing, analysing and proving correctness of algorithms
 - loads of algorithms and data structures
 - linear algebra, 3d geometry (incl. curves and surfaces), rendering,
 lighting simulation
 - image analysis, compression, etc. (incl. fourier analysis, btw)
 - some machine vision, pattern recognition
 - language theory, compiler construction and optimization
 - processor and operating system concepts
 - analog and digital electronics basics
 
 i don't regret having spent time with any of this.
 what i regret not having taken classes in is cryptography. i hope i'll
 find the time to make up for that...

I wanted to fill the gaps in my skillset, such as learning x86-64 assembler, networking and cryptography, and advanced data structures and algorithms (geodesics, graph theory, neural net algorithms, min-max trees etc.) No dice, but I've since learned a couple of those points. I also wanted a piece of paper. No dice.
 Chris Nicholson-Sauls wrote:
 I tend to tell people that all forms of art seemingly arise from some
 form of science. Programming just happens to be an artform still




It really is a trivial science, if you can see through it. We've built such an abstraction over it that it's hard to see that underneath a kindergartener is learning to use all of the same concepts as a first year university student.
 closely linked to its base science.  And our own Walter -- if I
 recall right -- is a prime example of a major developer whose
 background is in something else.  I'm pretty sure those airplanes
 didn't require new compilers.

My training is as a mechanical engineer, with an emphasis on jet engines. I was fortunate enough to attend a university (Caltech) that thoroughly believed that all their sci/eng majors should be well grounded in a broad range of fields, and as I've gotten older and wiser I see the value in it now. Caltech requires of all its graduates: o 3 years of calculus o 2 years physics o 1 year chemistry among other courses.

If all you know is CS, then I think you're restricting the kind of work you can do. It's not too tough to figure out how to be a competent programmer coming from a hard science or engineering discipline. But going the other way is pretty much impossible. My tack was to take a lot of CS courses, because they were fun and relatively easy, but go with EE as the major. It was much more difficult, but I'm glad I did it that way. The decent grounding in calculus, linear algebra, Fourier analysis etc that I got from that has allowed me to do things I never would have been able to consider had I just gotten the CS education.


Good stuff. We can't just "program", we need to have a field in which we are good at programming. For me, I'm particularly good with regular expressions and data mining, and I like refactoring code.
 
 I've heard that CS departments at schools these days are suffering from
 a big drop in the number of majors.  But that seems to me to be as it
 should be.  The IT boom brought on a lot of silliness.  You really don't
 need a CS degree to do most IT jobs.  Yes, *everybody* needs to know how
 work with computers these days to varying degrees.  Just like everyone
 needs math to varying degrees.  But that doesn't mean there need to be a
 lot of math majors, or CS majors.   Almost everyone takes a class or two
 from the math department, but very few major in it.  Likewise, pretty
 much everyone these days should have a class or two from the CS dept,
 but we don't really need that many majors.
 
 --bb


We actually do need those few people who are exceptional at CS. Desperately. A genius in CS who implements, say, bittorrent or linux or google.com can change how the world works and save us all billions and billions of dollars. The unfortunate fact is, that unless you're in the top 1% at it, you really shouldn't call yourself a programmer; or rather it should be distinguished that you can hack your way into making a computer do something versus actually understanding the machine and breathing it. Sincerely, Dan
Apr 23 2007
parent reply Don Clugston <dac nospam.com.au> writes:
Dan wrote:
 Jascha Wetzel <[firstname] mainia.de> Wrote:
 
 You really don't need a CS degree to do most IT jobs


I agree too. I'm not saying "anyone can do it"; I'm saying that a degree doesn't provide as much as it ought in this particular field. I found my experience almost debilitating and I think there are a few reasons why: 1) By the time you're done 4th year, the exactly implementation you were taught starting 2nd year is already obsolete. 2) Professors were taught by their professors were taught by their professors. The teacher typically has never been in the industry, and doesn't really understand programming beyond trivial examples on a theoretical capacity. They're also typically still stuck in the same paradigms and with the same tools as their professor's professor (the 70's). 3) First year professors are really there to study a master's, not to teach. They typically suck at teaching, not being able to frame the paradigm with the right analogies, but merely having acceptable technical knowledge.
 i'll have to stand up for the CS majors here, though... ;)
 i think, these (fairly typical) statements about CS majors are highly
 dependent on the university. i attended exactly one lecture during 

For anyone interested, don't go to University of Calgary for CPSC.

In the early 90's, they were still asking exam questions about I/O port addresses for teletype machines. Unbelievable. I came outright first in a course called "System Structures" for which I did not attend a single lecture. I've no idea what it was about. Seriously, I reckon I learn more CS every month just browsing the net, than I did in two years of CS. Fortunately my degree was physics. I think "Computer Science" is one of the all-time classic misnomers. There's hardly any science in CS. (Virtually no experimentation, for example).
Apr 23 2007
parent reply Bill Baxter <dnewsgroup billbaxter.com> writes:
Don Clugston wrote:
 
 I think "Computer Science" is one of the all-time classic misnomers. 
 There's hardly any science in CS. (Virtually no experimentation, for 
 example).

Prof. Kenneth Yip used to start his intro to CS lectures out by writing "Computer Science" on the blackboard in giant letters. Then he'd start the lecture by saying the name is kind of odd for the subject because it's really not a science. And he'd put a big "X" over the science part. Next he'd say, "and what's more it's not actually about computers either". Another big "X". --bb
Apr 23 2007
parent reply Jascha Wetzel <"[firstname]" mainia.de> writes:
the german name of this subject is more appropriate.
"informatik" suggests the science of information.

just because there are no experiments doesn't mean it's not a science,
though. mathematics is usually considered a science although has no
experiments either. that's because both aren't natural sciences where
there is a given real world complex that we try to understand by
sampling it with experiments.

in mathematics as well as "informatics" we try to find models of the way
we think. therefore all the experiments take place in our heads.
"informatics" additionally is an engineering science, trying to
build/program machines that mimick the way we think in those models we
found. in many cases we find that the way we think isn't most effective,
therefore we change the models to fit the machines we've already built.
which makes us drift a little more into the engineering direction.

Alexander Panek wrote:
 On Tue, 24 Apr 2007 13:28:43 +0900
 Bill Baxter <dnewsgroup billbaxter.com> wrote:
 
 Don Clugston wrote:
 I think "Computer Science" is one of the all-time classic
 misnomers. There's hardly any science in CS. (Virtually no
 experimentation, for example).

writing "Computer Science" on the blackboard in giant letters. Then he'd start the lecture by saying the name is kind of odd for the subject because it's really not a science. And he'd put a big "X" over the science part. Next he'd say, "and what's more it's not actually about computers either". Another big "X".

Heh.. I kept telling my colleagues at school something similar, when they had problems implementing the latest Hello-World-Calculator in C#. (I'm always the one helping those who are "not capable" of "programming", in my class..) "It's not about the programming language..it's just.. a problem and a solution!"

Apr 24 2007
next sibling parent Dan <murpsoft hotmail.com> writes:
Jascha Wetzel <[firstname] mainia.de> Wrote:

 the german name of this subject is more appropriate.
 "informatik" suggests the science of information.
 
 just because there are no experiments doesn't mean it's not a science,
 though. mathematics is usually considered a science although has no
 experiments either. that's because both aren't natural sciences 

Well said, sir. If you think the understanding behind computer science is trivial, being a mathematician is easy! All there is to it is a few variables and formulas and stuff. That said, I actually find myself pretty decent at understanding math, I'm just highly inconsistent at doing it - which is why I have a computer. : )
Apr 24 2007
prev sibling parent reply Don Clugston <dac nospam.com.au> writes:
Jascha Wetzel wrote:
 the german name of this subject is more appropriate.
 "informatik" suggests the science of information.

It's better -- works well for most business apps, but it's a bit of a stretch for things like games. IMHO, "software engineering" is a much better term.
 just because there are no experiments doesn't mean it's not a science,
 though. mathematics is usually considered a science although has no
 experiments either. that's because both aren't natural sciences where
 there is a given real world complex that we try to understand by
 sampling it with experiments.

In science, we're always trying to answer the "why?" question. Mathematics is no exception; that's what proofs are about.(*Why* are there no integral solutions to x^n+y^n=z^n where n>2 ?) But in CS, the question is almost always "how?". While doing CS, you almost never come away with more understanding about how the universe behaves. Most of the actual computer *science* is done in mathematics departments.
Apr 24 2007
parent reply Jascha Wetzel <"[firstname]" mainia.de> writes:
hm, how about...
why is problem X undecidable?
why does solving problem Y take at least O(...) time/space?
why are some problems NP and others P or aren't they?
why do these weights and activation functions make a recursive neural
network X do what it does?

"software engineering" is clearly a large subset, but you would have to
stretch the term pretty much to make most theoretical CS fit in there.

Don Clugston wrote:
 Jascha Wetzel wrote:
 the german name of this subject is more appropriate.
 "informatik" suggests the science of information.

It's better -- works well for most business apps, but it's a bit of a stretch for things like games. IMHO, "software engineering" is a much better term.
 just because there are no experiments doesn't mean it's not a science,
 though. mathematics is usually considered a science although has no
 experiments either. that's because both aren't natural sciences where
 there is a given real world complex that we try to understand by
 sampling it with experiments.

In science, we're always trying to answer the "why?" question. Mathematics is no exception; that's what proofs are about.(*Why* are there no integral solutions to x^n+y^n=z^n where n>2 ?) But in CS, the question is almost always "how?". While doing CS, you almost never come away with more understanding about how the universe behaves. Most of the actual computer *science* is done in mathematics departments.

Apr 24 2007
next sibling parent reply Dan <murpsoft hotmail.com> writes:
Jascha Wetzel <[firstname] mainia.de> Wrote:

 hm, how about...
 why is problem X undecidable?
 why does solving problem Y take at least O(...) time/space?
 why are some problems NP and others P or aren't they?
 why do these weights and activation functions make a recursive neural
 network X do what it does?
 
 "software engineering" is clearly a large subset, but you would have to
 stretch the term pretty much to make most theoretical CS fit in there.
 
 Don Clugston wrote:
 Jascha Wetzel wrote:
 the german name of this subject is more appropriate.
 "informatik" suggests the science of information.

It's better -- works well for most business apps, but it's a bit of a stretch for things like games. IMHO, "software engineering" is a much better term.
 just because there are no experiments doesn't mean it's not a science,
 though. mathematics is usually considered a science although has no
 experiments either. that's because both aren't natural sciences where
 there is a given real world complex that we try to understand by
 sampling it with experiments.

In science, we're always trying to answer the "why?" question. Mathematics is no exception; that's what proofs are about.(*Why* are there no integral solutions to x^n+y^n=z^n where n>2 ?) But in CS, the question is almost always "how?". While doing CS, you almost never come away with more understanding about how the universe behaves. Most of the actual computer *science* is done in mathematics departments.


Software Engineering IMHO is the application of the science to solve a given problem. This is the "how" question he refers to. Computer Science IMHO is the study of a subset of Mathematics such that we are bound to discrete sets and algorithms; and we have a set of typically consistent objectives, such as minimizing time and space complexity; which other studies in Mathematics don't explicitly define. On another note, you cannot understand "why" the abstraction is by examining the formula, you can merely understand "what" it is. Why can we not understand "why" a formula behaves a certain way? Because the concept of why is based on the concept of purpose, and the purpose is subset to existence; defined by it's users rather than being a necessary property of something that exists.
Apr 24 2007
parent 0ffh <spam frankhirsch.net> writes:
Dan wrote:
 Jascha Wetzel <[firstname] mainia.de> Wrote:
 Don Clugston wrote:
 Jascha Wetzel wrote:
 just because there are no experiments doesn't mean it's not a science,




There are experiments, but they're mostly done a-hoc and small-scale - like timing loops instead of trying to count cycles and predict cache behaviour, which is plain impossible on some architectures. Also, from a software-engineering POV every new programming language must be viewed as an experiment. D is one. So was Java (is still a bit).
 Software Engineering IMHO is the application of the science to solve a given
problem.  This is the "how" question he refers to.
 Computer Science IMHO is the study of a subset of Mathematics such that we are
bound to discrete sets and algorithms; and we have a set of typically
consistent objectives, such as minimizing time and space complexity; which
other studies in Mathematics don't explicitly define.

Well, I don't know about computer science, but "Informatik" is that plus electronics and electrical engineering aspects. This has traditional reasons: Mathematicians (and people working in other math-heavy fields) and electrical engineers where the most important "early adopters" of computers. They where also the ones who built and programmed them. So their academia teamed up and founded "Informatik". Therefore there is a strong hardware aspect if you study informatics (of course by now we also have lots of more-specialised courses that drop these aspects). Regards, Frank
Apr 24 2007
prev sibling parent reply Don Clugston <dac nospam.com.au> writes:
Jascha Wetzel wrote:
 hm, how about...
 why is problem X undecidable?
 why does solving problem Y take at least O(...) time/space?
 why are some problems NP and others P or aren't they?
 why do these weights and activation functions make a recursive neural
 network X do what it does?

Agreed. Those are all mathematical, science questions. And the CS department at the university I went to, thought that was what they should be teaching. But there isn't really very much of it, and most of it was developed by regular mathematicians (Goedel, etc), without much connection to actual computers.
 "software engineering" is clearly a large subset, but you would have to
 stretch the term pretty much to make most theoretical CS fit in there.

Yup. But theoretical CS is pretty much a specialised branch of mathematics, which I think is not how the CS term is generally used. But we're stuck with the name now!
Apr 24 2007
parent Lars Ivar Igesund <larsivar igesund.net> writes:
Don Clugston wrote:

 Jascha Wetzel wrote:
 hm, how about...
 why is problem X undecidable?
 why does solving problem Y take at least O(...) time/space?
 why are some problems NP and others P or aren't they?
 why do these weights and activation functions make a recursive neural
 network X do what it does?

Agreed. Those are all mathematical, science questions. And the CS department at the university I went to, thought that was what they should be teaching. But there isn't really very much of it, and most of it was developed by regular mathematicians (Goedel, etc), without much connection to actual computers.
 "software engineering" is clearly a large subset, but you would have to
 stretch the term pretty much to make most theoretical CS fit in there.

Yup. But theoretical CS is pretty much a specialised branch of mathematics, which I think is not how the CS term is generally used.

The algorithmic parts of CS is mostly math, yes. There's quite a bit of software specific stuff though, like research into information systems and the methodologies to build them. This is again closely related to software engineering, in which research also is performed. Then you have the hardware part of it (computers are equally much hardware as software). My impression of those doing research at my university, was that they _are_ highly professional scientists, doing everything from exceptionally boring stuff to exceptionally exciting stuff. I do to some degree agree that for what we as students did, science is a misnomer, and that is not a word used in the norwegian description of the studies either. In Norwegian terms, I'm an engineer in what we call datateknikk, meaning whatever means there are to treat data in a meaningful way. -- Lars Ivar Igesund blog at http://larsivi.net DSource, #d.tango & #D: larsivi Dancing the Tango
Apr 24 2007
prev sibling parent BCS <BCS pathlink.com> writes:
Chris Nicholson-Sauls wrote:
 Dave wrote:
 
 I tend to tell people that all forms of art seemingly arise from some 
 form of science. Programming just happens to be an artform still closely 
 linked to its base science.  And our own Walter -- if I recall right -- 
 is a prime example of a major developer whose background is in something 
 else.  I'm pretty sure those airplanes didn't require new compilers.
 
 -- Chris Nicholson-Sauls

I tend to see it the other way, or maybe more often the other way My continuum of understanding chaos: No understanding magic: you know how to get a finite set of result by rote execution. art: a skilled practitioner can get what they want some/most of the time, and can teach it to some people but can't really say how they do it. engineering: for most useful cases a solution can be derived from the desired result. (for a span of not more than X and a load of not more than Y use a Z type beam) science: for all cases within lax bounds, an exact description of what is happening can be described. Ironically I think Computer "Science" is generally somewhere between magic (for the "bad" programmers) and engineering (for the stuff Boeing, NASA and the NSA do) most of the hobby stuff is art.
Apr 23 2007
prev sibling parent Lars Ivar Igesund <larsivar igesund.net> writes:
Dan wrote:
 
 So if I could demonstrate that many (if not all) of these implementations
 should really be using a struct for strictly performance reasons, for
 example, would that have any weight?

Certainly, it would definately be an interesting excercise.
 
 I find that structs tend to be able to do alot in D, with Interfaces being
 the only remaining thing I miss.

We do have some classes that we are aware would fit better as a struct, but the lack of struct constructors prevent that for now. Similarly, lack of an interface notion prevents some usages. -- Lars Ivar Igesund blog at http://larsivi.net DSource, #d.tango & #D: larsivi Dancing the Tango
Apr 18 2007
prev sibling next sibling parent reply freeagle <dalibor.free gmail.com> writes:
Dan wrote:
 I just use phobos.  It gets the job done, instead of trying to be everything
and anything the user might possibly want to interact with; like the Java
libraries.

I think there is a reason why Java's library is trying to provide all the standard things that the coders might need. If you have a small std library, like phobos, or stdc, then there will be several groups of people trying to code the things missing. And so you have bazillion different libraries trying to solve the same problem. Trying to find the one that best fits your needs is a pain. Like trying to find the best linux distro. You can make a nice analogy with linux and freebsd e.g. It's very much the same. And majority of people will tell you that only one instance of FreeBSD is a better thing than hundreds of instances of linux Freeagle
Apr 18 2007
parent reply Stephen Waits <steve waits.net> writes:
freeagle wrote:
 And majority of people will tell you that only 
 one instance of FreeBSD is a better thing than hundreds of instances of 
 linux

Me included. But that's OT. The things about a "standard library".. first of all, it's "standard", second, it's singular. I want to (eventually) use D on the PS3. If you've got some giant standard library, then porting it to new platforms becomes burdensome. Welcome to smelly town. In my job, we don't need tons of library support. Basic math, basic containers, basic algorithms. As a matter of fact, we (and about a billion other people) have been using C and C++ and the associated (relatively small other than that iostreams crap) stdlibs for a long time now. Crypto in the standard library? NFW! KISS guys, KISS.. why not retarget Tango as an addition to Phobos? Something more kitchen-sink'ish? (ala Python) Community or not, it's Walter's language. Luckily for us, Walter is really freakin' smart about this kind of stuff, and he'll decide, and we'll all thank him for it. --Steve
Apr 18 2007
next sibling parent reply Bill Baxter <dnewsgroup billbaxter.com> writes:
Stephen Waits wrote:
 freeagle wrote:
 And majority of people will tell you that only one instance of FreeBSD 
 is a better thing than hundreds of instances of linux

Me included. But that's OT. The things about a "standard library".. first of all, it's "standard", second, it's singular. I want to (eventually) use D on the PS3. If you've got some giant standard library, then porting it to new platforms becomes burdensome. Welcome to smelly town. In my job, we don't need tons of library support. Basic math, basic containers, basic algorithms. As a matter of fact, we (and about a billion other people) have been using C and C++ and the associated (relatively small other than that iostreams crap) stdlibs for a long time now. Crypto in the standard library? NFW!

Then don't port the crypto functions. Seems like the obvious answer. I'm sure Phobos also has plenty of stuff you won't need. Whichever you go with, just port the parts you need.
 KISS guys, KISS..  why not retarget Tango as an addition to Phobos? 
 Something more kitchen-sink'ish?  (ala Python)

 Community or not, it's Walter's language.  Luckily for us, Walter is 
 really freakin' smart about this kind of stuff, and he'll decide, and 
 we'll all thank him for it.

It's pretty clear that Walter would prefer other people to take over the job of library design so he can concentrate on what he does best: compiler design. But it seems clear also that he wants to keep Phobos around as a place where he can dump in little additions now and then, like std.metastrings. I wonder if there might be some benefits to separating phobos and tango both out into a core lib containing only the barest essentials required to run D code (e.g. object and gc and not much else), and everything else. Seems like it would be helpful in your case, at least. It would seem somehow reassuring to me to be able to clearly see what's essential and what's optional. But in the end the linker should discard whatever you don't use, so, from a practical standpoint, it's not so necessary. --bb
Apr 18 2007
next sibling parent reply Lars Ivar Igesund <larsivar igesund.net> writes:
Bill Baxter wrote:

 I wonder if there might be some benefits to separating phobos and tango
 both out into a core lib containing only the barest essentials required
 to run D code (e.g. object and gc and not much else), and everything
 else.  Seems like it would be helpful in your case, at least.  It would
 seem somehow reassuring to me to be able to clearly see what's essential
 and what's optional.  But in the end the linker should discard whatever
 you don't use, so, from a practical standpoint, it's not so necessary.

This is what Tango already do. Tango's phobos.lib is just the language essentials. The only external interface coming from there is for the GC, threading and Object. -- Lars Ivar Igesund blog at http://larsivi.net DSource, #d.tango & #D: larsivi Dancing the Tango
Apr 18 2007
parent jcc7 <technocrat7 gmail.com> writes:
== Quote from Lars Ivar Igesund (larsivar igesund.net)'s article
 Bill Baxter wrote:
 I wonder if there might be some benefits to separating phobos and
 tango both out into a core lib containing only the barest
 essentials required to run D code (e.g. object and gc and not much
 else), and everything else.  Seems like it would be helpful in
 your case, at least.  It would seem somehow reassuring to me to be
 able to clearly see what's essential and what's optional.  But in
 the end the linker should discard whatever you don't use, so, from
 a practical standpoint, it's not so necessary.

language essentials. The only external interface coming from there is for the GC, threading and Object.

Okay, but we can't mix-and-match the "core" of Tango with the "core" of Phobos since Phobos hasn't been broken apart (DMD's phobos.lib contains the language essentials and fun extra stuff, too). Can we just use the tango source with the standard phobos.lib? I wouldn't think that we could since object is defined differently and parts of Tango probably depend on the GC changes that Sean has made. (Or is this what the "PhobosCompatibility" version is for?) Maybe it's time to try to convince Walter to separate Phobos into at least two parts to make it easier for us to plug-in our own GC, etc. In the meantime, I'll probably be using tangobos (http://www.dsource.org/projects/tangobos) rather than kicking the Phobos habit cold turkey.
Apr 18 2007
prev sibling parent Sean Kelly <sean f4.ca> writes:
Bill Baxter wrote:
 
 I wonder if there might be some benefits to separating phobos and tango 
 both out into a core lib containing only the barest essentials required 
 to run D code (e.g. object and gc and not much else), and everything 
 else.  Seems like it would be helpful in your case, at least.  It would 
 seem somehow reassuring to me to be able to clearly see what's essential 
 and what's optional.  But in the end the linker should discard whatever 
 you don't use, so, from a practical standpoint, it's not so necessary.

Tango is already designed this way. The compiler runtime and garbage collector are each separate libraries with no compile-time dependencies on one another or on any standard library code. See: http://www.dsource.org/projects/tango/wiki/TopicAdvancedConfiguration Sean
Apr 18 2007
prev sibling parent reply Chad J <gamerChad _spamIsBad_gmail.com> writes:
Stephen Waits wrote:
 freeagle wrote:
 
 And majority of people will tell you that only one instance of FreeBSD 
 is a better thing than hundreds of instances of linux

Me included. But that's OT. The things about a "standard library".. first of all, it's "standard", second, it's singular. I want to (eventually) use D on the PS3. If you've got some giant standard library, then porting it to new platforms becomes burdensome. Welcome to smelly town. In my job, we don't need tons of library support. Basic math, basic containers, basic algorithms. As a matter of fact, we (and about a billion other people) have been using C and C++ and the associated (relatively small other than that iostreams crap) stdlibs for a long time now. Crypto in the standard library? NFW! KISS guys, KISS.. why not retarget Tango as an addition to Phobos? Something more kitchen-sink'ish? (ala Python) Community or not, it's Walter's language. Luckily for us, Walter is really freakin' smart about this kind of stuff, and he'll decide, and we'll all thank him for it. --Steve

Size of library and porting difficulty are pretty much unrelated if the library is written well. I do believe Tango is written well. The porting difficult comes when there are OS or machine dependant features used (system function calls, ASM use), since all of those have to be replaced. When you start to talk about a large do-everything library, there are a couple categories of code that become very common: - Things like crypto that only need one dep: a turing complete language. (It can be asm optimized, but intrinsics and abstraction kill that issue.) - Things that sit ontop of OS abstractions. Once you write a File class that handles file level io, then you no longer need to use any OS dependant functions to handle file use. Port one and you port them all. Now I remember reading that Tango is interested in doing some media library stuff (SDL kinda stuff- low level graphics, sound and all) and that might be trouble to port. Of course, I doubt much of the other stuff will depend on it, so just don't port that part of Tango if you are strapped on time. If they decided to handle GUI at some point, it might be the same deal (espec for app GUIs where native look-and-feel matters). I've talked with kris some about the idea of porting Tango to arm-wince-pe, a popular PDA platform. Realize I have done this with phobos, so I have some experience in the matter. I liked what I heard. It is very layered. Get the bottom layers and the rest falls into place. Minimal OS function dependance, no ASM deps - dude that is /nice/.
Apr 18 2007
parent reply Stephen Waits <steve waits.net> writes:
Chad J wrote:
 
 I've talked with kris some about the idea of porting Tango to 
 arm-wince-pe, a popular PDA platform.  Realize I have done this with 
 phobos, so I have some experience in the matter.  I liked what I heard. 
  It is very layered.  Get the bottom layers and the rest falls into 
 place.  Minimal OS function dependance, no ASM deps - dude that is /nice/.

Ok. Now that does sound nice. Having not looked inside Tango, I appreciate your experience and insight. However, my first problem is getting a compiler to emit PS3 code. :) --Steve
Apr 19 2007
parent reply Sean Kelly <sean f4.ca> writes:
Stephen Waits wrote:
 
 However, my first problem is getting a compiler to emit PS3 code.  :)

Does GCC target Cell yet? Sean
Apr 19 2007
parent Stephen Waits <steve waits.net> writes:
Sean Kelly wrote:
 
 Does GCC target Cell yet?

Yah. The official toolchain is based on gcc and there's one in the wild too, used on PS3 Linux. --Steve
Apr 19 2007
prev sibling parent Oskar Linde <oskar.lindeREM OVEgmail.com> writes:
Dan wrote:

 Likewise I fear for Tango, as it's got that OO gleam in it's eye and is
implementing classes for crypto.. I mean.. crypto!?  What's next, a math class?
 *shudders*

Please propose a better way to implement stateful algorithms such as block based ciphers, cryptographic hashes or compression algorithms in a way that doesn't require all the source data to be present in memory at once and that supports working on data streams. /Oskar
Apr 19 2007
prev sibling parent Alexander Panek <alexander.panek brainsware.org> writes:
On Tue, 24 Apr 2007 13:28:43 +0900
Bill Baxter <dnewsgroup billbaxter.com> wrote:

 Don Clugston wrote:
 
 I think "Computer Science" is one of the all-time classic
 misnomers. There's hardly any science in CS. (Virtually no
 experimentation, for example).

Prof. Kenneth Yip used to start his intro to CS lectures out by writing "Computer Science" on the blackboard in giant letters. Then he'd start the lecture by saying the name is kind of odd for the subject because it's really not a science. And he'd put a big "X" over the science part. Next he'd say, "and what's more it's not actually about computers either". Another big "X".

Heh.. I kept telling my colleagues at school something similar, when they had problems implementing the latest Hello-World-Calculator in C#. (I'm always the one helping those who are "not capable" of "programming", in my class..) "It's not about the programming language..it's just.. a problem and a solution!"
Apr 23 2007