Slashdot Mirror
Forget Math to Become a Great Computer Scientist?
Coryoth writes "A new book is trying to claim that computer science is better off without maths. The author claims that early computing pioneers such as Von Neumann and Alan Turing imposed their pure mathematics background on the field, and that this has hobbled computer science ever since. He rejects the idea of algorithms as a good way to think about software. Can you really do computer science well without mathematics? And would you want to?"
Correction, make that minus one.
Who needs math? Bogosort is a good a sort algorithm as any. Hey, without math, how would you be able to tell?
Maths IS needed for computer science. Just be sure not to confuse Computer Science with Software Engineering. Software engineering is only a part of the computer science sphere.
Do the lessons of VB6 teach us nothing?
COMPUTING IS HARD. You can't dumb it down just because it would be nice to do so. And I'm sorry but mathematics is just the way in which meaning is expressed for machines. There's no free lunch here. And he's wrong about algorithms too - since a non-terminating algorithm is always expressible by deconstruction into a series of terminating algorithms.
Taking CS without math is like taking engineering without any physics.
WTF is the the author smoking?.. There are of course parts of CS that are less involved in math, but it is still overall a fundamental part.
- These characters were randomly selected.
Without mathematics, there is no internet porn.
Good luck on doing a kernel, file system, network stack, crypto, image processing, window manager, animation or 3D without math or algorithms. I look forward to reviewing some of this guys code.
This is all fine.. But it doesn't explain something I have long thrived to understand :
What is computer science ?
Computer engineering.. yeah.. I can understand that.. But man.. Computer SCIENCE ?
That's like saying 'car science', 'cooking science' or 'go at the bar and have a drink science' !
--Ivan
Obviously, I haven't read the book, but the article sure makes it sound like he's just trying to play word games, relabeling the concepts. And then, once he's done that he goes, 'see, it isn't mathematical anymore', when in fact all he has done is disguise the terminology. I sometimes think myself that math hardly covers the intricacies of computer work, but I think this guy is attacking it in the completely wrong way.
So I am not alone in questioning the maths side of things? Good. My major is computer science and let me say my maths is not strong but I have had no issues with any of my computer science papers. However when it comes to maths I am stuck, it's dry and does not relate anywhere to my degree that I can see. I've taken courses in algorithms, language theory, databases etc. and the majority of the work is not maths and if it is it's so obvious anyone can see it. To help gain experience I'm doing some part time work in the industry before I graduate and it comes up nowhere in that line of work either.
This is just another stupid generalization. There are some areas where you can do good computer science without math. There are other areas where you absolutely need mathematics. For example, you cannot do scientific computing without mathematics. Broad generalizations like this for a wide spread field just shows the ignorance/narrow mind of the author.
Isn't that pretty much the same as arguing that a surgeon doesn't have to know about anatomy? What we do is inherently mathematical - there exists no other way of defining and understanding complexity, computability and so on.
I agree that you do not need a good understanding of mathematics to create a homepage, but for anything remotely interesting you do.
I attained a Computer Science BS in 1986. At the time everyone was getting Math minors. I opted for a communication minor instead. I've worked in high-tech engineering environments with real-time programming for many years. What I found is that I've never needed the intense mathematics attained by those with math minors. I needed to be able to implement equations that staff mathmaticians would develop. Though math is a fundamental of computer science, I believe the ability to logically assess a situation from multiple perspectives; communicate your approach with the customer; and then implement a maintainable solution is the key components required for computer scientists.
This guy just doesn't seem to understand what math is. Substituting theory of computation with his "theory of expressions" just shifts focus on another field of math.
I actually remember hearing about a device similar to this principle of not using math... I believe they called it an Etch-a-Sketch.
As much as I disliked math I don't really see how computing is possible without it. Perhaps using math as the proverbial hammer for computing has created some nails out of screws, but I can't imagine one could have any sort of computing without some level of math built in. The brain is probably the closest example I can think of, and I'm sure there is a lot of math involved somewhere behind the scenes (or certainly would need to be to replicate a brain electronically).
lol: You see no door there!
Mainly, he claims to want to create a "comprehensive theory of process expression". Fair enough, but as soon as you want to extract usable, reliable results from your "comprehensive theory", you've really just created a branch of mathematics. Maths is not just numbers and calculus, but any systematic treatment of relations in a symbolic fashion - unless he plans a lot of fairly useless hand waving, "Oh, my process is expressed as *insert long winded ambiguous English description", he will be working within the remit of mathematics. Heck, one of my areas of study is the development of processes (studied through the use of process calculi) - a highly mathematical tool.
He also ignores the vast array of work on non-deterministic algorithms, stating that "Any program utilising random input to carry out its process, such...is not an algorithm". Sure, it's not a deterministic algorithm, but even if you artificially restrict your definition of algorithm to just be deterministic, it's a useful tool in analysing such problems.
Finally, statements such as "Computer science does not need a theory of computation" are just so bizarre as to be funny. I suggest he forgets all he knows about formal computational theory, and I'll contract "Theseus Research" to write me a program to determine the halting problem for an arbitrary program. I wonder what his bid will be, given that he doesn't need a theory of computation (that would tell him you can't do it, at least with our models of computation - and probably with any).
Now, all of this is not to say you can't make progress in computer science without the mathematics that's currently been developed - however, you will either spend a lot of time achieving unreliable results, be reinventing the wheel, or just be creating a new branch of mathematics.
I ok. Let me see if I am able to solve the Navier Stokes equations for unstady flows without the help of a computer. And the Schrodinger equation using a tridimensional net?
Buahhh! ha, ha!
....Abstraction.
And computer science, the software side, is really the science of abstraction physics.
http://threeseas.net/abstraction_physics.html
At some point in the higher levels of abstraction creation and use you use the lower mathematical level as more or less a carrier wave of the higher level abstraction, than for the purpose of performing a mathematical calculation. The analogy is that of using radio waves to carry the music you hear over the radio, but the carrier wave is discardedafter it has done it job. Likewise, the mathematics of computers boils down to binary flipping of transistor swiches upon which the higher level of mathematics is carried upon.
With a correct approach to the abstraction manipulation machine computers really are, we can accomplish a lot more, similar to the difference between using the limitation of roman numerals in math vs. the decimal system with its zero place holder.
It sounds like the author is suggesting it's time for computer science to evolve from an algorithm based system to process based. Doesn't seem all that controversial. Wouldn't that be the next logical step in the evolution of the computing machine?
I don't think he's saying do away with math, sounds more like suggesting not to be limited by a mathematical computing model.
That's our life, the big wheel of shit. - The Fat Man, Blue Tango Salvage
I feel that there are a lot of software engineering areas where you don't need much in the way of maths experience - just logical thinking. Most real world math related implementations I've done haven't relied on a high level of maths... linear interpolation and solving quadratics are probably as "tricky" as math goes outside of academia... but...
That's not the end of it. I've also done a lot of image manipulation work, and you NEED a good math background when you step over simple 2d convolution filters. Knowing your physics also helps - being able to identify trends and patterns in wave forms, and then applying the necessary maths is a great help. When dging into aliasing and reconstruction now, not just filtering, a high math proficiency is a must.
I've taken to game programming recently. If you know your maths, the physics comes easily. If you know your maths, specially advance vector and matrix theory (with integration and differentiation being prerequisites), things become a breeze. I didnt know enough. And I still struggled from time to time today. Experience is helping me, but sometimes I wish I had a math background to roll on.
I guess my ramblings are leading to a poor conclusion. Without maths you're limited in what you can do - but you're only limited by lateral field... In most cases you can take an specific soft eng field and go to town without hitting maths. I'm a very good software engineering and reverser, and I gotten here without having a math background. When I wanted to expand into games programming and image processing, things became much harder without the math.
With all that said, I'm very very guilty of obscuring simple procedures with valid but pointless math - and I know for a fact there's too much pointless formal theory in computer science now. The pointless formal theory is actually what push me away from doing a masters in computer science, and find something more vocational and rewarding!
Matt
You can be great at IT without knowing math. You can probably even be a good programmer.
You cannot go anywhere in CS without knowing math, because (as the author himself admits) CS is merely a discipline of pure mathematics.
This is rather like saying "Forget math to be a great stockbroker." You can start a Fortune 500 company from the ground up without knowing a cosine from a cosecant, but D. E. Shaw will never hire you.
Hmmm?
Deleted
Can you really do computer science well without mathematics?
You can't do computer SCIENCE at all without the math. You might do some software engineering. Without understanding phenomena that underly the principles you're studying, there is no science. Namely, without any study of algorithms, what's left in the major that anyone would actually call science?
I honestly don't understand the whining. To get the ACM-approved CS major, you end up basically having to get a minor in math, which will generally require a few classes in Calc, a Linear Algebra course, a Discrete Math course, and maybe two others. It's really not that hard.
Computer science IS applied mathematics at it's fundamental level.You can try to forget about it as a user, but never as a programmer, much the less as a computer scientist.
There is a reason why my MSc in Computer Science involved the third most mathematics education after applied mathematicians and physicists.
It takes a man to suffer ignorance and smile
Be yourself no matter what they say
Just look at any Knuth book (well "The art of computer programming" would be suitable). You can't separate mathematics from computer science. Geez - crypthography, all numerical algoritms are math.
Physics without maths is called philosophy. Philosophy without physics is called theology. Where the only true is called G. Computers without maths are a TV screen. A player without a screen is a windows machine. Were the only true is called B. Wait a moment! ...
Profit!
This is something I've thought a lot about. There have been any number of times that math has helped me in my software development efforts. Things like trig to predict the path of a moving target in Robowars (back when I was in high school) to various vector and angle related maths in CustomTF for Quake 1 (www.customtf.com) to partial derivatives to calculate the slope on a surface. I've also needed math for various economics related things over the years, and probability and statistics have also been exceptionally useful to me. Currently I'm having to decipher a guy's code which is all eigenmath, so my linear algebra course is saving me from having to hire someone just to explain all the math to me.
But the kicker is that you can't just tell a student that they should "study vector math" because one day they'll write a Quake Mod, because, truth be told, they probably won't. It's the trouble with all examples you give when students ask how math will be useful -- I could pull any number of examples from my life, but the problem is, they probably won't happen in a student's life. Instead, they'll have their own trials. The best you can tell someone is to study all the math they can, because some day it *might* be useful, and they'll want to have that tool in their toolkit.
And that's just not a very satisfying answer to students who want to make sure that they'll be damn well using what you're teaching in the future.
But believe me, I thought I'd never have an application for eigenvectors, and now not only do I have to clean out my brain on the topic, but I have to parse someone else's code (PhD thesis code no less) and add functionality to it. Two other friends of mine got stuck on legacy Fortran apps which are essentially mathematical solvers (one for differential equations, the other for huge linear algebra problems), and both of them are extremely happy they paid attention in their respective math classes.
So, yeah. To CSE students out there: take math. Pay attention. It could very well save your neck some day at a job, and if it doesn't, at least try to make it interesting to yourself to think of applications where you might use them. All math through the first two years in college can find applications for it quite easily.
I sometimes run into great algorithm programmers who were poor at math, but they're rare, and usually can be explained away based on what kind of drugs they did in college. For a good algorithms guy, I love hiring good mathematicians and physicists. You can train them into great programmers a lot quicker than the other way around. However, algorithms are really a very small part of the programming space we work in. I choose to work in this space because it suits me, but most programmers never need calculus. To build a tree-based data structure and a GUI to drive it takes about an 8th grade level of knowledge. Doing a GUI really well takes creativity I've never had (apparently a lot of guys like me work at M$. I don't know where Apple finds it's GUI guys).
The summary of the author's points in the article make the book sound dead wrong on several counts, though it could just be the review. Procedural languages are the natural way to code most programs, and here's why: we've been recording recipes as a sequence of steps, with if statements and loops, since the invention of writing. It's become encoded in our genes. That's really all that early computer scientists put in our early languages like FORTRAN. It's all the stuff we've added since then that's up for debate, in my mind. The author makes money by pushing the boundaries of computing model research. I get big programs written by teams by restricting what language features are used, and how. I'd be interesting to debate the ideas, point by point.
Beer is proof that God loves us, and wants us to be happy.
He can try as hard as he wants to create CS without math, but when he comes up with something usable, even if it's written in words, it'll describe a process that could be stated clearer and shorter with math. And if he doesn't state it with math those that know better won't pay him any attention.
Boole's framework for describing logical processes is math. That's why it's called Boolean algebra. Try to do CS without that.
"I may be synthetic, but I'm not stupid." -- Bishop 341-B
The author says that there are certain things within a computer that should not be modeled as algorithms due to their purpose and complexity. I partially agree with him: in some cases, the point of interest is not algorithms but how the process evolves to reach the desired goal.
And abstraction is a facet of logic. The challenge facing most programmers is how to represent their logic and environments/apis in a matter that successfully performs the desired task. Representations can range from simple to complex and the challenge is finding one that efficiently and effectively solves the problem at hand.
As an example, take First-order logic with it's classical statement of:
All men are mortal.
Socrates is a man.
Therefore Socrates is mortal.
For this situation I tend to look at it as a form of simplistic Venn diagram. It could be interpreted in a set theory way of:
A circle (mortal)
inside that circle: (man)
inside that circle: (Socrates)
So writing a program that deduces that Socrates is mortal is simply a matter of following the links from socrates through all the containers/super-sets until you reach mortal or the top level.
Shh.
Computing is driven by requirements -- we want a program or system that does X, and it needs to do it in total time Y, cost less than Z, and respond to operator input in less than W milliseconds. This in turn drives us to design programs, OSs, drivers, and systems that run "quickly" and consume resources such as RAM and disk space within certain limits. To meet this requirements, we need to quantitatively measure the performance of hardware and code to determine time and resource consumption. The tools with which we do this require mathematics. So computing inherently needs math to analyze potential solutions against qualitative requirements. This is pervasive at all levels of CS, whether it's a logic path that needs to complete a calculation before a clock cycle deadline, a sort that needs to complete in a reasonable amount of time, a network transfer that needs to deal with latency and bandwidth constraints, an OS that needs to grab data off a disk as quickly and fairly as possible to meet the various demands of running programs, or a user interface that needs to respond to user input in a timely manner while creating a DVD image.
There are also plenty of areas of CS that are even more fundamentally mathematical in nature. Network dynamic routing protocols don't work without various graph-related algorithms. Cryptography leans heavily on number theory. Sets/relations revolutionized databases. It's hard to imagine these advances in CS occurring without the strong connection between CS and mathematics.
That said, articles are notoriously bad at summarizing books. After all, if the book could be meaningfully summarized in a few paragraphs, the book wouldn't have been published; instead, the author would have just written an article to begin with. Certainly, there are aspects of computing that are heavily abstracted away from CS's mathematical underpinnings -- for example, non-modal application user interfaces, usability, software engineering techniques, and access controls. Perhaps this guy has a method for describing computer systems that makes it easier to think about these problems. Or perhaps not -- even if he has a "new model," if it doesn't make it easier to solve problems in CS, it's not particularly useful. Hard to tell without more detail.
I've been in programming business applications for over 7 years and I can you that I use little to no mathematics above high-school algebra. The fact is programming languages themselves require very little math. The math comes from what your programming "about".
Programming is much closer to the study of linguistics. They are programming LANGUAGES after all. They have subjects and verbs and modifying expressions. Putting a logical line of code together is no different from formatting a sentence in another language. Just look at modern languages like Ruby and Python, where's the math?
Math is based on computer science. Not computer science in math. Math is a subset of computer science.
Algorithms exist whether you think about them or not, but if you don't think about them, you'll accidentally create terrible ones.
Just as few telescope makers are astrophysicists, most programmers aren't computer scientists. The author himself is evidently not one. Instead, he is one of the more vocal members of an angry, ignorant mob trying to burn down the edifice of computer science. Its members do not understand it, so they fear it and try to destroy it --- look what's happened to computer science at universities!
It was bad enough when courses about a programming language replaced ones about algorithms and data structures (I'm looking at you, Java and D-flat). It was bad enough when pure profit became the raison d'etre of computer science departments. It was bad enough when I noticed my peers start to joke about how they didn't care about this "maths bullshit" and just wanted to earn more money. It was bad enough when the object, not the bit, became the fundamental unit of information.
But what this author advocates is still worse. He's proposing that we replace the study of computer science with a vocational programming, and call that emaciated husk "computer science." We already have a "theory of process expression", and that's the rigorous of algorithms and data structures. We've constructed that over the past 50-odd years, and it's served us quite well.
That field has given us not only staples, like A* pathfinding, but a whole vocabulary with which we can talk about algorithms -- how do you say that a scheduler is O(log N) the number of processes except to, well, say it's O(log N)? You can't talk about computer science without talking about algorithms.
The author's fearful denunciation of algorithms is only one manifestation of the anti-intellectualism that's sweeping computer science. "We don't need to understand the underpinnings of how things work", the angry mob chants, "but only implement the right interfaces and everything will happen automatically."
The members of this angry mob sometimes manage to cobble something of a program together, but it's more like a huge rock pile than a colonnade. It often barely works, uses too much memory, doesn't handle corner cases, and is likely to crash. (See worsethanfailure.com.) Members of this mob even think that if the same algorithm is expressed in two different languages, it's two different processes. People like this ask painful questions like, "i know quicksort in C# but can someone teach it to me in PHP?"
Argh.
Even "new" developments in programming are just new claptraps for old ideas, with fashions that come and go over the years. The only really new things are algorithms, and increasingly, we're calling people who couldn't independently create bubble sort "computer scientists." It's ridiculous. Call computer science what it is, and create a separate label and department for people who can program, but not discover new things.
It's this idea that one doesn't need to understand or think to be successful that's at the center of the article, and it's not just affecting computer science. Look around you. I wonder whether we'll fall into an old science fiction cliché and regress so far that we are unable to understand or recreate the technology of our ancestors.
Really..... What are we talking about here? Web developer? He/she is going to rarely use anything above algebra. Network admin? Hmmmm... The ones I speak with don't generally have to do much higher math on a day to day basis.
For systems development, I'd absolutely agree. If you're working on low level stuff, you're going to be dealing with math regularly and you damn well better know wtf you're doing. On the other hand though, when I did software QA... the heaviest math I did was figuring some median, max,min, stddevs on load test failure rates. Generalizing that everyone needs math (or needs to forget math) to become a great computer scientist is just begging for attention. You don't need to have an intimate understanding of the pci bus to install a soundcard. You don't need to have a diff eq understanding to test software, or to be a web dev. But you DO need it for other areas. And pretending you don't need it in those circumstances is just stupid.
end inebriated rant(waits for the flammage)
I'll believe in corporations having personhood when Texas executes one... - advocate_one
I believe the author's point isn't that you don't need to know any mathematics, or that it doesn't have an important role to play in CS. He's simply arguing that some of the main issues in computer science are not fundamentally mathematical problems (even if they require some mathematics).
If you buy that argument, then treating CS as if it were merely simply another branch of mathematics will not help solve those problems.
Of course, this also takes us into the perennial debate between where to draw the line between "computer science" and "software engineering". One could certainly define away the author's problem by saying that his examples are software engineering issues rather than computer science issues. And it's true that it's software engineering has been driving a lot of the theory with respect to expressiveness (design patterns and the like). But that view also seems to really impoverish computer science - if all you leave the field of computer science is the stereotypical mathematics, why not just become an applied mathematics major?
In fact, math is nothing more than a branch of logic. You can't seperate computer programming from math for two reasons, programming is nothing but logic and every function is an algebra problem whether you use that form of logic to derive it or not. The other is that the higher level programming used today is nothing but an abstraction of the pure number crunching that is the basic operation of a computer. A computer is a calculator with lots of memory, nothing more.
"Informatics" is a horrible word - it's certainly not English, and was probably derived/invented/whatever by some kind of acedemic lameass who did not have English as a first langugae.
"Computer science" is not a perfect name, but at least it does not make native speakers cringe every time someone mentions it.
Just my 0.2E-32 EUR
A.
Let me make this clear: your ability to write code in no way makes you a computer scientist. It's like saying that the ability to operate a forklift makes you a structural engineer. Stop it already.
That said, I'm sure you're good at what you do. I bet you can write good code in VB, as well as many other languages. This isn't a personal insult. VB, PHP, and other brutish languages are equally bad in my eyes.
These languages are brutish because they oversimplify key concepts. That oversimplification also makes them attractive to new programmers, and new programmers universally write terrible code. The languages themselves aren't bad, the coders are. That said, more experienced coders will generally choose more capable languages, so most of the time, a program written in a brutish language will be a bad one.
We need fewer programmers, not more. Maybe professional certification would help somewhat.
(Incidentally, we were lucky that Javascript became the de-facto client-side web language. We could have done far, far worse, and although we can change server languages, we can't change a user's web browser!)
Before groupthink nukes this person's comment into oblivion, could you please reflect on the last time you had to deal with someone else's shitty code? (I'm sure you don't have to think back very far.)
If you've never had to deal with someone else's poor work then you [are the luckiest bastard on the planet, but more likely you] may want to consider a career change...
Explains a lot.
As per the norm on /. the article title is incredibly misleading. The guy never once talks about ditching math. He doesn't even vaguely imply that math should be ditched. What he seems to be talking about is how the methods and tools of orthodox mathematicians (i.e. pure math guys) are still being used by Computer Scientists when all of that stuff should by now be far more "specialized" towards the things Computer Science really studies.
I think we can see what he's talking about in the many arguments about functional programming. I don't want to open that debate but I can at least attest I've met many people who are biased towards functional programming simply because it's so mathematical.
It's not hard for me to imagine that some of these same people (who are in academia) are pretty close minded about updating their skill set to something more suited to their actual jobs.
"Doing a GUI really well takes creativity I've never had (apparently a lot of guys like me work at M$. I don't know where Apple finds it's GUI guys)."
Maybe the question should rather be: Why doesn't Microsoft look for the kind of GUI-guys Apple hires. And the answer to that might well be found at the top of each company. A quote from Steve Jobs' Commencement address at Stanford (June 12, 2005):
"Because I had dropped out [of college] and didn't have to take the normal classes, I decided to take a calligraphy class [...]. It was beautiful, historical, artistically subtle in a way that science can't capture, and I found it fascinating. None of this had even a hope of any practical application in my life. But ten years later, when we were designing the first Macintosh computer, it all came back to me. And we designed it all into the Mac. It was the first computer with beautiful typography. If I had never dropped in on that single course in college, the Mac would have never had multiple typefaces or proportionally spaced fonts. And since Windows just copied the Mac, its likely that no personal computer would have them. If I had never dropped out, I would have never dropped in on this calligraphy class, and personal computers might not have the wonderful typography that they do."
Read the whole thing, it's quite interesting (if not to say: inspiring).
sig? Oh, that sig...
You were off by 19787949 - 1 = 19787948 in your calculation.
However aren't they all integers, and therefore morally equivalent?
Get thee glass eyes, and, like a scurvy politician, seem to see things thou dost not.--King Lear
write a bad sci-fi fiction (what amounts to abstraction sequence) and show me the logic.
Abstraction is not a facet of logic, and you proved it!
Of course there is a lot of math involved in many parts of computer *science*. Not so much in computer related jobs in the industry, but certainly in science. Where things go wrong is when this math is educated as a standalone subject. I can still remember the horror of math in the first year of the study. Come on guys, if we were interested in pure math, we would have studied something else.
What was important is -eg- statistics, logic and a bit of number theory. That was indeed present, but then you had "theoretical computer science", "calculus" and a whole bunch of other courses that for some reason were mandatory. Those could be important for further studies, but for some reason they went into these subjects way to deep.
Fortunately, at the Vrije Universiteit, the amount of math in computer science has been significantly diminished over the years. And that's good because I suspect that only a few remember much of the "calculus" of the first year. I'm pretty good in actually remembering the things I've studied, but almost everything about the real mathematical side of things has gone from memory.
So my opinion is: teach it, but only if necessary for the subject, and only if the subject has been choosen as a master or something by the student. And explain *why* it's needed if you teach it - students are not a bunch of drones that have some kind of photographic memory. I do think that computer science relies on algorithms a lot, but just teaching the algorithms without any context is just plain dumb. Algorithms are fine, but looking at computer science from a pure mathematical view point is something else entirely.
Other than this, there is way to little in the article to talk about. A full book review would be much more helpfull. Unfortunately, I could not find any using Google. Either the book is not read, or more likely, it's too new.
Hmmm?
A lot of the criticism of this guy seems to be knee-jerk defensiveness. Read his papers on 'NULL Convention Logic' and its applicability to asynchronous circuit design and you will see where he is coming from.
Computers are very simple machines providing only simple building blocks.
To get anything useful done you need to combine an awful lot of building blocks.
In comparison mathematicians and physicians torture their minds with
mindboggingly complicated stuff. But when they are pressed to explain it,
write a book about it, or code some program then all you get is
incomprehensible spaghetti FORTRAN.
The mathematician's answer to memory management is garbage collection,
i.e. it's left as an exercise to everyone else. The mathematician's answer
to optimizing run-time complexity is even worse; with functional languages
the problem is simply defined away.
Post tenebras lux. Post fenestras tux.
... if all else fails, sacrifice a chicken.
The tools that mathemacians produce need to be supplemented more with CS specific abstractions. And generic math classes become less important than more CS specific abstractions after certain point of mathematical prowess.
This is closer to real life situation. The point where more generic mathematics classes is not as useful any more is debatable.
©God
It covers networking, scripting, database management, web design, hardware, etc. It's computer science without the science.
Also, Computer Science != Programming: "Computer science does not need a theory of computation; it needs a comprehensive theory of process expression." That's not computer science, that's programming. The author is confusing the two. I know many great self-taught programmers who can't tell me what O(n) means. They get a feel for what data structures to use, but rarely create their own. There's plenty of use for such people - it's probably the majority of programmers. But it isn't CS.
The article is about computer science, not programming, but even in the latter some idea of mathematics can be useful. In the former it clearly is.
In some other parts of real programming you need to implement things whose idea is very difficult to construe or analyze without some kinds of mathematical methods. In other words, you need to implement nontrivial algorithms.
Of course most code (at least when measured in lines of code) is actually more or less trivial in an algorithmic sense, but nontrivial algorithms, although not as abundant in most code, are still needed. Think about audio or video encoding and decoding, image processing, string processing such as text search (no, that's not really trivial to do efficiently either), or 3D graphics; all of that requires nontrivial algorithms, and someone has to implement the code. Understanding those algorithms and concepts may require some understanding of algorithms and mathematics; coming up with those algorithms in the first place certainly requires that.
You may not have needed to work on things that require understanding mathematics but that doesn't mean nobody needs to do that.
The author really sucks at math but heard that there's big bucks in the computer stuff, right?
Computers are (by their very definition as well as by the word used to describe them) mathematical machines. A computer can essentially do NOTHING BUT calculate. It can in its core add, subtract, shift and move data around. How is this supposed to work without math?
We used to have a Bill of Rights. Now, with the rights gone, all we have left is the bill.
I am a DSP programmer, which basically means that all the stuff I code are mathematical formulas transformed into C code. I mention DSP because writing DSP algorithms forces the programmer to know his math really well... enough so that he can distill the complex math into an efficient C code implementation.
I remember trying to get my specific algorithm to run under 500 micro seconds and the best I could get was like 10000 micro seconds. My coworker who looked at the underlying math equations for my code easily saw a better solution just by looking at the math equations for 5 minutes. After I changed my code to suit the new math equation I got my code to run at 280 micro seconds.
The whole point of this example:
When you approach the solution from a mathematical viewpoint, the mathematical viewpoint lets you see more clearly how to optimize an algorithm. In my case, I got lost looking at the C code and missed the elegant mathematical solution because I did not look at the math equations. So I ended up not being able to "distill the complex math into an efficient C code implementation" to find the elegant solution.
In my case the elegant-math-derived-solution was about 35 times faster (10000 / 280) than the original solution I had come up with.
-----
Bottom line: The syntax and complex notations used for math equations lets you look at a problem from a much higher level of abstraction and this higher level of abstraction is much more conducive to seeing the elegant best solution (solutions that improve your algorithm by an orders of magnitude rather than solutions that improve your algorithm by some linear constant).
p.s. if you were wondering what I was working on --> the function was a GMSK modulator ( http://en.wikipedia.org/wiki/GMSK ) for a transmitter.
An efficient filesystem is going to involve using a tree structure of some sort (probably a B*tree). That's graph theory, and part of computer science.
Furthermore, there are such things as nondeterministic algorithms. Any program utilising random input to carry out its process, such...is not an algorithm." This guy is very confused about what an algorithm is.
Is he seriously arguing that this code: is neither an algorithm nor deterministic just because the user could input a random number??
"If all you have is a hammer, everything looks like a nail" applies to some degree to the responses to the review.
We use math for these machines because that's how they were designed. They didn't have to be, although from our perspective a half-century on, it seems impossible that they might work any other way.
Computers may need math because of how they were created, but consider that an animator didn't need math to animate, rotate or transform a figure. Though it may be reduced to math, an artist doesn't need math to give depth, shading and perspective to an image. In fact, computers make such analog tasks incredibly math-intensive, as a previous poster noted.
Despite the depth and complexity of the resulting orchestrations, no math created -- though it may describe aspects of -- Beethoven's Ninth Symphony. Learning language and grammar remain elusive to mathematicians, and even Chomsky's "universal" theories end up flummoxed by the Pirahã language. The multiple readings of T. S. Eliot's The Wasteland would take more time to track than the Internet in real time.
Even in the sciences from antiquity, increasing description and formulation result in increasing complexity, but not necessarily increasing understanding. Earth, air, fire and water made sense in societal context; then extended elements; then the periodic table; then subatomic particles, light as particles and waves, and behavior of quarks. Magnetism remains elusive, as does an elegant theory of everything.
Each of these may use math as a description or even a tool, but the careful tuning analysis of the different kinds of gamelans does not apply to the gamelans, but only their analysis. The reference is to itself, and the gamelans go on with or without analysis.
In other words, were our computers not based initially in creating algorithms to manipulate the basic elements chosen to operate them, impelling the ultimate triumph of binary data over other representations, math may have receded to its place as just one tool of computer activity.
Dennis
We Are All Mozart
Logic is math. In fact, there's an argument that all of mathematics can be formulated in terms of set theory.
Arithmetic is almost never necessary for programming, and if you're using it, chances are you're doing something very wrong, like hardcoding parameters. Myself, I'm terrible at arithmetic, but so was Einstein. Arithmetic is as relevant to theoretical physics as it is to computer science.
The important flaw in this idea is that computers model math, if the author had actually paid attention in math class he would have learned that math is used to model computers, and all other systems that need formal description. So if you are doing trivial programming forget the math, if you are modeling a complicated flow (or circuit) you are using math, no matter what you call it.
Seriously. Can any field of science do "without math" ? Even in fields like psychology, you still need math for statistics.
You're right, but maybe there's an argument that exposure to higher mathematics encourages the mind to think in a more analytical way, and that method of thinking might have applications to computer science and program design.
Well said, sir. And there's nothing wrong with being a software engineer, rather than a computer scientist; I just wish the distinction was clearer in most people's minds.
Well, in the case of TFA, I think it's politically motivated. In a many parts of the world, software patents are still illegal because algorithms are held to be essentially mathematical expressions, and mathematics is excluded from patents. On the other hand, if the big software houses can orchestrate some grassroots support for the notion that "algorithms != mathematics", then they might find the next EU debate on the subject goes a little smoother.
I think that's all this is - a bought and paid for study, intended to smooth a path for eventual legislation.
Don't let THEM immanentize the Eschaton!
Hrm. It seems to me that, based on what you said, that algorithims are a type of process expression. I think the author of TFA is saying that's too limiting because it only gives a single method to solve a problem. Yeah, that sounds annoying, but it's great for provability: if there is only a single way, you can prove that it will or will not give the desired result.
I'd also contest his argument that operating systems are not deterministic - they are, just with a huge amount of state information; I think the trick is they are deterministic between changes in input state. You don't complain that a car's behavior is "not deterministic" because you don't know the way a driver will turn the steering wheel at any given time; you know that, given a steering wheel input, the response of the car will be X and can then predict the vehicle behavior until the next input from either the driver or another vehicle or a wall or the road or whatever.
In other words, I think the article is about just making sure that we can think about things in different ways. But to say that it's not based on math - I don't know. Can it be done without math? Probably, just as cooking is most often done without even a cursory knowledge of atomic chemistry (you could probably argue that cooking is its own branch of chemistry).
So, I think it's a lot of noise about stuff that people already know and already practice but for which there just isn't a label.
"There are a dozen opinions on a matter until you know the truth. Then there is only one." - CS Lewis (paraprhase)
Long before there were 'electronic brain' computers, there was Data Processing. IBM excelled at producing DP hardware and systems. In the IBM system, the data records took the form of punched cards. The individual records took the form of single cards, and cards could be sorted, shuffled around, and a deck could be placed into a reader so that each line (or select fields thereof from said card) could be echoed to a printer. All of this could be done without math or computation. This is called Electronic Data Processing.
This occupation is custodial, and still a vast percentage of the people involved working with computers only work at this level. Many people involved in IT (to my mind, it's part of the dividing line- if you're described as an IT person this is your occupation) are simple data janitors. It is part of the reason that I react negatively when a job recruiter or HR type implies that I have work experience in IT. I do not, and am not a glorified clerk.
;TODO (defmacro play-vb (vb-like-code) .... ;Learn VB first, need keywords?
common lisp (clisp is a good app to start with, linux has all the good free lisp compilers)
Math underlies everything, and everything can be expressed mathematically. Wishing it away will not make it so. I wish it were not the case because I have always struggled with high order mathematics.
Saying that computer science doesn't need math, is like saying there's nothing else to be invented... Like maybe the future generations dont really need that Hard and exercising discipline... Well let me tell you (besides the fact that computer science is Taught based on math) you would be asking for math to understand and accomplish knowledge. After doing my Calculus II, I talked to my professor and asked "Why in hell do we need to know these things?!".. And he said: "Well, maybe when you get to work you'll probably wont need to know how to integrate a variety and such... But instead think of the levels of problems you can look for now... You opened yourself for a new range of situations.. Also, your brain has evolved since you first began doing Calculus.. You're actually smarter!...". Taking Math of Computer Science is taking the ability to improve itself, to discover itself and to redefine itself
God had a 7 day deadline... So he made the world in LISP
Imagine for a minute that Military Science was taught by the mathematicians.
After all, you need calculus to determine trajectories, statistics to calculate the odds of winning a battle, eigenvectors to locate a terrorist in a crowd, game theory to map out the politics...
These are all well and good, but Math is not War. The parts of math that are good for war, we need to know. But war is its own realm, and we need to accept that.
Put another way, biology is not just chemistry with carbon.
Computer science hasn't branched off the way its really needed to. Computer science is less similar to math than bio is to chem, but bio departments tend to be independent. I think CS needs to be as well. That we can contort math into CS does not mean that algorithms are the best way to view system administration, or even memory management and schedulers. Security can be seen through set theory, and graph theory, but so much of the work to be done is centered on tagging, tracing, and interpreting. These are things that, frankly, math sees as "should be automatic". Just take more samples!
It takes a process perspective to realize, of course the instrumentation is the hard part. It's a matter of getting an accurate view of the process, and all data anywhere that might affect it (and not getting a view of a bunch of other data that won't). You can use math to help compute this, but it's the tool, not the field of study.
No more. Now students just look up the answers on Google.
It's like trying to train to be a survivalist by looking up photos of Yosemite.
(In-class tests are the usual response of teachers to Google, but this is a poverty. Previously, math tests were almost univerally take-home because the problems required such deep thinking that hours were required. In-class tests allow only simpler problems and reward shallow quick thinkers who have mastered the art of test-taking.)
In the eyes of the corporate world, math is something mathematicians do, not computer programmers. If you are a developer and come up with an algorithm, for say, calculating the price of an energy contract or the risk of an insurance policy, chances are that the company, if sufficient large, has a Phd in Mathematics on hand whose job it really is to invent those algorithms.
Your job, in corporate eyes, is just put it into the computer, get it into the database (where appropriate), and put it on screen. Most of the time, the Phd in math has enough computers to produce a C language prototype, and they will just hand that off for use in whatever language the business uses. Frequently, this is going to be VB.NET or C#, and more likely, C#.
Now, this changes if you working for a software development firm. But, in the corporate world, such as working for a utility or a bank or an insurance company, a service industry basically, as a programmer, your job is not to be a math guy, but a computer guy. Let the math people do math, is what the corporate wonks would say.
This is my sig.
and to me mathematics is synonymous with thinking and abstraction. So if you can do computer science without ever thinking, good for you. But as soon as you start analyzing a problem, deducing a solution etc you are already doing mathematics, you just may not be aware of it.
I don't understand people who want to pidgeonhole math into a subset of itself and who think math is numbers, computations, or at best calculus, and forget that the processes of modeling, generalization, deduction, abstraction are the essence of math. So pretty much any scientist of any kind is doing math implicitly (even people who abhor it and who went for softer sciences because they did not like math).
As the island of our knowledge grows, so does the shore of our ignorance.
> Good luck on doing a kernel, file system, network stack, crypto, image processing,
> window manager, animation or 3D without math or algorithms.
And when, may I ask, did you last do any of these things? Only a miniscule portion of us are working on the kernel, file system, or network stack (and none of them involve any math beyond simple algebra). Only one or two of us has ever written a window manager, and that's the way it should be. Only NSA people work with crypto on a regular basis; the rest of us just use premade libraries (made by cryptographers, who require years of practice to become good in their tiny little area of expertise). 3D is all done in hardware these days; software renderers went out of style in the last century and if you are still doing it, your software must be either really slow or running at 320x240. And as for image processing, most of us don't do that either, and when we do, we don't invent the algorithms; we ask mathematicians to do that.
Face it, most of us write code that has absolutely no math in it (I don't count algebra - it's just the way you write code). We make user interfaces, write database queries, and, I am sorry to say, rewrite parts of application frameworks we don't like (and there are a lot of such parts). Instead of math and algorithmic theory, these tasks would benefit from knowing how to structure your code properly, how to ensure portability and ease of localization, and, most importantly, how to correctly think about object oriented design.
> I look forward to reviewing some of this guys code.
Yeah, do look forward to it, since you'll be waiting a long time to see anyone write an "algorithm". I haven't written one in years, and even then it was for a software renderer made for fun. Real programming is about arranging objects and the control and data flow between them, not about crunching numbers. Numeric algorithms only exist in academia and in a few specialized libraries that nobody wants to, or should, rewrite. Design is what programming is about and that is what programmers should know and be taught. Mathematicians be damned!
So why isn't rocket science just rocket engineering?
Because it pushes the envelope of what we know. In order
to make rockets work, humankind had to form theories and
hypotheses and test them by experiment; i.e. the scientific
method. The public just see the ultimate successess and
failures, but there are thousands -- probably millions --
of true scientific investigations along the way.
Engineering, on the other hand, deals with the routine. Sure
you might design new brakes for that car or whatever -- that's
why engineering is often called applied science -- but the
basic process of building an automobile or road is pretty
routine.
There's a fuzzy line between routine applied science and
science applied to discover fundamental new truths, but I'd
say that building a road and flying to the moon are on
opposite sides of the line.
So where is computer science? There are plenty of fundamental
truths left to be discovered, and I'd call the exploration
of those "computer science." The routine generation of some
payroll system or commercial app, I'd call "engineering."
"Software engineering," on the other hand, I would call "management
science" which, IMO, neither science nor engineering.
So the article isn't about all those. Instead, it is because that stupid guy didn't know that mathematics do not end at computing a function. He thinks there is no mathematics in programs just because they deviate slightly from the simplest model of computation that put some input to the RAM tape and have an algorithm put something into the output tape. He ignores that mathematics is rich enough to capture computations that lasts more than providing a single value. He ignores the wealth of knowledge of mathematics that deals with coordinating other computation. He ignores the wealth of knowledge that deals with random process and, indeed, the source of randomness, which is algorithmically created. And then he claim that mathematics has no place in it, ignoring that once you have any sort of idea, it requires mathematical arguments to make sure nothing wrong can happen to it. I can't help but believing that this is one of the most clueless article I've ever seen in
Yes, because that's how you design and implement a file system.
"Oppression and harassment is a small price to pay to live in the land of the free." -- Montgomery Burns.
I RTFA and the guy is off his rocker. Computer science isn't math and I don't think anyone (except maybe the author) confuses it with math. It uses math as a tool, but it's certainly not math. It's almost like saying a biochemist would be better off without knowing biology or chemistry. They're both tools of the biochemist, but he/she is neither a biologist nor a chemist. Many professions use math as part of the job. An accountant isn't a mathematician, yet an accountant also uses math as a tool. A mechanical engineer isn't a mathematician, but a mechanical engineer also uses math as a tool. I could go on and on all day.
Personally, I hate math. I've been writing software for 28 years. Math, at least algebra, is something I accept as a necessary evil to do the job, but I've rarely needed more advanced forms of math to do the job. Algebra is simply one of many necessary tools used by the computer scientist. But logic isn't strictly a mathematical concept, and logic is definitely a bigger part of computer science.
Most of the programmers I've worked with don't really spend a great deal of time thinking about math. They spend time thinking about object oriented design and interactions between components. These aren't mathematical concepts at all.
I agree with you in general, but there's a particular point I disagree with. VBScript is a great scripting language to embed into applications (well, nowadays you can embed python wherever you can embed VBScript, so it's not that great), but the GP's beef is with the actual Visual Basic language, I think. I learnt Visual Basic as a first serious language and you could do a great deal with minimal effort, and that is what is great about VB.
.NET is totally different I think). In VB, you don't really need classes, so you get by without them. I don't know if you need classes in python or if I just happened to learn them then, but the fact is that I couldn't understand a single word of advanced programming APIs when I knew VB and I know a great deal more now with python (admittedly, I learnt C/C++, assembly, php, etc etc in the meantime as well).
I was a staunch supporter for years, until I learnt python and realized that VB didn't teach me any important programming concepts like classes, exceptions, etc etc (that's until VB 6 or so,
To recap, my point is that since VB is good enough, you never become a "real" programmer with it.
Send email from the afterlife! Write your e-will at Dead Man's Switch.
I hate math... In college I was failing statistics so badly by the third week that I mathematically not be able to pass the class. I couldn't figured out statistics but I needed math to realize that I couldn't pass the class.
/) may really not be all that important since us geeks are surrounded by computers that can EASILY do that for us but I can't understand how you can even begin to work with a computer and understand computer logic unless you understand at least the basic principals of algebra.
Point is, I think the emphasis on math is a little skewed but the author of the post is more skewed than anything. Basic math (+, -, X,
So a system that is based on 1's and 0's (I checked, those are NUMBERS) suddenly does not require any mathematics to operate?
I would correct your analogy just a little bit.
Science: Physics
Engineering: Electrical engineering e.g. design a micro chip
Technology: Actually make a micro chip
There is big difference between knowing how it works at a physics level. A much broader class of people know this. A much much smaller class of people know how to design one. And even smaller class of people know how to make one.
Same with a nuclear bomb. I think we all know how it works. Some might even know how to make one. But very few have the technology to purify the materials to make one. See the distinction. At each level different kind of knowledge is required.
As the island of our knowledge grows, so does the shore of our ignorance.
are an idiot.
As the island of our knowledge grows, so does the shore of our ignorance.
I have dyscalculia - the trouble with numbers that people have with dyslexia have with letters. Numbers crawl all over the page when I look at them and the harder I concentrate the worse they crawl. I also put numbers into sentences when writing - like 5 for F and otherwise fairly neat block lettering gets pinched and scribbled when I write numbers. But my analytical skills are sharp. Maybe sharper because I had to learn how to compensate. But having said that, most of my problems as a software architect are 'word problems'. Get this damn pile of rubble to do X,Y, and Z'. I have realized fairly complex math formulas into algorythms to do the math that I couldn't otherwise do at gun point. In fact one of the reason I bought my first computer was to get it to do the math for me that I couldn't. I know how math works, I just can't get the ansmwers on my own. So when it comes to CS, IMHO - it's better to be a good analyst and detail oriented than be a math major.
Too lazy to create a sig...
on your degree. It really is useless if you think that way. You don't seem to even know what math or computer science is, after earning? a degree in it? Sad, truly sad.
As the island of our knowledge grows, so does the shore of our ignorance.
Do you have trouble just with numerals, or the more general concept of numbers? If the former, are just the arabic numerals affected, or are things like tally marks and Roman numerals affected too?
If it's the latter, and, say, a + b - c = d crawls around on the page, how do you compensate for that?
The trouble with math-oriented computer scientists is that they abstract the wrong things. Yes, we need to create abstractions in programming; it is what our job is all about, but we abstract processes, not numbers. A mathematician thinks in terms of numbers and functions, which naturally helps in creating numeric algorithms. But they forget, or simply don't know, sitting in their ivory towers, that real programming does not involve any numeric algorithms. Number crunching is for research. Universities are full of scientists who do just that, getting numbers from experiments and writing numeric algorithms to make sense of those numbers. Outside the universities, nobody ever does that; if there are any numbers involved, we do it in Excel. So when you write software for anyone outside the academia, knowing lots of math to know how to invent new numeric algorithms is worthless.
You will be creating abstractions in the real world, but they are different kinds of abstractions. These will not be based on numbers, but on processes and on structure. To make them you'll recognize similarities between functions or object arrangements and create abstractions to merge them. This is how you make small code. This is how you save time for others, who will be able to use your abstractions directly instead of writing lots of duplicate code or hundreds of special cases. Writing such abstractions requires a lot of skill, but that skill is not mathematical and someone who obsesses about math will not be able to create them correctly.
Look at STL, parts of which are a shining example of uselessness. One of its core ideas is a collection of abstract algorithms into which we plug in our own functions. Sounds great to a mathematician, but a horrible idea in reality. First of all, we don't have functions; we have objects, and STL does not play well at all with objects and member functions. Anyone who tries, discovers how quickly their code becomes an unreadable bloated pig. Second, "plugin" functions generate bloat. Yes, the compiler can inline stuff, some of the time, but in most situations you end up with larger code then you would have otherwise. Mathematicians also have no experience with PLTs and have no frigging idea how huge those instantiated template algorithm names are and how much they add to disk space usage and application startup time. OpenOffice enormous startup time is largely caused by such things. Third, "plugin" functions don't fit into an object-oriented design. They just don't belong anywhere. An academic doesn't care about such things, since all he has is a few hundred vectors of floats, with no structure whatsoever. He doesn't have to maintain his code, he just throws it away when he's done with the current computation. In the real world, programs live for decades, and clarity of structure is paramount.
It is the structural abstractions that are most common and most needed. Any programmer would be well served in developing the skill to do these properly, as only a few have that skill, evidenced by thousands of poorly designed projects on SourceForge. So screw the math and spend your time on learning design instead!
Deleted
When I was getting my BS in computer science, they made us minor in math. As a result, I had to spend hours and hours doing a whole bunch of math that I pretty much hated. The worst part was that in no way did the math help me to become a better programmer. Sure, if I were doing graphics processing or AI or something like that, I'd probably need some math, but those have never been my areas of interest. Since I've graduated, I haven't used calc or liner algebra or advanced stat a single time. By this point, I've probably forgotten it all.
It's sad to think that all the time I spent doing math in college could have been spent learning useful things, like design patterns or UI design or unit testing.
I'm all for it! Do away with those pesky additions and subtractions and "variables" that make programs so complicated! Get algebra out of the code!
Seven puppies were harmed during the making of this post.
"Computer engineering.. yeah.. I can understand that.. But man.. Computer SCIENCE ?
That's like saying 'car science', 'cooking science' or 'go at the bar and have a drink science' !"
Funny you should mention that last one. I remember reading about a study
that was done by a guy in a bar that related the rate of drinking to the
type of music that was being played. The guy had a drink for camouflage,
but he also had a concealed tape recorder and a pencil. Every time someone
took a sip of their drink he'd tap the pencil on the table near the recorder.
He found that the sadder the country & western song, the more the listeners
would drink. (As though they wanted to drown their sorrows, on behalf of
song's protagonist.)
How's that for 'go at the bar and have a drink science'?
There is another theory that states that this has already happened.
If you have ever used a matrix transformation in OpenGL you've already touched some high level maths. http://en.wikipedia.org/wiki/Linear_algebra#Some_u seful_theorems
Trying to do computer science without maths is about as likely to succeed as doing physics without maths, and lets just say you won't get very far...
I'd like to see someone make a computer that can navigate a spaceship to the moon and back without mathematics.
One of the 'hot' new topics in computers is heat dissipation. How to get anywhere in this without thermodynamics and its underlying mathematics? If this is not computer science, what is?
Maybe you can get logo turtles to make pretty pictures on the screen without understanding the math involved, but real computers exist in the real world. We use math to understand our world, so we need to use math to figure out how the computers interact with it.
To understand crypto, 3D graphics, image processing, etc you need math. But writing a crypto library is not part of the definition of software development.
If I build software for managing agricultural auctions, I need to have in-depth understanding about agricultural auctions; linear algebra won't be of nearly as much use as it would be for 3D graphics.
On in the contrary, my experience has been that you should just take the math. Everything else - computer science, physics, even a lot of biology these days is just an application of math. You can pick up the details of any of these fields pretty quickly and make yourself useful if you are have a strong understanding of the underlying patterns and logic math teaches.
(then again, it may just be that any education adds discipline to thinking and that once you have that, you can learn on your own throughout life)
CS is more than just programming. You don't need a large amount of math to code, but good luck doing anything theoretical without a solid math background.
If you don't want math in CS, you are either incapable OR lazy, neither of those personality traits helps in computer science.
Copyright infringement is "piracy" in the same way DRM is "consumer rape"
I hope this guy does better than Steorn, which claimed that they could throw away physics and produce free energy. You can see how well this went.
This guy has a beef with mathematics, since he wants solutions to be developed be more naturally. Well, natural intelligence took several million years to develop adaptively, but if I told my client "I'll take your spec and let it 'evolve' into a solution for the next 100 000 years", there's quite the possibility he'll find someone who knows math instead.
He's right about one thing, and in fact I've said this myself lots of times: lots of the consumer apps don't need heavy math to build. they just need work, good UI and adherence to functionality specs.
But all of this "easy development" is still built upon math libraries we take for granted (os kernel and management, image and video compression libraries, DSP libraries, sorting algorithms etc).
As a quick test: let's try and remove all math related machine commands from a CPU and try to work a usable solution with that.. Good luck.
I don't like people who reject hundreds of years of science work (math) and offer nothing as alternative, except vague dreams about more natural computing.
I really don't care what you do with Computer Science. There is a lot of research that requires math, as others have pointed out. And a lot of it is really valuable. Equally there is a lot of research bundled under "computer science" (because it uses computers I guess) that requires no math. Whatever.
What I'd like is an arts program that concentrates on programming. I'd like something that stresses *reading* and *writing*. I want people to learn how to *communicate* in these programming languages; not just with the computer, but also with their fellow programmers. I'd like people to do research in language design where they ask the question, "How can I allow the programmer to be more expressive about their intent?" I'd like classes on collaborative design. I could go on forever.
I was at the art gallery the other day and wandered into the modern art section. They had a display of a particular type of performance art where someone would write out a description of an artwork on 3x5 index cards. A bunch of other artists would take the description and make the art. Along with the index cards and pictures of the finished work, there were a couple of letters. The letters were describing the disappointment the original artists had in the finished work. They even went so far as to accuse the artists following the instructions as being "incompetent".
I described this to a programmer colleague of mine. His response was, "Wow... I didn't know I was a performance artist". I can count the number of times in the last 20 years that I've had to do hard math in my job as a programmer on my fingers. But questions like, "How the hell did you think *that* was readable", "How can I turn a bunch of requirements into something that isn't crap", "How do I get 10 guys working on a project and have a single vision", etc, etc, etc; those questions I ask every day.
Sure computer science is important and personally I think math is a part of that. But, someday I hope someone will realize that programming is an *artistic* endeavor and we need to do a crap load of research in that area.
If you read Knuth's Selected Papers on Computer Science, you'll see he argues that algorithmic thinking is fundamentally a non-mathematician way of viewing problems. And besides, as other people have stated, Software Engineering is just a subset of Computer Science.
Often, yes. :-)
Computer engineering.. yeah.. I can understand that.. But man.. Computer SCIENCE ?
That's like saying 'car science', 'cooking science' or 'go at the bar and have a drink science' !
--Ivan Edsger Dijkstra would appear to agree with you. Calling the study of algorithms "computer science" is like calling astronomy "telescope science".
I have a CS degree, and before that, I did three years in an Engineering program, so I have a grasp of the concepts here:
Computer scientist is to programmer where automotive engineer is to hot-rod builder.
A computer scientist knows the fundamentals of how computation works. The math determines whether or not your software works well and efficiently, and the computer scientist will know if an algorithm will work in an extreme case before building the software. The computer scientist also creates code for unique cases where there are no readily available pre-built libraries available.
A programmer, takes requirements and maps those to pre-built libraries and tools. A programmer is more of an "integrator" than a creator of new technologies.
Example: You want to look for intelligent life in mountains of sample radio data, you ask a computer scientist to design the system. If you want to sort and search through sales data, you get a run of the mill software shop to design you a system.
An automotive engineer creates new engines, suspensions, and safety systems for the application at hand. Many times, in a new design, there are no "off the shelf" components, so the engineer must know the math behind physics, materials science, and production methods to create a new system. The automotive engineer may also need to be familiar with the human body as well.
A hot-rod builder takes existing engines, modification techniques, and pre-engineered systems and integrates them into something unique. Many hotrod builders do not have the engineering knowledge to create a new motor, suspension, or safety system from scratch.
Example: If you want a new hybrid drivetrain that can meet federal and state emissions and safety laws, and can be produced in large quantities, you get an automotive engineer to build you that system. If you want a sub 10 second Camaro, you get a hot-rod builder to build that system.
The computer science field is starting to divide itself into the "white-collar" and "blue-collar" jobs that define other industries. I see a future where engineering jobs are separate from coding jobs, much like engineering/planning/architecture is separate from construction.
-ted
We've heard the claim many times that your have to have Math in order to know Computer Science. That is simply not true, especially on the empirical level. The argument factors down to the computational level and the fact that math is not needed in order for states to change in the computation. Also, when you get into AI, you'll find there are conscience levels of state changes that pure science alone can not explain but Computer Science can explain and except with AI. In science, the conscience levels are only defined up unto phenomenas. There is no language in Math to explain such phenomenas, but there is in Computer Science. Therefore, Math co-exists with Computer Science very nicely.
Its not so much that computer science isn't related to math. Its more that CS students are assigned the wrong math courses.
Algebra is an obvious key to understanding computation. Discrete mathematics including probability and combinatorics tend to pop up in computing problems over a wide range of disciplines.
On the other hand, it would not be unfair to suggest that computing is more useful to calculus than calculus is to computer science. Continuous mathematics, like calculus, show up rarely if ever in most computer science specialties.
Fant also seems to be stuck on the word "algorithm." Computer scientists have a very different definition of an algorithm than mathematicians. LISP was the only moderately successful attempt to introduce computer scientists to the mathematical notion of an algorithm. I'll take the groans and dearth of hands raised to the question, "Is LISP your primary programming language?" as proof of just how little regard computer scienctists have for the mathematical notion of an algorithm.
Moderating "-1, Disagree" is simple censorship. Have the guts to post your opinion.
IMHO the difference between computer science and software engineering is what they do with the knowledge. Software engineers need to be very much aware of the entire computer science spectrum but instead of doing the science (see research) and finding/creating new theories and technologies, they build systems with the existing knowledge. A good software engineer will know as much about computer science as the computer scientist but will use it in a different manner. A programmer is not a software engineer, programming is a prerequisite to be a software engineer.
That said a Mathematician is not a computer scientist and vice versa. Is maths required for computer science? Absolutely! But only up to the level of some calculus, matrix maths, discrete maths and some vector maths. What is not required is a deep understanding of pure mathematics unless you're specialising in a maths heavy area of computer science such as 3D graphics, image recognition, algorithmics and the like. I agree with the author that CS should start moving further away from the maths discipline but do think that the appropriate maths should be kept in the subject.
Silly rabbit
If I didn't know better, I'd say this was an attempt to hide how pathetic our North American school systems have become. I recently finished my first year teaching chemistry at a small University, and it included a course of "Chemistry for Liberal Arts Students" (mostly education students). At one point I made the mistake of trying to explain the concept of equilibrium ... which tends to come up with square roots and the quadratic equation. This produced a near revolt because I was trying to use "advanced math" ... If our school system has fallen to the point where university students think of the quadratic equation (grade 10 math) as "advanced math", then it's no wonder people are trying to introduce idiotic ideas like this into society.
My major was applied mathematics, and I have managed to forget 90% of the math I knew. Applied Math lines up with the engineering side of things. (Engineers should really be forced to take a few courses from the AM department). The science side lines up better with Pure Math and C&O.
Comment removed based on user account deletion
Thinking like a computer...using Boolean logic perhaps? Those if-then-else structures you love are a way of expressing algebraic statements, even if the language you're using to express them is more like English than algebra.
Further, when you simplify:
into
you're using commutation, a mathematical property.
See, you're better at math than you thought.
Math is so overrated with respect to programming. It's idiotic to have (for example) four years of calculus, unless you happen to be writing Mathematica. Programming is more like management than mathematics. I think this guy is right on the money.
And while there are facets of programming that do not involve more than the basics of reasoning about programs, almost everything you do above the simplest level will end up using some facet of mathematics in a crucial way.
There are quite enough simple examples to show this. For instance, suppose you want to generate a random permutation of a set of objects (shuffle a deck of cards...). There are several algorithms to do this and most are incorrect - but to understand why takes a nice (though relatively simple) bit of mathematical reasoning. While, in this case, just knowing that some algorithms are wrong and some right is enough, there is some underlying math that will tell you just how the wrong shuffles go wrong(but it is not at all trivial). In some other problems the math required jumps out much more quickly.
From the parent:
My personal hostility toward VB comes from two sources: First, it really is ugly. Second, and a bigger issue for me, is that VB was used by tons of of managers to try to solve the "programmer problem." As the grandparent says, programming is a hard problem.
Understanding the basics of a programming language or system is not so bad, but the ability to learn different business knowledge for every project, to creatively apply it to writing programs, to design programs that can be easily fixed when problems come to light, to communicate with a large population of users with diverse jargon and assumptions -- it requires a smart person who is willing to work hard.
There may be a lot of smart people in the world, but the willingness to work hard is less common. And, unfortunately, the hype and glamour of programming in the 1980s and 1990s tended to attract people who wanted to get big bucks for little effort. Is it any wonder that business people were freaking out about the cost/quality ratio of programming? Is it any wonder that they are still freaking out about it?
What has this got to do with math in programming? Oh, maybe not much. But, "removing math from computer science" sounds to me like just another silver bullet someone is proposing to make programming easy for everyone. The simple fact is that programming will always be a hard problem, just as medicine, law, structural engineering, writing symphonies, visual art, and other essentially human tasks will always be. If we ever get true artifical intelligence, perhaps programming can be made simple and easy for everyone. Otherwise, don't count on it.
I had forgotten how much cooler teenagers look when they are smoking. Oh, wait
I'm a certified Linux admin.
I can't do any math beyond very basic algebra. (learning disabilities)
I just decided to go to college.
I finished my first c++ class with an A.
The math involved was basic math.
The hard part is thinking like a computer.
I didn't need algebra to learn to program.
My brain's ability to do logic is quite different from the normal logic most other people do because I had such a poor background in math.
Even though I can't do advanced math, I'm still excelling in computer science.
I understand true computer and network security; I have a fresh view on how to approach programming problems.
I am starting my advanced c++ class in august and I'm sure I'll pass that class also. There's a lot less math involved in programming than you think.
Computer science doesn't need high-level math.
Computer engineering does.
They're using their grammar skills there.
It's lucky Jobs went to his calligraphy classes; if he hadn't we'd all still be using monochrome terminals. (A pretty arrogant thing to imply)
// MD_Update(&m,buf,j);
What you have written is 100% nonsense and puts you in exactly the same crank camp as Fant. It is always interesting to hear people that don't understand computer science describe what is wrong with it. The model of interaction that you (and he) describe is normally called Reactive software, and it is true to say that it cannot be modelled by a Turing Machine as it performs interaction continuously rather than at the beginning and end of the computation.
From here you've both made a giant leap to assume that programs can't be described by an algorithm. You haven't understood that the difference between a "computation" and "reactive software" is actually a technical triviality that is easily overcome. Indeed it is so trivial that most languages simply ignore it and have stateful operations for input/output. Reactive programs are normally modelled as a sequence of algorithmic steps, everything that the program does apart from sending / receiving data is modelled by an algorithm. So we can either consider this "non-algorithm" to be a sequence of algorithms or consider the program as an algorithm operating over a larger state that includes the environment. The input/output actions become alrgorithmic state transitions over the program/environment state. Look at the way programs in CSP/CCS or other process algebra are written to how this works. To see how the theory of algorithms can be applied to reactive systems take a look at multi-headed Turing Machines.
Finally, if you're going to lob a technical term into a discussion then you should understand what it means. Automaton is a well defined term in CS, and it doesn't mean what you think. In particular what you are describing is not a decision problem and so there is not a problem of language recognition to be solved. I vaguely remembering reading the crank research that you are pointing before, and would like to ask you a simple question. Name one problem that you believe can be computed by a UBM, but not by a UTM?
Slashdot: where don knuth is an idiot because he cant grasp the awesome power of php
Being a somewhat geek that has really wanted to get into the computer related work field, be a website designer, or a sysadmin or just a guy doing hardware repairs, I've always found it hindersome when it came to math.
Math was never, ever my strong suit. I can do your basics. Addition, subtraction, division and multiplication. Some real basic formulas but past that yea math is a subject I can't seem to learn. As you got higher and higher in math in terms of types and levels there were just even more and more formulas and types of equations for you to memorize. Just cause I can remember a shit ton about Star Trek doesn't mean I can memorize the first couple hundred Prime numbers or square roots of stuff or sign and cosign etc
Which was cool, cause despite how I always liked the idea of programming and such I knew that was well beyond my field of duty. But then you start looking at other mediums of the computer industry and a lot of jobs require a certain expertise in math. Hell even schools, want math math math. When I enrolled in community college years ago, before I could even set foot into a computer course of any kind (even real basic stuff like web design or web coding) I woulda had to take a ton of math classes. Since I never got around to Algebra 2 in high school (it wasn't a requirement to graduate) I would have had to take that, then Calculus then Trig, then all kinds of other stuff, just for a simple class on how to do HTML or graphical design.
Since then I've always been hampered by math. Sure I can memorize a telephone number, calculate a checkbook etc But memorizing hundreds of formulas (you may be able to look them up on the job, doing them for tests is different, not all teachers and professors let you write down the formulas). If I want a job as someone high up in the tech industry (that isn't ya know, rocket science) I still need some big time degree and high level of mathematics skill.
Aw Frell this
Judging by both some of the software I have to use, and the comments on /., apparently not.
:-)
A friend once defined hacker as someone who types "main(){}" and then invokes the debugger
Sure there are aspects of software/systems development where mathematics, as the underlying 'physics of software' are not so necessary. But saying that we don't need mathematics for developing software is like saying we don't need physics for constructing buildings. Yeah, it can be done, but the chance of the structure (physical or logical) falling down, particularly under conditions outside the nominal, is unfortunately pretty good.
You do not have to be a mathematician to construct correct programs, but in my experience, it helps A LOT.
dave
I read the site. Thanks for the link. A lot more GUI code gets written than real algorithms, and I do feel that we could possibly find a huge improvement in GUI programming through some sort of hard-ware methodology motivated paradigm, as suggested in the link. If that's the kind of programming you're referring to, you might be right. However, for doing things like finding good placements for components, object-oriented procedural programming wins, IMO. It's just the natural way to describe a system, and the algorithm to affect that system. For describing GUIs, I've always wished I could just solder a stupid button on a panel, rather than deal with crazy event loops. I have not seen a programming environment yet that makes GUI design seem natural to me.
Beer is proof that God loves us, and wants us to be happy.
It's not because the world doesn't need a concept right now or that it is not really practical that it is not interesting or cannot bring advancement for the society. How do you think we advanced in technology (radios were made possible with Fourier calculus), physics (everything...), architecture (phi) or even gardening (geometry) without maths? How can anyone think that maths should be left out of any field?
Although we should not leave math to non-mathematicians, saying that mathematics is not needed for any field is a proof by absurd that you don't understand the real meaning of mathematics. "So what" is just the QED.
Of Code And Men
Algebraic equations don't bother me as with any of the equations I used in electronics. These were the first things I wrote my early programs to do - ham radio stuff. It's only when I put actual numbers to them that I have trouble, As when I do math with numbers from Roman or the Chinese writing which I've learned, since I conceptualize with the Arabic numbers and have to write them down in Arabic. Other numbering systems as words are OK and I can read Arabic numbers fine as words. It's just when I try to do calculations on numbers that it becomes a problem. Hell if I know why. I was in my 40s before I was diagnosed - it was always supposed that I was just stupid and wouldn't be much more than a janitor or gas staation attendant. It was when the early microcomputers came out that I discovered how to make the machine do the heavy lifting - and I've made a damn fine living doing it for other people since.
Too lazy to create a sig...
Having done some work for a well known packaged food brand, in a research and development lab and pilot plant, I can definitely confirm that there is such a thing as cooking science and food science.
"Pure" math is math for its own sake, divorced from application.
And CS is riddled with that silly idea!
Here's what any sane person would think when presented with the idea of "pure" math,
"There is no branch of mathematics, however abstract, which may not someday be applied to the phenomena of the real world."
Nikolai Lobachevsky
clearly already abandoned the study of mathematics.... I just wrote this comment, and the damn captcha will not let me through. I must be a turing machine myself. "Computer science does not need a theory of computation; it needs a comprehensive theory of process expression." One could argue that the theory of computation is a comprehensive theory of process expression. Most formulations of the the theory of computation consist of ways of precisely describing states and rules for transitioning between them. Leaving that particular albatross aside for the moment, I would agree that there should be more emphasis on communications skills, teamwork and writing in most computer science programs. I do not agree at all that mathematics is irrelevant to computer science. Mathematics in its modern form is simply the study of relationships between very well defined abstract objects, and analogy and application can be drawn from it just about any endeavor. If you don't understand that, take my word for now, and give some group/category theory a read.
This bonehead doesn't know what mathematics is.
I think the better analogy might be to "movie science". It can both be the case that movies like The Matrix are more easily made with the aid of science, and yet the movies made by people with a camera for YouTube are leading somewhere organic that is different.
I see the issue he's asking (in the article summary--I didn't read the book) as not being about the questions are answered, but rather what questions are asked.
It's not that computer science doesn't provide good answers to questions it asks, it's that it locks a great segment of the population out of the right to ask questions relevant to them, by creating an immense jargon barrier to even involving themselves.
Law and politics have done the same things. Lots of people have opinions on law and politics, because these things affect them on a daily basis. But the world is not moving toward greater involvement of the individual in these areas. Rather, there are ever more ways to explain to someone why they are incompetent to discuss these matters. Which means power collects in a few.
Most of the arguments I've seen on this thread address the issue narrowly and defensively at the level of rejection of technique, or on the basis of the idea that if this one author has expressed himself poorly or slightly missed the mark in what he has pointed to, then there is therefore no issue. I don't think that's so.
When the web was born, there were people who made criticisms of the old internet/arpanet network that preceded it. Some may even have said "you built the wrong network before and now we've got the right one". Such a view might be attacked as technically uninformed, but it doesn't make it untrue in spirit. It's true that the Web needed the old internet to be brought up, but it doesn't follow from that that the people of the world were on track to make the web. It could have rolled out very differently, with very different properties, or not at all. And yet, as soon as it was in place, people didn't investigate alternate versions (many of which were in play), they instead set about beating those other things down. Or at least turning their back on them.
There are technology trends in CS, and that's good. And there are funding trends in CS, and that starves the availability of alternatives. And that's not so good. It's the same kind of battle that the Linux crowd has fought against the Windows crowd--trying to make the case that the emphasis of the market winners is not necesarily the full space of things all people might want. And that's surely so. Yet here another person is trying to make a similar point about computer science in general--how it might usefully do some different things, and who of all people are rushing to say "nothing useful here, just move along"? Slashdot readers. I see much irony here. Your mileage may vary.
It's not that I don't think there are improvements in computer science that reach mainstream people. I just don't think there are enough. And I don't think we get to a wider audience by assuming what we're doing is already ok. A few moments thought on what else we might be doing, not just in terms of techniques and technologies, but in terms of wishes and goals, doesn't seem like something that should be greeted by such aggressive debunking.
There are real barriers to people using computers, and there are artificial ones. We don't do much work to distinguish them. Nor do we understand the ordering issues as well as we should. Maybe if people did dive into computation without knowing, they'd come to an intuitive understanding that algorithms matter because they would confront the issues themselves instead of having to understand intellectually. Yet we dissuade people from even trying, so of course they never get that intuition. Before I ever took computation courses in a formal way, I wrote a bad search program in BASIC that it was easy to see wasn't going to terminate. Even without the math, it was very instructive. Because it motivated me to care when I finally did learn algorithms. I knew why they were going to matter and was ready to receive the information.
Kent M Pitman
Philosopher, Technologist, Writer
I think the problems people experience in computer sci/eng are systemic of the maths requirements of science majors in general
In my opinion all maths subjects should be dropped - and replaced by major-specific maths subjects (some of these exists for engineering majors). In my eyes the problem with taking a pure/applied maths subject when you are not a maths major is that come end of the semester, the lecturer can't say 'oh ok now you know what to do when you need to use this idea' because they have no idea what you want to do. Instead all they can do is stick to what they believe is the common ground between their knowledge of maths and yours, drilling you on how well you know the ins and outs of the the methodology, and basically I could not give a stuff about how quickly I can perform an algorithm on paper 50 times over.
I would rather be tested on how I can translate the ideas of my major into mathematics. Which is damned well all care about now that I am doing research.
It's worth the money of paying for extra classes. It's a core issue of the science education system. Academics need to be fed anyhow.
Here is my take on the obsolescence of mathematics in the spirit of what happened to Latin after Gutenburg's movable type
Comp. Sci. - Math = Comp. Engineering
In college I took classes in Science, Technology and Society. Basically, it was a critical thinking class. One thing I learned there is the true definition of science vs. technology. Science is discovery, engineering is building. While the pyramid builders needed good geometric skills, they didn't need to know the math behind the levers, pulleys, rollers, sand piles, etc. they just needed to know that if you have a long enough lever, you can push on one end with 3 people, and a really heavy rock will move. When it moves you can put roller logs under it and move it better. If you then take this rock, laying flat, and roll it up on a pile of sand in a column, then "drain" the sand from the bottom, the rock will "fall" vertically into place. No math there...just experience.
If you want to get insight into just HOW LONG the lever has to be to lift the stone, and WHY it has to be that long, you need the mathematics to DISCOVER these insights. You're not building anything...that's science. Once you discover that the length of the lever needs to be X feet long (cubits, arm lengths, whatever), then you can tell the engineers that their levers are twice as long as they need to be, and if you use a shorter one at least X feet long you can still do the work without so many of them breaking from the force. The engineer doesn't care WHY, just that it works.
A computer engineer just wants to get something that works. A scientist can tell the engineer which algorithms work better (heap vs. stack vs. hash table vs. whatever). The engineer needs the RESULTS of the scientist to build things better. The engineer can tell the scientist what doesn't work, and the scientist can figure out why.
In my case, I was pretty good at math, got in I think the 85 percentile of the GRE back around 1972,
and that with a BIG hangover. At first I was lousy at programming. I had my first exposure using
a PDP-8 around 1966 in a Numerical Analysis class. I was a math major with a 'C' average in mathematics.
Eventually, though, I did 'get it' as far as programming was concerned when I took an assembler class
and a class in digital electronics. All of a sudden I knew what the computer was doing, and then I
could program it. This was in the mid to late 70s, and for the first time I was an 'A' student in
college. With math, the problem for me always seemed to be holding tight onto the precise
meaning of the definitions, they would sort of drift in my mind, the way words do in normal human
language. This was perhaps also a problem for me in accounting and law classes that I took.
But, once I was thinking in true binary, there was no drift in understanding anymore. And if you
weren't sure, you could try it out and see if it worked. The computer was patient and unvarying
in its responses.
When I tried to learn Haskell, though, it was hard. Partly it may just be that I'm older. But it
felt like it was mathematics, because I didn't feel like I knew what was happening inside the computer.
From what I understand, good Haskell programmers are very productive. They win contests. But I think
they must also have good math skills. You have to be a special kind of programmer to learn haskell I
suspect.
In theory, theory and practice are the same; in practice they're different. (Yogi Berra & A. Einstein)
I believe it was Arthur Clark who coined the term (I'm paraphrasing here), "Advanced enough technology is indistinguishable from magic".
What we're seeing here is society's reaction to computers as they become so complex that they are effectively indistinguishable from magic. How does an iPhone work? Dunno. It's a magical gizmo, though! In fact, it's a veritable sorcerer's stone! See things from a distance! Talk to people from a distance! Listen to the music of the stars! In old-school Dungeons-and-Dragons-speak, it grants the owner Clairvoyance, Minor Telepathy, and Music of the Stars. Interestingly, the iPhone is basically the same meme/myth as the Sorcerer's Stone. And the Wii? Shall we compare the Wii remote with a magic wand? All sorts of interesting parallels there. One of my favorites, though, were the talking paintings at Hogwarts. Looks just like something you might find at MIT's Media Lab, or at a Sharper Edge Bottique.
The point is... technology is getting so advanced that society (non tech folk) is starting to resort to myth, magic, and superstition to deal with it. "a scheduler is O(log N) the number of processes"? That's not only greek to the normal layperson, it's technobabble, and it borders on discussing metaphysical abstractions that one would expect from a sorcerer or wizard. And the best part of it all? For the lay person just crossing the digital divide nowdays, learning a series of commands or the basics of a scripting language is practically like learning a rote or a spell. Want to turn on a scrying device? Try opening a webbrowser and watch some online videos. Want to animate an automaton? Try turning on your roomba, or build some Lego robots. Want to create an illusion or personal reality bubble? Play some music through iTunes or log onto WorldOfWarcraft or Everquest or whatever people are logging onto nowdays.
I, for one, learned all I need to know about maths from this "look around you" educational video. The BASIC code in the intro is easy to create with just this basic knowledge of maths.
http://en.wikipedia.org/wiki/Topos_theory
Bah -- which logical system is abstraction physics living in? It's so far down the tree from Infinite Fun Space that it's not funny.
From TFA: "Computer science does not need a theory of computation; it needs a comprehensive theory of process expression."
So what the writer of the book is really saying is that Computer Science needs a different kind of mathematics.
Just because you don't "drop out" doesn't mean that you only take "normal courses". But if you don't study logic it might. :)
Stephan
http://stephan.sugarmotor.org
"The notion of the algorithm," he concludes "simply does not provide conceptual enlightenment for the questions that most computer scientists are concerned with."
The assertion that computer science is not math is similar to the assertion made in the book "The World is Flat" saying the world is now "flatter" than it used to be. In the case of the flat world, Friedman (the author of "The World is Flat") claims the world is flat to create a sense of shock that he can then use to get his message about globalization across. In the case of "computer science is not math" Fant here is trying first to shock as a method of capturing attention...
Most Americans use math in the singular. The Brits say maths. That is because there are multiple branches of mathematics. What we are discovering is that the tie between arithmetic and calculus and computer science is falsely reinforced. The fact is there are other branches of mathematics that are more important to computer science. There are also many new branches of mathematics that need to be developed in order to solve the new kinds of problems we are trying to solve in modern computer science.
I am really bothered by programmers who, when I interview them, say they have been writing software for years and can't remember ever having to use math.
I know they can't possibly mean that... or they don't know what math is...
I know that in several years of programming you must have at least been tempted to write an if statement or at least one loop of some kind.
The if statement uses a form of algebra called boolean algebra. It was named after George Boole who was very much a mathematician. I know that there are many programmers today who use the if statement and this form of mathematics makes up a large part of many programmer's jobs. I guess it must be falling out of fashion.
I know how to perform boolean algebraic operations on a white board and I have many times been confronted with a gigantic morass of if and else if statements and using simple truth tables and a little boolean math have reduced enormous sets of ifs down to just a few.
The new computer science needs to focus on solving problems involving processes. Processes are like algorithms in that they have a set of instructions but they are unlike algorithms in that they also have many temporal components and may exhibit parallelism, asynchronous invocations, and may not have a finite product. These are the types of problems addressed in newer mathematic disciplines that are trying to see information processes not as tied to computing machinery but as tied to the natural world.
Computer Science may point to a new kind of science that describes an underlying natural computational order of the universe. We are starting to observe computational processes everywhere, in the brains of animals, to the interactions of ecosystems, to quantum mechanics. We may lack the right mathematics to describe these things and we may have to invent new kinds of math but that doesn't mean that math becomes unimportant. An understanding of math can help when studying logic and so too would it help in studying any new disciplines that we may need to invent.
New kinds of math are invented every day to describe new kinds of problems. To say you don't need math to study any formal science let alone computer science is just silly. It is just something shocking to say that grabs attention... and the article nearly contradicts itself by the end... and it's only 7 paragraphs. The distinction Fant makes is nearly academic. Just as the distinction between a Statistician, a Geometer ( a mathematician who studies geometry ), and a Logician is academic. Yet that is not what the readers of the headline will read... Fant is arguing to make computer science a new kind of science much as Wolfram has. Yet it would be sil
[signature]
The article is light on details on how to find the book (it just calls the author "Fant" with no first name and there is no title). This book it titled "Computer Science Reconsidered: The Invocation Model of Process Expression" by Karl M Fant ISBN 9780471798149.
Generally speaking Mathematics is most useful in the field of Computer Science when it is applied to eaither Hardware or Operating Systems. Further speaking, most people who write software or are software designers, or even most network designers, won't need extremely advanced mathematics, although I think most people on Slashdot would agree that a good BA in CS should always know his or her calculus at the very least (it is just too useful in some circumstances).
I read a post earlier on comparing programming to carpentry. Not a bad comparison I think, and yes, its true that for those once-in-a-while circumstances, you need a mathematician in software design. Most of the time, however, you can get a program (Mathematica) to do it for you (intersection of a regular cube with a plane?) or academia has long since crunched out the solution for you (Vector Systems). Interestingly enough, what makes Computer Science an actual bonifide science (in my humble opinion) is that it uses Mathematics in both the theoretical and practical/application phase. However, unless your working R/D in a very competetive company, or in academia, high-level math might not be necessary. Hell- even Google collaborates with universities.
Learning Math is a lot like learning Greek or Latin- you are most likely never going to use it day to day, but it offers a lot of peripherial benefits.
Right, so we are supposed to just throw away 2300 years of the use of mathematics as the underpinning of all rational abstraction of concrete problems because Mr. Fant thinks some other method i.e. "invocational process expression", which is essentially undefined by him or anyone else is a more suitable tool. All I can say is LOL.
(e.g.) a nice, user-friendly personal database program or a industry strength relationald DBMS with really good query optimization and full ACID, OLAP and general ETLA* compliance?
If you've thought of a really neat user interface for a personal contacts manager program, then nobody will care if you've used a bubble sort to keep a few hundred names in order. If you're trying to improve performance for Google then some theoretical homework might be in order...
The danger for education (for any technical subject, not just in CS) is that it tends to teach a subject at a pessimal level of detail - 90% of the class wastes time trying to memorize a few trivial proofs from that subject's equivalent of special relativity (which will be forgotten 10 minutes after the exam), for the sound educational reason that, otherwise, the Prof. that gets the top 10% of the class for the postgrad course will whinge about having to run a few extra lectures.
E.g. you could either:
(2) is the pessimal level of knowledge, as it is of no realistic use unless you then proceed to (3) and is certainly not required to write form-based database clients. It is, however, pure gold if you are trying to write a CS exam...
(I'm not saying that (2) can't be interesting or stimulating - just that you shouldn't make students cram it unless they're likely to go all the way).
(*Extended three-letter acronyms)
In a survey of 100 programmers, 111111 thought that duck-typing was a good idea.
I've certainly forgotten a lot of the math that I had in college. So that makes me a better programmer, right?
Most engineers never need calculus either, but we still take an awful lot. Why use does a geological engineer have for vector calculus? You'd be surprised where it shows up sometimes. But you need to know it to understand what's going on behind the scenes in various "standard" equations, modeling programs, etc., so you don't blindly follow what's laid down in a textbook. Most of the great engineers I know in industry and research (pretty closely connected in my industry actually) are also damn sharp at math.
This is the dangerous prodigy of the fuzzy math backers. Fuzzy math/logic works until the code goes to production. If you have the "joy" of working with software developers, here's a simple test of the "no math" theory: two months before their latest project goes to production, ask them what type of hardware is needed to support their software. Five will get you ten they will come back with something wildy over or under sized.
This is a pretty good question.
:-)
:-)
:-)
of course I have a really good answer.
Lets take a look at the last 50 or so years of computing, with regards to software development to answer this question.
You have to sit back and ask just one question: Has software advances changed the reliability, cost or efficiency of writing software in the past 50 years?
I don't think it has. Why is that?
Well, I still have my old "Dragon" book from computer science class I took in 1991 at UW Madison. In it much of the same is still the same for example, today as it was 30 some years before I took the class.
The same algorithms in that book can be used on a IBM 360 to compile Fortran or COBOL as today, which you could use the same algorithms to compile Java or C++.
Even the optimization tricks we used during the linking cycle to "Peephole" optimization on the code haven't really changed.
This IS the mathematics part by the way. What I mean by that is, well, we still do integration and differentiation since the 1900's but that doesn't mean thats a bad thing.
Whats important is that in this case we have made advances in computer hardware to solve some important problems in mathematics since then.
Software however is a different story. Although mathematics can point to a body of problems that have been solved, or new methods that have been developed, software engineers today still use the same methods without any tangible advances in the field. We still have efficiency problems, huge cost problems and lots of bugs.
I can still remember in the early 1989..1990's most of my instructors were telling me, by the time I reach my age now, people would no longer be "coding". Everyone would be using "case tools" and that everything would be drag N drop and you would program using "objects" and just connect them together.
I have a private consulting practice. One of the services I offer right now is the "get out of Visual Studio Wizard Jail" services to my customers.
These are the people who actually took this idea and ran with it today. Only to find that the code generated isn't readable by any human being. The tool when its upgraded, will not import their old projects. Furthermore attempt to modify such a brittle environment results in huge time delays to finish.
Thats usually when my phone rings.
So, I come in an scrap the tool framework (i.e. one of the issues I have with visual studio is that many of the wizards assume only Microsoft exists.), replace it with a open standards framework like Apache AXIS for example, and then HAND CODE everything so that is is documentable, and human beings can understand it.
I then tell the customer that they need to hire a well organized object design engineer to manage code reuse and stop using proprietary tool frameworks because they are nothing more than a revenue stream for the vendor. Use open frameworks and set up your own private internal intellectual property. Be your OWN framework provider and YOU decide how much money your going to spend.
But there is a light at the end of the tunnel, and academics nor industry can take the credit for it.
It's called open source. Specifically, the social structures that form when the GPL is enforced and software is built that brings to the table a solution that industry nor academics can solve: Scale of forced contribution back into the closed loop system of the development process when MILLIONS of developers and users come together.
I kind of like to think of it as a "quantum" development science. As in quantum mechanics, there is a "fuzzy" boundry between laws that work in the big, but do not seem to have any connection with the laws of the small. Well, we have been stuck for the past 40 years in the "small" because no industry or academic institution could do what the internet has done, in a software development sense.
Now we see "conflicting" seemingly IMP
Got Geometrodynamics? Awe, too hard to figure out? Too bad.
This guy has a web site, Theseus Research, where you can read some of his papers. There's a long, somewhat turgid paper on "null logic", which seems to be an approach to designing unclocked digital logic without race conditions. It's one of those off-in-its-own-world papers with no references and no indication of the ideas actually being tried.
He does have something called the "Theseus Warp Algorithm", which is a different approach to resizing images. The example looks OK, but he only tries it on one image, and that image is an unusual case.
The book is apparently an extension of his 1993 paper, A Critical Review of the Notion of the Algorithm in Computer Science". The main point he's making is that much of computing isn't about "algorithms", which, traditionally, are computational functions which take in some set of inputs and produce a set of outputs. Much of computing is about doing something about a stream of incoming events. Most modern programs, certainly anything with a GUI, are a set of interconnected working parts, not "algorithms" in the classic sense. That's reasonable enough, and that's as far as his 1993 paper got. He poses a question, but does not define a solution.
Does his book go further, or is he still just philosophizing? Don't know.
Please. The F-bomb over VB? Truly this must be an indignation for you. I hope you get over it.
Like saying relativity wouldn't have been discovered without Einstein.
I think it's not so much an "if" as a "when". Maybe without Eistein e=mc2 wouldn't have been know for another 20 years. Imagine how drastically that would have changed the 20th Century. Now if Jobs didn't have this artistic side to him, and that offset GUIs by 10 years, then things like the internet and the adoption of PCs might well be at about the 1997 level right now. And that's assuming that the current Federal administration would have pushed for the internet in the same way that Gore did.
We are all just people.
Have you tried Qt? I started using it a few months ago, and I'm really, really impressed.
brilliant...
math and cs are the same way, most programmers today really on their computer skills as opposed to any theoretical backing but that doesn't make math any less important to the field. first person 3d shooters today are noted for innovations in storyline/gameplay but what made them possible in the first place was a revolution in 3d polygon representation using quaternions back in the day pioneered by the likes of John Carmack. We still need the math to make new things work. And new things are cool.
In order to program well (by which I mean write code that performs quickly, uses minimal resources, has no (or few) bugs, is easy to change or enhance without creating new bugs, and consistently gets the correct result) you need to be able to think in a very rigorous, structured way. You also need to be able to hold many variables and logical connections in your mind all at once. It just so happens that the practice of mathematics exercises (and hence theoretically improves) this ability.
The world is full of people who oversimplify what is involved in programming (like my boss, for example...). There is a tendency to leave out relevant variables to make the problem at hand seem simpler to solve, and simpler to implement, than it really is. Because of this, a lot of people think programming is easier than it really is, and they also write programs which seem to get the job done but which wind up causing them problems further down the road. Such people usually aren't big math geeks themselves, don't see the relevance, and are very unlikely to ever become truly great programmers. When things get difficult, they will either run to a truly great programmer (who probably knows a lot about math, too), or try to make the case the the problem cannot be solved (either because there is no solution or because Microsoft didn't provide a robust enough toolset).
The times when you need to actually perform some calculus in order to write a program are quite rare (depending on the nature of your product, of course). Mostly basic arithmetic is all you need most of the time. However, the mental skills that are developed from the study of mathematics are crucial for the ability to program well.
I will also predict that the likelihood that a person will agree with me on this increases in direct propotion to their years of programming experience in the field (i.e., after completing school).
The web site often referred to the reliability of hardware compared to software, and argues we need a hardware methodology-like software development system. I disagree. Hardware is often incredibly difficult to design, we use procedural Verilog code to describe each process, and the rest is manual connections between them. At the manual connection level, we're not more productive designing circuits that we were when we used schematic entry. There's something called the "Design Gap", which refers to the fact that we don't yet know how to make chip designers productive enough for them to use up all the transistors now available on chips. This is one reason so many design teams where off-shored to India. We often can't afford the salaries of US engineers to design modern chips.
Many people have pointed out that programmers can describe the function of a chip in C several times faster than chip designers can do in Verilog. The point is that chips need to work no matter what system they're used in, while somewhat unreliable software can be ok. I'm releasing a 500K line program to a client this weekend. It has bugs. However, it passes hundreds of designs without failure, indicating most customers likely wont run into them. We built that system with only a dozen-ish man-years of effort, but AFAIK it's more complex than any chip ever designed. Our software methodology converges on reliability, but only to a certain quality point. Going beyond that quality point wastes resources that are needed for the next project. To get to Intel Pentium level of quality would take a team the size of Intel's processor design group.
There are several companies that now directly convert C (or SystemC - basically C++) code to hardware. The idea is to greatly improve hardware design productivity, but it only partially works. The bottle-neck is verification. If the link between the description and the hardware is difficult to see and understand, debugging and verification becomes a nightmare. A C model can be written much faster, but who cares, since it's the verification that takes all the effort? Maybe they can figure out how to improve verification flows, but until then, plain old procedural C/C++ programing with solid coding methodologies will continue to kick pants off of hardware design in terms of productivity.
Beer is proof that God loves us, and wants us to be happy.
Come on morons: real men program in Assembler. I have enjoyed slashdot.org for a few years now and (easily) this is the lamest thread ever. What starts out as a profound but ridiculously irrelevant discussion on the value of math in modern computing is degraded down into a childish catfight on which programming language is more manly.
What math do you need in computer science today? It's a tough call. But today, I'd study number-crunching rather than discrite math.
I have a classical computer science education - automata theory, number theory, combinatorics, mathematical logic - all discrite math. That's what CS was supposed to be about in the 1980s. It's hasn't been enormously useful, and I'm writing this as someone who ran a successful project to develop a proof of correctness system. Mathematical logic gets used a little, but tree-like algorithms are more important. I'm not sure automata theory is useful for much of anything. It's one of those things, like proofs in plane geometry, taught in schools because it was the first theory in the field.
Number-crunching, probability, and statistics seem to be more useful today. If you do anything in graphics, you have to have the 3D transformation math down cold. I've had to do tensor calculus and integration of non-linear differential equations (I used to do physics engines for animation) and that required plowing through difficult math books and getting consulting from university math departments. Bayesian statistics have become very important - it's used in spam filters, search engines, computer vision, and most things that have to intelligently reduce messy real-world data. I didn't get enough of that at Stanford.
On the other hand, where are you going to use this stuff? Outside of Google, Microsoft, and universities, who does real CS research any more? All the good research centers (DEC WRL, HP Labs, IBM Almaden, PARC, etc.) are gone, or a shadow of what they once were.
Oh I see. All this time I was lead to believe that Donald Knuth created TeX to satisfy the desperate need for a half decent digital typography tool and after all it must have been due to some class that steve jobs took when he dropped out of college. Knowing that TeX remains to this day the best typesetting system and knowing a bit about Adobe and the history of PostScript, I guess that that half baked assertion makes sense and must be true.
...or maybe not.
Please. Steve Jobs doesn't walk over water, nor is he behind every single thing which can be accounted as progress in the computer world. This whole jobs-worshiping thing is starting to become ridiculous.
Slashdot, fix your code or at least hire someone who is competent at it to do it for you.
I'm pretty good at math, but after while I realized something: Math is just a highly structured language used to describe relationships. As such, it is a useful tool. But it's not the only tool. Logic is the true underpinning for math and for devising non-mathematical solutions to a lot of non-mathematical problems, as well. One of the really nice things about both logic and math is that it is essentially impossible to use math or logic to lie. The closest to lying you can come with math or logic is to make false assumptions of one kind or another and then feed them into a mathematical or logical framework to produce some kind of false result.
Math is not so much important for itself, but because it is a tool that can potentially describe is so immense and comprehensive. Languages other than math have similarly immense capacities, too. Some of them are even superior to math in certain situations, if for no other reason than that they are more accessible to more people who don't have a strong math background. This doesn't mean that they are better than math. It means that they may be more *appropriate* than math for certain applications.
I think the same is true about using math in computer science or computer engineering. Math may be capable of getting you where you need to go, but there may be other methods to get essentially the same outcome. Logic, especially, can be very useful, but even intuition, to a certain point and in certain applications, can get you where you need to be faster tan pure math, although you have to "work backwards through the maze" to put it into code. The same applies to the current argument about languages (VB vs. C++, etc.).
This is like two carpenters arguing about whether using a driver or a ratchet is the best. The "right" answer often depends on which side of the wall you're on.
..without Gore the Internet would not have been invented.
my password really is 'stinkypants'
Like engineering, CS needs math.
Like engineering, CS is not math.
Some people seem to think that CS is in fact just math. These are the people the article refers to. They've screwed the field. Turing machines may be interesting in spite of their lameness, but they don't mean shit outside of ivory tower academia.
There are plenty of people who can do the math, both useful and useless, but write programs that are complete shit for various reasons. These people are NOT good at CS and do not deserve to be influencing anything related to the field.
Yeah, me too. The programmer I just hired to do algorithms got a 1600 on his SATs, and loves math. The Indian IIT grad I hired runs circles around me in math. However, most coders out there don't do hard-core algorithms (I'm guessing you do). It's even reflected in our programming languages: C++ is a wonderful language for describing a string class, but terrible for place and route algorithms (no, I don't want to answer why... no need to get into a religious war). However, it's great for MFC classes, though I still think GUIs could be a lot more intuitive if designed more like hardware.
Beer is proof that God loves us, and wants us to be happy.
we don't have enough math involved in most computer science fields.
In particular information theory is vital to good user interface design and an understanding of Human/Computer Interactions. For example, look at the density of input and output channels on a GUI vs a CLI and you will see why the CLI is so much better for system administration while the GUI is better for displaying rich information.
Can you prove mathematically that a program has access to a sufficient set of information to provide error-free (assuming no errors in input) processing of information? I think that in most cases, you can make this determination mathematically through relational algebra. This is what I call "information-completeness." Do most software engineers pay attention to this? Not in my experience... Many database engineers on the other hand do this very well because their discipline is steeped in this specific form of mathematics...
Now, the biggest issue with math and computers is that the mathematical models tend to assume omniscience or at least information-completeness. This has lead to a number of problems in the development of computer imeplementations of these things, for example the dual meaning of NULL in SQL (NULL has exactly one meaning-- "No such value"-- if you assume that the information set is complete but may have a second-- "Unknown"-- if you do not. One would expect many operators to operate differently depending on whether one really meant "No such value" or "unknown" but in reality they all have to assume the latter). Understanding this problem helps ensure quality software engineering.
Now, some people say "English majors make better programmers than math majors" and I suppose it depends on what area of programming. However, I think that for the mathematical evaluation of software (to ensure the information flow is solid), you need someone who knows math. Furthermore, the entire semantic structure of languages, both natural and computer, can be subject to analysis of things like information theory. At the end, mathematics underlies every other discipline and is the fundamental discipline of any sort of engineering. Sure, there are parts where creativity is also important, but the engineering (including the design of the UI framework and specification) itself is largely a matter of applied math.
LedgerSMB: Open source Accounting/ERP
No, the Soviets got everywhere else first. The Americans won because the Soviets randomly started killing all their scientists and we had stopped firing ours about a decade ago.
Please, for the good of Humanity, vote Obama.
I've only dabbled with it. I am a fan. Still, designing the front panel of an electronic device seems a lot more straight-forward. What makes GUIs hard (other than the rare creativity required to write good ones) is the way that good interfaces have buttons and things that can be activated at any time in any order. Algorithms are easiest when the read a file, munge it, and write out a file. There's a big disconnect in-between. Life was so much easier back in the days when all we had were command line interfaces.
Beer is proof that God loves us, and wants us to be happy.
Sure am glad that Donald Knuth poseur got no undeserved credit for TeX and METAFONT.
Admittedly, those tools target publishing, but still...
Get thee glass eyes, and, like a scurvy politician, seem to see things thou dost not.--King Lear
I cite from the linked article:
> And, he argues, important process expressions do not qualify as algorithms. "A logic circuit is not a sequence of operations. An
But it can be simulated by one. And actually it sometimes is a sequence of operations.
> operating system is not supposed to terminate, nor does it yield a singular solution. An operating system cannot be deterministic
The operating System i use is supposed to terminate. upon a specific input, it should halt the system.
> because it must relate to uncoordinated inputs from the outside world. Any program utilising random input to carry out its process,
Yupp. determinisctic to me only means that upon the same "uncoordinated inputs" the Machine produces the same result. that is also something i expect (in a weak, applied form) from an OS.
> such...is not an algorithm."
QED or what? A I forgot, no math today,,,
I sometimes run into great algorithm programmers who were poor at math, but they're rare, and usually can be explained away based on what kind of drugs they did in college.
Hah! Are you promoting the use of tryptamines as a means of improving programming skills? Sounds like a great idea! Unfortunately, the negative cultural stigma puts a bit of a damper on the idea...for various reasons.
This is easily the most lame flame war I have ever read on slashdot.org.
I wonder if you morons ever watch Norm Abrams on New Yankee Wood Shop. You should check it out once in a while. Norm shows something about craftmanship that I think every IT guy should know. Norm uses a table saw for rough cuts, mitre saws for angular cuts, and jig saws for round cuts. The point is: Norm uses the right tool for the right task.
Programming software is very much like woodworking, you get what you pay for (fine hardwood funiture or cheap composite crap). The reality is, if you code for a legitimate private-sector business (ie. not a subsidized public-sector boondoggle), nobody gives a crap about elegant code. It either works or doesn't work. Nobody before you or after you really gives a crap about elegance.
If you are smart, you know your tool well. If you are even smarter you know your known and use your competitor tools as well. All the other talk about which tool is better is syncophantic BX.
Please, for the good of Humanity, vote Obama.
Those are domain-specific knowlege. They happen to be math; often domain-specific knowlege is not math. Domain-specific knowlege includes stuff like knowing how a stock market works, knowing how lawyers bill their hours, knowing how oil pipelines are controlled, etc.
CS math is none of that. CS math is mainly the Turing machine, and the numerous things related to that.
Some of us need to apply a few concepts that could be proven with Turing machine math, but we sure don't need to do the proofs or even know what a Turing machine is.
Sure, but who outside the academic community uses TeX to do real print work?
Now who uses Adobe InDesign or QuarkXPress on a Mac?
N4st0r, trixx0r h0bb1tz0rz! Th3y st0l3 0ur pr3c10uzz!
Well yes, but now every computer scientist gets to achieve his true dream of being a wizard.
And we can eat big dinners in the Great Hall of Unseen University!
I'm just a GUI programmer, but every once in a while, the need for math crops up without warning: How do I quickly find the object closest to the place where the user clicked? How do I fill that polygon that the user just drew with color? What's the matrix math for converting between color spaces?
Hasn't anyone ever heard of Lambda Calculus. It was derived in the 30s to use formal math for function definition, application and recursion. Yeah... Computer Science can be boiled straight into this.
Engineering is about building things once you understand the concept behind them. So building a jpg viewer/writer isnt science anymore, it was back circa 1980. Dont get me wrong, building one in without libraries is a mess but could be done. Or building a DES encryption box, it isnt easy, but its not science anymore. its engineering, and we need a bunch of good software engineers because they are realy hard to find.
Most coders dont really fall into the engineer category, unless they are design pattern zealots, or have a robust methodology fro producing code, they are just using logic and application. This is where most of the really cool toys get built, this is where 99.8% of the absurd buggy code comes from. Most Computer Scientists dont Engineer their experiments, IE buggy test code. Without these people we dont really value software engineers. Without Computer Science, Software Engineers are stuck using the same tools over and over.
Storm
ya... and we wouldn't have had the mouse without apple
:-p
what... the mouse was invented BEFORE apple???? gasp
-- I ignore anonymous replies to my comments and postings.
is the same as writing litterature with a programming language.
The reason computer science is so heavily influenced by math is the binary architecture that every piece of hardware is designed around. Every real world problem, right down to choosing the color of a font, has to be translated into the digital world by algorithmic approximation - a lot of math! The problem is that it is this very abstraction that makes computers so "flexible" in what they can do. Analog computers existed many years ago but they could only ever be built for a single purpose.
Unfortunately(?) it is much easier to design and mass produce something which is based on a finite lowest common denominator (bits) than it is to do so based on the continuum that a non-digital solution would require.
That said, who's to say that a beautiful painting rendered in Gimp/PhotoShop isn't a program of sorts? Certainly it has input, (from the original creator), and output, (its effect on us), and the "code" can be modified to change both!
But programming is _not_ computer science. I have an M.Sc. in computer science and I've spent 6 years doing programming before joining a research lab half a year ago. Guess what, while solid knowledge of math wasn't a requirement to get hired, to do anything interesting you HAVE to know math there. Statistics, combinatorics, linear algebra, calculus, signal processing, machine learning - a heck of a lot of math. And after 6 years I'm _really_ fuzzy on most of it. It's getting clearer now, but only because I had studied most of this stuff in school. I spend my weekends reading mind-numbing books and writing code far beyond anything I've done before. Using your math can be pretty exciting.
The caveat, again, is that you must learn to not confuse computer science and programming/software engineering.
Grandparent didn't say UBMs can do anything UTMs can't. Just that they're a more natural abstraction. It's like the difference between lambda calculus and Turing machines. One could say Lambda calculus is better because the concept of functions is not readily apparent in UTMs. You might snarkily reply that one's an idiot because lambda calculus and UTMs are equivalent in what problems they can solve. But that's not the point. The point is, choosing one over the other makes some proofs easier and some proofs harder. That's also the sense in which forgetting math may have been useful - it's not that what we have learned isn't true, it's that had we chosen a different abstraction, we might have learned other, more useful things.
Yes, but I wrote a new book that claims that debate is better off without logic. Early debating pioneers such as Kant and Aristotle imposed their logic background on the field, and this has hobbled debate ever since. I reject the idea of convincing arguments as a good way to resolve any conflict.
Slashdotter, ID #101. UIDs are in binary, right?
"Mathematicians and computer scientists are pursuing fundamentally different aims, and the mathematician's tools are not as appropriate as was once supposed to the questions of the computer scientist. The primary questions of computer science are not of computational possibilities but of expressional possibilities. Computer science does not need a theory of computation; it needs a comprehensive theory of process expression."
This is fundamentally, ignorantly wrong. Anyone who has worked with lambda calculus or turing machines probably has an intuitive notion of why it's wrong too. I don't know how this dude describes "expressional possibilities", but I bet he uses the notation of set theory to do so, and probably relies on the axioms of ZFC when he's talking about the possibilities, especially when he tries to count them. What does that tell you? Apparently all he wants is some different representation, but he shouldn't make sweeping remarks about mathematics being inappropriate to talk about it. Everything in science relies on mathematics. Everything in engineering relies on mathematics. Everything in computer science relies on mathematics. If it didn't, it would be magic.
A logic circuit is not a sequence of operations. An operating system is not supposed to terminate, nor does it yield a singular solution. An operating system cannot be deterministic because it must relate to uncoordinated inputs from the outside world. Any program utilising random input to carry out its process, such...is not an algorithm
Some people like the ability to shut down an operating system. If the algorithm running the operating system can't halt, then you have DOS and you just have to kill it in the middle of whatever loop it's spinning in and hope it wasn't doing anything that wasn't written to disk properly. That's not to say that working with an entire operating system in algorithmic terms is easy, I've had numerous thoughts on the best way to interpret the actions of interrupts and timing and randomness. Perhaps the best interpretation is that the operating system algorithms are actually many small halting algorithms that are directly invoked by interrupts, and the data structures are all that remains intact over the lifetime of the operating system. Most processors have a HALT instruction for just that purpose.
Right, well, asserting that Knuth's work had absolutely no influence on operating system fonts, as Jobs appears to have done in his statement, seems fishy.
Get thee glass eyes, and, like a scurvy politician, seem to see things thou dost not.--King Lear
From the article's summary of the book, the author is arguing that programming is about expressing a process. Or to paraphrase in a less threatening way, programming begins with procedure description.
One way to do this has been procedural programming. Now, the favored approach is to translate a process into a bunch of things --objects-- that interact with each other --via methods. It's another way to model a process. It also more an architectural model than the proof model of Procedural Languages.
Comments pro and con Visual Basic have been thrown around in this thread. Scripting languages are often used to metaphorically treat different programs (Excel, awk, sed, grep, FileMaker, PostgreSQL, etc) as objects with methods. The methods just happen to have names like APIs, flags and arguments. I've solved a lot of problems in this way with either no math or math that is darn close to counting on my fingers. When I use multi-dimensional arrays to hold data and variables to remember where I in those arrays, I am not doing array calculus. I'm having the machine remember stuff so I can do something with that stuff. What I do with it might be simple math or it might be a list of error messages or it might be the name, contact info and resumse of a guy applying for a job.
There are typically two implicit requirements for a program. One: it models something accurately enough to produce useful results. Two: that those results (either directly or indirectly) will be understandable by people outside our field.
Model something? There is no requirement in Math that something has any relation to the real world. The history of physics is littered with advances that came because someone used math that the creator was sure had no real world application. Mathematics will not accept accurate enough; it requires provability according to very strict standards. Results that can be understood by people outside their field? No... mathematicians leave understandability to the technicians: people like physicists and computer (whatevers) that use a bunch of tools (including some of their math) to do something that produces something in the real world.
the clock on the wall says 4 til 7
Ok, I'll admit I did horribly at math in college - what little college I completed. Probably because I was too busy sketching logic diagrams and basically designing a microprocessor instead of listening to the lecture. In other words, I was too intent on what I considered the interesting parts of computer science to pay any attention to the boring, abstract crap.
Now that I'm having to work with DSP techniques more, I regret not getting more out of those classes. I think it's interesting that most of what I read about DSP algorithms comes straight from the math side of things. I needed an algorithm to demodulate audio frequency shift keying (AFSK) signals, and I found several, all well-defined and characterized in mathematical terms. That would have been fine, IF I was programming for an actual digital signal processor. But I wasn't - the chip in question is an 8-bit MCU running at less than 8 MHz, that sells for about $1.69.
So I threw all (or most) of that away, and did my heuristic best. I'm still refining the code, but even in its current state it does a remarkably good job. And the clock recovery algorithm works great - given the same input, it decodes more reliably than the equivalent $180 commercial modem I've got.
Only trouble is, I don't have the math background to know if it's even possible to model the algorithm mathematically in any meaningful way. I can only evaluate the performance by testing it - for convenience I've got it duplicated on a Core2 Duo machine and can process 30 minutes of audio data in under 2 seconds to test changes - but I couldn't even begin to characterize the system in mathematical terms. I'm considering some tweaks like allowing the algorithm to vary when the next sample will be taken to try to improve the discrimination without increasing the sample rate, and I've never even seen anything along those lines. (Possibly because it's just a bad idea, but we'll see.)
Anyway, I guess my point is that I don't like the tendency in CS education to shoehorn everything into mathematical terms. It seems like the level of math needed to understand and model some system is way beyond what's really needed to understand it in a different framework. I can show my demodulator code to any competent programmer and describe its operation in a few minutes, but it'd take higher math beyond anything I've taken to do it with math. So yeah, maybe pure math gets in the way sometimes, and the educational approach needs to be diversified a bit.
Your point is well made, and - it seems to me - fairly obvious. Why is computer science different from other science? You need more than just math to be a chemist or biologist or anthropologist. Why should we expect CS to be any different?
A-Bomb
...I think I've used math about a dozen times...and that's a generous guess. Unless you're actually _doing_ math, for plotting to the screen (or elsewhere) it really doesn't come into play.
I've found that troubleshooting and general logic plays the largest part of the sysadmin job; making data streams work, timing system chores, and writing in various languages to interpret those streams.
Sizing a database? Yeah, math. Predicting the weather? Definate math. But I've been a "documentor", Systems Analyst, IT director, as well as a general staff member...math is kinda rare. But I appreciate the folks who _do_ understand it.
--- For a good time mail uce@ftc.gov
All devoloppers must write algorithms. It doesn't matter how high level the tools they use are, they still have to give instructions to the machine to do the task and that constitutes and algorithm, even if they don't realize it.
I would have a hard time understanding how someone who's got zero abstraction capabilities with basic algebra ( say, up to grade 12) would suddenly develop such an aptitude when starting to develop algorithms.
Of course, a lot of people without those aptitudes write programs nowadays. But in most cases, they are quick and dirty scripts which tend to be non-optimized. It short, those types of programs are usually hard to maintain, don't scale well and have several security vulnerabilities.
Math and algebra, at least until grade 12, constitute an excellent way to learn to abstract things in your mind and visualize what the program is going to do BEFORE one starts writing the code. It is much more cost effective when you preview and debug the program (or just a function) in your mind first, instead of just writing it and adjust as you go along.
Everything I write is lies, read between the lines.
Ha! I guess that's why I like to see all the variable declarations at the top of a function, and some kind of comment above that. I've also seen recipes with goto statements. I guess you could call it a spaghetti recipe? :-P
Beer is proof that God loves us, and wants us to be happy.
I personally view computer science in the same manner as I do chemistry, as an emergent science that derives from physics. Each science is fundamentally structured by the laws of physics, yet this invariably yields mathematical approximations to each subsequently emergent feature contained within each field (think quantum mechanics mathematics approximating to classical mechanics mathematics at the larger scales). The mathematics contained within each field is, naturally, uniquely differentiated from the mathematics of physics (until, of course, you amusingly start coding physics engines), yet is still an integral part of the fields. you certainly don't need to be a math wiz to be a part of the computer science field just as you don't need to be a math wiz to do simple, basic chemistry; you do need an understanding, however, of basic maths. The deeper you get into each field, though, the more complex the math invariably gets; it's inescapable.
I've been reading a bit about scientific tools, "Thing Knowledge" and such, and find that often the tools and the understanding evolve in parallel. One could ask, is the thing the knowledge? Does the ultimate mathematical symbolism, best express the understanding? My impression is that much of the future of computation is going to come from sources other than mathematics. This doesn't imply that we don't need maths, particularly if we don't yet have the tools to express heuristics as process.
Frankly, we barely have a rhetoric for computing and what the ultimate goals will be in the future. How do we process images? How do we communicate with them? How do we type Mandarin? We have a lot of looking back historically to find the future. Perhaps, the question is, what is more important to the future of computing, algorithms or heuristics? I suppose that I'm in the heuristics camp as well.
There is a huge difference between CS and programming.
//pseudo-code
CS is Math. IMHO not fun math or very interesting Math (much like statitics and other icky parts of Math) but it still is Math.
Programming on the other hand is very far from CS and from Math too.
Reminds me of a great story. We just got a new guy on our (programming) team, straight out of Univ. He is writing and wants to check that two sets are equal. So of course he starts writing:
bool setsEquals( Set a, Set b )
{
checkContains( a, b );
checkContains( b, a );
}
Just like you are taught in school. Except that it is a lot easier to write
bool setsEquals( Set a, Set b )
{
if ( a.size() != b.size() )
return false;
checkContains( a, b );
}
Half the runtime. Because everything on your computer is finite.
Most of the time on desktop machines (not on crazy server applications) everything can be boiled down to MAX_THIS_OR_THAT and then all algorithms are just O(1).
My 2c.
God made the natural numbers; all else is the work of man - Kronecker
Knowledge of math is very important. How can you possibly tune your code's performance if you can't fathom how many times loops will need to execute?
LK
"Hi. This is my friend, Jack Shit, and you don't know him." - Lord Kano
I actually agree with the author that for a great many CS disciplines advanced math is largely unnecessary. One of the more important skills in actually developing software is the ability to synthesize complex requirements into a workable system. This isn't mathematical, it's structural.. and in my experience it's the hardest thing to find in hiring developers (of which I've done my fair share).
That distinction is important. While I took the requisite computer science math courses, I hardly consider myself proficient in math. That's because in my career I've very rarely had to write raw algorithms. I've found that most of my time has been spent in designing systems and utilizing other peoples mathematical prowess to implement them. I'm heavily reliant on the STL and Boost, whose authors I have no doubt are great mathematicians. Their work allows me to focus on what I do well.
There are domains (increasingly becoming smaller) that are heavily reliant on mathematics. Image processing, cryptography, and a host of others spring to mind. However, the majority of programmers in the world aren't inventing algorithms themselves. They're building useful and interesting things out of the work that others have done.
I would argue that the two are unique disciplines (with information systems another in the computer world). Maybe the time has come to begin introducing degree programs that focus on system design (ie: architect) in addition to the more mathematical computer science disciplines?
Turn s60 photos into awesome videos with mScrapbook for all S60 3rd edition phones!
Err no. I was serious that I've read his site before. He does claim that UBMs are a stronger class than UTMs. You'll also notice that he isn't responding to the claims that he is a crank - probably because he's had that argument many times before...
Slashdot: where don knuth is an idiot because he cant grasp the awesome power of php
Yes, you can try to express everything in math, but it's not necessarily _helpful_.
Music is math too. But you can be a great composer without knowing very much math. And even if you did know math, I daresay it's not the main source of the "good stuff".
Sure I think Computer Scientists should know all that math stuff - monads, NP completeness etc.
But there's room for a lot of other areas. I mean how about protocol design and syntax? Knowing stuff in Linguistics and maybe Data Compression theory might come in handy. And sometimes knowing existing practice is good enough (protocol = line based, command-response), since someone else new can easily understand what you're doing and _why_. How about breaking stuff into the "right sizes and places"?
You could also say doing certain things in a program is "Bad Hygiene" and some code is "bad taste", but where does that belong in Computer Science? Does it even belong there? What's "Good/Bad hygiene" and "Good/bad taste" may be obvious to some, but how would you teach it to others rapidly? Figure a way to define it in mathematical terms? Would that be so useful?
And oddly enough, according to the people who designed the original Mac, Steve Jobs tried to kill the Mac off a number of times... only the passion of the engineers kept it going on the sly. Every time Jobs found out they were still working on it, he tried to kill it off again. The Mac doesn't exist *because* of Steve Jobs, it exists *in spite* of Steve Jobs.
People need to understand this :(
I mod down anyone who says "I will be modded down for this", regardless of the rest of their comment
I'm majoring in Business Marketing, and although I'm not strong with numbers and never have been, I know being forced to learn annuities, interest rates, principal components etcetera stretch the perameters of one's thinking and can only be of benifit.
On the other hand, we may need more right-brainers in the computer science field (think Apple designers) who focus on interface and seamless communication between man and device. Computers need to meet our needs, and speak our language, and not the other way around. I'm not sure math geniuses have that kind of artistic headspace required.
SEO Copywriter. Just Say ON
...nor does he practice Islam, which is really the central issue, isn't it? Jobs may be of Arab descent, but he was adopted by whites and raised like pretty much any other white American. And there are times he eschews shaving.
In Repressive Burma, it's not just your connection that dies. slashdot.org/comments.pl?sid=314547&cid=20819199
TeX is not a UI renderer, though. Did any OS have nice fonts back then?
True confidence comes not from realising you are as good as your peers, but that your peers are as bad as you are.
Hmm... C++ ... Mapping algorithms... religious war.... MFC!....
He's clearly working on Microsoft's google maps killer! =D
Don't blame me, I voted for Baltar.
I don't see how the relationship between programmers, their programs, their computers & the math at the heart of digital computation are necessarily more integral than the relationship between musicians, their music, their instruments & the math at the heart of the way the sound is generated, transmitted & received. Yet, we generally do not treat music as a sub-discipline (or sibling, or however you want to define the general consensus of the CS/Math relationship today) of math. Should math be an important part of systems that focus on numeric input & output? Undoubtedly. Should math be an important part of systems that focus on human input & pleasing/practical/"human-like" output? As soon as I hear music by HAL that rivals that of Beethoven or The Beatles, sure.
I know what you did last summer. Just kidding, I don't work at the NSA.
Wow. That's probably the most non-sensical statement I've read in Slashdot in a while, including the huge iraq-related threads... Quite an accomplishment!
The primary questions of computer science are not of computational possibilities but of expressional possibilities. Computer science does not need a theory of computation; it needs a comprehensive theory of process expression."
s _theorem/
And for those expressional possibilities that are not computable? It's not like they won't occur in the Real World.
Actually, it occurs to me that we may have already reached a point of mathematical illiteracy among those practicing computer programming. At least once a month I see a problem report or feature request from one of our so-called 'software engineers' that reduces to a request that we disprove RIce's Theorem [1] or Godel's incompleteness theorems [2]. These do have a certain entertainment value, although I have recently been told not to toy with the employee's minds and so am somewhat restricted in how much entertainment I can derive from them.
1. http://en.wikipedia.org/wiki/Rice's_theorem/
2. http://en.wikipedia.org/wiki/Gdel's_incompletenes
Exactly. The algorithm is the worst thing to have happened to computing. It is the primary reason that software is unreliable. Programming is hard precisely because it is based on the algorithm. I hope that this new realization among some of us that computing should not be based on the algorithm becomes more widespread. It will usher in the next computer revolution.
Then what exactly would you recommend as an alternative? The human brain is based upon a huge number of algorithms, logic and processing. Each time I come over to my computer I don't go through the process of trying to figure out what my keyboard is, monitor etc. I have a process in mind to determine that my keyboard has not been replaced while I was away with a hard roll.
Until such a time as the basic unit of a computer isn't a bit or something which reduces to a bit, we will have a need for algorithms as the base for any decisions that a computer makes. Programming is difficult where it is difficult primarily because people don't typically think about the algorithms that they themselves use in solving a problem. I don't personally think a whole lot about how I know that a square is four sided or that a particular square is red, I don't have to because that thinking is done at a very low level, one which doesn't typically just pop up.
A computer doesn't have that going on to the same extent, for common operations, it can sometimes be built in, but for the most part the steps need to be followed. Any time the language does something for the programmer that represents a loss of flexibility which may at some point be important. Consequently languages tend to leave as much as possible up to the programmer, as the programmer knows more about what a program needs than the designers knew about a bit of code written 40 years after the language was developed.
Considering that Jobs took over the Mac project and managed it throughout the early 80's, I find that unlikely.
In Repressive Burma, it's not just your connection that dies. slashdot.org/comments.pl?sid=314547&cid=20819199
Computers are (by their very definition as well as by the word used to describe them) mathematical machines. A computer can essentially do NOTHING BUT calculate. It can in its core add, subtract, shift and move data around. How is this supposed to work without math?
I get where you're coming from, although I would split hairs and say that, by definition, computers read, write, move forward, or move backwards. Those functions are what formally define a Turing-complete system, also known as a universal machine. The universal machine then quickly lends itself to doing operations such as adding, subtracting, and so forth. Reading and writing are formally different than adding and subtracting; and its the reading/writing/moving which are definitial to Turing-completeness.
This is fundamentally, ignorantly wrong. Anyone who has worked with lambda calculus or turing machines probably has an intuitive notion of why it's wrong too.
Oh? See, where I come from, Turing machines and the lambda calculus are formalisms for describing and computing functions, stateless mappings from a domain to a range. Operating systems, for example, are not functions, because they are not stateless.
This is a common theme among functional programming languages. They want to remain as purely functional as possible (because that approach has proven to be powerful), but are unable to do so in various circumstances because they have to interact with the underlying hardware or user. For instance, Haskell has its monads. Functions, as such, are unable to maintain state. They cannot express the idea of waiting for an arbitrary condition.
I don't know how this dude describes "expressional possibilities", but I bet he uses the notation of set theory to do so, and probably relies on the axioms of ZFC when he's talking about the possibilities, especially when he tries to count them.
That irrelevant to his point. He's not saying mathematics isn't a useful tool in computer science. He's saying that the aims of mathematicians and computer scientists are different. Even if they use the same methods. The majority of people working on whether P=NP, or extensions to Rice's theorem (there are lots), or Oracle Machines, etc. are mathematicians. These are very different kinds of problems than computer scientists are interested in. The last computer science conference I went to had papers on Data Mining, AI, computer vision and other kinds of pattern recognition, the mathematical basis of computer security, HCI, and a multitude of other subjects.
More to his point, he's saying that the mathematician's focus on Halting algorithms (and other Rice's theorem-related constructs) is inappropriate for tackling the kind of (mathematical) problems computer scientists deal with. As such, there shouldn't be a focus on them in CS curricula. Alternatives that capture what computer scientists are interested in already exist (slightly modified Finite state machines, different sorts of logics).
Apparently all he wants is some different representation, but he shouldn't make sweeping remarks about mathematics being inappropriate to talk about it.
He didn't. He gave a concrete example of a real life computer program that cannot adequately be modelled by a Turing machine or the lambda-calculus.
After all, I am strangely colored.
Most of the programmers I know deal primarily with simple web sites or legacy apps. There aren't any demanding mathematical maneuvers involved. It's mostly flow control, modeling objects, and error control. As long as they're able to appreciate the basics of algebra, they're fine. The real skill involved seems to be the ability to define the application as a group of much simpler processes, and structuring the interaction between those. It's about fully appreciating the consequences of a chosen algorithm.
Beyond the ability to break down systems into simpler subsystems, programming also demands knowledge of the syntax and features a given language has. Much like learning a foreign language, this takes time to fully master, and serves as a relatively important barrier to entry for those virgin to the field. Compilers are unforgiving of the tiniest syntax error, and syntax is essentially arbitrary. Typically, one must know several languages to complete a project. If you spend all of your time consulting your language texts, you'll be inefficient. If you don't understand all of the features a language has, you'll invariably write code that's more convoluted than necessary. A great coder in Actionscript can easily be a mediocre C# developer. Knowledge of the language is critical, and said knowledge isn't easy to master.
Of course, there will always be programs whose purpose is to perform involved computations, so math will always be required somewhere in the field. Still, those applications are easily outnumbered by the sea of data driven form apps and middleware which require little or no tricky math.
It's Clark's third law: "any sufficiently advanced technology is indistinguishable from magic."
Your analysis is spot-on, and I see this phenomenon happing all around me. It's just sad that professions in the field are beginning to succumb to this mindset.
I completely agree with this. I am a computer science student, and I am terrible at math. I repeated entire high-school math classes just to pass. However, I am at the top of my Computer Science classes. I excel to the degree that I have obtained high-class contracts for programming.
I think that man should get real.
Then what exactly would you recommend as an alternative? The human brain is based upon a huge number of algorithms, logic and processing. Each time I come over to my computer I don't go through the process of trying to figure out what my keyboard is, monitor etc. I have a process in mind to determine that my keyboard has not been replaced while I was away with a hard roll.
An algorithmic process is a one-dimensional sequence of steps; only two objects can communicate at a time, a predecessor and a successor. In other words, there is a single signal path. In a non-algorithmic system, by contrast, the number of objects that can communicate simultaneously is limited only by physical considerations. The transputer (Occam) was such a system. That does not mean that a non-algorithmic program cannot be created on a single processor system. Neural networks and cellular automata are some examples of non-algorithmic applications. Problem is, current processors are optimized for the algorithm and computer languages are ill-suited for parallel synchronous systems. In this light, you're mistaken about the brain executing algorithms. The brain is the ultimate non-algorithmic system.
Oh, forgot to mention: teaching algorithms and data structures in Java makes it difficult to communicate some of the subtler points.
Consider a linked list. Many Java programmers, especially new ones, are confused about the difference between a reference to an object and the object itself, since the difference isn't explicit like it is in, say, C. Really learning about data structures requires keeping these fine distinctions in mind.
The article completely ignores the most important part about math: It's a language. A very good language, even. More modern than any of our natural languages, capable of expressing non-Newtonian, non-Euclidian and non-Aristotelian facts of the world we today know to be true but still struggle to fit into our mother tongues.
Also, it is what Latin used to be in the middle ages - the common language of people all over the world. Scientists from different continents may be barely able to communicate in their respective mother languages or in english, but if they write down their formulas, they both know exactly what the other is talking about.
But no, the most important part is that math still evolves, and rapidly. As so many other critics, the author of the article appears to have a very limited understanding of math.
Assorted stuff I do sometimes: Lemuria.org
Yes, but he tried to kill the Macintosh because he was working on the Apple Lisa which was pretty much the same idea but way more expensive, and then he switched to working on the Mac later on. As the uncle threads say, Jobs is still kind of full of shit, but not in that way.
"Never attribute to malice that which can be adequately explained by stupidity." -- Hanlon's Razor
If you don't care about my opinions, why are you reading them?
I take offense to your proposition that people are "trained" into anything. People excel on their own merits. The only thing companies do is make it economically feasible and advantageous for a person to develop new skills. I find this "act of creation" is a common view of management types who absolutely must have credit where none is due. Its one thing to take credit for a successful project, but another to take credit for someone else's skill.
It really does no good for you to describe a system on a high level, abstracting the levels beneath it, and then pretend that there's nothing of any complexity going on in them. You have not defined what an "object" is, but in modern computer science it has a fairly specific meaning: an instantiation of an abstract set of characteristics, among them behaviors expressed algorithmically. Yes, the way in which it interacts with other objects may be subject to changes in its "environment" but there's more to computing than interaction among objects. Even your example of occam, which was a language and not a computer itself, was procedural.
What you're missing in your insistence that hardware is more complex yet more reliable than software is that software is really nothing more than a simple abstraction of what's going on in the hardware, which conceals a great deal of complexity for the sake of conceptual clarity. But those lower layers aren't really absent and can't always be ignored.
This whole idea comes across as the naive theories of someone who has not done a great variety of work. Any time I've ever encountered someone who thought a complex or intractable problem has some simple solution that everyone but that person has overlooked, he's been wrong, sometimes obviously and dramatically.
And the brethren went away edified.
When talking about performance issues, certainly math plays a signficant role. However, when dealing with issues of human interaction with the computer, such as software maintenance and interface design, things get messy. One then enters into the realm of pyschology, which is a soft science and varies per individual. More on this:
http://www.geocities.com/tablizer/science.htm
Table-ized A.I.
I just have to say how nice it is to have a forum where I can talk to real geeks. I spent 18 years in Silicon Valley, and now that I live here NC, it's just not the same. Thank God there are people I can have a semi-abnormal conversation with on-line that know something about all of those things!
Beer is proof that God loves us, and wants us to be happy.
Ha! When I say "I hired" and "my programmer", that's actually misleading. My company doesn't let me manage anyone (and for good reason). These are guys I mentor, and I'm a big fan of mentoring. You're right that they do excel on their own merits. All I do is offer them an environment designed to help them succeed. I'm quite proud of how some of their careers have turned out, and I'll take some credit for giving them their first break. While I can't take credit for their skill, I'll take some credit for steering them in a fruitful direction, so they could attain those skills quicker. I'll also take some credit for being able to tell when a guy is super-smart and eager to succeed, and having the smarts to offer them a chance. Everyone needs a reason to believe they are helping the world, and helping these guys out is one of mine.
Beer is proof that God loves us, and wants us to be happy.
Quicksort has a worst case of O(n^2), however it normal profile is a very lean O(nLog(n)), there are only a very limited number of situations where it breaks down to O(n^2) and if you hit it with a sufficiently large data set that exhibits one of those cases then it will perform worse than the other O(nLog(n)) algo's.
The point is that VB is fine if you want to basically do completely trivial things with what you've already got - basic component connection.
I am not a VB fan, however, I think you guys don't understand the VB philosophy. VB is based on event-driven thinking. The application is divided up into small snippets of code that "hang off of" event-generating objects (buttons, forms, etc.) In a final project, there may indeed be a lot of code, or "complexity" because there are a lot of events to respond to. I don't necessarily see a problem in this approach. VB's annoyences are not do to the event-driven model itself. I have not seen any formal proof or coded demonstration that it is usually worse. It is a form of semi-declarative programming, actually, which I think the OOP-favoring crowd tries to dismiss for some reason. Much of the app configuration is via attributes.
That being said, I wish the GUI framework was relational such that one could query and find and display code snippets and GUI attributes as they please instead of how Bill Gates lets you out of the box. But this would probably require and open-source framework and dynamic RDBMS instead of the semi-static model in favor now.
Table-ized A.I.
Second of all, hardware fails all the time. Not only does it fail physically, it fails logically, it comes in over-budget and late. It is poorly documented and doesn't meet requirements - this happens all the time. When it happens you fix it with software. I make my living fixing hardware problems in software. One of the primary factors leading to increased complexity in software are the work-arounds that have to be made in software for bad hardware.
is degraded down into a childish catfight on which programming language is more manly.
You just triggered a marketing idea. I'm gonna create a programming language called "Bigdick++++". You will feel manly using it, regardless of its actual merits. Suggestions for keywords? PENETRATE, DOMINATE, EXPLODE...
Table-ized A.I.
gottem!
+5, Truth
I'm kind of torn between agreeing with TFA and not. On the one hand, I see the subject of this story as being akin to the statement "Forget physics to become an astro-physisist", or the concept of not needing maths to do something which is essentially based in maths is nonsensical. On the other hand, if you consider mathemetics to be a language, I wondwer whether writing code, or drawing circuit diagrams could be considered valid mathematical language, which makes the jist of TFA valid, even if the summary is poorly worded.
I think comparing someone who writes code to a forklift driver is a bit harsh. I would be more likely to compare someone who writes good code to an engineer, even if they don't have a strong mathematical background. Engineering is about applying established thought patterns to problems. It is not science. It's true that "computer scientists" are for the most part not scientists, but that's a seperate issue.
Some of the worst code I have ever had to maintain has been written by mathematics majors, the absolute worst shit fight I ever had to deal with was from a mathematics PhD. The maths was solid, but the design was shitful spagetti code that, while discreet algorithms performed well, the way thay were put together made the whole system run like an absolute fucking dog.
So I would say, if people insist on calling software engineers computer scientists, you certainly don't need to worry about mathematics to become a great computer scientist.
I don't therefore I'm not.
Correction, that should be "production apps", not "product apps".
Table-ized A.I.
A few weeks ago I came across Project Euler. Most of the exercises are good examples why math is good for coding; they have brute-force solutions that take a lot of time, but clever solutions should always take less than a minute to run.
Escher was the first MC and Giger invented the HR department.
The idea that math is not necessary is absurd, foolish, and dangerous. I have a specific example: in Portugal the distribution of teachers in public schools used to be done by hand. A regular software company was hired to write some software that would distribute the teachers according to a set of rules. The company produced thousands of lines of code, and yet failed to write the software --- there was a mistake somewhere but they did not know where. A different company, which employed Mathematicians specialised in specification and verification (yes, that is an area in Theoretical Computer Science), was hired to fix the mess that this previous company made. Of course, where "software heuristics" failed, mathematical argument succeeded, but not before several millions of euro where spent on these "software and system engineers". I have nothing against these people, but it is absurd to say that Mathematics is unnecessary. When it comes to real work --- millions of euro kind of work --- it does matter.
My hostility is due the the lack of backward compatibility - you have to work out if the VB code you are trying to run is really a tweaked BASIC, a tweaked PASCAL or a tweaked java. If the code was orginally written to be staticly compiled it wouldn't be an issue, but instead you need to keep a pile of old machines frozen at different dates so they have the right VBRUN and dozens of other libraries that will break the application if they are the wrong version. The closed source mentality means that you cannot work out what these rarely used apps are doing and you usually cannot track down the author and in some cases when you can they may not have the source code. Those that wrote the little geophysical applets I have to look after had very good mathamatical skills - just poor programing practice (like not keeping the source code!).
A developer will most nlikely to use math if he: * has to develop filters for audio * has to develop compilers for instruction optimalisation * has to develop Mathworks * has to develop software for Iter * has to use formal verification * etc But a lot of applied computer science doesn't need math nor science. If you're a researcher you most probably can not do much without math. Boring item.
Actually what I describe is CYA gained from experience. If the program stops upon the first error and doesn't finish the others, you get chewed out for stopping production. If you make it not report any errors, then you get chewed out for ignoring problems. If you do what I suggest and have it send an exception report, then you cover both basis. You have notified others of detected problems but finished the batch as best software can. You have Covered Your Ass (CYA).
If this is not obvious at first, one learns it over time by what one is chewed out for. Even if you are not taught this approach in school, you will learn it in the long run the hard way if you don't like being chewed out by managers. (Some people don't seem to care about being chewed out, and do the same shit over and over.)
Table-ized A.I.
Yeah, there's a lot of math involved, but it's always SIMPLE math. I'm not using calculus when doing bitshift operations. I was more than proficient at programming with a high school math education. The additional college math didn't do a thing for my programming abilities.
Incorrect. That is more of something that an electrical engineer or someone doing low-level programming will have to worry about. All the binary fun with xors, ands, ors, shifts, etc., are all unrelated to the sort of math of Alan Turing.
Come back to the discussion once you understand what a Turing Machine is.
So what do you write your TeX documents with on screen? TeX fonts? Bit-mapped non-proportional fonts?
Lars T.
To the guy who modded me down from perfect to terrible Karma - Apple haters still suck
Interesting point... I class myself as 'fair' at maths, but rather-good at programming.
I am particular good at boolean maths/logic etc. but as for general maths, I'd say "fair" (in the context of slashdot posters, not in the context of the general UK citizen who can't do anything without a calculator and someone to help him/her)
I've always 'heard' that being excellent at maths is invaluable to programming, but from my opinion, as long as your maths isn't rubbish, your personal creativity, and ability to think of solutions "outside the box" (damn, I HATE phrases like that, and will regret writing it in the morning) is far more valuable.
I'm not dissin' the maths people who program, I just agree that it's not the bee-all-and-end-all
Sig out of date
And what about Apple's Lisa machine? In a lot of ways, the original Mac was just a cheap Lisa.
The way I read TFA is that the guy thinks computer science is more about logic than about mathematics. Study logic seriously, and you'll find that very much of it is about "expressional possibilities," as TFA puts it.
Are you adequate?
This seems to be a very emotional point for many of you, but I think you miss the point of the agument in your knee-jerk defence of mathematics. Fant appears (I haven't read the book, just the review) to be arguing against the centrality of mathematics in computer science.
I think that some level of mathematics will always be required in computer science because computer scientists will always need to work with mathematicians, as well as people from a good many other fields.
Leave the deep mathematics to the mathematicians and concentrate on processes, is what I see as the crux of his argument. The formalisms which brought us to this point are details that burden the field with complexity that ought to be abstractions.
Last time I tried it, TeX doesn't render crap on screen, and Steve Jobs' prediction would have come true: if TeX was all there was, there may never have been a computer with real WYSIWYG capability. (Or at least it would be long-delayed.)
More to the point: it's just an illustrative example, not gospel. Pull the stick out of your ass and let one teeny inaccuracy past once in a while so that other readers might focus on the *point* of Jobs' speech, not the stupid, pointless details. Try the forest instead of the trees.
Comment of the year
Actually object-oriented procedural programming is a very unnatural way to program. It is what most people use because it is what most people were taught first.
Functional programming is a much more natural way to program and Lisp/Scheme/ etc. are much more powerful in writing complex algorithms simply than C++ or Java.
You probably aren't programming anything that requires math. Try 3D graphics programming - you need a lot of linear algebra, and some calculus if you're doing any kind of shading. Physics simulations require more differential equations than you can shake a stick at. Lossy compression requires frequency analysis and coordinate transforms. Of course, making business database front ends doesn't require much in the way of maths... *sigh* :/
Rampant carbon sequestration destroyed the Dinosaurs' tropical paradise. I'm here to help repair the damage.
Computers are powered by binary arithmetic. Say it with me now: "Binary ARITHMETIC"
Note the word "arithmetic". Without math you couldn't even make a computer say "Hello world" let alone write some book about how we "don't need math"
Seriously, hes hurting his processors feelings...
Do companies generally recruit computer scientists or programmers? Programmers. Where do programmers come from? CS majors!
Apparently the author is right. Whatever we name the CS department, we have a mismatch between what is taught and what is needed.
While it isn't likely this book's author has "the" replacement for the foundation of computer science, this isn't the only voice calling for a change in foundation from algorithms, the Von Neumann model, and Turing machines. The Interactive Computing school of thought is pretty interesting, for example, with some pretty heavyweight names behind the idea, such as Robin Milner (of the pi-Calculus).
-Stu
This guy knows math: A critical review of the notion of algorithm in computer science, which was published in the Proceedings of the 21st Annual Computer Science Conference 14 years ago.
Specifically he mentioned in the introduction (emphasis mine):
It is worth reading (RTFA :-) ). I guess his book is an expansion of his long-holding ideas. Though he speaks against mathematics in computer science, apparently he knows a lot of mathematics. He mentioned Hilbert's problems and Gödel's incomplete theorem. He also talked about the definition of computer science. If people had read his article, there would not have been so many posts trying to say what CS is here.
I don't know what the someone is thinking or what kind of drugs have used to suggest this kind of approach, but as Bsc in Computer Science and Msc in Electrical Engineering, all what I know is "everything is about Math". All the exceptional Academic Institutions of CS born from conjugation of Math+Physics+Engineering. The true is CS must come back to mathematics Web sites databases this is all results of Math. In this 3 main fields, the CS conjugation-formation, the only thing that matter is Math, the common point among them.
At least I did not read it anywhere. What I have found in his writing is:
It seems to me that part of the reason so many programmers, software engineers, etc. say that they don't use math in what they do professionally, is what their courses were called and who their professors were in college. They learned some math (e.g., calculus, linear algebra) from math profs in courses called "Math ". They also learned a lot of math (e.g., boolean algebra, elements of graph theory) from CS profs in courses called "CS ". They go on to use the math they learned in the CS courses every day but rarely apply the math they learned in math courses. They then say they don't use math. Of course, some CS grads use an awful lot of the math from the math courses as well as the math from CS courses but they all use the math from CS courses. Dean
I wonder where were you all these years?Qt needs people who can spread the word.It is indeed beautiful. And what i mean by beautiful is something to do with the way it is designed rather that what it does, although the outcome is indeed soothing to eyes without any mess.
Simple, clean and efficient. Moreover the elegant code which makes use of the OOD so well, does makes one more thing great and that is overiding the builtin capabilites. Yes you heard it right, you can change it because you did not like the way Qt works for your X component feature.And that too without breaking anything *mostly* :-).
A perfect example how to write object oriented code.
-- "Genius is 1% inspiration and 99% perspiration" - TAE --
... and here we find the fundamental problem. Programming != Computer Science.
More accurately, a programmer is not necessarily a computer scientist any more than a computer scientist is necessarily a programmer. Neither is better or worse than the other, and both should know something about the other's skill set, but in practice, there are many amazing programmers who are poor computer scientists, and even more great computer scientists who are poor programmers.
I would classify programmers as people who can get a computer to do what they want it to, and the measure of the skill of a programmer is how their code performs on some set of metrics (performance, reusability, readability, etc.)
On the other hand, computer scientists are people who figure out what they can get a computer to do and how to do it. More often than not, these people work in research labs and in academia, and their measure of performance is how many (usefully) novel methods they've found of doing things or how many new things they've figured out they can make computers do. In most cases, aptitude in more advanced math does help computer scientists, although in some sub-fields, there is less dependency on this.
Because very many math nerds like to refer to CS as "a branch of math". Some of these math nerds are the founders of university CS departments that budded from math departments due to shared expertise.
They're right, as long as one accepts a sufficiently broad definition of "mathematics".
in my old C++ class my teacher at the beginning used to do away with math altogether- he would give us these logic tests, the kind that you see on a lot of IQ tests with things like "which is the next in the pattern" and language like "what is wrong with this phrase" and the truth is that it applies VERY well to programming and optimization of code as well as things like conceptualizing code to achieve a specific goal. the machine as we know it needs a certain level of math, because in the end result we need hardware to use the conglomerates of 0's and 1's to do what we want it to, but the process of creating what we want it to do is less math and more concept. Personally I think that there should be an emphasis on "conceptual math" as opposed to traditional methods.
Possibly, The best software is often written in response to a need or just something for coolness. But, I have come to realize that a good math understanding is essential and I don't like mixed BASE-N math and anything more than a Bi-Nom give me an ache. :-(
I go look it up on amazon for kicks though.
--chris
http://nxdos.sourceforge.net/
Incorrect. That is more of something that an electrical engineer or someone doing low-level programming will have to worry about. All the binary fun with xors, ands, ors, shifts, etc., are all unrelated to the sort of math of Alan Turing.
:)
Come back to the discussion once you understand what a Turing Machine is.
As someone who's been in this industry for over twenty years in a wide range of positions and responsibilities consulting on well over a thousand projects for hundreds of companies of all sizes and industries, and knowing over a dozen programming languages, I feel I have the background to not only comment somewhat knowledgeably, but to do so in language that can be understood by most people, not just CompSci majors. I would recommend you re-read my parent post with a little more open-minded attitude...
Heh, not to reply to myself, but to reply to myself, this is the quote at the bottom of the page right now:
"A word to the wise: a credentials dicksize war is usually a bad idea on the net." (David Parsons in c.o.l.development.system, about coding in C.)
Rather apt I think!
The Book of Stuff that Other People Already Invented.
I generally don't do the algorithms stuff, for the same reason that I don't program in C (or assembly). I like to have a decent understanding of why a particular algorithm is good, but generally, there's enough work already done for me that I can take someone's word for how well a particular algorithm scales.
Don't thank God, thank a doctor!
I really don't like that attitude.
The college I went to seemed to have another policy -- throw the really shitty teachers at the 1st-year, 1st-semester comp sci students. Take some snot-nosed kid off the street who likes computers cause he played Halo once, and give him Hello World in Java. Just so you remember:
class Hello {
public static void main (String [] args) {
System.out.println("Hello, world!");
}
}
It was, very obviously, not designed to teach the kids anything. It was designed to find out who was good at doing one of:
- Already knowing the answer
- Looking it up online
- Learn it from the book
- Asking someone who can do the above
In other words, it was designed to figure out who already knew how to program, or who could learn quickly enough, and weed out everyone else. It was NOT designed to teach you anything -- that's what the second semester was for, if you survived the first.
That's all my subjective opinion, of course, but I really don't like that attitude -- we don't know how to teach, so instead we'll just fail you if you don't get it. I'm not saying that every Halo asshole is capable of learning Java, but we should be paying for an education, not a certification.
Also: I seem to be fairly good at programming, and fairly bad at calculus and math in general. Maybe I'm just bitter about failing Calculus, though that was my own damned fault (I didn't go to class)...
Don't thank God, thank a doctor!
Indeed. I wrote a program in Scheme the other day, and just because of that, you'd have trouble arguing it isn't algorithmically-based.
The program takes inputs by instant messages, and updates our ticket tracking software based on it. (There's a complicated story as to why I chose Scheme, but it involves a messaging library that generates S-expressions.) It's certainly "Reactive Software", or a "Universal Behavior Machine."
How do I reconcile the two?
Probably not even 20 years, more like a few months. You can read this book.
Perhaps if WISYWIG had never been invented, people would know how to format their thoughts rather than their paragraphs?
You are describing single-threaded algorithms, not algorithms in general.
An algorithm is not necessarily a single sequence of steps. An algorithm is an abstract description of a computable task. There are such things as parallel algorithms, which are not necessarily "one-dimensional" as you put it. At any rate, it doesn't mater (read on).
Transputers are nothing but early SMP with a fancy name, with zero SIMD or MIMD capability (I know, because I programmed them back in the day), and occam has nothing on modern parallel languages like (who would have thought?) High-Performance Fortran. In particular early version of occam sucked at floating point.
Furthermore, it is a well-known theorem in computer science that any computable task (in particular a parallel one) can be computed on a Turing Machine. In fact is is the very definition of a computable task. Since Transputers perform computable tasks, they are simply Turing-capable, no more, no less.
Finally, whether the brain is or is not a TM (i.e. performs computable tasks) is still an open question. Evidence on either side of the debate is at the moment cirumstantial.
There was a period of time when 3D graphics programming didn't require much maths at all, all the work was done by the pipeline you didn't need to write shaders so no maths there and all the transforms were done by the graphics card so no linear algebra.
Shaders kinda flipped the whole needing to know maths thing on it's head, but there are plenty of books out there with ready made solutions for most shader effects that you can think of so unless your in the rare position of making something truly original you don't need that much maths to do 3d programming.
thank God the internet isn't a human right.
Except when using Prolog
. That was always the complete head mincer at Uni.America, Home of the Brave.
Um, nobody said that there are no parallel algorithms, but that "Algorithms are easiest when [they're serial and non-interactive]".
Since I'd have to learn this "process calculus" to really get into parallel algorithms, I would tend to agree (what could be easier than not having to learn anything new?).
I'd like to see the author try and fly in a plane designed by computer scientists using his methods. I'd prefer to try the new Boeing Dreamliner which involved a lot of math to design. In fact, in embedded systems you have a lot of mathematical analysis to make sure stuff happens when you want it to happen, otherwise you could have serious accidents and loss of life. I'll guarantee you that Boeing ain't gonna use Windows OS anytime soon to run its planes! The only windows you'll find on that plane are the kind you look through to see the clouds and the kind running on the laptops/pdas of folks dumb enough not to just sit back, relax, and chill for just a while. The main point, though, is that math is a language of reasoning just like English is used for communicating ideas. How would he sell his book without being able to actually write it and then talk about it? It's the exact same idea, except math allows you to be very, very precise in what you mean. And if something dosen't quite fit, it gives you the language to describe something new that does. One can't just carve out one area of the universe like programming and say it dosen't need math. The goodness of being able to communicate reasoning precisely is that it enables others to use a piece of work and build on it, or show flaws in the work's reasoning.
Hence, after many iterations a dumb programmer can just code away with not much thought to "formal" mathematics. With not much thought to how his dumb mind even functions when he goes to take a piss. Never mind the fact that mathematical models of his dumb ass were used by the marketing folks to lure him into buying all that beer which made him want to take a piss in the first place (even modeling the precise place to place the beer in the store so his dumb ass dosen't miss it). The great things about technological progress is that things change fast thanks to all the above and so eventually the programmers who are too dumb to know math will be replaced by computers or programmers who do. We've already replaced a world chess champion with a computer! Anyways, everyone has their own story of that one programmer they know who didn't really understand the algorithm and replaced some "small" thing and seriously F****d everything up - and you weren't even surprised! Eventually simple arithmetic done by the cost conscious company executive will make sure programmers who do not add value do not add any more 0s to the cost line using the simple subtraction algorithm. Luckily, it does not take much to get into math. Your brain already has more than you need to begin so don't listen to all the fear against math and just begin. You will be surprised what your brain can do because it is far, far, far more powerful than you can imagine. This was assured by the great designer who designed you. For all we know, you're just an algorithm appearing in someone else's consciousness - a very powerful algorithm, though. The classical definition of infinity in mathematics is that an infinite set is one in which if you remove a tangible piece from it, the remaining piece is still equivalent to the original. But, to be fair, let me read the author's actual words before judging him because maybe it's the reviewer who was being dumb.
I love Prolog, and even coded a Prolog interpreter once. Writing a program to do derivatives in Prolog rocks. Writing algorithms, however, in Prolog isn't much fun.
Beer is proof that God loves us, and wants us to be happy.
Recently at work I wrote the back-end of a phone book line ad typesetting system using TeX (a programmer here at work created the web-based front-end).
3 6401bceced0ee9a
My previous employer has a nifty system which uses TeX to typeset XML databases, demo of it here:
http://cuspub.atlis.com/
And there are a lot of non-academic examples in ``The TeX Showcase'':
http://www.tug.org/texshowcase/
Using Quark and InDesign is fine, so long as one works within their feature limitations --- anything which steps beyond that involves large amounts of repetitive work and tediousness. Interesting discussion on that on comp.text.tex once:
http://groups.google.com/group/comp.text.tex/msg/
William
Sphinx of black quartz, judge my vow.
But it's there.
h tml
n tosh&story=Origins_of_Spline-Based_and_Anti-Aliase d_Fonts.txt&sortOrder=Sort%20by%20Date
n tosh&story=Close_Encounters_of_the_Steve_Kind.txt& sortOrder=Sort%20by%20Date
InDesign's H&J system for example is based on TeX's, Adobe having acquired the HZ system from URW which took TeX's H&J algorithm and extended it to include character expansion/contraction and optical margin adjustments. These improvements have been folded into TeX by way of Han The Thanh's (sorry, his name has Vietnamese accents not easily entered here) pdftex (interesting Adobe funded his studies at Masaryk University). His doctoral thesis is available here:
http://www.tug.org/TUGboat/Contents/contents21-4.
As regards fonts themselves, while William Donelson's work wasn't TeX, it was quite ground-breaking and influential:
http://www.folklore.org/StoryView.py?project=Maci
And of course, there's the classic meeting of Steve Jobs and Knuth:
http://www.folklore.org/StoryView.py?project=Maci
William
Sphinx of black quartz, judge my vow.
Reminds me of a recent dailywtf "how to write a method to calculate factorial thread". I know I've been in development too long when I start by writing
void testFactorial(){
assertTrue(120, factorial(5));
}
Many mathematicians I have encountered argue that maths is the only real science and that all other subjects are either off-shoots or applications of maths. An interesting, if somewhat egotistical viewpoint.
Certainly, computing owes a lot to maths, both from the hardware and software angles. That does not, however, make any of the forms of computing a sub-section of maths (or even 'just an application of maths'). That relationship cannot be easily inferred beyond saying that there is a link there.
Maths is an offshoot of the historically all-encompassing subject of philosophy. Philosophy includes the study of art, theology, logic and psychology (and many others, sorry if I missed out your major). Maths appears to dangle somewhere down the logic shoot, but of course the best arrangement of the branches of human thought is not well defined. For example, maths doesn't really draw on psychology (although without human thinking, the subject of maths wouldn't exist - but that's a whole 'nother can of worms). Software engineering, my favourite bit of computing, certainly does. Software is created by people, used by people and maintained by people. Ignore psychology at your peril! All this is just one example where the subject has become more than just maths.
Yeah, if you're going to do hard computer things, you almost certainly need a strong understanding of maths (naturally or taught). I know many people who code well because they have the arty or people focus and no heavy maths background. Obviously I wouldn't ask them to do a simulation of a solution to the n-body problem, but for 80% of software engineering they're probably stronger than most of the mathsy people I know.
In answer then: don't forget maths, but it's not always a mandatory requirement.
The author has also stated that books are wasted space in libraries, food is the hobbling point of cooking, and words are cluttering up language.
And perhaps if sanitation had never been invented, we'd all be super-geniuses. As we wallowed in our own filth and died at the age of 35.
Comment of the year
>>> howDoILoveThee = ['nekkid','clothed','here','away','angry','delight ed','flushed and sweaty','cold and angry']
>>> print len(howDoILoveThee)
8
>>> aRose = 'Sweet'
>>> bRose = 'Sweet'
>>> aRose == bRose
True
>>>
>>> thee = 'thee'
>>> aSummersDay = 'thee'
>>> thee == aSummersDay
True
>>>
It's a lot easier in a dynamically-typed language, but it don't exactly trip off the tongue.
The problem with "obvious/not obvious" kinds of thinking is that there are many things that are obvious which turn out to be not true, and there are many true things that are not obvious. Math is the foundation of everything, and computers are what I call "Big Math"; just more math with big (or small) machines to do it for you. The problem is, everyone should have a solid mathematical foundation, just as everyone should have a solid foundation in the language they speak. Computers have now become a major component in the consumer marketplace, and the paradigm should be on what they are to be doing instead of how to do it. Math is simply the foundation of "how to do it."
As we move to an era dominated by the web, expect the requirement for understanding algorithms to go up. Case in point: Google. It will take just a couple of more guys to conjure up new algorithms and build a super network to rival Google. This is because the web is like one big frigging algorithm and it can shift easily from place to place. And when folks find something on the web that works better, switching immediately then telling all your friends is a no brainer. In the web, a better mouse trap definitely means a better service because there are tons of mice and each mouse is giving birth to tons of more mice. If I find a better search engine than Google's (and I sure need one), I will drop Google in a heartbeat. I bet someone can prove that the more useful a search engine is to people, the more new information they create with it such that the search engine starts to suck and it's a rat race. The average teen alone is spewing so much info that Google and all its network of computers won't be able to catch up fast enough. So, crack open Knuth's books and be the next Google. For a billion plus+ payout even the dumbest programmer could burn at least one midnight lamp giving a shot at ruling the net...for a time at least...and who knows, he or she might get lucky!
Everyone seems to miss the point of higher education qualifications.
* You go to school to learn the basics about life, social interaction, etc.
* You go to university to learn how to learn. You learn how to ask the right questions, and how to get the answers.
The information and data acquired at university is mostly redundant on a non-academic life (how many conversations have I had about speculative cache-coherent locking synchronization primitives for large-scale cache-coherent multiprocessors? None), however it teaches one how to think, how to question, how to learn, skills difficult to teach directly.
This is the one significant difference I find with people who have attended university (does not imply completion) and those that have not.
As for people citing examples, there is always an exception to the rule and that fraction of a percentage of the population that you interact with has no bearing on the overall makeup.
GPLv2: I want my rights, I want my phone call! DRM: What use is a phone call, if you are unable to speak?
Writing algorithms, however, in Prolog isn't much fun.
No.
I hate to be rude, but I'll believe that when I see it.
I often do the same thing, by the way, I'm just not using calculus, at least not consciously. I'm sure you have a theory to prove just how much more elegant, maintainable, efficient, and simple your code is... I just have eyeballing and benchmarks.
I suspect that I will want to go back and finish the computer science degree I started at some point, just not now. Frankly, I don't have the self-discipline for it. But if I do go back to school, it will be mostly for the degree, and not for the gaps in my knowledge -- which are there, but I usually fix those as I run into them.
Don't thank God, thank a doctor!
Heck yeah, you should have seen my Apple IIe in 80 column mode!
Once and for all, CS has little if anything to do with writing code. CS is not in itself a practical field at all. It was never intended to be.
The computer scientist is only vaguely interested in designing or coding a real application or even a language that can be used to produce a real app.
Have you ever seen what happens when a physicist does wiring? It's far far better to have a EE and an electrician do it for you.
The physicist may know more about electricity and electrons than the EE ever will. However, the EE knows how the real world behaves and has thought about the practical aspects. He knows that a fuse is more than a device to protect the wires in the wall. He knows that no matter how well it works, if it defies the expectations the next guy will have about the design, someone may be killed.
In the same way, you hire a PE rather than a materials scientist to design your bridge. The materials scientist can tell you more about the behaviour of a steel beam than the PE will ever know, but the PE knows that in the real world we face manufacturing defects, corrosion, installation errors, bad welds, etc and that a good design must tolerate that to some extent without falling down.
In the same way, a CS is not the right choice for producing a real world app. If you go with a CS, you'll get a beautiful slow system that assumes the real world provides perfect input. It maay be written in LISP. LISP is a beautiful language that practically nobody can maintain. It makes no concessions whatsoever to readability and maintainability. Nobody was more surprised to see LISP actuaally implemented than it's original creator.
The problem is, we don't really have the formal major we need, Software Engineer. We have CS and a technician class of programmers and a vague fuzzy line. Software engineers currently are either self taught, CS majors who developed a taste for the practical, a programmer who got interested in the high level design, or a EE that got interested in software. To my knowledge, nobody offers a BsSE.
In that sense, exactly ZERO applications have ever been written by a person formally qualified for the job. Everyone who has ever written an application has been to some extent self taught, either in total, or to bridge the gap between their formal schooling and the non-existant formal specialty.
That's also why instead of having a well understood set of best practices, we have a zillion snake oil filled silver bullet fads of the day.
Meanwhile the assertion that math shouldn't be part of CS or that CS shouldn't be a part of math is just wrong. I CAN see a call for a more applied mathematical approach to Software Engineering and even in CS, but not it's elimination. It may be useful to evolve a more domain specific symbol set to express some CS concepts but that's hardly an elimination.
Congratulations AC, you completely failed to understand my post. Well done you.
Slashdot: where don knuth is an idiot because he cant grasp the awesome power of php
Robert Pirsig is that you?! Would you sign my motorcycle? :)
People who quote themselves bug the crap out of me -- Me.
The origin of the Mediator pattern is when you have a network of object that somehow need to act in response to the change of state of more than one object. One example is a GUI form where checking a box can enable or disable other controls on the form. The Mediator is a kind of master Observer, where the Form is the Mediator and it gets events (notifications of state changes) from all of the widgets on that Form.
The advantage of the Mediator pattern is that by gathering together all of the events into one place, or into multiple places, the event hooks of the main form, you can figure out all of the logic of how multiple controls interact with each othere. The disadvantage of the Mediator pattern is that by gathering together all of the events into one place, it leads to spaghetti code. The Form because the Master Control Program that has to implement all of the logic of what happens when state changes anywhere on the form. It is kind of a like a flat organizational chart where the head person has to supervise an enormous number of employees without intermediaries. Yes, form logic is split into stubs, but it is still in a global form namespace.
Apple may have a better idea in XCode with their Objective-C version of VB. Haven't looked deeply into it, but it appears to allow one of more mediators to a form (kind of like Java where you can have a single event inner class object for each control or an inner class that aggregates actions from multiple controls), only the XCode version is more visual, VBish.
As to this notion that events should be marshalled by a relational database, that sound like something Tablizer would come up with . . . wait a minute, you are Tablizer!
The trouble with pure mathematicians is they have such a poor grasp of english ;-) Less is a measure of degree: you don't want lesser girls, they're not as good as better girls. Fewer is a measure of quantity: you want more girls, but because you're a math geek, you get fewer. Less is common usage, I know, but that never makes it "right", it changes the core of the language and meaning gets lost between generations.
Back on topic (and there was a point to my nit pick) programming is a symbiosis of mathematics and linguistics. If you like, the less/fewer mixup is like not understanding the difference between while/wend and do/while.
"I hope you like Guinness, Sir. I find it a refreshing substitute for, er... food." Col. Jack O'Neil, SG-1
Oh? See, where I come from, Turing machines and the lambda calculus are formalisms for describing and computing functions, stateless mappings from a domain to a range. Operating systems, for example, are not functions, because they are not stateless.
Operating systems are functions of software, hardware and user input. This can be represented in at least two ways. The straightforward way is just to specify the interactions with hardware and the user as part of the input to a turing machine. E.g. at every step where the operating system relies on a user or external device there is enough information supplied in the input on the tape to determine the action of the turing machine. It can even be proved that the TM never needs to examine input out of order (the turing machine must process them in temporal order since it must travel linearly along the tape.), which maintains the temporal order of operations in a real operating systems. This only works for finite inputs, which is sufficient for almost any real operating system. If infinite running time must be considered then the turing machine can be made nondeterministic at the points where external input occurs in the operating system. This causes the NTM to branch nondeterministically at every step where user input occurs, and the resulting NTM follows all possible execution paths of the operating system being modeled.
This is a common theme among functional programming languages. They want to remain as purely functional as possible (because that approach has proven to be powerful), but are unable to do so in various circumstances because they have to interact with the underlying hardware or user. For instance, Haskell has its monads. Functions, as such, are unable to maintain state. They cannot express the idea of waiting for an arbitrary condition.
Only because modern computers are made that way. ENIAC and other early computers were purely functional: Plug the wires in correctly and flip the input switches, and the answer appears on the output. All microprocessors are inherently functional, they just synchronize their functional evaluations with a clock signal so that elements of some state are loaded into the inputs of a function, and during the clock cycle the outputs stabilize and are stored to some output state. All that functional programming requires to act like a modern processor is an analog of this process, which can be generalized to monads or some other serializing method with intermediate states. As far as I know, The main reason for this design is that not all functions and not all inputs and outputs can be processed as single entities. It takes a while to type a program, and it may produce pages or gigabytes of output. Imperative processors are a method of evaluating very large functions over very large values without actually having a very very large number of transistors.
That irrelevant to his point. He's not saying mathematics isn't a useful tool in computer science. He's saying that the aims of mathematicians and computer scientists are different. Even if they use the same methods. The majority of people working on whether P=NP, or extensions to Rice's theorem (there are lots), or Oracle Machines, etc. are mathematicians. These are very different kinds of problems than computer scientists are interested in. The last computer science conference I went to had papers on Data Mining, AI, computer vision and other kinds of pattern recognition, the mathematical basis of computer security, HCI, and a multitude of other subjects.
Here you have a point. Within a research field it's rarely useful to reduce the problems to basic computer theory, unless the field is brand new and needs a solid footing. However, specialization comes at the cost of generalization, and where education is concerned I prefer a general approach so that specialization can come later with the benefits of a general understanding backing it up. People do switch fields occasionally. Research into computational theory is sti
Operating systems are functions of software, hardware and user input. This can be represented in at least two ways. The straightforward way is just to specify the interactions with hardware and the user as part of the input to a turing machine...
I'm not so sure about that. I do agree that an operating system can be modelled by a running Turing machine. But only degenerate cases of operating systems halt. The purpose of an operating system is all the side-effects it creates while it doesn't halt. That is to say, it creates an environment in which other programs can run. It interfaces with hardware to output, say, video and sound. These side-effects are essentially analogous the states a the TM are in while running TMOS. (This analogy is why I'm willing to agree, with the stipulation that the TM must be running) By definition, a Turing machine only computes a function when it halts (and the result is what is written on the tape once it has halted). Operating systems make pretty boring Turing machines anyway. Unless something like a kernel panic happens, if they halt, they'll always halt with instructions to reboot or turn the hardware off, no matter what the user input or what side-effects it has created.
When I got my CS degree, the halting problem was only one section of one of the finite automata courses. It took maybe a week to cover, and explaining turing machines was necessary anyway in order to explain NP completeness. In light of that, is such a fundamental theorem worth dropping?
Recursive function theory is a much neater way to prove that no halting function exists. Rice's theorem is an easy generalization of the methods used. This can be covered in a day, if suitable homework problems are given. Turing machines are tangential to this topic, especially since Turing's contribution was to prove that TMs can compute the recursive functions, putting them on par with plain old recursive functions as a model of computation. Using provability logic, the proof is downright trivial.
After all, I am strangely colored.
Oh, wait! Variations of provability logic known as "Dynamic Logics" can deal with expressing algorithms and proving things about them (like the non-existence of a halting function) all within the same formalism. I'm sure this is what the article's author has in mind for a pedagogical replacement to Turing machines.
:-)
Dynamic logics don't handle concurrency very well, but then, neither do people.
After all, I am strangely colored.
...a WONDERFUL idea!
One that the Chinese (/Indians/Russians/Japanese/ect) would love for us to take to heart.
You know, there used to be a time when Americans actually studied. Not bitch about how math is hard and useless, how they don't need a college degree to be a decent coder, and how school is a waste of time.
The most patriotic thing you can do for this nation is to educate yourself. All else follows.
I am very small, utmostly microscopic.
Seriously, though, I think it's mostly just corporate philosophy. Windows looks primarily for scientists, engineers, and so on; a friend who was an artist/graphic designer at Microsoft said they felt very much a second-class citizen, and recommendations often didn't get really listened to. For years, Apple has recruited artists and creative sorts right alongside devs.
In fairness, I think this is changing a bit; Microsoft's learning that the front-end is as important as the back-end, and is rethinking things and has done things like hiring artists and photographers, or even more importantly, building XAML so that artists can actually design real UI instead of just mockups. Whether XAML changes the UI playing field as much as Microsoft hopes remains to be seen, though.
--Rachel
static const char* const totc = "It was the best of times, it was the worst of times, it was the age of wisdom, it was the age of foolishness... "; #include int main() { std::cout totc std::endl; };
damn formatting arraaaghhh!!!!!
I remember when I was much greener, I lambasted my experienced coworker's code for doing stuff redundantly and wasting cycles without understanding his ingenious use of L1 cache. In reality, my rewrite ended up 10x slower despite being algorithmically faster. Algorithms are they way they are because of the machines they run on. It's amazing how fast an algorithm changes when the nature of the machine changes. What happens when we move to massive brain-like parallelism? Some classical thinking stays, but some go out the window. To the point of the original article, I don't think the general involvement of math and physics will change, but the type of math and physics will. At least, until we invent a machine that runs on Fun Art and Feelin' Good (tm).
Non-sequitur.
The point is that there were very good typesetting systems before WYSIWYG were invented. People who use TeX now can tell you about it, but that's far from the only one : classic WordPerfect is another one.
WYSIWYG like in Word sounds good until you have real typesetting needs, such as searching and replacing styles so that you have a consistent look across chapters, printing a single chapter with only its matching bibliography instead of the whole document, etc. Writing a book in Word is an ordeal (I've done it) compared to (La)TeX. It's even worse if your co-authors have different versions of Word or use OpenOffice, say.
With a plaintext source there are no such problems. Maintainting a consistent look is as easy as maintaining a good web site with a CMS instead of hacking HTML.
I don't see why a lots of things that you believe are 'outside traditional math' can't be explored with math.
Mathematics is no more about numbers than is about objects and their arbitrary relationships. In fact, it sometimes defines the objects in terms of their relationships.
What makes mathematics what it is, is the method of theorems, and logical proofs. Anywhere you can state something abstract as a theorem and use it to prove statements, there is mathematics.
In that sense, all Knuth books are heavily mathematical.
However, maths is so often related with just calculus and advanced calculus, but I think it is because that's the part everybody has to suffer because it is useful for traditional engineering. It is time to change what's being taught as mathematics (there's much more to it than it's being used now).
We are Turing O-Machines. The Oracle is out there.
I know this is just feeding a troll, but...
:)
I'm pretty sure his lack of a beard or turban has nothing to do with being "careful" and a lot to do with being a middle-class white guy. Your culture/religion is something you're brought up with, not something in your genes. The fact that his biological father is Syrian influences nothing but his looks.
I think the only place Steve Jobs is considered a terrorist is in Redmond, where they're all scared of him
You probably aren't programming anything that requires math. Try 3D graphics programming - you need a lot of linear algebra, and some calculus if ...
But if you are doing a chemistry app then you need to know chemistry, and if you are doing a non-trivial financial app you need to know finance, etc. etc. In other words, "specialties exist". Nothing new there.
Table-ized A.I.
I think this is really a syntax versus semantics argument. Many great developers have degrees in English, philosophy, and linguistics. Look at all the Perl developers.
.. 200) { print; }
Some people (me) prefer rigid syntax and "functional" languages which tend to be more mathematically based. Others prefer syntax that is more loosey-goosey where symbols change meaning depending on where and how they are used (more natural language based).
Which do you prefer?
if (this == that)
for (c = 101; c = 200; c++) print that;
or
if (this eq that)
for (101
I prefer the first one even if it means more syntax. It's much easier for *me* to debug. But others will find the second option more "natural".
-CF
While I thought that it's easier to copy names with accented characters off Wikipedia as there does exist an article about Thành then seeing the name with accented characters is a different business, especially when support for Vietnamese accented characters is not installed. This was of great help in trying to overcome that hurdle.
In 'Hàn Th Thành', I can't see the ế character, likely because the page in Slashdot uses ISO-8859-1 encoding, whereas pages in UTF-8 show it correctly.
One way to make it universally visible is like this: 'Hàn Thê’ Thành', using an e with a circumflex and then adding the right single quotation mark (’) next to it, because any other character remotely similar to an acute character fails to show for some reason. The right single quotation mark can be confused with a apostrophe when text is at its normal size (Arial font). To see the difference, the text size has to be increased twice in Firefox 2 (this experienced in Windows 98).