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?"
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.
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.
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.
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.
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
Right. Teach COBOL instead!
Job security well into the next millenium!
We used to have a Bill of Rights. Now, with the rights gone, all we have left is the bill.
It's called Scheme.
Meta will eat itself
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.
> 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.
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
God forbid, don't teach em python first. Learn assembly, c++, ML, fortran even fucking visual basic. You can't learn python first, it's like eating the pudding before the salad. Python is the *last* language you should learn.
Yes, I'm serious.
http://rareformnewmedia.com/
Fortran hasn't had those limitations for decades - Fortran 90 and later are ideal languages for expressing mathematical algorithms and crunching numbers
Fortran hasn't had those limitations for decades - Fortran 90 and later are ideal languages for expressing mathematical algorithms and crunching numbers. The handling of arrays, matrices are just what they should be.
I wouldn't use Fortran as a general purpose language - having used Python for more 10 years I shudder at using Fortran for string handling, databases, user interfaces and more - but as a tool for expressing math it's the best, and also the most widely used. The alternative would be matlab (much of the syntax isn't that different).
End users rarely pay for supercomputer time. Very rarely. There's an application process and peer review in most cases, but the time is, in the end, free.
Yes...I am a rocket scientist.
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.
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
OK, OK.
Fortran is old.
But Python? Are you serious?
pffht.
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
The idea of programming as a semiskilled task, practiced by people with a few months' training, is dangerous. We wouldn't tolerate plumbers or accountants that poorly educated. We don't have as an aim that architecture (of buildings) and engineering (of bridges and trains) should become more accessible to people with progressively less training. Indeed, one serious problem is that currently, too many software developers are undereducated and undertrained.
Obviously, we don't want our tools--including our programming languages--to be more complex than necessary. But 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. We can and do build tools that make simple tasks simple for more people, but let's not let most people loose on the infrastructure of our technical civilization or force the professionals to use only tools designed for amateurs.
- Bjarne S.
No sig today...
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.
I believe that it is the architecture that COBOL usually runs on that is what makes it so conducive to "manipulating and moving massive amounts of data". As far as maintainability is concerned, COBOL makes good software engineering a hard and frustrating task. That being said, I am always amused at attempts to marginalize COBOL. I am quite certain that in the 2 1/2 hours that I have been awake this morning, at least two of my actions have been processed by COBOL code. I don't buy that "nothing beats COBOL," but I am convinced that COBOL does make the world go 'round.
God forbid, don't teach em python first. Learn assembly, c++, ML, fortran
This seems to me like saying you should learn to drive an F1 car, or a Model T, before being allowed anything with an automatic gearbox.
I would say driving a car is like running a program. Designing or repairing a car is a much better analogy. And in that case, learning the old designs, and the physics they used is much better than "run this diagnostic tool; replace factory-made black-box widget". Learning assembly or C forces a person to recognize the limits of the machine (and thus the limits of interpreted languages).
Fortran has it's place, even though it's a bit of a fringe language today.
It has evolved since Fortran 77, and is better. It's also one of the languages where it doesn't require the programmer to have a detailed knowledge about how to parallelize a problem since later versions has those features built in. The programmer just have to be aware that it can be parallelized, but not waste time on the details about how to do it. Unfortunately GNU Fortran doesn't support this yet (unless it has been enabled lately).
Python is certainly not an alternative - unless you want to have a replacement for Basic.
Education shall primarily be done in type-safe languages that forces the developers to learn the importance of type safety. Way too many bugs have been created through history that are related to operations that aren't type-safe. Ada is one language that is really strict. Java is acceptable. C# is not acceptable since it has some unsafe parts when it comes to data typing.
And Visual Basic should be taken out, shot, drowned, burnt and sterilized for all it's abilities to make things unsafe and bug-ridden.
If builders built buildings the way programmers wrote programs, then the first woodpecker would destroy civilization.
I believe that what gives COBOL the edge when it comes to working with large amounts of data (in addition to the fact that it runs on mainframes built for throughput) is that...
1. The data record can be/is defined clearly in the application (it's required).
2. The data record can be redefined many many times, allowing you to subdivide the data many ways, naming each individual part, retyping it, etc. If done with just a little bit of common sense, it makes the code fairly clear about what's going on.
3. What some would see as a weakness is actually a strength when used in the normal COBOL processing environment. That is that you really can't get too fancy in the code without it becoming unreadable and unmaintainable.
So you are forced to break up your processing into steps, which are managed by some kind of process management system. OK, JCL in 99% of the cases.
While seemingly clunky, it provides a great amount of resilience because you are able to restart jobs after failures from just before the failure, not from the beginning.
Bottom line, is that COBOL and the surrounding technologies and procedures are designed to get the job done, every day, 365 days a year.
It's not as pretty as the O'Rielly Animal House series of languages (perl, python, rattler, donkey, whatever) but it's rock solid and unstoppable when done with even just a bit of care.
Contrast this with the ASP.net web app development I'm doing now. Talk about finicky, temperamental code. Speaking of which...need to deal with the Object not set to an Instance of an Object.
When Fascism comes to America, it will call itself Anti-Fascism, and tell you to give up your guns.
Evidently, you don't go out that much. People use interpreted languages in science all the time. At least I do. Where I sit, there is quite a bit of spare capacity waiting. When I try to figure something out it is way more reasonable to write a program in three-four hours and have it run overnight than to write it in two days and have it run in (say) thirty minutes.
I would like to die like my grandfather did - sleeping. And not screaming in terror, like his passengers.
The problem with scripting languages is that they hide the architectural details of the system they are running on. They abstract everything to the point where programming becomes simply algorithm design implemented in a language so simple that it could have been pseudo-code 20 years ago. This is fine under two circumstances:
1) You are only interested in training "programmers", not computer scientists or computer engineers. In the case of this article, you could have a valid argument, since these are not computer science students. They're scientists in other disciplines who's primary goal is to write programs to figure out problems in their own fields of study. It is clearly not acceptable for computer science students who, in theory at least, need to understand the fundamental concepts of how computers work. Much of that understanding comes from learning "close to the metal" languages that are harder to learn, but remove abstraction and aid low level understanding.
2) You don't expect to need the power present in "close to the metal" programming languages. Because they are less abstracted (and because they are compiled), languages like C, C++, and Fortran tend to run much more efficiently than abstracted (and usually interrupted) languages like Python and Perl. This is where the argument from the article breaks down IMO. I've never seen Python used in scientific research, except in control scripts or GUI front ends. I'm not myself a scientific researcher, but I've spent a good chunk of my career doing admin work for various kinds of academics, so I have some idea what I'm talking about. When you've just spent 10 gajillion dollars on a 7000 CPU cluster (or even $300,000 on a 200 CPU cluster), you're not going to waste computational CPU cycles on less efficient language. There's not WRONG with python, don't misunderstand me. It has many valid uses, i just don't see it as a scientific research language.
I don't need a million points of light, just two points of multi-mode fiber and a 10 Gig-E router.
The idea of programming as a semiskilled task, practiced by people with a few months' training, is dangerous. We wouldn't tolerate plumbers or accountants that poorly educated.
Not at all. Most homeowners do a lot more around the house with a lot less training, whether opening up the garbage disposal or trying to manage their retirement accoutns. The goal of these classes--especially for scientists--is the equivalent: Not to get people ready for programming a bug-free third party app; it's so they don't have to sit on their hands waiting for someone else to "build tools" to solve a perfectly manageable, one-off program that will let them move their research forward.
There may be things where there's a nice pre-built commercial or open source app; there will also be problems where there's a need for paid consultants. But there's a lot of ground in the middle, especially in specialized fields.
While I basically agree with you, in that programming is a task best done well or not at all, it's a common mistake to think that everyone who programs should be a career programmer. It must be possible to teach the necessary programming skills (and they are necessary) to college students in engineering, science, and a few other fields. It's a little bit like mathematics except that many students don't start learning it early enough. If one doesn't start learning programming before college, then it's possibly too late to really learn enough in college. I think these days really successful students primarily learn it outside of formal classes.
My take on the topic of Fortran is that it is not important to learn in school. I've written a lot of Fortran, but with a strong background in C it was not hard to learn when it was necessary for me to. Even in experimental physics, Fortran is used increasingly rarely so most students would not have a need to use it.
I think that learning one programming language in school is not nearly enough. Students should learn basic procedural programming concepts, something about data structures, object oriented design, and good practices in some scripting language to get comfortable with hashes and regular expressions. Python is great for a lot of this, but it's probably better to establish more low-level concepts first, including pointers. Maybe learning C and then Python could be a reasonable, minimalistic approach? C++ could actually be avoided since the syntax and rules are so complex. (I'm not talking about comp-sci majors who should certainly learn C++.) Perl is awesome of course, but again the syntax is complex and in the context of a college course that just takes time away from learning the essential concepts. Java is possible but doesn't really get either low-level or high-level enough for my tastes.
Whatever a student learns, they should have enough breadth, conceptual knowledge, and practice so that whatever language is required for a given project would not be too hard to learn on the job.
Many of the subjects you mention are directly related to writing applications like code coverage testing approaches, SDLC, documentation of code, etc. I agree there are two aspects involved here - learning to program and learning a particular programming language. It doesn't mean you can't learn software engineering if you narrow down the academic focus to current programming languages. Studying arcane programming languages like COBOL doesn't prepare you well to write a business application.
Sudheer Satyanarayana
www.techchorus.net
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
Seriously? Most scientists just need to do either:
1) Lots of math that would be tedious to do manually.
2) Lots of pattern matching in large data files.
Both of these things can be accomplished with small scripts by semi-skilled programmers. This isn't application programming. It's on par with macros.
I too had to learn FORTRAN (it was v77 then) as part of my undergraduate degree as did my now wife. We were both studying Environmental Engineering. There are many US Federal government agencies (e.g. EPA) who have mathematical models that are programmed in FORTRAN as per the federal regulations mandate. For those students who will be studying to work in this field it makes perfect sense for them to study FORTRAN. There are no plans I am aware of to update these environmental modeling programs from FORTRAN to a 'better' language. For the non-computer science students / environmental engineers it is a good place to start with computer programming and will add to their skills required for the work place. If they have the desire to enhance their computer programming skills they should be encouraged to minor in CS etc. For anyone else, dear God NO! Do not subject them to this language. My $0.02.
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.
TAIL-CALL RECURSIVE PROGRAMMING is probably the number one thing that sets real programmers apart from the wanna-be's.
There, fixed it for you...
Don't blame me, I voted for Baltar.
I realize you're probably joking, but our intro class actually teaches VBA, and even though it's a general overview for engineers of all shapes and sizes, they really do a poor job of teaching the fundamentals of programming, choosing instead to focus mainly on the syntax and the language itself. As far as I know, no subsequent class ever uses VBA, so we struggle with any future programming almost as much as we would have without an intro class. They may be looking to fix that, but for now it functions primarily as a weedout class and nothing else.
I didn't go into computer/software engineering, but I did TA the intro class for a semester and have worked with its graduates (my engineering peers) on group projects and the like. In my opinion, they really ought to teach the logic of programming (flowcharts and the like) much more heavily than focusing on any one language. That way, you don't have people sitting and memorizing the way a certain program is written but lacking the common sense to so much as use a loop rather than writing the same calculation over and over again.
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 and that computers don't necessarily think the way you do.
Python? As an intro language? And I thought people were misguided teaching Java as the first (and often only) language.
Second, while some of these scientific programs can run overnight, a lot of them will take a day or more to run, even when compiled and on a super or parallel computer. I don't know of any highly optimized Python compilers for big metal. Fortran is still the number one language for performance computing.
Third, there seriously needs to be major scientific libraries pre-existing for the language to be useful. An added benefit is being able to support more than one floating point number format.
Finally, the number one most important reason that Fortran is used in the sciences, is because everyone else uses it in the field. Seriously, what good is Python if all your prof's and advisor's and boss's programs that you need to maintain are in Fortran 66? It's faster to learn Fortran than to port it all. This is part of the "dusty deck" problem, where decades old libraries still have to be used and supported. This applies to many languages - many languages are popular precisely because they are popular, not because of inherent elegance or suitability.
In the sciences, the students are not being taught programming for the sake of programming, and they're not even being taught to write good programs necessarily. They're being taught to program as a mere tool for the important stuff being taught. Some classes may not even care what language you use, as long as you can read and understand the sample programs and the math library is correct.
Being in the sciences and not knowing Fortran will be a drawback. In some areas it may not be as big a drawback, but it will be there. This is like trying to do embedded systems without knowing C.
Clearly whoever was teaching python to the people you were watching made a pig's ear out of it.
I teach python to our beginning programmers and they find learning other languages *easier* than they did before python.
You just have to teach the principles properly and use python as runnable pseudocode.
Can you imagine trying to teach a new programmer how to troubleshoot Haskell?!
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.
I specialized in programming languages in general in school. I'm one of those people that can honestly say he has forgotten more languages than most people will ever learn. While fortran isn't a language I ever intend to use, having learned it was a useful experience. Other odd languages like lisp, algol, assy, sequence/state, etc, also provide you with unique insight into how to do things. I occasionally run into problems today where I think "that would be SO much easier to do in (name a language)", and that gets me to thinking of how to modify the simple solution in the other language to the language I'm currently working with. It's a bit like the towers of hanoi problem, it seems dreadfully complicated until you realize that done correctly the solution is very simple, and you just need to change your point of view.
This also makes you extremely flexible. I have absolute confidence that I can sit down at any new job using any language I've never so much as heard of before, and be able to read and understand the existing code immediately, write useful code that same day, and be highly proficient with it in under a week. The only reason I can do this is I've "seen it all" for the most part and so I've already beaten the basic obstacles like "object oriented", "pointers", "procedural based" etc that a new language might throw at me and would at least temporarily derail/disorient another newbie.
I work for the Department of Redundancy Department.