Slash Boxes

SoylentNews is people

SoylentNews is powered by your submissions, so send in your scoop. Only 17 submissions in the queue.
posted by NCommander on Wednesday April 02 2014, @07:11PM   Printer-friendly
from the I-remember-Applesoft-BASIC dept.

An article was recently published that looks at evaluating First Programming Languages (FPL) the language to use for an introductory course of programming.

An existing issue is that formally assessing a programming language isn't really defined, with a lot of evidence being anecdotal. The proposed evaluation framework looks at technical and environmental feature sets. "The technical feature set covers the language theoretical aspects, whereas, the environmental feature set helps evaluating the external factors." These feature sets are covered in table 2 of the article (link to PDF) and consist of the following:

Technical Features

  • High Level
  • Orthogonality
  • Strongly Typed
  • Enforceability of Good Habits
  • Security
  • Feature Uniformity
  • Less Effort for writing simple programs

Environmental Features

  • Demand in Industry
  • Contemporary Features
  • Easy Transition
  • Readable Syntax
  • Quality Coding
  • User Friendly Integrated Development Environment

The article explains each of these points in details, and gives each of the languages being evaluated a rating based on this explanation, followed by a detailed explanation of how the scores of each rating can be compared this includes allowing an evaluator to weigh certain criteria they deem important against the others. As this is for choosing a language to teach someone to program with, different places will have different reasons and goals, so would want to weight things differently.

As the default weight settings do not conform to the original popularity index of the languages, so there should be a different weighting criterion. However, it is very hard to come up with a generic and correct weighting criterion. Therefore, the scoring function should be customizable and the user should be able to tune the weight of each feature based on her preferences. As an example, consider the fact that Ada holds 3rd position in overall scoring, but is not being considered among highly used FPLs as of now.

NCommander adds: lhsi was kind enough to include a summary of the results. I looked through the paper and it seems like a fairly interesting read.

Using the default weighting, the top five First Programming Languages evaluated are as follows:

  1. Python
  2. Java
  3. Pascal
  4. Ada
  5. Modula-2


  1. Java
  2. Ada
  3. Python
  4. C#
  5. C++


  1. Java
  2. Python
  3. Ada
  4. C#
  5. Modula-2
