Ask HN: What programming language do you recommend starting with?

Maybe go straight to functional. Check out Scala.

Java or C++. Both have great IDEs (Visual Studio, Eclipse, Netbeans) that come with a debugger and make tools, so that you can focus on learning the language before learning what a linker and a compiler is. The debugger is also a must for learning properly by trial and error.

Don't bother with anything else.

> Is there a language, like Latin, that can help form the basis for understanding other languages and make learning easier?

As inetsee says, Scheme is this. It will provide you with a firm basis for actually understanding how programs execute. (Theoretically, learning C will also do this, but if you want to come from that direction I recommend learning some assembly language instead, since the semantics of C are surprisingly complex). Stretching the analogy rather dangerously, Scheme is as relevant to the past, present and future of other languages as Latin (though this is a conceptual rather than historical truth), as pedagogical/minimalist as Esperanto, and as expressive as English.

Also, if you find HtDP too tame or SICP too challenging (certainly possible unless you have a science/math background, though most parts requiring specific knowledge are optional), try Concrete Abstractions (http://gustavus.edu/+max/concrete-abstractions.html).

You have a fairly good understanding already, although you have not realised it. Being able to see that there are a set of core principles (Meta principles, if you will) at work behind every language is a big (and hard) step for beginners to take. Alas, you already surpassed that point. Yet, you should not waste any time learning how to code. Invest your time learning about patterns. Every program out there is a pattern. From the moment you start to think about how it may work, to the moment you ship it, all you are doing is thinking up patterns that aim to solve a problem. Let's take for example the following problem:

     You have to get some data from the user through 
     a webpage. The pattern to do that is to include a
     form in the webpage where the user types in the 
     data we want. Then the user submits the data by
     clicking on a button. Following that we receive 
     the data and store it in a variable or 
     array (like a  bucket, but for data). From that point
     forward we process it with things called functions 
     ,which are nothing more than little bits of code that
     only have one task to complete. We then test to see
     if that data is in a condition that we can use it. 
     Thus we include in the pattern a set of conditionals
     to test if the data is good to go. If its not good to
     go, then we either fix it or trash it. Our pattern
     might include some functionality to tell the user that
     the data typed in is good, and conforms to what we 
     need. We may also need to return the data in modified
     form to the user. Maybe the user wanted to know
     what is the meaning of the word *perro* in English
     , so we send back the answer to the user. Perro is 
     dog in spanish.

     Now, let's write a simple program that follows that
     same pattern.

     
     
     
     
     
     


     

But wait, we can also do it in python. Let's use a simple python program to show you how.

     #Python 2.7.X
    
     input = raw_input("What do you wish to translate?") #get the data from the user.

     def translate(input):  #the translate function.
         if input == "perro":
             return "dog"
         else:
             return "I don't know"

     output = translate(input) #use the function on the data gotten from the user
     print output  #display the results back to the user.

See the similarities in the programs? Notice the pattern? Even though they are two different languages (three if we include HTML), they both follow the same basic pattern to solve the problem at hand.

You must now focus of learning new patterns of how given problems are solved. For example, getting data from a website, processing it, etc. Patterns do get more complicated as you advance, even to the point of not being able to understand them. But dont feel bad, most problems are solved using the simple stuff.

From here on, I would focus on learning every possible language I could get my hands on. But learn by doing, and not by reading (read -> test and repeat).

If you need any assitance, feel free to email me. Best wishes.

> Where should a beginner who is interested in coding start?

Python is a very easy language to learn and is also very powerful.

> Is there a language, like latin, that can help form the basis for understanding other languages and make learning easier?

Assembly language. It's a text language that corresponds one-to-one [1] with machine language, the numbers which are given directly to the CPU for execution [2].

I would not recommend assembly language to a beginner, but rather to an intermediate-level programmer who's already proficient in at least one other language. The main problems with it are (1) it's not portable, (2) it's not easy to find tutorials and documentation geared toward beginners, (3) it's not easy to find programmers who are comfortable with it, and (4) it tends to produce very long, difficult-to-read programs.

So even if they know assembly language well, most programmers don't use it directly very much; there's a reason that it's mostly a dead language outside of very specific areas.

Learning assembly language immensely helps your understanding of how computers work, and gives you some idea of what operating systems and higher-level languages must do behind the scenes to provide the tools that they give you.

To summarize, assembly language is a mostly dead language, with very limited direct practical use in modern times, which, when learned, will greatly help your general understanding of other languages -- and which cannot be avoided if you want to master complete knowledge of how computer software works.

[1] Modern assemblers often provide higher-level tools like labels, macros, and linker data, so the correspondence isn't necessarily one-to-one.

[2] I originally said "used directly by the CPU", but modern CPU's, at least in the Intel world, translate the user software's machine code into a proprietary internal code that's only visible to the hardware. This is largely a workaround for the fact that the x86 is constrained by backward compatibility to be a CISC-style machine, even though we now know RISC-style machines are much simpler and faster. The extra abstraction layer provided by the translation from backwards-compatible user instruction set to the internal proprietary instruction set means the latter can be RISC, can be shuffled around however the chip designers want, can use a strange number of bits per instruction, can be tied closely to tiny architecture details which may change in next year's chip, can actually change instruction order to increase speed as long as we can prove it doesn't change the semantics of the user program, etc. And all we software people see of this is that, inside the CPU, magic happens -- which makes our programs run faster.