Slashdot Mirror
Should Undergraduates Be Taught Fortran?
Mike Croucher writes "Despite the fact that it is over 40 years old, Fortran is still taught at many Universities to students of Physics, Chemistry, Engineering and more as their first ever formal introduction to programming. According to this article that shouldn't be happening anymore, since there are much better alternatives, such as Python, that would serve a physical science undergraduate much better. There may come a time in some researchers' lives where they need Fortran, but this time isn't in 'programming for chemists 101.' What do people in the Slashdot community think?"
But only if they have to do it on punch cards, like I did. Give each student a can of WD40 to keep the machines working smoothly, too.
--No one-- should be taught FORTRAN. Ever...
*sobs in fetal position*
I had to learn it. Everyone else should have to go through that hell!
Are there any cheap but quality tutorial for Fortran? O'Reilly has no contemporary introduction to the language and their last book on Fortran, Migrating to Fortran 90 , came out nearly two decades ago.
Fortran is still one of the best, fastest, most optimized tools for number crunching. It's also very easy to write simple programs in it. No way I'd use Python for serious large data set numerical calculations.
Ironically we're doing an implementation of a "new" HR system and a big chunk of it was written in Cobol. We have one guy past retirement age who knows it, but otherwise the bulk of our developers just know those fancy new languages.
Some of those older languages have a surprising amount of life left in them, out in the real world.
Unlike Pascal, Prolog, Smalltalk and the rest of the fad languages, Fortran is still here, and it will still be here when Python is long-forgotten.
I would suggest teaching them C, but it may be too complex for a first language.
My brother is both a mechanical and structural engineer and he uses Fortran for creation of simulations of simple to moderate complexity. I built him a FreeBSD box with an open source Fortran compiler and he uses this box for said work. I know nothing of Fortran myself. My brother just needed a UNIX machine and didn't want to spend untold sums of money for an HP-UX workstation. My brother seems to feel there is a lot of value in knowing Fortran. Personally, it looks evil to me. I like C/C++
MatLab is essentially Fortran.
When we did FEA work, we used NASTRAN, which still required inputs in Fortran.
That being said, I think colleges should teach more relevant materials to get them better acquainted with current standard programs.
Arguing with an engineer is like wrestling a pig in the mud. After a while, you realize the engineer enjoys it.
Isn't as hard to write fast python code as fortran code? When you're paying large money for supercomputer time, your multi-day molecular dynamics simulations better run quickly.
The question of whether a computer can think is no more interesting than the question of whether a submarine can swim.
Does it really matter what language they're taught in? They should be learning the concepts of programming, not just a language. However, FORTRAN has the benefit of already having a large existing code base and deployment in the field in which students in those particular disciplines are studying. There's no reason for them NOT to learn it, and if they feel like learning Python later, then then may. Python isn't the solution for every god damned thing in the world, even if it can do it.
The answer is that there are so many libraries readily available, especially those for certain areas of physics. With python, this is not the case.
While Fortran is old, and I'm not a fan either (and can't program it), I was surprised when I heard a presentation about a code in Fortran.
It is a high-level programming language, and aside from syntactic ugliness (like this uppercase stuff), it is as powerful as python (aside from lambda).
So let them. The effort of reprogramming the huge amount of libraries will not be paid. Maybe a good python-fortran bridge can help both sides.
NB: The message above might reflect my opinion right now, but not necessarily tomorrow or next year.
For their sins.
What do people in the Slashdot community think?
The easy route is just to let them teach what they want to. Professors will talk and push whatever they feel is valuable and they sure the hell aren't going to listen to a Slashdot user half their age that will get on his knees and write Java for an extra buck. If you get a whack job professor teaching only archaic languages, the University will probably hear complaints from alums about getting into the job market and wishing they had learned R instead of Fortran. I don't know about the other engineering programs but I'd sure rather be a master with R than Fortran. Is Fortran more efficient? Depends on if you're talking about cycles or amount of time it takes to write a quadratic sieve for prime numbers.
... maybe even Ruby?
I had to learn C and I actually like plain jane C in all its simplicity. I think colleges should stick to a low level language for numerical computation courses (in my case C but I believe Fortran would function fine), an intro course to an interpreted language like lisp scheme perl whatever and should of course offer full courses in whatever is the latest craze for usable languages like C++, Java
I wager this will be a hot debate and I think it's fine if people want to teach Fortran, I learned scheme and I've never used it in my professional work! Just so long as when they enter the job market, they're prepared.
My work here is dung.
Nah, give them a can of AC90. Encourage diversity..
If I had an Ass, I'd call it Fanny Bottom, then I could slap my Ass; Fanny Bottom, on the Arse.
i spoke to someone studying engineering in 1990 who was being taught fortran. they were using a mathematical library that would solve partial differential equations, by presenting the user with the actual mathematical formulae to them.
these kinds of libraries are staggeringly complex to write, and they have been empirically proven over decades of use to actually work.
to start again from scratch with such libraries would require man-centuries or possibly man-millenia of development effort to reproduce and debug, regardless of the programming language.
so it doesn't matter what people in the slashdot community think: for engineers to use anything but these tried-and-tested engineering libraries, that happen to be written in fortran, would just be genuinely stupid of them.
If all you need is to crunch numbers, Fortran is a good choice even today.
It might not be the best language to introduce someone to computer science, but it is very powerful for anything that has to do with matrix operations.
A few years ago in a physics graduate course we had a simulation project which left the choice of language to the student.
We compared performance between implementations in C C++ and Fortran.
Fortran was consistently faster by a big margin.
It's also very easy to learn.
That said, I do most of my coding in C.
As of Postgres v6.2, time travel is no longer supported.
As with any profession, in order to work effectively, you need to know the tools. Just like the classes teach notation/language of the specialty. Would anyone even think not to teach mathematical symbols for Calculus. The students will be dropped into jobs using and maintaining programs written 40 years ago.
If the majority of special written software is python, then yes the initial programming should be python. Go with what they'll need to know.
-- Ed Bugg --You have freedom of choice, but not of consequences.--
Disclaimer: I am not a programmer.
It seems to me like there should be a good "introductory" language where, though the utility of knowing that language may or may not be practical, would help teach programming concepts and good practices to new programmers. That is, if the goal is really to teach programming. Usually, when you're introducing someone to a topic, it's a good idea to start with something representative and likely to instill interest in the topic.
I don't know which programming language fits the bill, though.
I think it's a shame Slashdot can't go a month without someone submitting a "Which programming language is best?" flame war firestarter. This has been done to death.
I love Fortran (or FORTRAN as we old folks spell it).
But, no one should be forced to use an IBM 026 Keypunch (http://en.wikipedia.org/wiki/Keypunch#IBM_024.2C_026).
Dave Barnes 9 breweries within walking distance of my house
Fortran sucks.
Get those 50+ year old programmers out of the industry if they are using such an old language.
Fortran needs to retire, just like every single programmer that thinks that Fortran is worth using.
No.
You make a persuasive argument, but on the other hand, yes.
I was never formally taught to use Fortran, just C. I think this worked best for me since this seemed to be the vanilla of languages and it gave me what I needed, a solid understanding of how and why to program. I did not need to know the intricacies of a specific language, that comes later depending on:
A) Where you end up.
B) What you end up doing.
So really, the language isn't the point, but more so the techniques of programming. Early courses should be basic, but challenging in that you need to know how to work with the power of number crunching and programming is the tool.
As an aside, I've later taught myself Perl and Fortran as needed and knowing the fundamentals helped.
One of the staff at Purdue (back in the 80's) was a Fortran guru. He had never seen a true fortran complier, i.e. one that would pass all the standards tests. I don't know if this is any different today, but I doubt there's a compiler that will compile any and all arbitrary Fortran programs.
Besides, just write your code in a real language (one with a real grammar) and link it to the time tested Fortran libraries. What value is there in actually writing in the language?
All ideas^H^H^H^H^Hprocesses in this post are Patent Pending. (as well as the process of patenting all postings)
I had a half-year "Intro to Engineering" class at Purdue my freshmen year (1999) - Frosh Engineers weren't allowed to pick an engineering discipline until sophomore year, so we got all sorts of intro classes. In it, we first learned FORTRAN, and then we learned C.
The reason we learned FORTRAN:
* We had to compile code from one language and reference it from code in the other, to prove it was all worked the same once compiled.
* We had to have it beaten into us that, if we ever wanted to bitch about how confusion C was, all they ever needed to say is "at least it's not FORTRAN."
* They had read an article out there saying that FORTRAN coders were the highest paid coders out there, since lots of companied had legacy code and systems to maintain, and very few people cared to learn legacy languages anymore.
So yeah, it didn't kill us being part of an intro class where it wasn't the only thing we learned. Quit bitching about, it and GET OFF MY LAWN!
There's no problem for teaching Fortran if it's the right tool for the job. It was 13 years ago that I took Fortran in College. It went great with physics and modeling courses. These days I write web-based database apps in Java/Perl/whatever language-du-jour is required of me, but I wouldn't want to use many of these languages for scientific purposes. I'll leave that to Fortran and C.
Addlepated - punk & metal
OTOH, we tend to teach what we know and what has worked well. This has been Fortran. It is stable, which means it is easy to get and easy to teach. Most universities has extensive mathematical and scientific libraries, which means that unless one is teaching programming, all that is really neccesary is some glue code to put the functions together.
As an aside, it is also moderately difficult to debug. While this is annoying to the undergraduate, debugging a fortran program does teach important investigative skills and encourages a level of precision that is not so necessary in some more modern languages.
"She's a scientist and a lesbian. She's not going to let it slide." Orphan Black
Python is scripting. FORTRAN is programming. MPI is vastly more supported by FORTRAN than any other language - grow MPI support for C++ or Object C, and then FORTRAN can go away.
Fortran has all sorts of what we would now consider artificial limitations and restrictions on its syntax that make writing even simple programs a lot less simple and intuitive. For example, line length limitations, special columns, short & special variables names, etc. I'd rather not spend time teaching/learning (especially non-standard) syntax and more time on the concepts while encouraging good stylistic conventions (use commenting, readable variable/function names, etc). I found Pascal a much better first language. Not to mention that many of these programs using FORTRAN are arcane, dated in their teaching concepts, and force FORTRAN despite students who often already know many other languages.
I work at a university research lab and Fortran is still very much present. If nothing else, students need to be able to work with legacy code. I agree, however, that new projects should make use of more modern languages. Special consideration should be given to functional programming which naturally fits many science problems and is easily parallelizable due to its "no side effects" philosophy.
why something that was written in a year and used over two decades, need millenia to be reimplemented?.
Back in the mid-90;s I was taught Fortran (77?) during my 1st undergraduate year of my Physics Degree at Imperial College, London. We were told not to use the first 4? characters on any line as a left over form the punched cards day. This was quite amusing to myself and my fiends as most of us had been programming for years, and had PDA's that could manage a faster baud rate terminal interface to the mini computer than the 9600 baud green screen terminals we told to use. 2nd year was Fortran 90 on unix workstations so things got a lot better. By the time I was doing my PhD the computer labs Windows PC, with visual studio and C++. The course had got a lot harder during the switch and was teaching more advanced numerical methods and object orientated programing methods.
It's called Scheme.
Meta will eat itself
because Python is interpreted and FORTRAN is compiled. And honestly, lets admit it, the whole object oriented thing has pretty much failed and its time to pack it up and get procedural again.
This is my sig.
When I was an undergrad, the CS requirement forced all students to take classes in Pascal.
I think the reasoning was that a student should learn a language with extreme, formal structure, and then later they can learn ones that aren't quite as strict. Maybe that the same reasoning behind teaching students Fortran? At least it's a little more useful than Pascal.
Genocide Man -- Life is funny. Death is funnier. Mass murder can be hilarious.
Yes, teach it to them for historical purposes. So they see how awful it is and no one makes that same mistake again :P
so, damnit, everyone else better go through the same thing.
Seriously though... though I learned it as part of my CS coursework, I used it more often in the math minor portion. Lots of the examples were in Fortran, and I remember having to write Newton-Raphson and trapezoid functions. It served the purpose of showing how numerical methods worked.
I'm not certain how useful it would be in a current CS course. Today you'd just link a library and and make a call. I'm not saying that's in any way worse than how I learned it, but may not be as useful as a learning tool.
In my opinion, yes. I am an undergrad Physics student (senior) and had my first contact with Fortran in my third semester, in a course called Computational Physics I. We learned the basics of Fortran 77/90 and how to solve some numerical problems using it. We also simulated some interesting problems that amazes undergrad students such as chaotic oscillators, Magnus effect in action and a few other simple yet curious systems. I had already some programming experience, but most other students didn't. They got it quite quickly and I think this is due Fortran's simplicity.
Even if you are never going to use Fortran in your own projects, you will stumble on it now and then if you are going seriously into applied and theoretical research field. NASA, for example, has tons of production code written in Fortran and even new codes are written on it. Many many Physics and Chemistry groups around the world have their most important codes in Fortran, and sometimes they use clever hacks to make the code faster, so a minimum understanding of it is necessary. I work with a Computational Chemistry group and much of the code they still develop, even for new applications, is Fortran. It is good and solid code, they are very experienced on it, and they are not willing to change to another technology so easily.
As a first language I don't know if Fortran is the best, maybe Python or Java would be my choice in this case, but it is definitely worth learning.
The greatest misconception about fortran is this: although yes, it goes with heavily optimized compilers for number crunching, the real problem is beyond. The problem, as I have constantly witnessed for decades, is that the people who write fortran usually have no basic knowledge of computer science, and e.g. have never even heard of algorithmic complexity, balanced search trees, hash tables, nearest-neighbor problems, and the like. So they write, spaghetti style, very efficient code, which is then turned into very efficient object code by the compiler, implementing utterly inefficient numerical methods. I can remember blank stares when I told some of them that, despite very clever space partitioning, their nearest-neighbor search was still O(n^2), and that switching to a binary tree would obviously gain so much that they would be able to run the whole thing on a Linux box instead of a Cray.
I'm not making this up.
> It's also very easy to write simple programs in it.
99% of programs are not simple any more...
> No way I'd use Python for serious large data set numerical calculations.
No way I'd us Fortran for serious large data set numerical calculations...
First I use Python - it is fastest to write and debug and has advanced data structures that simplify algorithms...
What good is that my program run one day shorter if it took me 2 weeks more to write and debug...
If I need to optimize - I am moving the internal part to C - it optimizes almost as well as Fortran...
There is Also NumPy ...
The key thing is that it is algorithms what are more important - and these are easier to write/learn
in Python - so it students should learn Python first and only some need to learn fortran..
Are you serious? Python?
I am somewhat a Python fan boy. I love it. Its freaking wonderful for prototyping and really has a great, natural flow that reminds me a lot of pseudocode I might just invent on a napkin. Great language. But its also a factor of 30 times slower than a compiled language like C.
(http://www.osnews.com/story/5602/Nine_Language_Performance_Round-up_Benchmarking_Math_File_I_O/page3/)*
And Fortran is able to do optimizations (due to differences in the language for evaluation of expressions) that C is unable to do. This has to do with guarantees of ordering that Fortran does not give that C does. My point is that Fortran is even faster than C. Why do you think its still around?
The physical sciences aren't using a fast language because they are bored, or obsessed with speed for the hell of it. They use them because the problems they solve are typically deep into polynomial space, like O(n^3) or O(n^4). Having something 30 times faster means they can run 30 simulations instead of just 1. It makes a big difference to them.
I think the author of this article has lost some of this perspective.
That said, what this article should have tackled is, what do we want to teach engineering students about computer science? Right now, they take a class that teaches them C++, Java, Python, or whatever. They get some procedural programming skills with maybe a little tiny bit of object-oriented stuff (without really covering OO fundamentals IMHO, which are a more advanced topic) and they are thrown into a world where they are writing code in C for embedded controllers or Fortran for computational codes. As a result, there is a huge body of code out there written by people who know how to get the job done, but don't exactly write code that is very maintainable. They relearn the lessons of CS he hard way over 10-20-30-40(?) years of experience. Are we really giving these young students (who are not CS majors) what they need? What kind of curriculum would be ideal for someone who is going to end up writing code for something like a robot control system in C?
* I didn't really look too closely at this particular source, but I've seen numerous benchmarks all saying the same thing. If you want a surprise, go look at how LISP stacks up compared to C. It is better than you think.
IMO universities should be teaching core principles and methods, not attempting to impart up-to-date job skills.
If you are going to teach FORTRAN because it's of use in the real world, then why stop there? Why not also (god forbid) teach .NET. JavaScript, C#, etc. May as well teach them Excel macros and how to interact with Microsoft Clippy while you're at it.
No!
Teaching programming should be done in a langauge that imparts the principles easily and teaches good habits. You could do a lot worse than Pascal which was often used in this role, or maybe today just C++. I'd argue against Java and scripting languages as the core language since they are too high level to learn all the basics. You could throw in Perl, Python or any modern scripting langauge as a secondary, and for a Computer Science (vs. Physics, Engineering, etc) it's appropriate to teach a couple of other styles of programming - e.g. assembler, and functional programming.
While used extensively in a number of scientific research programs, it isn't used commercially in any great amount, if at all. Unless the student is planning to work in an area where the language is used, there aren't any great benefits to knowing it. College should be more about leaning the discipline of software engineering, not learning a multitude of programming languages. C or Java serve that purpose perfectly well and have extensive use in the non-academic world. It it is needed at some point, learning it won't be terribly difficult if one is already conversant with other languages.
I used fortran 30 years ago, stopped using 25 years ago, and, outside of a few PhDs who use it where I work, nobody uses it for anything.
In my area of Research, almost every program written has been in Fortran. Maybe Python would be better- i wouldn't know. But it is a lot easier to update a program written in an old language than learn a new one and start from scratch. And fact is Fortran does work and works quickly. Being 40 years old means people have spent that time optimizing the routines.
why something that was written in a year and used over two decades, need millenia to be reimplemented?.
He said "man-millenia". Look: If you have two guys who each work one hour on a task, then you've expended two man-hours on that task, even though only one hour has passed. I've no idea whether the OP is right or not about the manpower that would be needed, but it's not implausible.
FORTRAN is still used so heavily because a) the architectures used for HPC are some of the rarest, most singularly-purposed machines on earth -- your Crays, your J-Machines, your Cell BE"s. These are not the commodity architectures for which gcc is designed; in many cases, gcc support might not even exist. In any case, it's certainly not going to have the intense and often, frankly, bizarre optimizations necessary to properly make use of these machines. Does python even allow one to manage cache prefetching, SIMD, the floating point model, etc? b) FORTRAN's easily parallelized by compilers -- even moreso than C with OpenMPI, etc -- due to the simplicity of its loop constructs and a rich heritage of automatically parallelizing these constructs (look at Ken Kennedy's work etc. google for DOALL and DOACROSS). For HPC, you're often working with massively parallel architectures, often SMID-heavy. Check out the Banerjee inequality sometime if you want to see something cool. c) Vector notation in FORTRAN is easily compiled into vector registers and operations. Python slices could probably be amenable to this, but Python isn't really ...
d) Array-oriented. Everything in the microarchitecture world is designed around fast access to and operations on arrays. If you're not working in the array model, it's gonna be hard to compile it in a fashion that one can make use of architectural features designed for high performance.
Language research is ongoing that seeks to address these issues. Python doesn't get there.
I'm currently porting a large Fortran 77 program to C++. I can safely say that Fortran 77 is a dangerous, bad, damaging language to teach anyone, especially impressionable young programmers.
There are several idioms in F77 that must not be taught to future generations. Probably most importantly, the use of "common blocks", and "entry" points, and the hacks needed to get around the lack of dynamic memory allocation.
I'm sure that newer versions of Fortran are more reasonable, though.
I'm a civil engineering student who had Fortran in the curriculum. Although I don't use Fortran very often, I believe the article poses the wrong question. Instead of "why learn fortran" the question that the article's author should ask himself was "why am I forcing Python as a replacement of a tool that benefits from a battle-hardened technology that has the benefit of having a extremely serious, decades-long test on production environments in the real world?" I mean, "fortran is old" is not a technical argument. So it's first inception was decades ago. Is that even relevant?
More to the point, mentioning Python as a tool for numerical analysis is laughable, not because of having any blatant weakness but because there are a whole lot of tools that fit that job even better than Python, both in terms of speed and available APIs. If we were forced to abandon Fortran then why exactly would we adopt Python when there are other tools that are far better suited for the task? (Read C, C++, Maxima, Mathematica, Matlab, Octave, R, etc...)
Slashdot, fix your code or at least hire someone who is competent at it to do it for you.
Whatever the server's implemented in, it's definitely not fast enough.
Today's Fortran is not the Fortran of 40 years ago. Ever since Fortran 90 (i.e. for almost twenty years) the language has real dynamic memory allocation and real ways of sharing data between different parts of the program. Fortran got its bad reputation because the lack of these features caused most old Fortran code to be hard to follow -- emulating memory allocation by using lots of large arrays, and tens of lines of repeated COMMON blocks scattered all through the code .EQ.ual very opaque code. And let's not forget that those codes were written to be extremely efficient in terms of CPU time as opposed to developer time.
It's no surprise that Fortran got this bad reputation some 25 years ago when the art of language design had advanced significantly beyond what was in Fortran originally, but people who still think they need to pontificate on that point should catch up with the times -- or at least with 20 years ago.
IMHO I would have to say yes. With the rise of multi-core systems I found that FORTRAN has some programming habits that would carry into multi-threaded and multi-core programming. While I don't think it has a high relevancy for finding employment I do think that FORTRAN, along with at least a 3 credit hour course in assembly is crucial for fundamental programming skills.
I think we can drop PASCAL (If they haven't already) and swap it with either Ruby or PERL for undergraduates.
-=[ Who Is John Galt? ]=-
May as well require them to speak Esperanto too just to make sure nobody understands them.
I still work with Cobol geeks. It's actually in regular use. But I don't know of anybody who uses Fortran except for comp-sci departments. And if you're using it to teach programming practices you might as well teach said practices in a language they stand a chance of using.
My office has been taken over by iPod people.
In the high performance computing and physical simulation world, Fortran and C are still king. In large part this is because of the BLAS, LAPACK, MPI and OpenMP libraries which are the standard libraries to use for linear algebra and parallel programming and upon which most physical simulation software is built. These libraries started out in Fortran but C ports are also widely available. Thus a new engineering graduate is much more likely to need to work with Fortran and these libraries than with Python.
Also while most code written by scientists/engineers isn't written very efficient (because they don't know algorithm design and analysis), it needs to be written in a language where someone (usually a CS person) can come in a cleanup/tune the critical bottlenecks. At that point the efficiency of the language does become important. In this field, a 3% improvement in performance can make or break you. (Yes, you can mix C and Python, but its easier to stick to one language rather than having to keep marshaling back and forth.)
They should be taught SOMETHING. I recently saw a case where a new programmer was asked to add CR/LF to the end of his text strings. Well, when we saw the code, he had done exactly as asked. Each string had "CR/LF" (the string literal) added to the end.
Nail guns have been around for a while, but a lot of houses still get built with hammers.
If a simple tool does a job efficiently and effectively then why "change for the sake of change"?
I'm a fiscal conservative, it's a pity we don't have a political party anymore
Remember what the name means.
Because the language has been around for decades (40 years?) it has matured to the point where the libraries and compilers are highly optimised and reliable, and performance on the most significant and "heavy" computational problems has been tweaked to go as fast as possible.
Maybe in another couple of decades, Python, Perl, and other interpreted languages will come close. But not now (IMHO of course).
-- This
From what I understand, most of the scientific computing applications of python involves using bindings to C/C++. Efficient, fast code for crunching numbers is written in the lower-level language, and the program is organized at a higher level using Python. This way the program is both easy to read and runs fairly quickly.
I am a manager in a highly technical organization that relies on computer codes to do our job. In my experience, there isn't ENOUGH FORTRAN teaching in the college level. Maybe its location based, but most of our new-hires (we get most from the northeast, but still get a noticeable amount from as far away as University of Washington, Univ of Hawaii, and USC) actually are NOT taught FORTRAN and instead are taught something object-oriented, typically C++ or Java. I know for a fact that Penn State suggests C++ for all undergrad engineers (FORTRAN is offered though - the classes hold less than 50% total students than does the C++ course). In my organization we also have a 'double-hump' age distribution: lots of people ready to retire (or could have retired 5 years ago...) and lots of people who are within 5 years of their first day on the job. This creates a problem of knowledge management; our new guys need to know the details of the FORTRAN code they are using every day to the extent that our ready-to-retire guys know it, and fast. If they are not taught FORTRAN, this creates an even larger learning curve for them which isn't desirable. So one option would be to 'rewrite the code for the future generation'.. We definitely do not have the resources to rewrite our workhorse codes that have been in use and development since the 70s. I don't know if an organization as large as Microsoft could rewrite Windows in a new language. Also, we can't retire our old codes because they are still actively needed to respond to emergent issues (it is easier to maintain the codes than it is to make a new model to be inputted into a new code). So, our hands are tied (mine specifically!) and my organization actually needs MORE FORTRAN programmers coming from the university just to maintain the status quo.
Except I'm pretty sure that there are modern languages and libraries that can handle this without Fortran. I don't have much experience with it myself, but I'm pretty sure that's exactly what MATLAB is for, for one.
--- Bwah?
Yeah--let me know when python is even 50% as fast as optimized fortran out of the box. Look--I've used numpy, scipy and all that--python for distributed computing. And it's *great* stuff. But when it comes right down to it--while you can do numeric computation in python--it just isn't as snappy. C, Fortran--they're still faster, and they probably will be for some time.
It isn't the byte code--todays CPU caching and branch prediction seems to handle all that...it's the freakin' memory structure and GC as best I can tell. Maybe if that gets better...problem solved.
so it doesn't matter what people in the slashdot community think: for engineers to use anything but these tried-and-tested engineering libraries, that happen to be written in fortran, would just be genuinely stupid of them.
So, your idea is to teach everyone FORTRAN because if they become engineers, they might need it?
How many projects do need those kind of computations? There are some cases, I agree, but I could also argue that everybody should be taught assembler, because they have tons of microchips in every-day devices, such as mobile phones, televisions or cars. NO! Leave FORTRAN where it should be, with the mathematical experts, don't feed more useless stuff to undergrads.
Next question, please!?
While I agree that languages like Python may be better as an introductory language, Fortran is still heavily used in the scientific community, which these students will (theoretically) all eventually be part of. It makes, at least some, sense to teach the tools which they will be using. In any case, once you know one imperative language, its not too difficult to pick up another. Syntax is easy to learn.
Personally, I think learning Fortran as a first language is better than learning Java as a first.
I tend to think that the goal is not to learn specific instances of skills in college (ie, a particular language), but learn principles. It's very much worth any science student's time to know a programming language. It's a reasonable thing to learn programming well enough to pick up any language - but really, this is one path of many, and is probably best called 'minor in computer science'. Yes, Fortran is not exactly cutting edge, but it's a fine example of one kind of language.
If you wanted to learn the language most commonly used in science labs, sad to say as a programmer type, probably spend some time with Visual Basic.
As an ecosystem, the best thing is probably variety. It's good that some percentage of new graduates know Fortran, so it doesn't become burdensome to hire people to work at places with legacy codesets, but it's also good that it's possible to hire someone working in a language that might be more suited to what you're doing. Or to a different type of brain. Diversity is good in a larger sense - someone who might be a mediocre Java programmer might be a star Perl programmer, and vice versa. The more diversity gives more individuals a chance at finding a niche they excel in. I think this aspect is overlooked massively when people talk about 'the right tool for the job'.
If you're a scientist that likes programming, though, a minor in CS so you can pick up whatever language comes your way is an approach with a lot of practical potential. (Or a double major, but CS is hard and most Science programs are hard, so I'm not sure it's worth it - even the people that hire programmers that like degrees would not find fault with a Physics degree and a CS minor.)
-- Kate
I'm a post-doctoral researcher and never had any Fortran training in my undergraduate studies and I've spent this week trying to learn Fortran as there are several pieces of code I need that are written in it. Unless people start porting old code/models to a new language then it's necessary to learn it.
For a scientist, FORTRAN is still a valuable skill since there are so many libraries and applications that represent many years worth of development to draw from. Plus it is efficient, etc.
The question here is what is the best way to introduce students as a first exposure to programming. FORTRAN has many quirks so it is debatable whether it is really the best language to learn first. You can write truly horrible code in FORTRAN, but that is true to some extent of all languages, although Python does make it harder.
On balance, if students are taught a modern dialect of FORTRAN and the instructor stresses good programming practices, it remains a good way to introduce students to solving a problem numerically and of getting the job done for people who may not code for a living.
Static memory allocation, all arguments pass by reference all the time, no type checkin anywhere etc lead to a function call overhead being a simple jmp instruction. Imagine a clueless physicist passing a large std::vector by value in C++. A simple oversight of missing an & in the function declaration. At every call a copy of the vector gets passed in and discarded at exit... There is no way a higher level language with all kinds of dynamic type testing and dynamic memory allocation and dynamic binding to be as fast as Fortran.
I am not arguing Fortran is better in anyway. It is very easy to create very hard to debug bugs in fortran and maintenance is a nightmare. But once the bugs have been ironed out and the code has been trusted, it is hard to beat fortran using modern languages. Heck, fortran is nothing but one small step above assembly language. It comes with all the benefits and disadvantages of assembly language.
No
This is why they should be teaching the science undergrads Python. When they get to the point that they need to do some serious numbercrunching, F2PY allows them to interface to any Fortran library.
http://www.scipy.org/F2py F2PY is part of the SCIPY project to create a science-oriented distro of Python.
The Mayan Long Count Calendar turns over in 2012. Mayan date 12.19.19.17.19 will occur on December 20, 2012, followed by the start of the fourteenth cycle, 13.0.0.0.0, on December 21st.
The event was first flagged by megalith scientist Terence McKenna. The end of the thirteenth cycle would break many megalith calculations — which conventionally use only the last four numbers to save on standing stones — with fears of spiritual collapse, disruption of ley lines, Ben Goldacre driving the chiropractors back into the sea and the return of the great god Quetzalcoatl and the consequent destruction of all life on earth.
Megalith programmers from 4000 years ago are being dredged up from peat bogs and pressed into service to get the henges updated to handle the turnover in the date. "It could be worse," said one. "I could still be programming COBOL."
http://rocknerd.co.uk
I find it difficult to accept the argument of one, while overlooking the other, which is why I'll go with
maybe
You speak London? I speak London very best.
There are problems, where fortran is a better (or at least probably a faster runtime) solution. But teaching fortran to every undergraduate would be a big mistake.
They should be taught how to program, not how to do it in fortran. (And if you don't understand the difference here, you don't understand the problem.) Use any kind of language that is easy to teach and learn, or something that is used regularly out there.
Anyone programming fortran or cobol (same issue, just with banking instead of physics) will tell you that it takes about three weeks to teach a decent programmer how to do this language as well. But if you start out by teaching them the old school stuff, there is almost no way to get them up to speed on todays programming styles.
So teach them how to do proper programming, and make specialized courses for those very few who needs the legacy languages.
Bo Thorsen.
In my day we had to learn it on our own. Without a book. Or a computer.
Confucius say, "Find worm in apple - bad. Find half a worm - worse."
There's always Maple.
My webcomic
As many on these hallowed pages have pointed out, the focus needs to be on how to program, not necessarily the language.
As for those who think that languages like Python are too slow, they are being too simplistic.
Writing an LU factorization routine in Python for real world use is silly.
Writing such a routine in Python for educational reasons is perfectly fine.
And using such a routine for real work will involve calling a LAPACK routine _from_ Python, and will
work great until the problem size isn't doesn't get too large.
So numerical work in Python or similar is perfectly fine, just as long as you use the right tool for the job.
So back to that FORTRAN thing... Why not ? Ultimately it depends. I'd say that other languages _are_ more suitable unless the student is going on to a life of hard-core number crunching. Dedicated simulation tools and programs like Mathematica and MATLAB are really what people use for everyday work.
Absolute statements are never true
Who programs in Python anymore? ...Oh wait...
I forgot I had my time travel suit on. Sorry about that.
Oh, of course Python. Good choice.
Using the criteria specified by Mannila & de Raadt [1], the answer is: NO! As far as I can tell, Fortran is just as bad as C by their criteria.
[1] L. Mannila & M. de Raadt: An objective comparison of languages for teaching introductory programming, Proceedings of the 6th Baltic Sea conference on Computing education research: Koli Calling 2006
This was clearly written by someone who doesn't actually do any scientific computing.
As hard as it may be for some CS-types (myself included) to believe, Fortran is still the language for scientific computing. I've worked at flight simulation companies for two different companies (and 5 different groups) for the last 15 years. The math required to simulate a flying aircraft in realtime is ungodly hairy. It also has to get done fast. We typically have 50 or so different simulation models (plus all the I/O) that have to run to completion 60 times a second. That's about 17ms, or 8ms if we want %50 spare. In addition, for a realtime app like a simulatior it needs to take the same time to execute every time (no runtime dynamic allocations, GC, etc.) or things "jitter".
Everywhere I've worked, with the exception of Ada mandated jobs, had this code done in Fortran. Yes that includes today. We are today writing new Fortran, and we are not alone. When we request models from the aircract manufacturers, they come in Fortran (or occasionally Ada). Fortran is still, and quite possibly always will be, the language for Scientific Computing.
Suggesting non-CS math and science students learn some other programming language instead is just wrong. Further suggesting that it should be the author's favorite hip new interpreted languge is just laughable.
Where did you get the idea that he's talking about everyone?
All our calculation kernels are still written in FORTRAN 95. They are parallelized using Open MP very easily on a loop level (admitted they are quite easily parallelized problems). This was painless to do in fact.
We do financial optimization (risk, credit, futures and portfolio analysis), electrical optimizations (hydropower, gas power, plant portfolios) and cross-border energy trading. With the amount of number crunching I've done using Fortran (IMSL), C/C++ (Boost, COIN-OR CLP) and Java (with COLT from Cern). I'd say that Fortran was the easiest, most concise, manageable and complete solution.
So yes, teach good fundamentals in Fortran. Great to learn, interesting projects to work on, fast and future safe (50 years and counting)!
There was a point in my graduate career where all the students in the class were asked if anyone knew fortran, only one student raised his hand. Not that the other students couldn't learn it, but the student that already knew it, had a great advantage. Python and other newer languages may not always be in vogue and may eventually be defunct, while fortan will always be a rock solid foundation.
I have seen several arguments above regarding the speed of Fortran. Sure, its faster. But speed is not the point. The majority of these undergraduates aren't going to be a position to benefit from the speed. They are doing homework and projects, not optimizing a serious computational problem.
Simply put, python is much better at handling all of the non-numerical work and good enough at performing the numerical work. Where it is deemed too slow a method could be reimplemented in fortran and almost trivially integrated into the existing python program. Heck, f2py is even integrated into Numpy at this point:
http://www.scipy.org/F2py
So all the students should learn python and your serious thinkers will learn fortran as well and only occasionally be called on to use it.
Another argument one should consider is that python enjoys broad adoption across many scientific disciplines. There are active projects for practically every discipline. The Fortran material seems to be less accessible or isnt shared as broadly. Having a helpful community is useful.
A benefit of python's adoption is that it has interfaces to many other programming languages. For example Gnu R and MATLAB. If fortran has any integration with these, I would bet that its not as extensive and actively maintained as the python interfaces.
im a 4th year math student soon to be grad student
and i was not taught fortran had to learn it on my own on the fly
really wish i had been taught it though
there is a huge code base out there for various types of models
and recoding all that is just pointless and not to mention stupid when fortran is the fastest for it
i mean some of these simulations already run for weeks or days on numerous computers at a time
do u really want to slow that down or take the hit in over head from other languages
No. No. No. and No. We already learn enough useless theorical stuff at the university let us at least learn something usefull in the industry in the few practical course...
You have to teach in those very few practical course the bit that will be usefull right out the university. If you really do need fortran (in the case you go on specific area of specialisation/research) you'll learn it on your own easily because of the basic understanding you'll have of other language.
stop teaching stuff only usefull in very narrow field or research !
I had to suffer with Hollerith so why shouldn't they.
Uh, just a point of note, I believe my TI-89 from high school in 1999 solves partial differential equations. Hell, I think Mathematica could do this when I used it in college in 2003.
:-) ;-)
-Posting anon as I've moderated.
I did my PhD in mathematical modeling......
Which algoritham do you think *I* trust most to give the correct answer to the squillianth decimal place..... The one in your TI-89, the one in Mathematica, or one proven bombproof since the 1960's ?
Which one do *you* think will be the fastest to run?
Thought so
How did we ever make progress with people like you around?
Change for changes sake (esp in mathematics) does nobody any good.
Show me better code, and we WILL use it. We're not masochists you know
FORTRAN is much better at very large and very small number calculations, and it seems to keep the significant digits and all in play, and is able to deliver output in a nice form without much work, its best they keep on teaching it. I know we would all like to see students learn python as a requirement, but if they have to replace one to do it, this is certainly not the one to replace.
Freefem++ (GPL code) however is C++ and solves PDE's by writing the weak formulation. I never saw fortran recently.
Even the famous VODE fortran code to solve ODE's has been rewritten to C++. It's now called sundials (BSD code), and guess what, there is a python implementation, pysundials.
IMO universities should be teaching core principles and methods, not attempting to impart up-to-date job skills.
IMIO, Fortran is not about "imparting up to the date job skills" as much as showing students a powerful tool to accomplish a high-level task that they'd otherwise have to learn more programming to do - and that takes from time spent with the science they are trying to learn.
Just because something is real does not make it a "trade skill" with al of the scorn you heaped upon it bountifully.
"There is more worth loving than we have strength to love." - Brian Jay Stanley
Python may be great for serial processing, but when it comes to massively parallel computing, fortran is still king.
Maybe when MPI-aware Python gets out of Alpha stage you can dump fortran. Until then I don't think you're going to see much python running on the world's supercomputers.
-----BEGIN GEEK CODE BLOCK----- Version: 3.12 GIT d? s: a-- C++++ UL++++ P++ L+++ E- W++ N o-- K- w--- O- M+ V PS+ P
Having taught CS (and non-CS) Undergraduates I have to say that you should teach Fortran...or Python. They should be taught some data representation, basic algorithmic design and how that might be used to develop programs. If you teach them a language, you're almost always starting from the wrong point. At least, that's my experience.
I'm an engineer with a large aerospace firm. All our major programs are in Fortran and have to be used, modified, and maintained. I remember a few years ago we hired a new grad from MIT; she had studied Basic, Pascal, and C; so of course we had to teach her Fortran so she could do her work. The engineering world is heavily dependant upon Fortran, and to not know it puts you at a huge disadvantage.
The only way Fortran be taught to undergraduates is if they have a corporate sponsor that have agreed to hirer some if not most of the graduates. Why? Because the all jobs I have seen posted for Fortran is to replace the guy that has been doing the job for the last 35 years and HR thinks they need a replacement with 5-10 years or recent experience. What is the point to learning Fortran if you can not get a job using Fortran, and all the jobs that require Fortran tend to need mutli-years of experience in Fortran.
Reminds me when I applied for a job as a Java Developer... long ago. I did not even get an interview so I phoned the HR department and ask why not. They said that they needed someone with 10 years of Java experience. At the time the earliest publish book on Java was only 7 years old. I asked how the company was able to afford the an inventor of Java. The HR seemed dumbfounded by my indications that if the person they hirer claimed 10 years of java experience they where lying to them.
I have seen many stupid moves by bureaucratic HR personnel and trying to learn Fortran in school then finding a job is backwards. Either claim you are a Fortran expert and learn on the job or join a company and a result of drawing the short straw become the company's Fortran resource (learning on the company's dime). I have found my programming skill translate over to any language - the underlying principles are basically the same on only the syntax and structure changes. I have learned new languages in a week and was able to efficiently work on large teams with individuals with years of expert knowledge in the language. Schools need to teach the underlying programming principles that can be adapted to any language - that way the company you work for can training you in their preferred language and expect that you will be some what skilled and productive.
That said, what this article should have tackled is, what do we want to teach engineering students about computer science? Right now, they take a class that teaches them C++, Java, Python, or whatever. They get some procedural programming skills with maybe a little tiny bit of object-oriented stuff (without really covering OO fundamentals IMHO, which are a more advanced topic) and they are thrown into a world where they are writing code in C for embedded controllers or Fortran for computational codes. As a result, there is a huge body of code out there written by people who know how to get the job done, but don't exactly write code that is very maintainable. They relearn the lessons of CS he hard way over 10-20-30-40(?) years of experience. Are we really giving these young students (who are not CS majors) what they need? What kind of curriculum would be ideal for someone who is going to end up writing code for something like a robot control system in C?
That is totally the core of the question. How can the body of CS be distilled into something that would improve the base of code coming out of hard sciences? As you say they learn enough to produce working code but possibly not enough to design an API well or have really robust code, especially in Fortran... a lot of these guys are going to intro to programming courses but there needs to be some glue between that and the practical stuff they do later.
"There is more worth loving than we have strength to love." - Brian Jay Stanley
Python is a scripting language. FORTRAN is a language for high performance computing. Engineering, Physics, Chemistry need high performance computational tools. Has anyone ever tried performing Molecular Dynamics simulations in Python? I didn't think so.
Except I'm pretty sure that there are modern languages and libraries that can handle this without Fortran. I don't have much experience with it myself, but I'm pretty sure that's exactly what MATLAB is for, for one.
Dude, what do you think the libraries Matlab uses are written in? Check out netlib to get an idea, ATLAS, BLAS, LAPACK, LINPACK, etc. Matlab stands on the shoulders of the giants of scientific computing (implemented for the most part in Fortran).
What does it mean to be "taught" FORTRAN? Does this mean that students are merely exposed to the language from a historical perspective, maybe asked to write a few simple programs, and then offered notions about the benefits and drawbacks of using this language? Or does it mean that they have to craft complex programs to solve difficult engineering problems, thus displaying their mastery of the language? There's a big difference between those two objectives.
I think that every computer science student should at least KNOW about this language, what it offers, and the drawbacks of using it. A language is a tool... and even ancient tools can frequently be applied to modern problems (everyone remember that whole fulcrum/lever thing?), so discounting FORTRAN, simply because it's an older language, is simply "linguistic ageism" and is not a conclusion based upon sound logic.
If anything, a university should be teaching about how to find the right tool to do the required job, regardless of the age of that tool, and how to apply sound reasoning in making that selection. Any programmer can learn any language... the point is to optimize your learning, coding and debugging time in an effort to solve the problem that needs solving. When we start discounting tools because they are "dangerous" or "too complex" or "lacking in strong typing", then we're presupposing that we know better than the talented artist that we hope each programmer will be.
It seems like fortran would be an awful choice, sure it's fast and lots of big-deal libraries use it, but who cares?
Firstly, it's not as if you can't call fortran libraries from another language (matlab anyone?), secondly, if you learn to program, and become a professional, then you can learn another language. I don't think there's too many people out there who honestly find it easier to program in fortran than ${ANY_OTHER_LANGUAGE}
I've always felt C and C++ to be ideal intro languages, they are fast on their own, they very closely represent what is happening on the CPU (pointers, they're easy enough to optimize by hand) so as a student you get some good insight into how the computer actually works, and they are much more similar to modern languages (matlab python php etc etc) than fortran.
Furthermore, the speed of the language isn't the only thing that matters, if I'm writing stuff for in-house processing, and it takes me a month to write it in fortran, and a day in python, I don't really care if the python is twice (3 5 10) times slower, because my calculation will still be done faster. Furthermore consider the time it takes to debug matlab/python vs a compiled language like C or fortran, matlab and python (or java, etc) tell me where and what the problem was, as opposed to "SEG FAULT" 5 hours into processing.
And what happens when I decide I need to change my code? Attempt to decipher fortran or C, rebuild it, test it, sic it on my huge dataset and hope all goes well? Or just edit a text file and have things work.
Not to say C and other truly compiled languages don't have their place, I still use them for my biggest of big data, and I know in a lot of fields (let's take particle physics for example) the data is just too big to do in anything slower than C.
But for teaching first year students, a language that they can understand, will be useful to them, and will give them a taste of what they can do with a text editor and compiler/interpreter is what's really important. Teaching fortran like that seems like early optimization, and we all know where that leads.
Ze Atomic Device! It iz Ztolen!
They should be taught Fortran by screaming lifers to save them from a life of static compilation.
org.slashdot.post.SignatureNotFoundException: ewg
I regularly find myself compiling scientific applications that were written in fortran. Which means that plenty of scientific software development is still done in fortran as well. Even if the students aren't going to write their own software, there is a good chance that they will at some point need to be able to install scientific software, and a little basic knowledge of fortran can go a long ways towards understanding the snafus that they will likely encounter along the way.
That is in no way something of insignificant value in addition to learning the basic logic structure of a language like fortran.
Damn_registrars has no butt-hole. Damn_registrars has no use for a butt-hole.
... You're WAY behind the times.
I got a buddy who is an astrophysicist and worked at NASA, and he tells me his department ditched FORTRAN years ago in favor of Python+Numeric.
I hear you about the need for badass number crunching tools. It's your assumption that only FORTRAN fits that particular bill which is erroneous.
Not to say that FORTRAN doesn't have its use. It's just that other tools have since become better at some of those.
Python Numeric homepage. Check it out.
-- B.
This sig does in fact not have the property it claims not to have.
Only if they misbehave...
Most physicists I know have moved onto C++ code. At least I know they use this at the Brookhaven and Tskuba Particle Accelerators in Long Island,NY and Japan respectively.
The reason why universities teach fortran still is because it is very simple to learn. My roommates were taught it and they had trouble with the language. I couldn't imagine trying to teach them a more complex language. The most important thing about learning your first language is not the actual syntax, it is learning how to think.
I feel that they should only be taught one or two languages that help accomplish their projects and goals as physical scientists. Only computer scientists and the like need spend so much time with languages that enforce low-level concepts like memory allocation. If a physicist wants a program to be more efficient, he should hire a computer scientist!
Yes for FORTRAN, but no as a first language. Hi, students of Physics and Chemistry here in Cracov Poland also are learning FORTRAN somewhere on first or second year. I think it is horiblle language compared to modern ones, but it is really fast, and libraries are really robust. So FORTRAN is needed, but i think most times students should write C code which talks to FORTRAN libraries, this is simpler. And FORTRAN shouldn't be first language teached. I opt for Phyton, it is so easy to learn complex aplications. I also personally like D. :)
I think ODE is going to be one of the simplest case of numerical library. I can simply copy algorithms from Numerical Recipes and get away with it. But, there are a LOT more written exclusively in Fortran that you don't want to touch with 10 foot pole.
For example, you should know R and why R does contain some Fortran libraries, especially BLAS and LAPACK. I think BLAS is the easiest one to translate over albeit tedious. It's simply matrix operations (add, subtract, multiply), but there are lots of them with multiple cases making it really fast. LAPACK (and other associated libraries like LINPACK, etc) requires a more intimate matrix theory. I have the necessary background to do, say, Singular Value Decomposition (SVD). But to date, the only fast SVD routines I know are in Fortran or derived from Fortran, ALONG with quirks and limitation of Fortran 77. Don't believe me? Check Jama's SVD routine and how it doesn't handle matrices with number of columns greater than number of rows with only one pass. You can get around that by invoking the routine twice (and believe me, that happens in a lot of places although 1 pass is possible), but that's partly due to the limitation of Fortran 77 of not being able to dynamically allocate arrays. The routine is so tight and fast that the option of translating it to other languages depend on the luck of machine translation (and making sense of it and try to clean up the mess, yada yada).
You have no idea that many of the libraries in the 80's are still in Fortran 77 and left untouched. Try Netlib (http://www.netlib.org/liblist.html) and try to pick one Fortran library and translate it to another language. See if you don't cry river. Believe it or not, many of them are still in wide use, usually as a part of other newer algorithms. I myself have done that. For example, a B-spline shrunk smoothing library of GCV (downloadable from Netlib) from 1985 is known to have a very good result. It's not your usual (and cheap) B-spline smoothing that you can find off the net, it's almost heaven-and-earth differences. This GCV is used in Q-value routine of 2003 to determine false discovery rates by smoothing over the P-values of thousands of genes. Nobody has tried to translate that off of Fortran. I did a daring job and spent 200 hours to translate that one library to Java with success. If I had the option not to do that, I'd rather spent 200 hours somewhere else and use whatever Fortran-Java glue to get around it. Seriously.
So, if you've never been into serious scientific library development, please don't make such arrogant and ignorant assertion. Although you can assert that Operating System is complex, the principle behind it is simple. Much simpler than a scientific formula, which requires much more math skills than just Calc1-3 and DE1-2. It's not simply translating differential or integral or what have you, that's the easiest part if somebody is giving it to you. The hard part is to read the scientific paper behind that Fortran code in order to try to make sense what the code is doing. Many of the algorithms contain some hack that makes the formula work. For example, certain algorithm define limits, magic constants, assumptions, etc that are NOT explained anywhere in the paper AT ALL. Some can be found from the papers cited by that paper, with reasons that might be unclear to you. Now, if you translate the mathematical formula off of the paper without reading it, wouldn't it be a recipe of disaster?
Many people may be gifted in coding, but very very rare have sufficient skills to translate highly numerical algorithms. Seriously. Most coders know absolutely nothing about higher-level maths. Netlib is just a start. They only contain algorithms of the 80's and early 90's (which are still widely used). Even Numpy uses plenty of untouched Fortran codes for its backend.
This ignorance of gigantic proportion of yours needs to stop. Now. If you still cling on your assertion, start an open source project that translates gigabytes of Fortran numerical library into a more modern language. See if you can even get some contributors. Good luck.
--
Error 500: Internal sig error
Sure, make undergraduates learn to implement theory in as many languages as possible. Teach them the theory make them learn that the language is irrelevant.
I'm a graduate student in physics and let me say that I feel that I've been able to go further and do more with my degree because of my knowledge of Fortran. There is a TON of code out there that is in Fortran and will always be in Fortran. My first undergraduate job was doing optimizations on 30yr old Fortran code. My current research uses about 30K of Fortran code.
I'm not a big fan of the language, but for the stuff we're doing, it works well and reliably and fast, so there's not much incentive to move to anything else.
Of course, it's completely dead from a CompSci perspective, so those students should be spared.
Forget Fortran, forget Python
In my university I teach MathLab ( or Octave the GNU version) to students of Physics, Chemistry, Engineering. If you are not from computer science you probably hate programming, so it is better to use a more user friendly environment. With MathLab/Octave
MathLab has a large set of libraries. It is easy to plot charts, do statistics,do matrix operations and the language is very simple (C like without types).
A simulation can be up and running in no time. Other languages require too much knowledge in CS to be useful to these people.
For the more experienced users, it has C, java and python bidings.
I'd imagine C would be more useful. I went through a graduate program in CS and took several classes cross-listed in the Computation and Applied Mathematics program, as well as some numerical methods classes in the CS dept. We had to link with Fortran occasionally (BLAS), but we always did it from within C code. Just have to make sure your two-dimensional arrays are laid out correctly (i.e. column major).
I believe science undergrads should be introduced to a few languages. A quick list of the languages I would teach:
1. Fortran
2. Python or Visual Basic
3. Maxima or Mathematica
After introducing these languages, I would have the students do a few programs in each language. The programs would involve such tasks is data collection, data analysis, and numerical simulation. I would have them each task in all languages.
The result is the students should discover a few things:
1. They can quickly write a program to take in data from various source and do some analysis on that data using a language like Python or Visual Basic. This is appropriate to tasks where computational speed does not matter. Having a computer collect all the data samples from various test equipment that runs one test every second does not need a supper fast language, you just need to get it running.
2. When doing a large number of calculations the Python and Visual Basic languages are a lot slower then Fortran.
Maxima and Mathematica are included to introduce languages that can do symbolic evaluation.
Around my old research lab everyone used Matlab. Fortran is great and all, but most researchers are terrible programmers (think 1 method per 2000 lines of code). Matlab is just easier. Money for a license usually isn't a problem. Octave is available if money is a problem.
They should have it in the computer science curriculum too. I was upset when I found out that it is no longer taught by my university's Computer Science department.
In principle, you can solve any programming problem in any complete language. But why not take the right tool for the job? Fortran is suited to numerical analysis and is highly optimized for it. Python isn't, nor is Java, nor is C++. In particular, if you are doing numerical number crunching, you do not want object oriented crapola getting in your way. OO is great for the vast majority of standard programming problems, but it is a hindrance in a lot of scientific and numerical analysis tasks.
Here's an example: you are analyzing radar signals. These come in as a continuous stream of numbers, which are packed into arrays and analyzed. There are no objects yet, just lots of numbers to crunch as quickly and efficiently as you can - and that's what Fortran is good at. Once you have identified airplanes and figured out their distance, speed, etc - then maybe you want to pass these on to an OO module written in another language.
Enjoy life! This is not a dress rehearsal.
Seriously, force all undergraduates to learn at least 4 programming languages.
[signature]
They should teach PHP because it is the strongest programming language right now.
OK, OK.
Fortran is old.
But Python? Are you serious?
pffht.
The question was very specifically aimed at physics, chemistry and engineering students. I can't speak for engineering students, but I know that in physics and chemistry virtually all useful software is written in Fortran. All the code works perfectly, so why rewrite it? Not only does it work, but it's fast (Fortran code almost always outperforms the best optimizing C compilers). The difference between running a 3-day simulation of Fortran code vs. a 4-day simulation of C code (plus whatever development time there would be) can come in handy sometimes.
The Elders feel that if they had to go through it, so do the young'uns gol durn it!
Seriously, though - as far as I know, Fortran has always been the language of those humonguous numerical models because of its optimizations with regard to array handling. I think it makes perfect sense as a first (or second) language for science majors. However I imagine the person asking this question is likely one of the young'uns being forced to learn it; and that person doesn't really have the perspective as to *why* this is so. After all, he's been hacking around in C and Python for years - they're in his comfort zone and have been good enough for the sorts of things he's been dealing with.
#DeleteChrome
Same here. Pascal was the primary language used for the CS degree track. This was back in 1990 or so.
Personally I didn't care because when I got to college I had already been programming for almost 10 years and knew a whole bunch of languages. For me, college was just a bunch of bullshit busy work so I could get the "worthwhile employee" stamp (actually that pretty much sums up my entire scholastic experience).
I'm a scientist who does the bulk of his programming in Python. Numpy (the numerical package for Python) runs at only a 30% overhead over C. When that's not fast enough, I drop into C/C++ for bottlenecks and wrap that back into Python (using the Python C API more often than swig/boost). When there's a great Fortran library that's fast and battle tested, I wrap that into Python using F2Py--and I don't even know that much Fortran.
Just like it's good to know more than one spoken language, it's good to know more than one programming language. It's a mistake to think one programming language fits all needs. That said, it can also be helpful to know one really well, and others enough to convert them into your primary language. For me, Python fills that role very adequately, and I would highly recommend it be a part (read: part) of the undergraduate programming curriculum.
Many years ago I did a real-time military radar simulation using a flavor of Fortran. At the next job, I helped build a stratigraphic wellhole analysis package using Fortran. At the third job the team built a package that predicted thermal, radiation and other propagations through hardware, wetware and urbanware. At no time was there more than 4 people in the development team. Fortran has done serious work over the years, and people forget there's more to life than the GUI.
Back when I was in college, I maintained a Fortran77 program that was a custom built TCP/IP client-server system. But wait! F77 didn't know what a socket was! right. The network code was written in C and compiled into object code which was directly linked into the F77 project.
Great. So there are these massive libraries written in Fortran to do wonderful things. Best case scenario is you can link them directly into your language of choice. Worst case, call them from the scripted language of your choice with a wrapper
Bottom line? Program in what you are comfortable with. Would your peers would frown on your efforts if you learned anything but ALGOL? Fine. Use ALGOL. There are valuable lessons to be learned in any language. Strong vs weak typed, functional vs object oriented, structure, best practices
The surest way to corrupt a youth is to instruct him to hold in higher esteem those who think alike than those who think differently. - Nietzsche
"Glory is fleeting, but obscurity is forever." - Napoleon Bonaparte
Since this is not the place to find actual engineers, it's not a surprise that no one has pointed out one of the primary rules of engineering: "Minimize Innovation."
FORTRAN and the vast mathematical and physical libraries that come with it have been tested and matured over a period of decades to create an open-source, highly dependable, essentially error-free framework for mathematics, science and engineering computations. We teach FORTRAN because it's the only language that meets that spec and because open-source is useless if you can't understand the source language.
The intent is not to develop programmers but to give mathematicians, scientists and real engineers a working knowledge of a vital tool.
I'm a Programmer. That's one level above Software Engineer and one level below Engineer.
They should also learn Latin and Sanscrit
Every time you call tech support, a little kitten dies.
When I started working at Kodak in 1983 I had to use a Tektronix Basic computer with 32k memory and 8-in floppy drives. The language would only allow variable names that were two characters so you would have names like V9 or A2. Of course after a while you ending up using I1 and O0 so on a dot matrix printout the code was unreadable. On a PDP-11 I used FortranII. If the program was too large I would get "Fortran Start Fail" error messages and would remove lines of code until it ran. Occasionally I would have syntax error messages like "Error 142 on line 629" and find that there was no line 629... (Insert Twilight Zone theme here.)
Sorry, but gray text on gray background is making my eyes bleed.
It's definitely not a language for amateurs in the sense of people who like to fiddle with the system, are interested in how the compiler works, or who just want to make gee-whizz web mashups. It's a language for people who don't care a rat's *ss about computers or programming, but who need to get their calculations done without wasting time on fiddling with pointers and who need reliable answers without being bitten by silent array-boundary overflows to boot. So Slashdot might not be the best place to ask for an opinion.
Besides, most of today's numerical libraries (BLAS, LAPACK, ATLAS, EISPACK, FFT) are written in Fortran. If you want to use them, you could do worse than learn Fortran.
True, it's not a language you'd want to do sophisticated datastructures in, or tree-searches or text-processing or payroll accounting or database manipulation. But especially chemists (and to a lesser extent physicists) have more call for numerical software than they have for non-numerical software.
So no. It's not at all ridiculous to teach Fortran as a first programming language to non-computer-science students. Alongside Matlab (or Octave or Scilab) it will do fine for chemists.
As someone who has actually helped to teach Fortran at the university level (I was TA for the course, just this last semester), here are two reasons I think Fortran is still useful to teach:
1) It's still relevant. As others have pointed out, libraries have been highly optimized over decades of use and reuse, and it's hard to throw that legacy code out for a newer language, especially when there is no benefit to doing so. In many cases, you would actually be trading better performance for worse, even, and when you're dealing with things like weather models or geological simulations, raw performance means extra/better information. So, much as I may personally not find Fortran useful and wish it would go away, the fact of the matter is that there is plenty of legacy code around that has been kept around for a good reason. Before I ever worked as a TA at my university, I interned for two summers at Lockheed Martin Space Operations working on, guess what, Fortran code that was being used for meteorological purposes (the code had edits that were initialed by my office mates from before my birth, which was an odd experience, to say the least).
2) It's a good place to start. It may not take up the mantle of OOP like Java or even C++, but Fortran is a great starter language since it is syntactically very simple, which lets the students really dive right in and not worry about getting hung up on things like semicolons or curly braces. Having TAd C and C++ in previous semesters, I cannot tell you how many concepts students simply misunderstood or never used because of the fact that they were still struggling with syntax. While all of these things are painfully simple to you and me, remember that these students are coming from a place where an if statement will take a day to explain, and arrays are pushing them pretty hard at the time.
As a very quick example, I probably had dozens of students out of the 130 in my last C/C++ class use the phrase "if loop" at some point in the lab or in office hours, since if and while statements look very similar syntactically. In contrast, I never once had that issue with the 50 students in my last Fortran class. To go along with that little fact, in the C/C++ class, it was not at all uncommon, despite frequent correction, for students to persist in trying to misuse an if statement as a loop, but I think I only saw that attempted once in the Fortran class, simply because the syntax between a loop and a conditional is so drastically different and dead simple.
When the language is simple syntactically, it means that they can focus more on the concepts and less on the language, which is really the ideal situation. I had more students who took Fortran come to me at the end of the semester, express an interest in learning more languages, and ask what additional or more advanced courses they could take, than I ever did when TAing C and C++. And for an intro-level course, the concepts are really the important part, not the syntax, since you want them to be able to take what they learn and apply it practically, whether that means Excel macros or just the ability to communicate an idea logically to a developer.
---
Fortran and I have a love-hate relationship. Compared to more modern languages, it's not as pure, it's not as easy to program (for someone from a CS background), it's not as convenient, and it's not as concise. All of that said, it still has raw practicality going for it, as well a low learning curve and continued widespread use, which makes it, in my opinion, great for teaching to students in related fields. It's hard to make a decent case against Fortran. Even so, my university has cancelled the class for upcoming semesters, so, after decades of being taught here, this last semester that I TAd really IS the last semester of Fortran at my university, period. Maybe they know something I don't.
This often comes purely from what the teaching faculty knows... which causes a lot of teaching of excel (+ maybe visual basic) too. If you don't know it, you can't teach it.
The Intro to Programming course I took at Indiana University (a few years ago) taught the basics of programming in Pascal followed by 2 weeks or so of FORTRAN. Both languages are primitive compared to modern languages. But I learned the basic idea of programming, which is still exciting to me, and the lesson that learning a new language is not so difficult and well worth the effort.
I used both languages as an undergraduate: FORTRAN in part time jobs in the chemistry department and Pascal for an undergraduate thesis project.
I'd like to give a plug for Javascript as an intro language. The language itself (not the browser DOM) is extremely simple and surprisingly powerful, with OO, C syntax, type, functional, and imperative aspects. Perhaps a version with an integer type could be used for practical considerations.
In my opinion the current practice of teaching Java to new students is a mistake, but then again I think any use of Java is a mistake.
Verbum caro factum est
Interesting. I just retired after 30+ years as a software engineer at a large R&D lab. For many years now, the overwhelming majority of people we interviewed for jobs had learned Matlab in school, not Fortran or any other language. This applies at the undergraduate level, Masters, PhD, and post-docs. I can't think of a single resume that mentioned Fortran. I wonder what schools the author is thinking about?
I learned Pascal as my first programming language. As far as I know, Wirth specifically designed it for teaching. Sure, it doesn't provide low-level hardware access as C does, but it enforces good programming practices by not giving a programmer as much freedom. However, nowadays it is hardly used anywhere, so I would probably recommend C++ or Java as the first language to learn. My school chose Java and I think it is was a good decision, mostly because for a beginner Java code is much easier to debug in a good IDE (as opposed to C++).
You cannot (well, actually should not) do it in pure Python, but even today, there are very few people working in pure Python systems (PyPy is the only project I know of). Python is a language that allows easy use of functions written in other languages, including C, C++, Java, C#, and FORTRAN. Yes, more easily than in native C. See The NumPy and SciPy and libraries for access to massive piles of FORTRAN libraries.
I've run 4-day programs "with Python" where total execution time of the Python interpreter (if measured properly) would
have been less than ten minutes of execution. Python manages the calculations well, but the actual array processing was in a blend of C and FORTRAN (and, no, I neither know nor care what the mix was there).
Engineering still uses a bunch of Fortran. It may be called from C or C++, it may be standalone, but it's all still there.
It even optimizes better than C and C++: there are no pointers to muck up the alias sets. The language is very simple and well-defined, and that makes the compiler very, very happy. And reliable, you don't get into this "oooh, you assigned to a float from an int pointer and that breaks the ANSI Alias Rules so the compiler trashed your code for you".
It may be a bit clunky, but it is well-defined. (Compare the rampant "implementation defined" behaviours in ANSI C++....)
Sun's Performance Library is Fortran. IBM's ESSL is in Fortran. (Both are derived from the famous BLAS and LAPACK libraries.)
Fortran seems to continue to be the standard in aerospace engineering. I think that anyone getting a degree in AE should take the time to at least familiarize himself/herself with Fortran.
'nough said.
A good portion of the *tested* and *reliable* scientific computing libraries, in http://www.netlib.org/ are written in... yes you guessed it, FORTRAN. Sure some of the code there is in some of those other languages, but most of them were machine-translated with things like f2c. (Also, NAG and IMSL code is in FORTRAN)
To paraphrase Twain, efforts to get it replaced are frickin' exaggerated. Maybe the author should try rewriting LAPACK in his favorite language. :P
Ballmer:
So I got these girls in the other room, and they're naked, I mean like gorgeous naked, and I told them you were making a computer language, and they started moaning. Oh computer language, Fortran, ohhhh Fortran. So don't say I never did anything for you.
Gates:
Drop dead Ballmer...
For a Freshman seminar (now 12 years ago), we used Fortran 77 because that was the last version that GNU had (at the time) a compiler for. We were doing really simple modeling, and the limitations of a then 20 year old language weren't a problem, we weren't building UIs, just crunching numbers. Fortran 90 cleaned up most of the Syntax and made it as friendly as Pascal, which is probably the cleanest teaching language for it's simplicity. Later version supposedly added object oriented and other modern niceties.
Wrapping Fortran in Python seems simple enough, the languages are all fundamentally the same. But if you leave your logic in Fortran for sciences, where you have 40 years of libraries, you can certainly use Python to build a simple enough UI, but why NOT learn Fortran, it's damned simple, works, and teaches the basics. All the modern syntactic sugar pulls away from the basics of programming.
Ok here goes:
Should science undergraduates be taught Fortran? Yes
Should it be the FIRST language, NO, not any more
So much of science, especially physics, is done on computers now - as both a software engineer and someone transitioning into Physics I ran into many people that had severe problems learning FORTRAN and applying it to problems. I really feel science students should have a couple of general courses in programming in C before moving on to other languages or even programming classes specific to their science. Here's the reasoning:
A) Science students need to learn programming basics away from the pressure of also learning within their science field at the same time - if your learning the science at the same time, the actual basic programming concepts get lost and muddied with the science being learned.
B) It can allow a science major to learn the concepts of programming in a general purpose language without muddying it with a lot of OS specific, library specific, attitude specific usage (aside from the compiler use)
C) There is a C compiler on almost every system you will most likely use in your lifetime as a scientist
D) C has enough structure to be "readable", but doesn't have so many constraints that it has problems being fast
E) C syntax is the basis for many other programming languages including Python and Java (both of which are heavily used in science as well)
and finally if a science major has a good understanding of programming concepts they can know what to look for when they're learning a new language (whatever it might be) - they will know that they have to learn the syntax for control structures in the new language (for, while, if, etc) as well know they'll have to find out more esoteric language specific concepts like how do I create functions and libraries? How do I use them?
ALL THAT being said, yes FORTRAN is a critical language to know with the sciences, because of the availability of libraries. HOWEVER, many of those libraries are now available in other languages and/or can be called from a different language via an abstraction (a concept that would be taught in a more general computing course)
It's ok to teach people who are liable to be working with FORTRAN, how to do FORTRAN. It's one of the better tools for certain tasks.
However I wouldn't include computer science people in on it. Computer Science shouldn't be about learning a language, it should be about learning a paradigm. FORTRAN is therefore a subject of curiosity, rather than a subject of study.
About 10 years ago, an industrial firm asked me to review converting from its "obsolete" FORTRAN code to C. This company used many-dimensional matrix and linear algebra to solve for the correct solution in its physical processes. And, yes, I wrote much of that code. I re-wrote the core calculations in C, using the libraries available at that time, and compared the results. The C code was slower, but the solution results were also significantly different. When I plugged those results into the process simulator, it caused a (virtual) violent reaction. That review ended with "... and people could die." The firm decided that FORTRAN wasn't so bad after all, and they would continue investing in scientific computing folks rather than general CS majors (as it turns out, saving money on staffing was the real motivator). OTOH, they were very happy when I suggested moving to more modern languages for user interfaces.
Absolutely... I'd rather see the children learning FORTRAN than something awful like .NET or to a lesser degree Java -- I'd actually like to see the whole .NET thing go away permanently...
but in all reality I think c/c++ is the best language to start in because it is in at least some ways syntactically similar to many languages, and is a good introduction to object oriented design. ...or as of late I've been finding objective c to be a worthwhile endeavor.
What do people in the Slashdot community think?"
That almost all of the physicists I know program in Fortran. People trying to do better than "double precision" tend to be fairly conservative about such matters.
I'd only recommend Python to my enemies, but I don't hate anyone enough to suggest that they learn Fortran.
Pure sciences folks would be better served by something like Mathcad or Mathematica, advanced mathematics packages which include reasonably rich scripting languages. No form of "real" software development will serve you well in your core discipline.
Moderating "-1, Disagree" is simple censorship. Have the guts to post your opinion.
I had trouble logging in so I'll do the Anonymous Coward.
A very surprisingly large amount of the actual calculations in software, from car crash simulations, to aerodynamics, to stream flow and groundwater simulation, and all EPA air quality models and weather prediction models use FORTRAN. The user may see interfaces that are written in other languages, but in the guts of the thing, FORTRAN is what drives the model. At some point in the student's Senior thesis or soon after they get out in a real job, they may run into the need to get into the model. Certainly in the atmospheric sciences and air quality areas - you are really handicapped, and your employer is, if someone doesn't know FORTRAN. If you look at the list of top supercomputers a lot of them are spending most of their time running FORTRAN. We had to start a Computations in Meteorology class for our upper level undergraduates and graduate students in atmospheric science, primarily to teach them FORTRAN and how to deal with the multitude of flavors of "standard formats" that data comes in. Our word back from employers is that knowing FORTRAN and C is a definite plus, four B.S. and is virtually assumed for higher degrees.
The languages taught to undergrads need to be driven by industry, period. Educational institutions need to focus on what they want their students to get out of their program. Are they being prepared for grad school, to perform IT tasks, to develop system software/operating systems or to write some other kind of software with different needs. Once you have that defined the choice of languages is very obvious. Some schools are already doing this and the difference is very noticeable when it comes to interviewing candidates with specific skills.
There is a difference between asking what should be taught and what do I personally find useful in my work.
I don't know what should be taught...I am not a teacher.
But I can tell people what I find useful in my work.
It doesn't matter what language Engineers and physicists learn as undergrads, the language isn't what matters. It's the numerical methods that matter.
In fact, I think it's good that they learn FORTRAN because so much of the code they'll work with in industry is written in FORTRAN.
In my first programming class we spent the vast majority of the time learning numerical methods like taylor expansions and how to write them. In the very last few lectures we talked about what OOP did one homework assignment where we wrote and used a class. This was the right way to go because for an engineer, because the mathematics are far more important than the structure.
I've seen aerodynamic, structural, and acoustic calculations where the mathematics make your head spin, but it only takes two or three functions to write the numerical method to solve the equations. This is the kind of program engineers need to be good at.
I work in space science and engineering, and the two most widely used computing tools used directly by scientists and engineers are Matlab and Excel. FORTRAN is still used, but it is used by _programmers_ to solve numeric science and engineering problems.
The only problem I have with Matlab is that it is proprietary. I tried Octave but it just wasn't quite good enough -- there were some things that worked in matlab that broke octave.
I wont say any more about excel, other than it is the most widely used computing tool by engineers, other than maybe powerpoint :)
I started Engineering School in 1988 and we were required to take Fortran. The required text was a lousy, out of date and cheaply published (mine fell apart before the end of the semester) book that was written by the chair of the Computer Science department in the late seventies. The professor barely used the book, relying mostly on handouts.
I think the book was used to keep the prof in royalties.
is like birthday cake without catsup and mustard.
Seriously, it's time for Fortran to die. I'm a Chemical Engineer and end up having to use Fortran for programming custom routines inside commercial chemical process modeling software. I was just talking to one of our support reps the other day, and he deigned to pull out the "C++ code doesn't run any faster than well-written Fortran code" argument. The problem isn't about speed or code execution efficiency anymore, it's about 1) ease and efficiency of programming/debugging, and 2) availability of people who are competent programming in the language. Fortran is an epic fail on both fronts; it had its place, now it's time to cede it to better tools. Python would fill its place nicely for many uses when relatively small programs are required (NumPy is a great numerical method's module for arrays and such.) More powerful languages like C++ are well-suited for larger projects. It should be telling that the authors of the venerable book Numerical Recipes have decided to no longer update the Fortran version of the book and only update the C++ version.
There is a reason FORTRAN is still used heavily in numerical computing. I still develop software I started nearly 10 years ago as part of my graduate program. I looked into rewriting it in other languages and none seemed as well-suited for numerical computation as FORTRAN.
Bands play 'medleys' it when the times have progressed, but the tunes are still a vital part of their lineup, why their fans came in the first place, etc.
If anything it should be taught as part of an "Exploring Legacy Computing 102" course. A little FORTRAN, a little Pascal, some LISP (no threats, please), BASIC, COBOL, as well as magnetic and paper media technologies.
1. Toggle an Integer BASIC interpreter of your own design into the Altair 8800 you wire-wrapped in 101, using the front-panel switches.
2. Punch a master card with a FORTRAN program to perform a bubble sort on the following data set:
2a.: 12, 14, 66, 31, 988, 292, 747, 90922, 1...
2b.: Error-check and reproduce Master until 45 copies can be created with the IBM 514 reproducing punch.
3. Restore PDP/11 from with 2.11BSD from tapes.
3a. How many tracks are available on your tape?
3b. How tracks would be present if you circumambulate the PDP/11, and beginning at the rearmost right corner, affix the tape to the exterior of the machine, with no overlap, with each course at approximately 22 Degrees?
My thinking is computer science programs need to focus on Programming rather than Language I wish they'd teach just one language regardless of what it is, and teach it well. Rather than try and cram 40 different languages in 4 years. Be that language Java, C#, Fortran, LOLCode, etc...
Within those guidelines, which languages should it be? Probably having to do more with the ethos of the Computer Science program in particular. Do they pride themselves on training for math and engineering? Fortran should be a consideration. Business world? Java or C#. To work for LOLpeople...well you get the idea...
...in bed
Objective-C, used by Apple, was originally implemented as a preprocessor on C. During the NeXT computer days, we used to sell Objective-Fortran and Objective-Cobol. Both put the Objective-C's object syntax and constructs on top of the base language while being backwards compatible. It was an interesting way to update a language.
I wish there was a repellent I could use to keep away all the python fan boys. I think a course in the history of programming languages would be a valuable addition to the curriculum and, in such a class, do some programming in Fortran, Smalltalk, Ada, Algol, and so on. In a 101 class, teach something practical. As ugly as it can be, something as simple as javascript can be used to illustrate a lot of concepts in programming and is useful to most people who will never write anything more than a greasemonkey script.
What I got from the article is:
The most telling points in the article are:
In other, he knows a lot of people who are now working out of their degree field and aren't using the programming language they learned specifically for said degree field. Apparently, this is his justification for suggesting the removal of FORTRAN programming from undergraduate science and engineering courses.
Here is a neat idea: If you are going to work in IT, get an IT degree so you will know IT things. Don't get a physics or chemistry degree where you will learn things specific to physics or chemistry then complain that those degrees didn't prepare you for your career.
I will give him one point. It may be worth while to have an intro to programming course that uses something a bit simpler than FORTRAN, but if one is going to be doing serious science and engineering (you know, what the degree is about) one should be required to learn FORTRAN.
There is no "-1 offended" or "-1 you don't agree with me" mod options for a reason.
Should undergrads be taught FORTRAN as an intro language? It depends.
If the purpose is an intro to programming, then the answer is a resounding "NO. NOT EVER." FORTRAN really has no place in a modern programmer's toolkit.
However, if the purpose is to give a certain class of physical science students a 'quick-'n'-dirty' tool to write computationally-intensive applications as research or scientific problem-solving aids, well... I'm not thrilled, but okay. Just beware if any of those students go on to do any more serious programming, because the worst thing in the world is a software developer who thinks like a FORTRAN programmer. And for God's sake, at least teach them some proper functional programming methodology with it!
I work for a company that has a very substantial base of FORTRAN-77 code that is actively maintained. It's UGLY -- but that's only partially due to the language. It makes heavy use of global data structures, and violates just about every rule of good programming -- even good FORTRAN programming. I don't even know why it's written in FORTRAN, since it's a financial app & therefore one would think COBOL would have been a better choice.
Bottom line -- it's okay to teach someone to use an outdated tool if it suits their needs. Just don't neglect to teach proper tool safety just because "it's only a hammer".
I'm the developer in a Google Summer of Code project that integrates Fortran support in Cython.
Cython (http://cython.org/) is a project that takes a python program with partial type information ('cdef int foo', 'cdef char *str') and generates a C file that is compiled to an extension module. It is possible for Cython to generate pure C code for the hotspots, all while keeping the nice python syntax. It can also call external functions very easily, so you can integrate other libraries as long as the compiler can link it together.
Thats where the GSoC project comes in -- it allows the programmer to take Fortran source code, wrap the subroutines/functions he wants, generates a fortran wrapper and a C header, which can then be called from any C code or Cython and by extension, Python. There's an older project, called 'f2py' that overlaps, but our GSoC project has some different aims, and is focusing on all versions of Fortran -- 77, 90, 95 with full array support (assumed shape, assumed size & explicitly shaped) and support for derived types.
Lastly, there is an entire numerical/scientific community in Python, known as scipy (http://www.scipy.org/) that has all the functionality of Matlab/Octave, with the full power of Python. Scipy has optimized arrays with a very good array syntax. Just like Matlab, Scipy hands off all numerically intensive work to external libraries, BLAS, ATLAS, etc.
So to the OP's question -- certainly teach Fortran, since that is the langua franca of numerical programming and will be for a while. But learn Python, too. They play very nicely together, and its getting better by the day.
I think every undergraduate computer science student should have one semester where he learns a large number of different languages, and has to write a simple program in each one. Every two weeks, you switch to another language. This will give the student some exposure to different language types, and if a particular language appeals to him, he'll remember it.
And the men who hold high places must be the ones who start
To mold a new reality... closer to the heart
Taco docks a jock cock.
A resounding YES to undergrads being taught FORTRAN. I am a graduate student in Meteorology and FORTRAN is alive and kicking in the meteorological community. It is a vital part of many of our programs and models. Perl and Cshell are also very important but I wouldn't be able to do major parts of my thesis without the aid of FORTRAN. The undergrads at my graduate school are required to take FORTRAN (especially if they are in the met program) and they use it in their upper-level core classes. I wish I'd taken the FORTRAN class at my undergrad so I wouldn't have had to catch up during my thesis. Knowing FORTRAN definitely helped me grasp other languages faster.
âoeQuestion with boldness even the existence of God.â - Thomas Jefferson
...if it is instructive or not.
Disclaimer I graduated in 2000.
People get too hung up on this or that language. A programmer is a programmer, either you know the fundamentals or you do not. Knowing the particular syntax of one over the other is pretty limited in the grand scheme of things really I think.
When I started University the standard was Pascal of all things. My second year they changed the Standard to C. Go figure. We also did VB, and in my 3rd year did some Cobol and Assembly. I actually found Cobol a pretty simple and interesting language, though somewhat limited. Practice and theory changed between instructors as well. Some (most) were all horny about programming recursively for efficiency, on my final Cobol project I did just that, and nearly gave the prof a heart attack and he actually took marks off me for doing so... shrug. Assembly was horrible as you can well imagine from it being such a low level language, but it was sort of novel as it is the closest I have come to typing ones and zeros in machine language. Stuff like that also helps tie into other courses like architecture and binary algebra etc...
Anyway long story short a new language comes out every couple of years. A few stick around in one form or another for a long time, but may have limited use. If you want to program you are pretty much committing to learning new languages for the rest of you life as demands change.
Having said that, I don't really program much anymore. Mostly I script in specialized languages to simply make my life easier by automating certain processes, and VB of all things, because that is what is commonly integrated in some off the shelf software. As for application design and development I mostly just find out where something is going wrong and say "fix that" to a vendor. 9 times out of 10 it has nothing to do with syntax or the abilities of a language, but more a misunderstanding of the specifications or requirements or perhaps the process. In any case I am pretty confident that I can take whatever modern language I want out there and in a pretty short span of time be able to use it functionally.
Its just like there are a number of specialty languages out there that will never be taught at any school, so you will either have to have your workplace bankroll the ridiculous training fees from a private training company, or learn it on the job (to buy the software is usually out of the reach to do it personally because of the cost).
Hell I had a friend (mind you he was pretty bright) who bid on a job that required a language he had never used (Pearl I believe). He learned it over a weekend and did just fine. He now works pretty high up in a corporate IT structure. Anyway so far as I am concerned I think I would rather hire someone who has a broad base of knowlege, than someone who knows one language really well. Unless I am getting someone for one contract, and that is the language it is to be written in, then and only then would I take the mono language guy.
As an old Fortran programmer now doing Java work by way of Pascal, C, C++ Fortran is a good base for learning.
I also have taught all of those at a university level so have some context as well as working for many years.
There are several different things involved in the art of programming. The first and most important parts are being able to turn a problem into steps with assignments, conditionals and loops. The data structures are best learned by having to do them yourself. Too many wimpy programmers today have never implemented a data structure, they just use them out of the box, and look for a framework or library solution to a problem rather than having any desire or confidence they can program it themselves. We need knowlegable and confident programmer that use tools reluctantly, or design the tools themselves. Those are the programmers that make the changes.
As to Fortran and teaching it to Math and Science students, my understanding is that Fortran 90 which has restrictions on pointers and a support for parallel processing and a simpler memory mechanism is well tuned for scientific programming. It optimizes better and more easily, has a shorter code/debug cycle and no memory leaks. Just what those scientific programmers need for large scale quantum, high energy and molecular, fluid flow computing. Why teach them a language that is not the best for their type of field.
Of course I feel a good CS education requires learning multiple languages. I don't think you "get it" until about your 3d language. It is not about a language, it is about your ability to work in this virtual computing envirionment with the tools and approaches from all fields brought together to solve the problem.
But Fortran for the audience that was suggested seems more than appropriate.
Everyone should have at least one semester in PDP-11 assembly language.
...and that is that even new folks coming into a modern job may need to support older programs and need to understand the language it is written in. I am not in programming, but as another type of example, my clients run software from the 90's and some of their hardware is at least that old. Having the knowledge of those "obsolete" programs is a necessity.
10 FILL MUG WITH COFFEE
20 DRINK COFFEE
30 GOTO 10
I started using FORTRAN (66 and 77) as a Physics grad. student in the early 80s; since then I've also used C and C++ heavily, dabbled in Perl, Java and Python. As well as developing a lot of code, I've also had to troubleshoot other people's complex systems, particularly C++ and Java. I now describe myself - somewhat tongue-in-cheek - as a "born-again FORTRAN programmer".
Java, C++ etc., are useful for complex applications that are event driven and require independent threads of excution performing many different tasks, but I prefer to avoid these for simple number-crunching tasks unless I need additional layers of abstraction or interaction.
When I write FORTRAN I know what's going on under the hood; I know that memory is not going to be allocated without me knowing - in fact, allocatable arrays are a relatively new addition to the original static allocation model. I can concentrate on the implementation of an algorithm and achieve deterministic performance.
Flexibility comes at a price and C++ and Java applications frequently run into performance problems as they become bloated by hidden activity, particularly where the OS is called behind the scenes (e.g., hidden constructor methods). This is a particular problem for real-time codes where an unplanned trip into the kernel may hurt determinism.
I think FORTRAN still has an important place; with extensions such as OpenMP it has tremendous value for parallel computing on multi-core systems. With MPI it can exploit cluster/grid systems. FORTRAN generally has an edge in performance for HPC codes.
If you're building something from scratch that contains requires numerical computation then consider FORTRAN, if only for computational kernels that are called by other languages such as C++ or Java (e.g., the latter for GUIs, external interaction/communication, with the heavy work in FORTRAN).
Fortran is very important in the world of modelling and high speed computation. When I was an undergrad Fortran was taught for the physical sciences but the computer science dept refused to teach it so it was being taught by some geophysical modellers. I'm not sure that the university even offers Fortran anymore.
However, frustrated by that, the dept of physics and astronomy now has two courses in computational physics (both in Fortran) taught by modellers from the department. They deal with real world issues (well, real world modelling issues when applied to a spherical cow right?). Only one course is mandatory but both courses are very popular.
For myself, I use several modelling programs that are purely Fortran that I've had problems dealing with. I'm glad I did take a bit of Fortran though I am much more fluent in other languages these days. In fact my wife, in the private sector, has proprietary software that they use for modelling digital elevations and gravity fluctuation that is written purely in Fortran as well - simply for speed. Until someone invents a real quantum computer, I don't think Fortran in the physical sciences is going anywhere.
you can write FORTRAN in any computer language...
Lee Smolin, the physicist, writes that "Smart people should not program". He used to program, and at one point insisted that his department continue to teach physics students programming. But then he realized that the needed functionality was either available off the shelf or could be written by lower level people. So he now recommends against wasting students' time on programming.
I graduated from college in 2002. I've seen over 20 different software packages written in Fortran. Many widely-used applications are written in Fortran or COBOL. You're going to see it, so learn it. Also, I disagree with those who want to learn .NET or some other flavor of the month. It's useless to know too much about .NET and nothing about other languages, like Fortran. You really box yourself in for life if you become dependent on a single language. Many students today have disdain for anything but an drag and drop, plugin based system with 15,000 unnecessary libraries. Therefore, they're unemployable to our organization.
Matlab lint (code-checker) recognizes constructs like x=inv(A)*b and suggests you use x=A\b instead. I wonder if it's so smart why doesn't it just make that substitution internally before interpreting the code.
Please don't drink and derive.
Fascism starts when the efficiency of the government becomes more important than the rights of the people.
A program language should be taught on the basis that it teaches the student programming and not that it jigsaws them into the world of business. I student that can transcend languages is likely to be a better programmer anyways, as they'll have more tools and models with which to get a task done. Note that some languages are more suitable than others. For example, Python is useful in the academic setting, where a quick turnaround is important for meeting deadlines and finding solutions. In the business world, languages like C/C++/Cobol/Java might be more suitable for performance or legacy code. That being said, any student interested in programming should be taught languages that are based on different paradigms like structural, functional, object oriented, or shits-n-giggles code (intercal, befunge), that will ultimately enable the student to learn other languages which were not taught, more easily.
My favorite class with respect to this was assembly. It was fairly easy to pick up and taught you how the computer interpreted commands at a relatively low level.
Lets say that you are working on a project to evaluate the effects of theoretical gravity waves through a nebulae. You have a choice
And oh, you have to publish results in 2 months in order to get your next NSF grant.
Yes, the new code might be all object orienty, and you can use the latest IDE to develop in, and you can hire a bunch of fresh young (cheap) grad students that are familiar with the latest python, perl, C#, etc. development and they can bang out thousands of lines of code a day. But are you really really sure that that freshly written eigenvalue routine produces the correct result? Has that new compiler been tested on the super-computer you have limited access to, can it even take advantage of all the power of that system?
I'm not saying that FORTRAN compilers are not bug free, but I suspect that the chances of finding a basic compiler or runtime library bug is lower in FORTRAN then in say Perl 6.
A couple of years ago my son spent some time doing some intern coding work for a private atmospheric research group. The group was/is doing bleeding edge research. My son was helping out one of the researchers in updating code that handled 2D models to 3D models. All the code was in FORTRAN and there was no desire to move away from it.
I think the reasoning was that a student should learn a language with extreme, formal structure, and then later they can learn ones that aren't quite as strict. Maybe that the same reasoning behind teaching students Fortran? At least it's a little more useful than Pascal.
Pascal...I had to learn it early 90's.... On the other hand, what's the point to bore students to death with such languages lacking all the nice stuffs of modern languages? I remember that I learn a lot more by my own playing with graphic library because it was funny, extremely visual. And once you want to make some animation, you need to understand the logic behind buffering, and other basic concepts.
I would rather take a high level language and then I would gradually move to the core. It's like being in front of a car...first you want to drive it. Once you master driving...You wonder how this thing works? I always had the feeling that CS takes the opposite road, first you have to know how an engine works before driving...What you learn has no practical use ( read funny for a teenager) until very late in your study.
FORTRAN is one of the fastest compiled languages around, at least for numerical problems. Using one of the slower interpreted languages around is no substitute. The commercial FORTRAN compilers out there produce very efficient code suitable for commercial, industrial, medical, research and military use. When, and if, Python gets anywhere near that point we can consider it.
Having easy and pretty syntax is not the only metric we should go by. If after a decade or two you can't squeeze out some performance where it counts in a general purpose language, then I believe your language's design is flawed or there is a lack of interest in your implementation. Python really is supposed to be general purpose (as is Ruby), and neither seem to compare favorable against Java, C, FORTRAN or a number of other languages.
You can argue about how performance isn't the only metric either, and I will agree. What's the point of a language if it's too hard to use for anything. But swinging the opposite way is not a solution either, ideally we want both speed and ease. And I am not aware of any specific law or property of compilers that prevents us from having both.
C - advantages: fast, moderately easy to use by ex-assembly programmers, easy to implement a compiler(a single target compiler that is, multi-architecture is hard to get right)
C++ - similar advantages to C, but the compiler is harder to implement. The rest of the bits are neither a clear advantage or disadvantage, just a matter of preference if you like the modular and OO style it has built-in.
Java - advantages: still fairly fast, abstraction makes it easy to improve the performance of compiled code, syntax is easier than C (but harder than Python). The rest of the bits I don't see as an advantage or disadvantage (like the built-in OO support or large library). .. I won't go over my thoughts in too much detail on Python, Ruby, Io, JavaScript, PHP, Lua, etc because it could be easily interpreted as a flame. Although at least some of those languages are special purpose languages, and I think therefor the criteria we use to judge if they are good or not should also be special. If Python was a special purpose language, instead of a general purpose one, it would be a lot easier to dismiss all of its performance flaws. There are benefits to using Python, I'm just not willing to explore them too deeply them until it can meet some basic needs we have for a general purpose language.
“Common sense is not so common.” — Voltaire
I recently graduated with a degree in aerospace engineering and, during my time in college, I was a TA teaching Fortran to freshmen and sophomore (primarily) engineering students. During that time I realized that the objective of teaching Fortran to these students was not necessarily to have them learn the language, but to learn how to think in a procedural manner. Say what you will, but engineering and the scientific process is full of procedures. These kids come in to college not knowing how to analyze, formulate, or even how to follow procedures and learning programming, especially in a language such as Fortran where you don't have a choice, is one large step in that direction. Therefore, when I would teach, I would focus on the program design process rather than the syntax because, as we all know, anybody can learn a syntax.
I realize that the previous argument was more programming-general rather than Fortran-specific, so here's my Fortran plug. It all comes down to this: Almost Every Major Company in the Aerospace Field Still Uses Fortran! Many of my fellow TA's moved on to become employees at NASA, Lockheed, Boeing, Harris, and others based primarily on the fact that they know Fortran. I should also mention that I have a friend in a graduate physics program who uses Fortran for his modeling because of the extreme computer-intensive computations it requires. It's still out there. It's still strong. It's still important.
FORTRAN has it's uses, mostly in legacy applications, but I don't think it's a good language to learn programming in. I'd go with either (object)pascal or Python there. Certainly not Java.
Compare
-------
print "Hello World"
-----or------
begin
writeln("Hello World");
end.
------
with
------
class myHelloWorld
{
public static void main(String args[])
{
System.out.println("Hello World!");
}
}
----------
A language to teach people to program should not have to bother students with class definitions, "public static void" or any of that. I'm no expert on FORTRAN, but what I've seen it isn't stellar either in it's ability to minimize syntactic sugar.
RogerWilco the Adventurous Janitor
If the purpose is to show how a computer really works ... teach an assembly language course ... have the last project be to write a simple device driver. That will teach a person to appreciate what a computer REALLY does!
If the goal is to teach Fortran for modern programming ... not worth it (I can say this after programming in Fortran from '78 - '90 !!!).
I totally agree that Fortran is inadequate for a first language. In fact, at my university, we had to learn C (now some are getting around to Scheme), Pascal (cleaner syntax, etc.) as a first language. Then we get around to learning pointers in the context of data structures and algorithms. This use of pointers is just something you have to go through in life, just like learning your ABC. A little bit of Maude (yes! In the context of specifications) was taught. Applied Math students learn Fortran later, but they also learn Matlab prior or simultaneously. R is learned in statistics. Maple is also used in ODE, etc., classes.
In terms of the article, Python is a very weak choice. You need to learn about pointers. Then, if you need a simple language high-level language for math/physics you should do what everybody does: use MATLAB (sadly, the excelent Scilab is neglected - probably due to it being European and not having the marketing penetrating capacity the MATLAB firm has), use Maple. IIRC, even the Python numerics packages are not on par with its proprietary counterparts, lacking many things. I'm not sure, but it seems to me that in terms of data visualization, Java might be a good choice (C++ being an obvious one). So Python doesn't seem to fit anywhere, in my mind. It has this niche as a scripting language (and some would argue it's not well designed) and it should stay there. As a "glue" language for scientific computing it doesn't achieve much, it seems. At least, it seems there are other options that deliver more speed, more features, more power (want abstraction + foreign functions interface? I'd do Common Lisp) and, thus, more productivity. In fact, were it not so, Python wouldn't be such a minority choice. Now, if your talking web sites...That's another issue altogether.
There's no way around Fortran for numerics. Numerics code is the domain of experts, and they work in Fortran (Fortran being faster than C for this task), Let's hope Sun Microsystems gets Fortress in a usable state - because that has a lot of good ideas in it (ideas from functional programming).
Main difference between the BSD license and the GPL license: one is from California and the other is from Massachusetts
What should be taught is the ability to look at and analyze a problem to find the best available tools (in this case computer language) to accomplish the solution of the problems, not how to use a tool or tools directly. It needs to be taught how to decide whether to use a screw or a nail, then which tool is better (a screwdriver for a screw and a hammer for a nail), and finally how to use that tool in a practical way. Schools should be teaching computer languages as after thoughts and as a means to problem solve, not as an end in themselves.
Learning and using most all higher level programming languages is a no-brainer for someone that has been trained in problem analysis, compilers/interpretors are self-teaching tools. Has C++ brought us better solutions (more efficient, easier to maintain, less complexity, ...?) over C? over Ruby? over Cobol? over fortran?
Your computer programming ability will only marginally change should you learn FORTRAN. Your time is better spent on it's children that copied and made better it's functional properties.
However LISP will expand you programming experience and should be taught at some point after C++ or PHP and before Python. This would have a profound impact on the way you program.
That's because a married man has to spend so much time trying to figure out how to keep his staggeringly complex wife happy.
I was taught fortran 77 this past year as an undergraduate to do atomistic modeling. People tried to use C, C++, matlab, etc but they were too slow
You are so clueless, you are beyond help. Your TI-89? Throw in the garbage (you should have bought an HP, anyways).
What a joke education has become.
Now go program your PHP site.
Main difference between the BSD license and the GPL license: one is from California and the other is from Massachusetts
since you're talking about physics - it sounds like yes it should still be taught.
I would have thought either matlab or fortran is perfect. a language for calculating
shit. as opposed to a general purpose langage.
languages like python can be particularly cumbersome to do maths in.
(unless python has got some sort of maths module which I don't know about).
I don't know much about fortran vs matlab tho so perhaps matlab is a decent alternative.
anyway fortran is still used in all sorts of areas in code hardware or systems etc where you need
actual number crunching for example radar systems and that sort of thing.
I'm not a fan of fortran myself but the fact is it's a tried and tested language for
numeric computations.
however having said that, the question was not 'is it any use' but should it still be taught.
the answer to that really depends on the course. the course I learnt it in was called
'programming paradigms' and the intent was to show different types of languages. fortran
is a good example of a different paradigm from your bog standard boring procedural C
style languages.
so, yes it should be taught. at least there's no reason it shouldn't be used as an example
of that type of language.
also, I have to say, learning how shit some of these old languages are provides appreciation
of features of modern languages.
F2003K is less than 5 years old in terms of implementations.
You make a persuasive argument, but on the other hand, yes.
Are you insane?!! Only an idiot would not see the clarity and logic of the arguments for 'no'! It's people like you who are ruining the internet and rational discourse with your constant contrarianism. A pox on you!!
Now that I think about it, I'm pretty sure everything I just said is completely wrong.
Fortran is not the future.
My college is pushing perl as an engineering and scientific language since 99.9% of the work a scientist might have to do will be in Unix or Linux whose administrators favor perl over fortran for such tasks.
They're using their grammar skills there.
Despite the fact that they are hundreds or thousands of years old, people are still being taught English, French, Spanish, German, and various other Romance and/or Germanic languages. Not to mention the various non-Indo-European families.
They still work. They each have history and legacy.
People are still using fire to cook, too, and that's got many thousands of years on the odometer. It also still works.
Several posters here have made the point I answered to espouse - It is not the language per se, but the concepts of organizing and structuring data, preparing logical flow and execution, and maintaining a standard of documentation and coding which others can interpret and verify that is the essence of the teaching. There are any number of "quick and dirty" languages, and the argument that there is excess capacity available to make up for their inefficiency is merely a cover to excuse the lack of clarity in these solutions. Analysis and interpretation of hard data requires the same rigor as gathering and validating that data, and none of the easy ways of manipulating the "for dummies" languages will meet the test of that exacting and essential process. Teach python as a quick tool for making approximations; but first teach, through whatever language that meets the standards that science must hold itself to, the process of managing the idea and logic in code. Computers are fast idiots; they do what we tell them to do at fantastic speed; not what we want them to do. Failing to understand that will produce results that never stand up to the level of accuracy needed.
they aren't going to teach you PROGRAMMING. They will teach you CODING, and probably do that pretty poorly.
Fortran 95 is a fully munitioning OO programming language. Get rid of you biases and old misconceived ideas. All that, built in parallel programming and fast.
It's a natural choice if you need number crunching.
If you need string processing, Perl or Ruby or some other scripting language.
Python lower on the list.
putting the 'B' in LGBTQ+
I vote NO.
Sure, there's a heck of a lot of working legacy code out there (e.g. NAG, &al.). There are also a lot of clay tablets lying around with pre-written cuneiform on them. There's a difference between "re-inventing the wheel" and switching from a wooden-axle-through-a-roundish-stone to a truck with independent suspension, and well balanced wheel bearings.
I spent several years working as my research group's primary computer "guru" -- including having to port old code that had been written to run on an out-dated UNIX box (in FORTRAN) to run on a newer computer system. 1st, I ported from the old FORTRAN 77 to FORTRAN 95. Worked fine -- only took me a couple of hours. Later, as requests for improved functionality started coming in, I compiled the old FORTRAN code into a .dll, and wrote the calls in C++. Still fast, accurate, and all -- from a user's perspective -- but UGLY from a programming/maintinence perspective. Eventually, I spent the better part of an evening re-writing the core functionality in C++ (with - I'll admit - some embedded ASM), and got a result that ran fine on a 486 box just as fast, and just as reliably as the original FORTRAN code on a it's dedicated workstation... and it was a *heck* of a lot easier to maintain. After that, I just left the old FORTRAN compiler alone. [For the curious, the code in question modeled the physical response of a visco-elastic microstructural composite material to applied stress/strain -- not an entirely trivial application -- and involved a fair amount of tensor calculus]
I know that FORTRAN has come a long way since the old days -- but it's still a beast. Anything that you can do in FORTRAN, you can also do in C/C++ -- but the same is not true the other way around. Pointers/dynamic memory access/allocation. Graphics. Hardware interfaces/communication. Cross-platform compatibility.
I think colleges should teach the fundamentals of programming using a variety of languages first, then offer specialization courses and research opportunities. Teaching "programming" using one language is a seriously outdated idea. Modern software developers need a solid understanding of fundamentals that they can apply to any number of programming languages. It's like music where one set of fundamental rules can be applied to a large number of existing and future instruments each with their own interface. I currently work in Objective-C, Java, C, C++, and a bunch of scripting languages like perl, python, etc. For me to do this effectively I have to view the language as an interface to the machine or platform while applying techniques, concepts, algorithms, and data structures that transcend language alone. Taking a FORTRAN class may be beneficial to one's completeness as a programmer, but I don't think it should be required for a CS, PHYS, or ENG program.
How did we ever make progress with people like you around?
Yes, let's do it your way and rewrite rock solid, decades old, high performance math libraries every time a new language hits the streets. Just think of how much progress we'd make!
You damned kids, get off my lawn!
Modern versions of FORTRAN don't have the odd reliance on source code formatting anymore that come from the punchcard era (although ironically Python relies on identation now).
I've taught graduate students FORTRAN 90 and they could pretty quickly implement matrix calculations, use imaginary numbers and I/O to solve the kind of problems they need to solve, often without prior programming experience. Science and engineering computations often require vast numerical throughput, and FORTRAN compilers are unrivalled at that (and have the best optimizers and parallelization support).
I'm not saying Python can't do the same, but change for change's sake is a pretty poor argument, and the existing huge FORTRAN libaries and code bases mean FORTRAN users truly stand on the shoulder of giants.
It really depends on what you are planning to do. Fortran is certainly still being used in real world applications. We use it here to write custom functions for software that controls the electrical grid. I would imagine that it's still in use in other environments that require engineered modeling as well. I didn't learn it in school, but I did learn C++, Java, Perl, and PHP. When I started here I had enough general knowledge that it was really just a matter of learning the syntax. So I think it's plausible to expect a student to be able to pick it up as long as they are taught the basics of programming in some respectible language.
I don't believe in karma, I just call it like I see it.
There are no new facts to this whole thing. FORTRAN fans will come here and praise the advantages of using numerical routines developed over the last 40+ years. Lazy grad students and alikes will say they have to use it because the old code they were handed is written in FORTRAN.
The truth is that even though FORTRAN is an efficient language with loads and loads of available numerical routines, it is old, and we should gradually change to something more modern. If only we weren't so lazy!
I for one, am a graduate student in Physics, working in a group with several other students and post-docs. Even though our supervisors legacy code was sure written in FORTRAN, we all write our own serious stuff in C or C++. Most of what we do is Monte Carlo, and Linear Algebra (BLAS, LAPACK, etc). We use MPI, OpenMP and the threaded version of Intel's MKL very heavily. I doubt FORTRAN programs would give us any performance gain over this setup, but it sure would require us to keep writing stone-age code, making sure to leave enough space on the right-hand side for the holes to be punched!
Give me a break! If you are a senior programer, than you might be excused for sticking to your old programming language and codes. If you are new in this game, and you don't want to take advantage of the best tool available, fine too! I just hope I won't have to work with you. Ever!
My friend at cern working on programs for the LHC has to do everything in c++ or python. So python might be a good one to learn. I love fortran 90/95 its a good language that only has a hint of the unpleasantness that was fortran 66. As, I'm sure others have posted there are some very high performance libraries/compilers for fortran number crunching. But, its not that hard to pick up if you know c/python.
But it was pretty funny taking that FORTRAN class with some cs students who only knew ADA. They were sort of freaked out by its "modern" features and "easy" string handling. It was right then and there that I realized I had dodged a major bullet by not becoming a cs major at the school.
Well.. maybe. Or Maybe not. But Definitely not sort of.
Let's get real. If you're going to make the case for every CS student to learn FORTRAN, then why not COBOL? Or why not PASCAL? Perhaps it should be broken out to it's own course structure, based on the field or major/minor of the student. That way you don't bore the crap out of someone that will never use it.
I still have the books and notes from the PASCAL I learned in High School, and the notes and printouts from the FORTRAN and COBOL courses. Never use them now, and never used them after I left College.
- Goran
Carpe Scrotum - The only way to deal with your competition.
Just for the record, FORTRAN is at least 50 years old. I wrote a program at GE Evendale for the IBM 704 using FORTRAN in the summer of 1959. The language was very young at the time. The documentation, such as it was, was typewritten, not printed. Typical FORTRAN scenario: run it once, tqweak it a little, run it again, all done.
I really wish that I had experience in programming in FORTRAN before I started my current project. It's very fast, simply because it is so lightweight. We're doing resevoir simulations...ie....how much CO2 can one put in a rock formation. The extensive programs already written (and often free or inexpensive) for FORTRAN make it a great language. The only problem is....thought must be put into threading FORTRAN applications. MATLAB and Octave already handle threading many programs. This gives great advantage to the user, who can easily scale to cluster-size computing without a lot of thought.
Call me crazy, but shouldn't they be learning Chemistry, Physics and Engineering?
one aim should be to make tools that will serve skilled professionals--not to lower the level of expressiveness to serve people who can hardly understand the problems, let alone express solutions.
But shouldn't we keep an eye toward eventually moving into a Star Trek-like future, where anyone can ask things like, "Computer: is there a compound that is superconducting at 50 deg C? If so, what is the formula?" And the 48-core, terahertz processor cranks through sophisticated molecular models to find the answer.
That that is is that that that that is not is not.
...but we geeks are getting old. Fortran, punch cards, and then you had to go and drop the D&D bomb. Now people are going to start bragging about what color box set they started playing on. Well, I'll nip that one in the bud, dammit.
My D&D box was clear. Yup, you heard me. Clear. Not blue, not red, not white. Clear. Gary Gygax made it for me himself out of cellophane tape and saran wrap as a gift commemorating the fifth anniversary of the D Day landing. The books were written on bar napkins and held together with roofing nails and bubblegum because staples hadn't been invented yet. The cover was done in Dodo pelts. Monster manual actually had an entry for North Koreans. There.
So top that.
Weaselmancer
rediculous.
They should learn functional programming, for sure. Fortran specifically need only be taught to those who need extreme performance for scientific/mathmatical calculations.
Perl is the FORTRAN of interpreted languages.
The answer is - NO! There is no compelling reason to teach FORTRAN since it doesn't offer any concepts not available in almost any structured or OO programming language. If you know how to prrogram in almost anything, you could program in FORTRAN.
When I started Purdue University in 1984, they had long since dropped FORTRAN from the CS curriculum.
Use the right tool for the right thing. Do you hammer with a chainsaw ? Why would you crunch numbers with Python ? Sure, a Chainsaw is a lot more powerful and can chop trees, but what you need to get the job done is a hammer.
Assembly language is almost always totally impractical to actually use, but gives tremendous insight into what a computer is and what the limitations are.
...anyone else?
Populus vult decipi, ergo decipiatur...
"Force shits upon Reason's back." - Poor Richard's Almanac
Many posts I've read seem to be missing the whole point of computer programming.
It is not computer science: that is another course and I agree it should be taught in a language-independent manner; it is not scientific computing, as many posts have implied; it is not job-skills workshop. The point, I believe, should be to make as many students as possible fall in love with computer programming and understand its usefulness, to the others it will only be an experience better forgotten.
I love FOTRAN (I even capitalize it, see? I'm young but old-fashioned) but let's agree that it is not the simplest language, and it has a steep learning curve: it takes longer to see your work done, and this might act as a deterrent for weak hearts. I have never taken a computer programming course, yet I am competent (at least not incompetent) in C, C++, FORTRAN, and Perl and Python. When you love computer programming, you don't need a teacher, you only need time to spare.
My belief is that the computer programming course should aim for making students fall in love. I would lean toward Python, and have students see their computers obeying them sooner rather than later, allowing them to imagine further ways to dominate the computer and just get shit done.
FORTRAN is faster? This is the same as saying Linux is free. Only if you don't take your time into account! Sure, inverting a matrix with your processor-optimized LAPACK works great in FORTRAN, but the kids are not designing rockets or predicting weather, they are learning how to program. If they learn how to do it and, most importantly, they learn to love it, they may very well end up designing rockets in assembly if you will. They will pick up girls with hexadecimal compliments. Maybe not the last one.
As anything else in high-school or college, the point is to "get it in the bull-park", learn to love knowledge, and learn how to learn.
Aeroespacio.org
I think we're seeing two completely different questions here. You're seeing "get rid of Fortran? BLASPHEMY!".
The actual issue is not about removing Fortran. The actual issue is that we should teach programming first, then teach fortran. Currently we try to teach both programming and Fortran at the same time, therefore often doing a poor job at both, therefore additionally often making it much harder to learn other languages later than might otherwise be so.
Why is it important to not cripple the ability to pick up other languages? Besides that students might switch to something else? It's important because while the libraries stay the same, the stuff that calls those libraries is in flux. (And it's also important to know *how* the libraries work, so that one can use them correctly.)
Teach them C or assembly first. They will thank you later when they have switched to Python because of experience, not because you forced it down their throats.
The point is to learn how to use programming to accomplish a task on a set of numbers (most likely some big comma-separated text document) and output some other set of numbers.
I want the students to get to the point that they have the numbers read and writable on the first day.
Perl or Python. Suck it in, split on commas, and it's in a 2D array. 3 lines. Bob's your uncle. Write it out in a preformatted template. Boom.
I coded some things with my undergrad science major friends (atmo sci roommate). The FORTRAN students not only devoted pages of code to the trivia, they spent hours debugging it. The code part was simple for any of them. Our Perl scripts were seriously 10 lines long to their pages, and better looking output to boot.
Old programming languages never die. If the code written in those languages still work, then they are run forever, which is why 50 years after its invention, FORTRAN (and Cobol) are still in use.
To become a truly competent programmer must learn as many different programming languages as possible. My first programming class was split into 3 sections over the school year; FORTRAN, Cobol, and Assembler (IBM 360). During my CS education my professors exposed their students to as many types of programming languages as possible. We learned the design and functionality of these many programming language examples so we would be able to pick up any new languages in the future without problems. You want a hard language to learn, try APL or LISP... I did, and got a paycheck for the work I did.
It is likely that as a new graduate, you will enter the programming world and encounter legacy code written in some ancient programming language like FORTRAN. If you tell your boss, "I can re-write this in X (java, python, ) and it will only take me a month (likely 6...)", your boss will nod his head with a smile and tell you he will think about it. What he is really thinking is "Why would I pay to re-write code that was paid for 40 years ago, that already works".
Whatever you use, it better have 128bit precision support for when you have to do large matrix diagonalization (often needed in the sciences).
Here is my qualified "yes": it should be required only for archaeologists.
What a great many posters here miss is that these are not CS majors, this is not a programming course, per se. This is about preparing them for coding their science problems; maybe even on supercomputers. If you're never going to do that, fine.
But, what a few insightful posters have pointed out is that ForTran is still used quite extensively, and was designed for exactly the problems that these students are dedicating their careers to.
Exactly: clearly you should teach the appropriate computer language for the course. So Fortran should be taught...but in ancient history not science (of any discipline).
FORTRAN is still widely used and newly written in many computational tasks, simulation, fluid/aero mechanics, elasticity, oil ... and many necessary libraries are only available in it. Compilers, and certainly not GCC can do a very good job of optimizing it since its semantics allow this. BTW FORTRAN is type safe unless you deliberately break this using EQUIVALENCE statements.
Now let me be a little more extream, strongly typed languages especially nastily complicated ones like C++, object oriented or otherwise, do absolutely nothing to teach people how to program or develop large complicated critical systems, just the reverse. It introduces completely un-necessary complexity and JARGON that simply confuses the beginning developer, and by the time they have been drinking the kool-aid for a while they dont have a clue why they are doing what they are but they saw it recommended in a book or magazine. For C++ you at least have Scott Myres books, to make them learn by heart how to avoid the worse problems but you tell me how these people, who can barely write what they mean are going to debug CTOR/DTOR sequence problems without also knowing an assembly debugger and how the code is compiled.
Please, academic/tools-consultants go away. Learn to write correct code yourself and stop the lie that goes "Just use Language X" and all will be OK.
We have too many programming languages now. We need about six or seven.
Fortran and C, but not COBOL, Java/C++ (which can be well written), Perl, Python and Erlang.
Assembly and Lisp will always be with us.
So teach FORTRAN, teach VB6, teach them LOLCODE or whatever the hell you want but please make sure you're teaching them why the code is written the way it is ...
HAI
CAN HAS STDIO?
VISIBLE "HAI WORLD!"
KTHXBYE
Why is it written that way? Because I CAN HAZ CHEEZBURGERS!
Do not mock my vision of impractical footwear
I use GOTO quite often. It is useful for keeping code from getting deeply nested, which in fact can impair code clarity.
Where you might say:
... function body ...
if( OK ) {
}
return;
... function body ...
I would say:
if( NOT_OK ) goto DONE;
DONE:
return;
Now imagine the above example, with 8 or 10 different places where the value has to be tested before proceeding. Without GOTO, your code is indented at various depths across the screen. With it, your code lines up neatly and is easy to scan.
A quick search on dice nets around 80 jobs looking for FORTRAN skills. In this economy that isn't bad for a language that is perceived as dead. I also noticed the jobs look entirely more interesting than the typical Java coder is going to get. Personally, I'd rather write scientific code than web apps. I noticed the pay was good too. I say learn some FORTRAN and go to work dong something a little bit more specialized. I haven't written a line of FORTRAN in 15 years so I won't be applying anytime soon!
back in 1989 was an engineering analysis tester written in FORTRAN. The language was chosen because my assignment was temporary and the guy that was permanently in the department only new that language. The tester code was a combo of FORTRAN and Micro$oft Assembler for all the bits FORTRAN couldn't handle. Even in the late 80's, as a EE student, I thought FORTRAN was outdated when it was required in our studies. However in my case, it did prove useful.
Since graduating, I've learned many other languages on my own, but FORTRAN was the cornerstone. Not the language, but the concept. As long as the concept of programming is taught correctly, other languages should easily be picked up as needed and it shouldn't matter what course you took in college. C is probably a bit much for the casual programmer, but FORTRAN is a simple alternative. Chasing the latest 'flavor of the week language' really shouldn't be the goal. Teaching 'programming as a concept' is the important thing. If done correctly, a person should be able to easily apply the concept to whatever language their job demands.
"You can't really dust for vomit" --Nigel Tufnel
Fortran 2003 is a very different language to ancient fortran.
Teach them modern fortran at least.
But no, don't teach them python. Python is a toy scripting language.
If you're going to teach a bunch of mathematically inclined people (engineers!) a higher level language than fortran, they are way, way better choices than python, such as Common Lisp or Haskell.
His two reasons why everyone hates Fortran can be made to apply to any language (let's get that out of the way), or indeed any course where some of the students already know the subject materials and others don't know it at all.
I don't know what 'foibles' of Fortran he's talking about, except perhaps having to type numbers in with a .0 on the end if they want them treated as floats. That's all that I can think of.
Fortran 77 was painful - I never learnt it, but as an F90 programmer was exposed to it and saw how ugly it was. F90, on the other hand, is not painful. Stuff works, the language is forgiving (with the exception of the thing about getting integers to behave as floats) and it does what you want with the minimum of fuss. Compared to C (I'm only going to compare to C - you don't do scientific programming in high-level languages); C may be (at a stretch) twice as powerful, but takes 4 times as long to write, and 10 times as long to debug. Most stuff that you want to do is build directly into the language - you don't have to monkey about linking math libraries in to get a square-root. Fortran is case-insensitive (this is GOOD - it shouldn't be possible to have two variables named power and Power)
Now, that's just stupid - that pretty picture drawing and should be accomplished in matlab or similar. Fortran is not supposed to be used for writing programs with a GUI, and whining that it's hard to shoehorn it into that role is monumentally stupid. You can bosh that out with minimal training in some higher-level language like matlab - what you cannot do it write some efficient, high performance program after 'learning programming' in matlab, and being given a crash-course in Fortran. Granted, it doesn't give you as much of an idea about what is going on on the underlying metal as, say, C, but it gives you enough. If you don't initially tell your students that they can copy part of an array using colon-notation, they have to do it with a for-loop. Now they get the idea about how ugly such an action is to perform. That sort of thing, and having the number of clock-cycles that common operations take explained to you, is what gets you into a programming mindset where every other line you think 'how can I be doing this more efficiently?' How many python programmers do you know who, when needing to divide a number by 2, multiply it by 0.5 instead?
I still use Fortran,. when I was an undergraduate I used it for my project, and as a masters student I chose to use it for my dissertation, despite it not having been on the syllabus. My Fortran skills also enabled me to help some of my colleagues who had to use codes provided by their supervisors which were written in fortran, as they were hopelessly out of their depth, not having been taught any fortran at all.
His rant about compilers shows a total lack of backbone. A small number of shouty people call for their own preference of compiler and he seriously considers buying them all. The choices are, of course, obvious. gfortran or G95. If you're using the supercomputer you can also have access to the Intel compiler. Choosing a compiler because it's very standards-compliant isn't very clever. Firstly because standards compliance is best achieved through good teaching and secondly because at least one part of the standard (invalidness of tab-characters) needs to be safely ignored, without having to teach the students about shutting the rest of the standards off with compiler switches. The idea of picking a compiler on the basis that it allows you to shoehorn fortran into being a GUI language boggles the mind - if you must have some sort of GUI, write it with a C-library and cross-compile.
What he doesn't seem to realise about first programming languages, is that they're like a ratchet - it's very hard to later go to a lower level language than the one that you started with. If you start people on python or matlab, they'll be very hard to turn into decent fortran programmers later.
FGD 135
Where you spend one week on each important languages and actually write a program in each language. Fortran, Pascal, Basic, Algol 68, Lisp, Scheme, C, C++ , java, and a few others. A different survey of scripting languages would cover sh, ksh, bash, tcl, perl, and others.
Scene: Group of us sitting around the lab. Mike and I were 30-somethings, Brenda and Padmini were 20-somethings.
Usenet article appears:
Bullwinkle: Hey, Rocky, watch me pull a computer program out of my hat!
emerging-from-hat: 100 PROCEDURE DIVISION...
Bullwinkle: Arrgh!
Rocky: Guess you gotta get a new hat!
Mike and I: [laughter]
Brenda and Padmini: [blank stares]
The scary part wasn't that our younger coworkers didn't recognize C0B0L - they did.
They didn't know who Rocky and Bullwinkle were! Arrgh!
(Brenda had grown up American; Padmini at least had _some_ excuse, though she'd been over here since high school...)
Bill Stewart
New Fast-Compression-only CPR http://preview.tinyurl.com/dy575ks
My slashdot user ID is lower than yours.
Le français vous intéresse?
but interesting one. Fortran was my first language. It's good but not modern enough, and not multi-purpose enough.
C/C++? Not sure about that either. Most students are dirty and don't clean up after themselves. So writing clean code,
where the students have to de-allocate memory etc. may be a way to turn off students.
Java? (the circumcised language) Maybe?
Perl? Why not? Perl!
> This GCV is used in Q-value routine of 2003 to determine false discovery rates by smoothing over the P-values of thousands of genes
Are you referring to this paper ?
http://www.genomine.org/papers/Storey_Tibs_PNAS_2003.pdf
The authors didn't mention any numerical difficulties. Maybe it would have been worth contacting one of them for help--assuming you're not one of them.
The reason you indent is so you can quickly scan for all conditions affecting program flow (if, while etc). i.e you are looking for the reason the program isn't reaching a block of code.
You GOTO hack fails this scan test. If you insist on using a GOTO flow control you damn well better indent.
If you want things to 'line up neatly' just don't indent. Results are the same.
'Easy to scan' is in the eye of the beholder. Your code will grow in maintenance.
If you get too indented it's a sign you should break your functions up.
I'd fire your ass, second use of GOTO.
At least it's not a calculated GOTO (FORTRAN lets you calculate the line number you want to jump too) like jumping to a pointer but uglier.
John McAfee 'It was like that time I hired that Bangkok prostitute; to do my taxes, while I fucked my accountant'
In the real sciences (chemistry or physics) where they need to get real things done, the elegance of the language is a very minor consideration. Major ones are: are there libraries that contain key specialised functions and subroutines that apply in my discipline and does it avoid any obscure object paradigms that though a steep learning curve into the procedural code I really want to write and does it manage variable memory for me in ways that will not create unstable code from poor pointer management?
For most scientists, FORTRAN fits this requirement perfectly and I doubt Python will ever have 10% of the scientific libraries FORTRAN has acquired over the years.
Even in commercial technical codes FORTRAN is widely used. 80% or the computational-assisted-engineering cluster cycles at automakers (and at many other industries) are consumed by materials deformation codes like LS-DYNA which has always been and is still written in FORTRAN. (Lots of the key engineering codes were written in the 60s for NASA and they survive today)
People use languages that work best for them, not what some meta-discipline like computer science says is the right thing.
My opinion / experience, for what it's worth, is that the style of education can only do so much to turn out a good programmer. The smart, motivated students will be stuffing themselves to the gills with everything they can get their hands on. The resources online are incredibly abundant. There is MIT opencourseware, tons of books are made available by their authors free online, pretty much every other book is available via torrents. Not to mention hundreds of programming blogs, and sites like this. Even more importantly, the FOSS movement has triumphed in making so many programming tools available for free. Someone trying to learn a new mainstream language can expect to start by downloading a good, free IDE.
In short, I think that the good students have the resources available to make themselves into great programmers. The students that see computer science as a gravy train, and just want to scrape by with the minimum necessary to pass each class are never going to be great programmers. No matter how much the curriculum prods them towards greatness, as soon as they don't have a grade on the line they will stop working. I met way too many of these second class of student in my undergraduate career, and precious few of the first.
In Electrical Engineering, it is accepted that many of the graduates are going to be second class. The career path for these individuals is sales, technical management, and marketing/application engineers. Maybe it would be helpful to have a similar tacit understanding in Computer Science. Only the top 10% or so are actually going to be programmers, the rest should go into sales, management, IT, etc.
I have fond memories of Fortran from the only programming course I took in college 25+ years ago. Warm, fuzzy, marshmallow-scented memories. That will sound weird until I tell you that the *other* language we had to use in that class was APL. That wacky-charactered, right-to-left, overstruck, array-spouting beast was the unholy spawn of Greek and Chinese psychotics, raised by ancient Egyptians. While marveling at the power available in a single dense line of APL code was fun (for certain values of "fun"), when we were allowed to use Fortran we felt like subsistence hunter-gatherers visiting McDonalds. "You mean you just *tell* it what to do and it does it? And these words actually mean what they say? Wow!" These days when I dabble with Linux and work on social science software syntax files, I'm grateful for two things from that long-ago course: the general programming concepts I learned in Fortan, and the fact that I don't have to touch APL. Mailbox! Open Mailbox!
But it's still really efficient at matrix math, so for some science/math applications, it a great choice.
Even if it is not broken, hack it anyway! You'll learn something in the process!!
I once had to copy Nixdorf data-entry files to 360K single sided 8" floppies for General Dynamics in San Diego. So I wrote a FORTRAN program to reprogram the floppy controller to write the data in raw mode to 128 byte sectors to emulate a card punch. The floppy drives were connected to the serial port on the I/O controller (Harris H-series) So to make it work we would drop the data-entray tape in the harris tape reader and mount it, insert a blank floppy in the monster driver, start my program to begin reading the tape and keep swapping new floppies as they filled up with data. Why they needed the data in the archaic format I will never know.
In GOD we trust, all others we monitor.
As a language, Fortran supports pretty much what C++ supports (including overloading, templates, and objects), but is probably easier to use.
In terms of compilers, GNU Fortran supports Fortran 95 and many newer features; it's pretty much as good (or bad) as commercial Fortran implementations.
Python probably is a good first language. But writing numerical code in Python is actually harder than in modern Fortran because a lot of "natural" code in Python (loops over arrays) will run very slowly; in Python, if you want to write fast numerical code, you need to figure out how to convert it to array expressions. Fortran has both array expressions and loops, and they both run fast.
If people are going to learn just one language, with modern Fortran dialects and compilers, Fortran may be a reasonable choice again. In many ways, for people writing numerical code, Python is not an easy language. In fact, many people may opt for Matlab, because Matlab now (apparently) has a JIT that makes numerical loop code run fast as well, so it combines some of the advantages of Fortran and Python (but it's hugely expensive and a not a very good language IMO).
The idea of Python as a modern replacement for FORTRAN is totally risible, given that Python is actually more dependent on significant whitespace than FORTRAN. In fact that's why Python is so called.
Clearly you've never met a Real Programmer.
Cheers,
Michael
strategy doesn't work: In your example value_expected may not be computable if the boundary_okay condition doesn't hold. (I.e. you're not doing short-circuit evaluation). If your language is lazily (or non-strictly) evaluated you might get away with it, but given your example syntax I doubt you were thinking of lazy/non-strict language. :)
HAND.
I think one should take into account that someone who decides to study chemistry or physics has a specific "mind-set". She wants to know how things work. And for every little detail in the explanation of how things work, she wants to know how _those_ work.
If you use a programming which is close to the machine, it's easier to explain why things are they way they are.
At my university, the introduction to computer programming was given by the CS department, and they used a special "educational language" where MAXINT was 10000. This was deliberately chosen because the real MAXINT (4G) would look arbitrary and weird, and thus scare the students.
All the physics, chemists, and mathematicians immediately fell over this number. 10000! What a wonderful and weird coincidence that "the largest number" would be a nice power of ten! All of them had to be explained "Well that was just chosen as an artificial limit. The real number is 2^32, since this is a 32 bit machine." And they all went "Ahh, of course."
If you balance it all out, I still think C is not so bad a choice for a first programming language. Disclaimer: I wrote an introductionary computer programming book. (http://www.curly-brace.com)
Fortran is entirely reasonable here. For numerical algorithms Fortran is still king. C is the alternative not python. You don't write numerical code in python. Either C or python are the sensible choices. Fortran has an edge in general because of the existing size of existing code. However, it is also true that fortran is easier to optimize than C (strict aliasing is the default there). Fortran has lots of optimzation constructs that made it a decent choice here.
If you've ever read "real" numerical code ... Its aweful. If it was in python it would still look aweful. it would just be slower and differently ugly.
Optimizing C and fortran is easy (even if it can take longer) .. optimizing most HLL gets hard fast.
So, no .... fortran or C is 100% right here.
If they were CS majors (and not taking a course on optimization / computational science ) ... Fortran is the wrong choice of course.
Perhaps he should use the DIVORCE libraries.
Of course he will have to be cautious while calling from a library created by lawyers.
only if toddlers be taught Latin or Greek..
APL - good for matrices too. Plus, there's the fun of trying to write your entire program in a single line of impossible-to-decipher code.
There is a great deal of scientific code already in Fortran. I wouldn't be surprised to see the same code with or without revisions STILL being used 20 years from now. Some of the code being used now referrs to the input file as a deck because when it was written, the input and output happened on punched cards if that gives you any idea of it's longevity.
Unfortunately, much of that code accomplishes it's tasks in spite of the source being a horrible jumble of spaghetti without comments.
Really Fortran AND python would be a good choice. Fortran for long running simulations that need to be as efficient as possible to complete in a reasonable time and python for less performance sensitive cases.
While I agree FORTRAN (especially the older dialects) is relatively easy to optimize for parallel operations and clusters and the like and the libraries are platinum, I do think they need rewrites from time to time; those libraries can be hard to understand and I want every generation to have lots of people who understand, not just use, the things.
Also, every 10-20 years assumptions change. The early libraries did floating point entirely in software and memory was tight, in 2009 we can almost assume any desktop (and most laptops) have floating point to IEEE standards available in single and double precision plus virtual memory.
Now we are seeing GPU's being used in non-graphics computation so algorithms that are stable in single precision and can actually use 64 pipelines are being written and memory is tighter.
No, you should learn Forth codes. Forth is good program language that you should learn how to do it
I learned to use fortran77 in college. I would've been better off learning Java or C++. I would've enjoyed a class that discussed collecting data, processing it and producing control signals on the cheap. Every place I worked used some kind of customized system to do that and I almost never worked with anything I had seen in classes I had taken.
Not 100% sure about Fortran, but I do know there is good value to learning older languages. Take COBOL for instance. Anything you can do in COBOL can be done in more modern languages. The problem is that there is a LOT of COBOL out there. It works, and businesses have found that projects transferring all their old programs to newer languages ultimately fail more often than they succeed. It is much better for them to find a COBOL programmer than translate everything to a newer language.
Open Source: Eroding the Digital Divide
All of the above can be taught in any language, including one made up by the professor (RIP Edgar Dykstra.)
Edsger Dijkstra maintained that anyone who was first taught an unstructured language like BASIC was completely and totally brain damaged from there on. See:
http://www.brainyquote.com/quotes/authors/e/edsger_dijkstra.html
I hope he rots in hell and I'm glad you totally mangled the spelling of his name.
The rest of your post was +5 insightful.
My CS 101 in college was in FORTRAN on punchcards, though by that point I already knew an assembly language and four or five flavors of BASIC. I've lost count of the number of different languages I've been paid to write code in. I've lost count of the number of languages I've forgotten. When I was very young I kept count of the number of computer languages I had learned until I, well, lost count at something like 20.
I think a better example is Donald Knuth. I can't find one of his intro quotes to _The Art of Programming_, but he maintained that dealing with code in several different languages before lunch was something one had to deal with. I fully agree. I also like:
The most important thing in the programming language is the name. A language will not succeed without a good name. I have recently invented a very good name and now I am looking for a suitable language.
Ref: http://www.brainyquote.com/quotes/authors/d/donald_knuth.html
There's nothing intrinsically wrong with traditional BASIC or traditional FORTRAN, and traditional FORTRAN is extremely important historically - it proved that compiled languages could produce better code than skilled assembly language coders. Just keep in mind that learning *programming* as versus the FOTM computer language is the most important thing and you'll be fine.
No numerical difficulties at all. But the algorithm was implemented in R. It uses smooth.spline which in turn was implemented in FORTRAN. The original FORTRAN code was GCV and PPPack from Netlib. As far as I know, nobody off the net other than me has ported these routines out of FORTRAN so that I can reasonably use them for QValue routine without invoking R whatsoever.
--
Error 500: Internal sig error
As other posters point out however, the prowess of languages like Matlab and Octave at linear algebra, differential equations, etc. comes from the fact that in such cases the interpreted language merely acts as the glue between successive calls to subroutine libraries (BLAS, LAPACK, FFT, etc.). The amount of work spent in Matlab (or Octave) mainly consists of setting up the library calls and storing the results. The hard work is done in the libraries.
Of course this is of no interest if you just want to get the calculations done. Octave etc. will get you the right results, and make them easy to inspect and process as well. Therefore, provided you can arrange your calculations so that the bulk of the work can be confined to a couple of library calls, by all means: use Matlab, Octave, or Scilab.
However ... sometimes you need to carry out massively repetitive computations on data that is not easily expressed in terms of function calls to standard libraries. In other words: loops. When you code such loops in an interpreted language (like Matlab) the overhead of the interpreter is added to every iteration you do. To the detriment of your runtimes.
Now Matlab afficionadoes will contend at this point that you only need to configure loops as vectorized code to still get the speed benefits (because vectors are handled inside the libraries that Matlab etc. call). I agree that whilst sometimes loops can be so vectorized this by no means holds for all all of them. And even if the code can be vectorized, the process takes insight, effort, and concentration. On the other hand, coding an algorithm exactly the way you would do it by hand is a lot easier, and a lot more suited to the real world of non-programmers writing programs. What's needed in that case is a compiled language, not an interpreted one, which doesn't impose all kinds of overhead when you do loops.
Java proponents will rear at this and will proceed to wax eloquent about byte-code interpreters, JIT compilation, and lazy evaluation. Unfortunately Java is a very poor choice for numerical work. Mainly due to the way the floating-point stuff is implemented, and how the interpreter e.g. doesn't respect the flow-sequence of your code but feels free to substitute any expression you write with one that's algebraically (but not necessarily numerically) equivalent without ever telling you about it. This tends to disqualify Java from numerical and scientific calculations in favor of a language that allows the programmer more control over the way that expression evaluation is done.
Thus a simple compiled language is needed. Just about any third-generation compiled language will do. C or C++ for example will deliver the same kind of performance as Fortran. Pascal will do likewise. Ada is fine too.
However, as we all know, coding in C or C++ is not for those who are sloppy about implementation details. At best the code won't run at all. Even worse, the code may run and silently hand back nonsense. It takes time to learn how to program properly (and safely) in C and C++, which is something the average Chemistry or Physics student can ill afford. Even if he has the inclination to learn.
Pascal is great for clarity of expression in programming and maintainable programs. Unfortunately it's less well suited to writing reusable programs, and (barring non-standard extensions) its strict typing can play hob with resizeable arrays. And as soon as you go allow extensions, you lose compatibility. I can be quite confident that I can take my old standard FORTRAN-77 code and run it in Japan, Russia, France, and Brazil with no more than a recompile and get the same answers every time. Try that with manufacturer-specific add-
Undergraduates should be taught programming principles that should easily carry over to different language paradaigms. Direcly learning Fortran in an undergraduate cirriculum is unneccessary.
As someone currently doing a postgrad in Particle Physics, the answer is very much no. They should be taught C++, preferably on a Linux machine using the GNU compiler. Nothing I see is in Fortran, it still exists somewhere but the old guys who actually like it are covering that for the time being. We do use a little bit of Python for some basic scripting for "jobs", but you can cut and paste those easily from examples.
In my company, a HUGE number of our analysis codes are still in FORTRAN. I never learned it in school and have had to teach myself enough to keep the codes working properly. I've even suggested in the past that we upgrade our codes, but there was much howling from the gray beards that own them.