This discussion has been archived. No new comments can be posted.
Display Options Threshold/Breakthrough Mark All as Read Mark All as Unread
The Fine Print: The following comments are owned by whoever posted them. We are not responsible for them in any way.
  • (Score: 5, Insightful) by SplawnDarts on Wednesday April 02 2014, @07:19PM

    by SplawnDarts (3962) on Wednesday April 02 2014, @07:19PM (#25092)

    This study assumes that making a first programming language easy, friendly, and useful is necessarily a good thing. I'm not sure that's false, but I'm certainly not going to accept it without proof. Anecdote-wise, my first language was HP-48 RPL. The first program I wrote of any consequence did symbolic integration (including trig subs, U substitution etc) vis STRING MANIPULATION in that somewhat unfriendly language. Was it easy? NO. Was it useful? Not really. But nothing I've ever had to program subsequently has ever been even vaguely as hard, and that has some value - I know I can program pretty much anything I can conceptualize.

    Hard programming may in fact be a one-way ticket out of larval stage.

    • (Score: 1, Insightful) by Anonymous Coward on Wednesday April 02 2014, @07:32PM

      by Anonymous Coward on Wednesday April 02 2014, @07:32PM (#25101)

      It depends on why you're learning the programming language. I think you have the right idea for people who will go on to a job where they need to program regularly. Other people just want to get an idea of what "programming" is about, much like I took history 101. If your goal is simple exposure to the concepts, ease of use is an extremely important criterion.

      • (Score: 3, Informative) by lhsi on Wednesday April 02 2014, @07:43PM

        by lhsi (711) on Wednesday April 02 2014, @07:43PM (#25110) Journal

        It depends on why you're learning the programming language. I think you have the right idea for people who will go on to a job where they need to program regularly. Other people just want to get an idea of what "programming" is about, much like I took history 101. If your goal is simple exposure to the concepts, ease of use is an extremely important criterion.

        One of the non technical features is easy transition, I.e. how easy it is to then teach another language after the first. As the framework allows for weighting you could weigh that highly to chose a language that is a better jumping off point to other languages. Demand in industry is another of the weightings if the selection was just going to be job based.

    • (Score: 2) by lhsi on Wednesday April 02 2014, @07:37PM

      by lhsi (711) on Wednesday April 02 2014, @07:37PM (#25107) Journal

      The article proposes a framework that allows selection of a language of a course to be weighed according to what sort of language you want. You could weigh it to select a more technically challenging language if you desired.

      Of course if you just wanted to teach someone something unfriendly and hard you'd just pick assembly or brainfuck and ignore the proposed framework altogether.

      • (Score: 4, Interesting) by VLM on Wednesday April 02 2014, @08:00PM

        by VLM (445) on Wednesday April 02 2014, @08:00PM (#25125)

        "teach someone something unfriendly and hard you'd just pick assembly"

        The problem is not setting the goal. The paper talks about educating computer scientists, and then lists criteria for vocational training of IT people. Going a third direction anyone can teach assembly to a EE / Verilog designer a lot easier than trying to hop right from NAND gates directly to Clojure, or even just mere Pascal. I wouldn't advise skipping machine language when hopping from NAND gates to assembly, but I guess you could do worse. At least pick a sensible comprehensible architecture like the PDP-8 had, then you can literally understand the whole simple system from transistor up to OS design, later branching out into other more complicated systems. And no I don't remember today how the wiring worked for the auto-incrementing address range system or all the IO ops, but I did understand them completely once...

    • (Score: 2, Insightful) by Ethanol-fueled on Wednesday April 02 2014, @07:46PM

      by Ethanol-fueled (2792) on Wednesday April 02 2014, @07:46PM (#25115) Homepage

      "Hard" programming is a sure-fire way to turn new students off of programming, because not everybody is a whiz-kid like you are. Of course, turning people off to programming is an idea I like, because the more of us are floating around, the less each of us will generally be paid.

      I think it's funny that the most frequent recent language in the article is Java, because there's a lot of bullshit in it (starting with that everything has to be a class) that is not necessary for simple operations like converting Celsius to Fahrenheit. C++ came in second, and personally I think it's ideal for a first programming language - You can start writing out only what you need done, and introduce classes later, and in between learn functions and pointers/references (the understanding of which is important to the understanding of how a computer works). It is important to reinvent the wheel in certain cases to get a better understanding of how things operate before you get unfettered access to all those libraries that do all the work for you.

      Sure, Java and Python allow you to concentrate more on the algorithm, but having C++ as a first language really allows the student to question if Computer Science/Engineering (as opposed to say, a degree in just programming if offered) is really for them. C++ is the best of both worlds -- high-level with low-level features -- and of course a good way to learn how many ways you can shoot yourself in the foot.

      • (Score: 2) by lhsi on Wednesday April 02 2014, @07:56PM

        by lhsi (711) on Wednesday April 02 2014, @07:56PM (#25120) Journal

        I think for the environmental criteria Java has quite a big benefit from the demand from industry section - have a look at table 11. If that isn't a major requirement if you're choosing a language you could weigh it less in the framework.

      • (Score: 4, Insightful) by SplawnDarts on Wednesday April 02 2014, @08:02PM

        by SplawnDarts (3962) on Wednesday April 02 2014, @08:02PM (#25127)

        I'm OK with turning people off programming. Far too many people are in CS who don't belong there.

        C++ Isn't a bad choice, were the console IO not so horrible. Seriously, the way I print to the console is to use the overloaded shift left operator? I can't even imagine standing in front of a classroom and trying to explain that with a straight face.

        C out of the K&R book is a better choice IMO.

        • (Score: 2) by umafuckitt on Wednesday April 02 2014, @08:42PM

          by umafuckitt (20) on Wednesday April 02 2014, @08:42PM (#25152)

          I'm OK with turning people off programming. Far too many people are in CS who don't belong there.

          You're apparently assuming that everyone who learns to program is in CS. They're not. I'm a neuroscientist and my major was also neuroscience. So in college I learned biology-related stuff and pretty much nothing else. Now that I'm a researcher I produce large volumes of fairly complicated data and the only way to analyze it is to program. A lot of people in fields such as mine had to learn to program and a lot of us have chosen MATLAB or Python, since these are high-level enough to make the stuff we need to do easy. Now I'm dabbling in C++ because I'm building hardware with microcontrollers. "Scaring away" people like me from programming has negative implications for a range of research topics. Conversely encouraging people like me to do a little programming college would make people's early research careers easier. In particular, it would be valuable to have courses that teach good coding practices early on. As it stands, a lot of us have to learn optimization techniques and best practices the hard way. This is a big waste of everyone's time.

          I realise that biologists who've learned to code have a bad reputation in certain circles, but some of us are better than others and we're willing to learn. Furthermore we need to learn. In some labs I've seen the data and interpretation carried out by the biologist and the coding and analysis done by CS people. The result is usually not pretty. The CS people don't understand the biology and waste lots of time doing unnecessarily complicated stuff that isn't relevant to the issue at hand. The biologist, if he doesn't code, doesn't realise that the CS people are barking up the wrong tree. He also doesn't understand what they're doing (partly because it's over-complicated in the first place). The CS people think that "biology is easy" and don't put in enough time to learn what the experiment really is. The end result is a Frankenstein's monster. In some labs a biology/CS partnership can work if each side puts in effort to learn about the other.

          • (Score: 4, Insightful) by VLM on Wednesday April 02 2014, @09:40PM

            by VLM (445) on Wednesday April 02 2014, @09:40PM (#25178)

            I think you'd do a lot better with IT than CS.

            To do CS I had to sit thru automata theory classes and the whole proof of 3SAT being NP complete and all kinds of computer science stuff that important to the science of computing machines but irrelevant to making most code for most things. Sounds like you need IT classes, like an intermediate Python class or C++ class, or maybe a systems analyst class, or a modern DB class. If you're in one of my CS classes where you hear all about lambda calculus and the y-combinator (not the VCs, the real thing) then you're probably in the wrong classes.

            So yeah, there's a lot of people gaining an intimate knowledge of red/black trees and converting NFAs to DFAs who really belong in a code slinging class not CS. I agree with GP post, there's a lot of people in CS who totally don't belong there.

            And there's nothing wrong with code slinging, just like there's nothing wrong with sitting thru yet another proof of yet another obscure NP complete problem. But there is something wrong with the IT folks or most neuroscientists taking CS classes when they need IT classes. Just like if a bunch of chemists invaded your field, because, hey, neurotransmitters are just chemicals, so its all good right?

            Sounds like your lab needs IT guys who know a lot of neuro. I agree, you really don't want CS guys there other than interesting philosophical discussions and internet debate sessions.

            I've made a lot of money for a long time by being a guy who knows EE, especially telecoms, and especially EE telecoms RF, inside and out, and also can sling at least some code and admin some machines when I have to. So I think I know exactly how you feel, other than you being a neuro-bio guy. My CS degree was a pure hobby after I already had 20 years experience in the industry doing this stuff, and it is of course completely useless on the job, although it was huge fun. So I'd strongly advise finding IT type classes which you can actually use and not doing the CS stuff at all other than as a hobby when you've got time.

            • (Score: 2) by umafuckitt on Wednesday April 02 2014, @10:45PM

              by umafuckitt (20) on Wednesday April 02 2014, @10:45PM (#25222)

              Yes, I see what you mean. I wasn't suggesting people like me need CS classes but that they need basic programming classes before being launched into research. I suppose our needs are closer to what may be taught in an IT degree than to a CS degree, but really all we need to know is how to do some fairly simple computational stats using a programming language. So stuff like PCA, clustering (k-means, hierarchical, etc), classification (linear discriminant analysis, support vector machines, etc), linear models, bootstrapping, cross-validation, etc. Stuff like that.

          • (Score: 0) by Anonymous Coward on Wednesday April 02 2014, @10:06PM

            by Anonymous Coward on Wednesday April 02 2014, @10:06PM (#25193)

            If you're dealing with large amounts of data I'd actually recommend you extend your dabbling with C++ to work, too - or at least to some other lowish level language, because reliance on the likes of Matlab and Python are going to be killing your runtimes. Dedicated C and C++ methods are easy to call from Python (give [] a look), which gives you the best of both worlds -- Python to set a problem up, and native code to get the performance boost. (Fortran works well with massive datasets since ultimately they're just big arrays and that's still one of Fortran's major strengths, but it's a bit of a pain to call from other languages, though you could run through C interfaces to get there which wouldn't be too shabby, so long as you were careful to invert your matrices along the way which itself comes with a penalty cost; depending on the situation you may well find yourself better sticking with C-like languages.)

          • (Score: 1) by SplawnDarts on Wednesday April 02 2014, @10:10PM

            by SplawnDarts (3962) on Wednesday April 02 2014, @10:10PM (#25195)

            I'm was at least half joking. For scientific computing types, python with NumPy/SciPy etc. is GREAT!

    • (Score: 4, Insightful) by The Mighty Buzzard on Wednesday April 02 2014, @08:02PM

      by The Mighty Buzzard (18) Subscriber Badge <> on Wednesday April 02 2014, @08:02PM (#25129) Homepage Journal

      This is exactly why I'd say make their first language C. It defaults to just barely usable enough that you can write useful things while learning.

      As for good habits... A lot of those depend entirely on the language you're using. If python gets you so hung up on whitespace that you think it actually means anything to most languages, you're in for some nasty headaches. Learn the language and the customs but never form habits. A foolish consistency is the hobgoblin of little minds.

      My rights don't end where your fear begins.
    • (Score: 4, Informative) by melikamp on Wednesday April 02 2014, @08:15PM

      by melikamp (1886) on Wednesday April 02 2014, @08:15PM (#25134) Journal

      I agree. I have a huge issue with security: why does that matter for FPL? Isn't the point just to teach basic programming? No first year will even begin to understand the concepts related to the security anyway. Demand in industry is also dubious; the industry uses more than a dozen languages, so the CS majors will have to pick up most of them anyway: some in higher-level CS classes, and others on their own time. Learning a relatively "useless" language may be a great trade-off, as long as it really helps to be more proficient with "useful" languages later on. Why bother with "contemporary features" if they are not even taught, as TFA itself says? And, of course, the development environment seems largely irrelevant for writing programs like "hello world" and basic sort, and can only produce pointless instructional overhead. (This alone should spell doom for Java, which I personally found really hard to use outside of DE.)

      Even though the other metrics are sensible, this whole study doesn't conclude much for my money, since it is hopelessly subjective and the goal is unclear. The one true way to evaluate FPLs is to set a measurable criterion (for example, performance in following CS courses) and do a statistical experiment, where first years are assigned different FPLs randomly, and 4 years later their academic performance is compared.

      Finally, I'd like to go out on a limb and to suggest that the only language to be taught for its own sake should be Common Lisp. The reason is two-fold: it has very nice features, of course, but it also is one of the hardest to learn on your own. And its features are indeed awesome. It is multiparadigm, allowing for declarative, functional, or OOP style of programming, either in their pure form, or mixed together. Its OOP facility, CLOS, is probably the most powerful and flexible one around. It has dead-simple syntax. It can be both interpreted and compiled, which is an awesome thing to have in a classroom. It has an amazing array of built-in types: (long arithmetic) Gaussian rationals, floats, strings, multidimensional arrays, single-linked lists, and hashes, to name a few. It checks types at run-time, and it collects your garbage. It has an incredible reference: the hyper-spec, which is also its official definition, to which implementations must adhere. It is not a highly used language, but this may very well be the consequence of it being hard to learn on your own. I believe that if taught, it would quickly enter the mainstream.

      • (Score: 1) by Heathen on Wednesday April 02 2014, @08:54PM

        by Heathen (965) on Wednesday April 02 2014, @08:54PM (#25157)

        I disagree that Java is hard to use outside of an IDE for basic programs like hello world. Such programs can ignore features like packages and concentrate on the basics such as loops and conditional statements. There is a minimal amount of boiler plate code (public static void main), which can be initially ignored.

        1. Save
        2. javac
        3. java HelloWorld

        Granted it's one more step than Perl, but I don't consider it to be that much harder.

        • (Score: 2) by melikamp on Wednesday April 02 2014, @09:12PM

          by melikamp (1886) on Wednesday April 02 2014, @09:12PM (#25163) Journal
          You are probably right, I never gave Java a second chance :)
  • (Score: 4, Interesting) by dx3bydt3 on Wednesday April 02 2014, @07:27PM

    by dx3bydt3 (82) on Wednesday April 02 2014, @07:27PM (#25096)

    The first language I used was BASIC on a vic-20. The first I had a course on was Fortran. I wonder if it had been C++ instead, would pointers and object oriented programming make more sense to me now, or would I have just got a poorer grade in the course.

    • (Score: 2) by Blackmoore on Wednesday April 02 2014, @07:42PM

      by Blackmoore (57) on Wednesday April 02 2014, @07:42PM (#25109) Journal

      My first was BASIC, and when i was at college they pushed PASCAL and Modula 2. they didnt even OFFER a class on C. (assembly was in the engineering major)

      I'm sorry but the damn paper is so tilted tword academic that it hasnt even noticed what was being used in the workplace. (which then would target COBOL, Perl, PHP and a lot of others depending on the programming flavor of the year)

    • (Score: 2, Informative) by qwerty on Wednesday April 02 2014, @08:26PM

      by qwerty (861) on Wednesday April 02 2014, @08:26PM (#25142) Homepage

      My first language was flowcharts written in pencil on sheets of paper; then BASIC on sheets of paper. That was before the VIC-20 existed, but the VIC-20 was the first computer on which I eventually got to run the programs on my sheets of paper. This was followed by VIC-20 assembler via pokes using BASIC. This sequence helped me understand what was "inside" computers, before moving to abstracted languages. When I started CS-undergrad, it was Pascal and C on a VAX-11/780, at which point the insides of the computer started to became an opaque cloud when programming.

      When it came to time to show my son some programming at about 8 yrs old, I introduced him to VBScript; which is close-enough to BASIC to make me think that it would emulate my learning sequence. But of course, it didn't exactly. Today's PCs are very comfortable to use without ever needing to even imagine what's under the cover.

      If the goal is teaching computer architecture, then maybe assembler is the best first language. If the goal is teaching algorithms, then a teaching language like Pascal would be fine, or even Knuth's MMIX machine language. If the goal is teaching how to be a software engineer, then C++ is expected. If the goal is teaching scientists how to code, then C++ and maybe R and maybe even FORTRAN would be a good combination.

    • (Score: 1) by jackb_guppy on Wednesday April 02 2014, @11:42PM

      by jackb_guppy (3560) on Wednesday April 02 2014, @11:42PM (#25249)

      Basic on HP/200F
      Basic under CPM
      Z-80 Assembler
      PDP-11 Assembler - What C got it ideas from.

      OOP is a state of mind, any language will do.
      Pointers learn Assembler!

  • (Score: 2) by lhsi on Wednesday April 02 2014, @07:29PM

    by lhsi (711) on Wednesday April 02 2014, @07:29PM (#25098) Journal

    I was taught Java at Uni for one of the reasons listed - desirability in industry. This was in addition to C, Scheme and assembly in other courses of the first year. The Uni had taught other languages in the past, but had moved onto Java for the main programming module mainly due to industry demand.

  • (Score: 2) by mechanicjay on Wednesday April 02 2014, @07:31PM

    by mechanicjay (7) <reversethis-{gro ... a} {yajcinahcem}> on Wednesday April 02 2014, @07:31PM (#25100) Homepage Journal

    I'm currently teaching an intro to Computer Science course and we're using Python. It might not have been my first choice, but I sort of inherited the course.

    My biggest complaints about python as a first language is that it doesn't enforce enough to really help the students understand what's going on under the covers. Some of the convenient things, I think make it easier, like the first week, but when you start writing slightly more complex programs, they become a hindrance.

    Of course having done my undergrad programming work all in Java, I might not recommend Java either, but then I think about how Java actually makes you follow rules, so maybe that is a better choice.

    My VMS box beat up your Windows box.
  • (Score: 4, Informative) by randmcnatt on Wednesday April 02 2014, @07:32PM

    by randmcnatt (671) on Wednesday April 02 2014, @07:32PM (#25102)
    The PDF is here []. The given one points to a PNG.
    The Wright brothers were not the first to fly: they were the first to land.
  • (Score: 2) by skullz on Wednesday April 02 2014, @07:44PM

    by skullz (2532) on Wednesday April 02 2014, @07:44PM (#25111)

    Ada and Modula-2 as first programming languages?

    I hacked some Ada and Modula-2 in my programming languages class so we could learn where the modern features such as OO and the like came from. But outside an academic exercise they are useless to learn now.

    Java and Python are fine. C# if you have do develop for Windows. C and C++ are still highly relevant. If they wanted to put an archaic language up there to use as a teaching tool go with Smalltalk or something.

    • (Score: 2) by lhsi on Wednesday April 02 2014, @08:04PM

      by lhsi (711) on Wednesday April 02 2014, @08:04PM (#25130) Journal

      The authors explain the selection criteria for the languages used:

      The other contribution of this work is that we have evaluated and ranked widely used FPLs using our proposed framework. Therefore, we have considered different imperative and object oriented programming languages which have been top ranked FPLs at a certain stage. It is evident from Table 1 that Ada, C, C++, Fortran, Java, Modula-2, and Pascal have been the most frequently used FPLs, whereas, Python and C# which have recently gained popularity as FPL.

      Ada and Modula-2 were more popular in 1994, where table 1 starts showing data. You could pick a different set of languages to evaluate with the framework if desired.

    • (Score: 1) by Aiwendil on Wednesday April 02 2014, @10:30PM

      by Aiwendil (531) on Wednesday April 02 2014, @10:30PM (#25215) Journal

      Ada makes sense, a lot of sense actually - in fact it makes so much sense I encourage C(and derivates thereof)-coders to write at least a few hundred lines in it every other year.

      The language is mostly readably by non-coders, every named block must have a named closure, it encourages/enforces good structure, and at the same time it is insanely flexible and it is standardised in how to interface with other languages ( pragma Import; ), and most compilers (including gnat (it is in most linux-dists, and it uses the gcc toolchain)) allows one check if the style conforms to standards (ie, do you have the right indentation or no spaces after a semicolon that isn't at the end of line? no, that either is a warning or an error depending how what flags you passed to the compiler - this is also is one of the reasons why all ada-code looks pretty much the same no matter what coder wrote it).

      Anyhow, as a first language it will be good in that it punishes bad behaviour severly (implicit typecasts - forget it, reading non-initialized variables - nope, only setting a few items in a struct - nope, having case/switch without all options handled - nope, and those are just the first few features I enjoy with ada, having unreachable code - nope).

      However its tedency to punish badly planned projects makes it take away about as much spontanity and joy of coding as protected memory does when exploring how far one can push the machine - so it is a language for projects and reliability rather then quick hacks and "just getting it out the door".

      I do have a hard time thinking of a better language for people to start out in - especially if the code is to be audited, proven, geared towards high reliability, or in case another class is in ASIC design (due to VHDL). It is an industrial language.

      But all in all Ada 83 is horrible and I'd recommend you avoid that, but later Ada-versions (95, 2005, 2012) are nice. :)

      • (Score: 2) by skullz on Thursday April 03 2014, @04:52AM

        by skullz (2532) on Thursday April 03 2014, @04:52AM (#25340)

        I see what you are saying but I must disagree. The constructs in Ada etc are good were designed to handle the mistakes developers make but they aren't suitable for a first language. Pointers, stacks, and understanding WTF a string actually is are important. Why are structs and function pointers so awesome? How is memory allocated? Why are binary trees so cool? These are the kind of things that they need to understand if they are going to actually harness the power of a language such as Ada or Java. They need to really get the why.

        And while Ada may be a good teaching experience it has no practical application. They need some C++ with a lot of Java/C#/Python/etc.

        • (Score: 1) by Aiwendil on Thursday April 03 2014, @10:33AM

          by Aiwendil (531) on Thursday April 03 2014, @10:33AM (#25443) Journal

          Pointers - Ada have them (access types)

          Stacks - Probably best described with a simple poll-based system, like reading non-seekable input (ie, polling the keyboard or stdin/fd0), I have a hard time imagining a computerclass that doesn't do this.

          What a string is - This probably will be explained at the same time that it is explained why ada has fixed, bounbed, and unbounded strings, and also why many compilers has support for c.string in the libraries they ship with. (Also, the Ada RM's section A.4 specifically describes how the strings are implemented - and yes, the RM is heavily used by people using Ada). However the compiler defines its default strings as a simple array of fixed length (null-terminated strings are not the norm in all languages)

          Function pointers is called "access to subprogram" and are explained (with examples) in the RM at section 3.10)

          How memory is allocated is dealt with in section 4.8 (describes "new") and in countless other places (mentioned in section 4.8 and the sections it points to), for an non-typed pointer it is unchecked_allocation (called "unchecked access types" in Ada)

          Binary trees are something that be implemented in any language that has any kind of pointers and is a good excersice to learn them - yes (this argument was not in line with the other ones).

          Structs? You mean record types ;) and yes, the entire RM is littered with them and you quite frankly can't learn Ada (nor understand the RM) without them getting second nature.

          "Function pointers" are probably the epitome of reinventing the wheel. But yes, having the address of a call stored in a variable is useful to write programs whose behaviour changes at runtime.

          However, just doing something simple like implementing a generic menu-system for use in other programs would force one to deal with all of the points above (or for that matter writing a simple interactive text-editor) so it is just a matter how of you set up the course - and it is language-agnostic.

          And no practical application for Ada? Don't tell that to industrial/avionics, banking, nuclear, space-exploration, medical, infratructure or other safety-critical systembuilders ;) ( ary.html [] for a quick list of wellknown Ada-projects ) - as I mentioned before, Ada is an industrial language (it is geared towards reliability, big/changing teams, and big projects)

          But having a mix of multiple languages would be the best, so probably the best setup would be to run multiple courses with all in different languages (there is something oddly appealing with the thought of seeing someone being forced to solve problems in Ada/C/Java, erlang, perl/python, non-macro assembler AND lisp/clisp)

          Also, the whole "first language"-assumption is flawed in that it tends to assume generic computers to start with - take a look at programming for PLCs for a situation where one has to throw out everything one learned about coding and fetch the nearest engineer to get stuff done.

  • (Score: 3, Interesting) by weeds on Wednesday April 02 2014, @07:46PM

    by weeds (611) on Wednesday April 02 2014, @07:46PM (#25114) Journal

    I think it depends on what age you are when you take that first course. If the students are younger, the focus should be on easily translating stepwise thinking into getting something done; Easy to get variables from the screen and easy to get results out.
    My first language in high school was FORTRAN. First application (written on a Decwriter over an acoustic coupler) was a quadratic equation solver. It was easy and quick to get the hang of it.
    There seems to be some presumption that you have to study this language for a year (school year) before moving on. I don't see why you couldn't start with BASIC (or even a short stroll through assembler) to get off the ground and then switch to something more comprehensive. I also don't think that marketability or security should ever be considerations when learning a first language. A first language (or languages) should teach programming concepts and give the prospective developer a chance to see if they have an aptitude for this type of work and if they like it.
    When I got to the university, the engineers were learning FORTRAN and the CS students were learning Pascal. Developers use the tools they are given to solve problems. I would bet that any developer who's been at it for more than 10 years is not writing in the same language they started with.

  • (Score: 2) by VLM on Wednesday April 02 2014, @07:53PM

    by VLM (445) on Wednesday April 02 2014, @07:53PM (#25119)

    I have no idea how rom based microsoft basic didn't win.

    I glanced thru the paper, and the criteria listed are awesome for community college vocational job training in it, but nominally claim to be for education in cs, which I thought was pretty funny. If you're trying to educate someone in cs you can make a decent argument for a lisp family, but obviously priorities are a little different if you're just trying to turn out as many job trained ruby on rails web developers as possible to push salaries down.

    You can have a lot of fun with this topic in general by using whatever criteria is proposed to design a curriculum for english literature or drivers ed. I've seen some pretty comical examples for each. The english lit one usually ends up with people magazine as being the pinnacle of human knowledge, and the drivers ed one usually turns out to be a ten speed bicycle.

    Having been in this biz since '81, my observations more or less match the claimed data. At least with respect to what is the current .edu fad. Whats used in industry has always been quite a bit different.

    Also I'm getting pretty f-ing tired of "filter error: please don't use so many caps. using caps is like yelling!" no its called using acronyms, mr ee f-ing all lowercase cummings.

    • (Score: 1) by dvader on Thursday April 03 2014, @07:30AM

      by dvader (1936) on Thursday April 03 2014, @07:30AM (#25376)

      Now that I think of it, a 10-speed bicycle isn't such a bad choice for drivers ed if their level of knowledge is similar to what people know about computers and programming. Actually, walking by foot would be even better.

      If people knew as much about driving as they do about computers, the first questions would be:
      * What's a road?
      * Speed? What is it and why is there a limited supply of it? If my mother goes below the limit, does that mean I can go above it?
      * Traffic? Oh, that is way too difficult. It's a very peculiar and abstract concept representing a large set of vehicles occupying a limited physical space. It's such an advanced topic they don't teach it until 3rd year at university. Seriously, I don't see how anyone could ever have use for such a silly concept.

      Just walking or biking would be a very good start for drivers ed.

  • (Score: 5, Interesting) by maxwell demon on Wednesday April 02 2014, @08:29PM

    by maxwell demon (1608) on Wednesday April 02 2014, @08:29PM (#25146) Journal

    For a first programming language, I'd use another list of critera, and disagree with some of those given. For example, it is of advantage if it is not used in industry, because it forces you to learn a second programming language. Knowing more than one programming language makes you a vastly better programmer. I'd say the first programming language should have at least the following critera:

    • Minimally cryptic: There should not be a steep learning curve just to be able to read an existing program (other than understanding the algorithmic content, of course, that one cannot be avoided). Prefer written-out operators to short ones (except where the operator is commonly used in school-level mathematics), and avoid double meanings (like the symbol "*" being used both as dereference operator and multiplication operator in C), subtle differences in usage (like C's a++ vs. ++a), or very similar operators with different meanings (like C'S & and && operators). Prefer written-out keywords and function names to abbreviated ones. Make the syntax easy to parse to the human brain. Avoid excessive boiler plate. Whereever reasonably possible, make slight mistakes cause error messages instead of different meanings. Remember, the first language is the one where the learner not just learns the language, but he also learns programming. The language should not get in the way of learning programming by taking unnecessary time for learning just the language details.
    • Fun to program in. That is, don't restrict the programmer more than necessary. Languages which enforce a certain programming style are great as second languages, but the first language should be forgiving wherever reasonable (except that it should not reward dirty tricks, if possible). The learner should not be fighting the compiler/interpreter, he should be encouraged to experiment with it.
    • Support for all important programming paradigms and constructs. Today, that means procedural, object-oriented and functional programming. It should also come with easy to use libraries for things people would want to do today (like GUI stuff, graphics, and maybe even basic Internet access).



    The first language should

    • get in the way as little as possible,
    • invite to explore it as much as possible,
    • enable to do as much as possible.


    Now, the second language should have different criteria. Some of the criteria given in the list are fine for the second language; especially it should be quite strict, so it teaches you good habits.

    Case in point: Back in the Turbo Pascal times, I enjoyed writing Pascal programs very much. But I'm not sure that I also would have enjoyed it if it had been my first language.

    The Tao of math: The numbers you can count are not the real numbers.
    • (Score: 1) by Daiv on Wednesday April 02 2014, @09:10PM

      by Daiv (3940) on Wednesday April 02 2014, @09:10PM (#25161)

      I cut my teeth on Pascal in high school, then I learned Fortran, Cobol, Java (Java 2 has JUST come out!) then C++ in university. It's been long enough I remember only minimal basics of each but I'm looking to get back into programming. Anything I pick back up on might as well be my first language.

      Based on your criteria, what would YOUR suggestions be for a 1st and 2nd language?

      • (Score: 0) by Anonymous Coward on Wednesday April 02 2014, @10:10PM

        by Anonymous Coward on Wednesday April 02 2014, @10:10PM (#25194)

        I'm not the guy above but I am the guy below, and from your list, C++ or Java. C++ is in some ways practically a different language now - the change from pre-C++98 which I knew before to C++11 and 13 (particularly with boost additions to deal with some of the... weirder bits that are in the STL) is surprisingly large, and I find it makes it a much nicer language to work with. So obviously I'd suggest C++, but then I don't know Java very well at all.

      • (Score: 2) by maxwell demon on Wednesday April 02 2014, @10:43PM

        by maxwell demon (1608) on Wednesday April 02 2014, @10:43PM (#25220) Journal

        Based on your criteria, what would YOUR suggestions be for a 1st and 2nd language?

        Unfortunately I'm a bit out of touch with current programming languages. It's been a while that I've done some serious programming. I don't even really have enough time to learn everything I need for my job, so there's very little time left for really learning new programming languages, although there are quite a few I'd like to learn because I feel they'd bring something on the table which extends my understanding.

        Anyway, the fact that you've already learned quite a few languages means that anything you'll learn will not be your first language. I mean that not just pedantically: Although you may not remember the details, you should have the basic structures still in your brain, although possibly dormant; you can simply fill them with the constructs you learn, no matter whether you re-learn a language you've forgotten, or learn a new language. Through Java and C++, you probably are also familiar with the basics of OOP. What seems to be missing is experience with functional programming, so if I were in your situation, I'd look at languages which are strong in this regard. Those languages also tend to be sufficiently different that in some sense it really would be almost like learning your first language: You'll have to relearn all your concepts. But afterwards, you'll have a deeper understanding of programming (and wonder why Google's MapReduce was all the rage, given that it's just the parallelization of a natural combination of two fundamental functional programming paradigms). And as bonus, you'll not be terrified if you encounter template metaprogramming in C++, which basically consists of functional programs written in horribly complicated syntax and run at compile time. ;-)

        The Tao of math: The numbers you can count are not the real numbers.
    • (Score: 1, Interesting) by Anonymous Coward on Wednesday April 02 2014, @09:13PM

      by Anonymous Coward on Wednesday April 02 2014, @09:13PM (#25164)

      I read the criteria and immediately concluded they wanted Java to come out top, probably followed by Python or C#. Turned out that that's what happened. I think the issue is that any such list is going to be driven at least as much by the prejudices (in the academic sense, not a perjorative sense) of those who draw it up as anything. In this case they "hid" it by selecting criteria that would demand it come out as Java, Python or C#. The killer is "Demand in industry". Since when was "demand in industry" a criterium for a first language? Surely ease of use would trump it, but then we might end up with the likes of Pascal or (horrors!) BASIC entering the mix.

      Not that I've a strong opinion on an alternative -- my first language was Sinclair BASIC, then I did some QBasic, then Pascal, bits of C++ (back before C++98 was fully accepted, so I was using an old Borland compiler from the mid 90s), then Fortran 9x. These days I program in a mix of Fortran 03/08 and, when the ungainly OO syntax becomes too much to bear I swap to C++. At work I'm exclusively in C++11. I wouldn't recommend *any* of these as a beginner's language with the possible exception of Pascal (or, if very tightly controlled, Fortran 08 and C++11 and above, but the danger of tangling yourself with either of them and producing horrific code is pretty strong).

      • (Score: 2) by lhsi on Thursday April 03 2014, @07:21AM

        by lhsi (711) on Thursday April 03 2014, @07:21AM (#25373) Journal

        If you read the paper they also point out that Java is a popular teaching language anyway - so it would be a little weird if it wasn't high as it would mean that their framework was really off base. They also stress that they have created a framework and not objectively ranked languages - you can add different weights to different criteria if you like (and choose different languages to evaluate) which will change any rankings.

    • (Score: 1) by Aiwendil on Wednesday April 02 2014, @10:36PM

      by Aiwendil (531) on Wednesday April 02 2014, @10:36PM (#25217) Journal

      As someone who actually had Turbo Pascal as first language - it was fun, it was _VERY_ fun, especially after one found out how to add inline assembler (less then two weeks). Suddenly the computer went from being a unit to play on to a unit to explore and prod.

      Probably the most fun combinations of languages I've encountered so far.

  • (Score: 2) by VLM on Wednesday April 02 2014, @09:17PM

    by VLM (445) on Wednesday April 02 2014, @09:17PM (#25168)

    Aren't all the tech features listed good in "a language" and simultaneously bad in "a first language"?

    Doesn't need to be high level because the programming tasks are not going to be high level. You'll be implementing the concept of a loop, recursion, the idea of GIGO and input sanitization... no need for high level there.

    Doesn't need to be orthogonal, after all you're going to be stuck with non-orthogonal languages in the real world occasionally, and no better time to learn than with a professor rather than google. And see above, noob is going to be solving real complicated problems like "implement a bubble sort" or "use an array" so having some limits is, in itself educational.

    Can't enforce good habits WRT LISP macros or OO polymorphism if you're still trying to figure out hello_world.cpp. So irrelevant. Not irrelevant in industry, but irrelevant in training. And encouraging the learner to trip over themseleves in a mid-semester sized project is an Excellent learning experience. If you get them to crash and burn in about 3 pages, thats awesome for education. You want to fail early to build good habits for good inherent reasons, not raise them to go all cargo cult on what may be good habits or may just be a fad and they won't understand the difference.

    Security. Uh, what, you're having CS101 students implement your SSL library or babbys first AES implementation? That is just so wrong on so many levels. Nothing from that class should ever be on the internet in any form. Again, another awesome feature for a vocational training language or an on the job language, but probably awful for CS curriculum. Even for vocational training, how exactly do you explain the features required to prevent buffer overflow / stack smashing to a bunch of noobs who don't know what a stack is or why they'd want one or what an buffer is for that matter? Just going to confuse them. And looking at it the other way, go Socratic on them and let them build buffer overflow victims and teach them how not to. Again, experience and rational thinking troubleshooting always beats cargo cult tradition. A good educational language should be easy to write vulnerable code and just a little harder to do it right.

    Don't let your language get in the way of your learning. But don't use baby talk language all your life either. Don't be the "All I was trained on was hammers; but don't work so gud on deck screws." guy.

    • (Score: 2) by melikamp on Wednesday April 02 2014, @09:37PM

      by melikamp (1886) on Wednesday April 02 2014, @09:37PM (#25177) Journal

      I agree more or less with everything, except may be the "level". It depends on how we define "low-level", of course, but I am used to think of it as dressed-up Assembly: impossible to interpret, memory micro-management, and complete absence of non-functional paradigms. As much as I adore C, I don't think it would be a great FPL even for CS majors, and a pretty terrible choice for everyone else. At least a CS major will learn something about the way a computer actually computes, but everyone else will probably just shake their head in disgust.

      • (Score: 2) by VLM on Wednesday April 02 2014, @09:56PM

        by VLM (445) on Wednesday April 02 2014, @09:56PM (#25188)

        There's an old saying about you can write Fortran in any language. Now a days they probably say PHP. But the point is something like assembly would make someone who refuses to learn functions subroutines modularization unit testing libraries include files, crash and burn real fast, which is awesome for learning. Better to crash and burn at three pages in school than thirty on the job.

        I was thinking low level as in a noob who may never take a data structures class might get thru a 101 intro class better without a long discussion of call-by-value vs call-by-reference. Or a noob who might never take a data structure class because thats just not how he rolls, doesn't need a language that can do more than ints/floats. Or no idea what a lambda is, no need for language features like macros or ability to create domain specific languages. If you're working on "what is a flow chart" or "what is the basic concept of procedural programming" then a language with polymorphism is unnecessary.

        Crazy as it might sound, one of the toy languages like Scratch might be OK as a first language. Or perhaps javascript? Basic? Some people are baffled by "programming" a spreadsheet so that might be a place to start? Gotta walk before you can run...

    • (Score: 2) by lhsi on Thursday April 03 2014, @07:27AM

      by lhsi (711) on Thursday April 03 2014, @07:27AM (#25375) Journal

      Security. Uh, what, you're having CS101 students implement your SSL library or babbys first AES implementation? That is just so wrong on so many levels.

      That's not what they meant by security in this context. It was defined in the paper:

      "In order to evaluate a language for its strength in security we propose the following parameters: i) language should avoid dangling references; ii) there should not be any memory leakage; (iii) control over array index out of bound; (iv) pointers arithmetic; (v) prevent stack and heap overflows. "

      The idea being that not having to teach memory allocation and clean up means they can focus on the actual programming bits (and learn memory allocation with another language later on if required).

  • (Score: 2) by bob_super on Wednesday April 02 2014, @09:32PM

    by bob_super (1357) on Wednesday April 02 2014, @09:32PM (#25172)

    The main problem I had when I learnt to code (C/C++/Java) was the gap between the exercises and reality.
    Here, have a few buttons, you can enter values, click on them and a number will show up elsewhere...

    Then I got to a real job, and there was a massive pile of drivers that were used to high-tech stuff and produce system validation tests. Then someone needed a GUI to drive the new product and I inherited it because my resume said Java.

    None of my teachers had bothered with the useful stuff. I knew how to use the languages, but how to make something useful that collects and parses and organises and spits data? Nah, that's not for EEs, unless you're a full geek who thinks parsing databases on your week-ends is a fun pastime.
    Did they give me enough knowledge to figure it out? Yes, and they probably consider their job done.
    Should they have bothered to teach how you should go from Hello-world to actual useful stuff, running on real systems (OS or embedded), to do something useful for real people? That would have saved me a lot of grief...

  • (Score: 2) by AnythingGoes on Wednesday April 02 2014, @09:45PM

    by AnythingGoes (3345) on Wednesday April 02 2014, @09:45PM (#25186)

    What I find wrong is the assumption that we want more programmers and therefore should make it easy to get started.

    The biggest danger in this thinking is that we should be evaluating for interest and determination rather than getting more programmers .. after all, the best programmers I have ever seen all have a deep interest in computing and are determined to get to the root of any problem!

    Do doctors make it easier to be one? After all, you have to learn about the entire human body even before you get to pick a small area to specialize in.

    By teaching easier languages, we are selecting for the wrong kind of programmers - witness the crappy results of programmers who write 10000 line procedures with IF X=1... if X=2....if X=3 (apparently not understanding "if X>0")

    I would rather that these wanna-be programmers fail before they ever graduate..

    My suggestion - teach the first computing language as Assembly and C - then for those who pass, we can start on the path of learning easier languages.

    Why did Knuth create "MIX" to be his teaching language? He could have had the pick of Cobol, Fortran, Algol or PL/I, instead of choosing an assembly language to illustrate the effects of algorithms.

    • (Score: 1) by ramloss on Wednesday April 02 2014, @11:35PM

      by ramloss (1150) on Wednesday April 02 2014, @11:35PM (#25247)

      I kind of agree with you, the objective should not be to make it 'easy' to learn a programming language, but to teach programming concepts and technique. But why go out of your way to make it difficult? Simply use the language that best fits the concepts you want to teach and let the chips fall where they may.

      I put the quotes around easy because it may mean several things, among them 'lower the bar so that more people can pass', which is bad or 'present the subject in a way that is easy to understand', which is good. In the end it all boils down to why you want to teach a computer language, I guess.

  • (Score: 2) by naubol on Wednesday April 02 2014, @10:11PM

    by naubol (1918) on Wednesday April 02 2014, @10:11PM (#25197)

    If Djikstra is right, lly_Teaching_Computer_Science [], that computer science is really a branch of mathematics... maybe the most important feature of a first language should be how it exposes you to the mathematics.

    If that is the case, then I think really one of the few obvious languages to choose is C.

    But, there is a meta discussion about what constitutes a good programmer. Solving high level problems quickly vs. solving to the metal problems. Frankly, I think that the low level backend engineers often have great difficulty doing work that requires less precision and are more like "limited information problems". And, the reverse is certainly true. There is a multitude of programmers that could not write a basic data structure who are gainfully employed.

    But, in terms of pure CS, I still want to say that we should start with a language that makes it very hard to get away from the math as the most salient feature.

    • (Score: 2) by stormwyrm on Wednesday April 02 2014, @11:11PM

      by stormwyrm (717) on Wednesday April 02 2014, @11:11PM (#25234) Journal

      If Djikstra is right, lly_Teaching_Computer_Science [], that computer science is really a branch of mathematics... maybe the most important feature of a first language should be how it exposes you to the mathematics.

      If that is the case, then I think really one of the few obvious languages to choose is Lisp.

      FTFY. C exposes you to the innards of the machine in a way that only assembly language does more, and in many ways the fact that you need to deal with machine-level constructions with C all the time obscures rather than exposes the mathematics. If you really wanted to expose the mathematics, there are few languages that do that better than Lisp. John McCarthy basically invented Lisp because it provided a better means of illustrating theoretical computer science concepts like universal computation. Turing Machines are really a rather awkward way to describe computation.

      These simplifications made LISP into a way of describing computable functions much neater than the Turing machines or the general recursive definitions used in recursive function theory. -- John McCarthy, The Implementation of Lisp []

      However, I for one don't believe that CS is just about the mathematics. Computer science is not just about the theory of computation but the practicalities of computation on real machines. C I think fills the latter just as well as Lisp fills the former. Perhaps Lisp could be the first language and C the second, as both the theory and the practice are needed for a well rounded computer scientist.

      Numquam ponenda est pluralitas sine necessitate.
  • (Score: 1) by gishzida on Wednesday April 02 2014, @11:27PM

    by gishzida (2870) on Wednesday April 02 2014, @11:27PM (#25241) Journal

    I learned to program the hard way... First on paper in pseudo-code for an algorithmics class then several years later I picked up an HP-11c calculator and an HP67 desktop calculator attached to a digital height gauge from there I went to IBM PC basic and then IBM Compiled Basic then HP Technical Basic and Borland Pascal with some extended work on talking to peripherals on an IEEE-488 buss card and sending and receiving through a serial port to a punch tape... then later we added other smatterings of that and this... new basic and pascal variants and touches of various "dynamic" languages, TclTK, Lua, Python, Perl. Of these Tcl is the easiest to learn and actually produce running scripts. I also used Euphoria and IBasic [before it imploded]. Both were fairly fast and easy... I've also used a smattering of C, Fortan, Perl, Java... but not enough to be considered a programmer in those languages... the usual amount of use that a General Specialist such as myself uses. So take what follows for what you find it worth...

    Java [IMHO] is not on my list of recommended languages. First because it is not a "freely, available language"... Second it is from Oracle... Thirdly did I mention it is from Oracle... It was supposed to be the center of Sun's network computer initiative [the 90s version of mobile]. It did not work out until Google took it and built their own Runtime. The fact that Java has consistent and constant security issues has led me to block it in all of the browsers I use [Chrome and FireFox]. As for C#? C# is the MS answer to Java... No. Just say no again. If it isn't an open standard then you never know when the provider will "pull an Oracle" and want to be paid for your work.

    Javascript is not much better. I wrote a program that ran in Netscape 4.x It was a bear to code, it was as slow as molasses, and I had to take advantage of the security holes in the browser's sandbox to read and write data files. Modern JS does not appear to be significantly different. No. Just say no.

    C isn't bad except it has a generally "non-human readable" syntax. I understand the historic reason but just because the back end then was a PDP-10 doesn't mean your code needs to still look like unreadable gobbledygook. C is fast and has a small footprint but maybe not as fast and as small as Forth. [Yes I dabbled with that too... still have a copy of the Forth book around somewhere].

    One question is: Why wasn't Lua considered? It is not much different than Python... other than it was not developed in North America or Europe...

    As far as I am concerned OO languages are overrated. Originally they were "sold" as the basis of reusable code. Didn't happen. That it was easier to code. It wasn't. That it was better than sliced bread. I've discovered I have gluten intolerance. Yes I know there are those of you who are professional code wrights and will spout your favorite... for a dabbler like me BASIC, Tcl, Pascal suits me.

    Oh there are other languages that were not even mentioned for pushing algorithmics... Can you say Logo or Smalltalk derivatives like Squeak. The point here is [in my useless opinion] that it almost seems that programming language designers intentionally make their task more difficult. Programs are for solving problems... not for creating syntax that is not clearly understandable.

    My ideal language would have:

    1) A syntax something like Pascal,
    2) Have prepackaged functions for graphics and communication like CA-Realizer which had a slick set of functions which could do Log-Log graphs easily or communications without any sweat or serious amount of coding. As far as I am concerned Tk like windowing makes for faster delivery. OO windowing just seems to add a level of obscurity that isn't needed except by those obsessed with having access to all of the code of their windowing API. Additional complexity in a windowing library is a sign that the designer wasn't really interested in easier programming.
    3) Was cross platform
    4) Was native compilable [JIT is not as fast as native] but can run as a dynamic language. [Tcl, Python, Perl, lua do not compile to native... I've often wondered why. If you are going to spen the time to write a run-time environment why not just build a complete cross compiler?]
    5) Was open source software
    6) Had a sweet disposition for rapid debugging and development.

    I don't think there is currently a language that actually fits that bill. If there was an open source 64 bit CA-Realizer clone for RAD I'd be really happy... but it seems that compiler writers have fallen in love with complexity just because that is the way they think. If the point of programming is to solve problems then why create a language that of itself is problematic [buffer overflows, no boundary checks, explicit security, difficult syntax constructs, as well as countless others].

    The point of TFA is "Use Brand X because Larry the O says so". As a counterpoint -- One can also say "3 billion flies can't be wrong, eat manure..." Both are filled with the same "savory" flavor.

    Computer languages do not need to be complex to be usable. We have long since passed the point where a compiler does not have sufficient hardware resources to interpret a program in "human readable" code. Why do we continue to write code in non-user-friendly languages? Why do we continue to believe that shaving nanoseconds off execution time on a single processor when hardware has moved on from the heady days of Fortan and C in 10K of core memory.

    A general Specialist's Rule of thumb when evaluating a tool for a specific purpose: "If it was ugly going in, it will look worse coming out." A language should be elegant and fluent. It should be easily communicated and understood. Most modern languages are a serious FAIL in this regards... but then again consider the source. ;)

    • (Score: 1) by hendrikboom on Thursday April 03 2014, @03:06AM

      by hendrikboom (1125) Subscriber Badge on Thursday April 03 2014, @03:06AM (#25313) Homepage Journal

      Have a look at Modula 3. It conpiles to machine code, will cross-compile to machine code for another machine, is serious about run-time checks and garbage collection and similar security, and has object-oriented stuff that you don't need to use if you don't want to. It has a syntax like Pascal.

      And if the security gets in your way, it you can explicitly declare that you'll use unsafe language features and start pointer-punning and explicit storage allocation and freeing to your heart's content.

      It's one of the few languages where, once you get the program through the compiler, it's reasonably likely that the program will actually do something like running.

      Oh. And nowadays there's a new code generator for it that compiles to very portable C.

      Look it up on the wikipedia and follow links from there.

      Don't' confuse it with Modula 2. That's a completely different language.

  • (Score: 2) by hybristic on Wednesday April 02 2014, @11:30PM

    by hybristic (10) on Wednesday April 02 2014, @11:30PM (#25242) Journal

    I wont lie, I am a bit surprised to not see Ruby up there. Maybe its because I come from a Python and C background, but I find Ruby to be a pleasure to work with, very readable, easy to learn, and useful for a wide range of tasks. As a stand alone language I am unsure how often it is used in industry, but I know a few friends that work in the medical field that use Ruby as their primary language. Then, for better or worse, you can add it to Rails and make a powerful web application. I still think Python and Java make more sense, but the fact that I didn't see Ruby anywhere in there is a bit of a shock. I am no Ruby pro, so I guess I may be missing the parts of the language that allow it to fall short.

    • (Score: 1) by gishzida on Wednesday April 02 2014, @11:47PM

      by gishzida (2870) on Wednesday April 02 2014, @11:47PM (#25251) Journal

      As I noted above Lua was not mentioned either... It appears to me that if it wasn't developed in Europe or North America or other European settled countries [R for example is from New Zealand] the authors of the article did not consider it... Ruby was created in Japan and Lua in Brasil. One might consider this as ethnic bias.

      One may wonder if India or China have any "home grown" programming languages that we have not heard about because of a similar kind of bias.

      • (Score: 2) by hybristic on Thursday April 03 2014, @12:07AM

        by hybristic (10) on Thursday April 03 2014, @12:07AM (#25258) Journal

        Wow, good point, I seemed to have missed your comment about Lua. But evaluating the list that seems like it could absolutely be possible. I personally want to investigate the languages developed and used in other countries and see if there is in fact a correlation. I imagine that you are correct though.

        • (Score: 2) by lhsi on Thursday April 03 2014, @07:38AM

          by lhsi (711) on Thursday April 03 2014, @07:38AM (#25378) Journal

          In the introduction of the paper they explain why they chose which languages they used in their example - it was because they were popular languages used for teaching in Universities.

          The paper also describes a framework to use (the results presented are just an example using the data they had); the whole point is to grab any languages you want to evaluate and run the numbers yourself.

          Evaluating a different set of languages like those you've mentioned actually sounds like a good story submission for this site.

  • (Score: 2) by prospectacle on Wednesday April 02 2014, @11:51PM

    by prospectacle (3422) on Wednesday April 02 2014, @11:51PM (#25254) Journal

    It would be far more useful (and probably faster and easier, after a few weeks) to learn three or four very different languages, at the same time.

    First write and run "hello world" in each one. Then progress to a more complicated program (e.g. taking input, doing an operation on that input, presenting some output), again writing the same program in each language. Then gradually increase complexity until the many differences (and commonalities) between the languages become clear.

    This has numerous benefits that cannot be attained easily by learning any single language, such as:
    - Thinking about the algorithm as distinct from the implementation language.
    - Understanding each language better in itself, by seeing how it differs from others.
    - Learning how to choose the right tool for the job by learning what each language is good at.
    - Being better prepared to learn any other languages.

    I would suggest:
    - c++
    - python
    - javascript

    These languages are all free and popular, and you would learn a wide variety of:
    - Environments (compiled to machine code, command-line interpreter, host-environment (web browser))
    - Object models (classes, prototypes)
    - Typing (strong typing, duck-typing, no (or implict) typing)
    - Areas of usefulness (faster/close to hardware, application and scripting, user interface manipulation).

    In addition, each of these can be easily written with just a text editor and an easy to obtain compiler or interpreter.

    If you can learn these three, it would be fairly easy to learn almost any other language. They're also useful and in demand, in themselves.

    If a plan isn't flexible it isn't realistic
    • (Score: 2) by hybristic on Thursday April 03 2014, @04:37PM

      by hybristic (10) on Thursday April 03 2014, @04:37PM (#25675) Journal

      There is a fairly decent book called Seven Languages in Seven Weeks that uses a similar logic, and I think its very effective. I think the book approaches it a bit better though. You don't really do 7 "hello world" programs, what the author has you do is take a moment to learn the syntax, and then he has you build a completely different program with each language that highlights the power of that specific language. I think this is more effective, as it helps you understand different methods of programming, different ways to approach problems, and understand that each language is built for a purpose. The book teaches you Ruby, Io, Prolog, Scala, Erlang, Clojure, and Haskell, and he details why hes teaching each one. Seven Languages in Seven Weeks []

  • (Score: 2) by Snotnose on Thursday April 03 2014, @12:08AM

    by Snotnose (1623) on Thursday April 03 2014, @12:08AM (#25259)

    Stopped reading at the flowchart of what language led to what. Javascript and Java have nothing to do with each other except that the JS author wanted to latch onto the Java bandwagon.

    Don't get me started with Ada. A language that is only used when the government demands it is IMHO a failed language. I speak as someone who had to use the damned language for a year back in '91 or so.

    In this month in 1958 Project Snot was started. This has upset many people and is widely considered a bad idea.
    • (Score: 2) by lhsi on Thursday April 03 2014, @07:42AM

      by lhsi (711) on Thursday April 03 2014, @07:42AM (#25381) Journal

      The Java/Javascript thing was pointed out as one of the reader comments on the paper: n?root=78719 []

      The rest of the paper doesn't talk about JavaScript at all, it seems to have just been mentioned in passing as a sort of "history of" in the introduction.

  • (Score: 1) by albert on Thursday April 03 2014, @03:03AM

    by albert (276) on Thursday April 03 2014, @03:03AM (#25310)

    Check out [] and see how people are coding. At first glance this looks like a graphical programming language, but it's really just a structured editor for an ordinary text-based language.

    This editor is pure genius. It lets you see your options. It blocks syntax errors.

    The one problem is that they use a screwy language that is stuck in an interpreter that is written in flash ActionScript. You're slowed by multiple levels of interpreting and the only portability is to other people on that web site.

    Better would be to use a subset of C99 with the libSDL 2 library. Pick a subset that Visual Studio 2013 and gcc 4.6 can both handle, and ditch all the deprecated old stuff. (for example, modern C99-style struct initializers only) To run it in the browser, have the server compile to asm.js JavaScript. When the user wants to take it out of the browser, let them download a zip file containing everything they need: their code, a Visual Studio solution file, and a plain old Makefile.

  • (Score: 1) by EQ on Thursday April 03 2014, @04:00AM

    by EQ (1716) on Thursday April 03 2014, @04:00AM (#25329)

    C. Once you know that well enough to handle pointers, strings and indirection, then learn Lisp of some sort for the lambdas and recursion. Then Ruby if you want to go to the web/mutable side of things, Erlang if you want to go the other way and learn immutability and concurrency. Between those, there is no language that will stop you later on.