views:

439

answers:

16

It is well known there is a strong link between computer science and mathematics. In looking to improve my own software engineering skill set I'm interested to know what concept from mathematics has helped you to gain deeper understanding of software development as a whole? What would be the biggest bang-for-your-buck concept to learn from the domain of mathematics that would carry over into a software engineering career?

As a somewhat heavyweight example, Alex Stepanov of STL fame has often compared concepts in C++ (DefaultConstructible, Assignable, Regular, etc.) to concepts from abstract algebra (groups, rings, monoids, etc.) In fact much of the direction C++ is going (generic programming) can find its roots back in his initial observations. In his latest book he recommends brushing up on Chrystal's work on Algebra, which is a bit too much for me to chew off, but the point remains valid.

I'm not looking for answers as hardcore as the one above (though they are useful and welcome) - in fact I would find answers that are achievable to be more attractive, as I'm looking for something to put into practice.

Answers would be most helpful if they addressed the following:

  • How you learned it
  • How you applied it
  • How it changed your code / methods
+1  A: 

For me, Relational Algebra has been the most useful. It has applications from the database to LINQ...

You may find it easier to apply mathematical lessons to software if you deal with less abstract and more domain specific topics. The more general the application, the more abstract the math.

Eg its easier to deal with lambda calculus and relational algebra when you focus on data manipulation.

Nader Shirazie
+2  A: 

I don't really know which has helped me most, but next on my pile is lambda calculus, which is enjoying somewhat of a resurgence and becoming more applicable in the .net world at the moment.

spender
+6  A: 

Make sure you get counting down pat. Pretty much everything else can be abstracted with use of appropriate framework.

ChssPly76
+1: So true. It's more logic than math, in most areas.
Brian MacKay
Logic is math...
Nader Shirazie
Could someone provide a link on how to actually do this counting thing? Wikipedia is way more into academic descriptions and references for stuff.. Maybe like an e-how link or something?
snicker
Here is the tutorial for counting- Watch the little number next to your comment. When it goes up, that is called "incrementing". When it goes down, "decrementing".
Brandon Hansen
It never goes down :-)
ChssPly76
Here you go, snicker: http://www.youtube.com/watch?v=g9EgE_JtEAw
Artelius
+1  A: 

Numerical mathematics
Tensor calculus

Thomas Geritzma
+5  A: 

Set Theory. Especially when using all the Generic Collections and operations such as Union, Intersection, Difference etc.

Nikhil
Since lectures on set theory mainly deal with infinite sets, I'd say that set theory is one of the least helpful concepts in programming. When was the last time that the axiom of choice made a difference in your programs? :-)
Accipitridae
+1  A: 

The ability to think logically and clearly.

Peter
+6  A: 

For me hands-down is knowledge about graphs. Graph problems are really common. (but I guess this could be a cop out becuase they are so close to development already) I found it helps me to visualize certain problems by using graphs.

CodePartizan
+1  A: 

It's mostly just logic for me. Very little math is involved in the line-of-busines stuff that I do.

However, I wish I had paid attention in calculus, since most of the AI stuff out there requires it.

Actually, it doesn't require it. But most of the texts are very pretentious and academic, so without calculus it's a lot harder to understand what they're getting at.

Brian MacKay
+5  A: 

Linear Algebra.

Then again, this is most applicable when dealing with concepts such as 3 dimensional space in whatever you're developing. Mostly gaming and building information modeling.

Also calculus, especially differential equations and partial differential equations.. for physics applications.

snicker
+4  A: 

Algorithms.

Of course.

Artelius
+6  A: 

Number bases.

Hexadecimal, binary and octal.

Andy
+12  A: 

Basic Boolean logic.

Beyond just remembering what AND and OR do, I find de Morgan's law is useful for rewriting conditionals to be easier to understand.

Selene
+1 - Ditto. I got it from taking Symbolic Logic and Computer Engineering 101. For whatever reason (back in the day) the CS classes didn't teach it.
TrueWill
+1 - this is so crucial to understanding boolean statements. I got such an "ah-hah" moment when I realized that statements are distinct from their truth value. Now I can get into arguments all the time with my wife over who-said-what...
weiji
The problem comes when you're trying to have an argument about boolean logic with some person who doesn't understand boolean logic. Oh the hilarity. Oh, and the wife always wins.
Kibbee
A: 

Being able to mentally handle abstract concepts that aren't easy to visualize based on things in the real world. For example, how easy is it to imagine a vector space with 26 dimensions, one for each letter of the English alphabet? A 26-tuple may come to mind as one way to see it, but where else would you get that kind of idea if not from Mathematics. Imaginary and transcendental numbers are also part of this to some extent. That pi or e cannot exist as a fraction without some error isn't necessarily the easiest thing to absorb. Another example here is how Math can define something like infinity, which may or may not be easy for other people to get as it is not a number but rather a concept.

JB King
A: 

I want to say the Pigeonhole Principle, but set theory is my final answer.

Wayne Young
+1  A: 

First-order predicate calculus, which is a fancy name for symbolic logic with "for all" and "there exists" operators. It's related to set theory and relational algebra, but is worth knowing in its own right.

David Thornley
+1  A: 

Abstract Algebra (e.g. groups, rings, fields). Being able to understand how different concepts interact really helps in designing a data structure that is robust. It helps you to define rules of interaction between objects, and draw conclusions from these rules.

Martijn