Which programming language would you learn if you were starting today? #141
Comments
matjack1
changed the title
|
Javascript & nodejs |
|
Javascript, Python or C#. |
|
My choice was based primarily on which languages have the best pedagogical material for teaching one to think as a programmer: so, Racket, Ruby, Smalltalk, Logo, Eiffel. Haskell, Mozart, Python, Shen (different flavours of functional programming basically, basically I see everything from the background/context of functional programming). When one gets into stuff like Javascript, a lot of the functional programming ideas can be seen to derived from prior ideas in the canonical textbook in functional programming (after all Scheme was supposed to be one of the dominant influences on Brendan Eich in constructing the language). The thought was that the most difficult step is the thought process that allows one to methodically construct programs. How important is it for a programmer in their first steps to form a coherent model of programming? I still think the best introduction to functional programming bar none is How To Design Programs which includes within it the specification and testing of programs. I reckon though that a person would gain a lot by just reading a good introductory text in some of programming langauge above over, say, a year, if they do not want to push too hard. The context gained would allow a lot more things to fall in place easily later, as opposed to madly searching for specific tutorials all the time, where everything fits into place would just be "known". It it has taken me a while to piece together a lot of different elements, and I find myself reading and learning something from an introductory book on Perl "Elements of Programming with Perl" But the final answer to the question for me is: it depends, it depends on a large number of things which are different for each individual. The process above would likely take too much time for most people, as they would like to get stuck in building stuff to showcase to others. |
|
Actually, if I was going to do everytihng all over again, the book I would start with is Harley Hahn's Guide to Unix and Linux. For one thing, going through the book teaches one how to read documentation! After reading the book, I instantly "leveled up", where before almost all the time Linux was mentioned it was all vague and mysterious and I did not know how the pieces fitted together, and the book is one of my top examples for how to write docs, tutorials, readmes, etc--the examples the dude uses are just so delightful. |
|
I would actually like to say that Swift is probably a really interesting and a good language to get started with. It is open source 🌟 and Apple has created some amazing resources for learning it. |
|
I really like this answer @nelsonic gave last year for this question: |
|
From my point of view, the main problem with Javascript as a first programming language is the problem of "overwhelming choice"; in that a beginner to programming would have to make an almost neverending sequence of choices at the time when they have the least amount of experience to make sound judgements. There is overwhelming choice within the language itself ---what style do you want to use? Simple imperative programming where you are mutating variables with stuff like for loops? Functional programming style with higher-order functions? Shall we pretend that Javascript is Java and mimic Java's OOP? Should we try to learn how prototype-based OOP differs from the classical? What subset of Javascript should we call the good parts and use a linter to enforce? These choices create significant barriers in quickly being able to read other people's code. As well as overwhelming choice in external libraries--Just which library should we use to do testing? Do we want to do property based-testing? How are we going to implement the concepts of modules in Javascript? How do we structure Javascript applications? What is the best way of documentating Javascript code? Asynchronus Javascript what is that? The overwhelming choices puts the beginner either in the position of consuming large quantities of hours to answer basic questions to do basic stuff, so as to develop beyond the very first introductions of using variables and for loops and whatnot, or having to lean upon a community of experienced people who simple "know better". Leaning upon a community of people who "know better" depends upon other people exerting significant efforts and time to fill in the pedagogical black-hole that Javascript exists within, e.g. which introductory book on programming using Javascript introduces the writing of specs and testing from the very beginning and not as an after thought? It is not so much that explanations of basic concepts are missing (you can probably find Medium posts that nicely cover various aspects of Javscript), more what is missing is an escalating sequene of exercises and projects. For example, one of the things that mark "Eloquent Javascript" as not a beginner book is the lack of exercises. Sure, one could supplment with codewars but what codewars lacks is sequence, that which Exercism attempts, but ya know, a good book with a nice sequence would likely save someone months of time, many many months. |
|
I'm a bit biased here since I specialize in sysadmin work, but With all that being said, I believe others who've suggested Python are right on the money in terms of what used to be thought of as the "
I'll close with this quote from the creator of
Don't get me wrong; I'm currently working with |
|
Hello @cwonrails I too have written about how the command lines basically forces you to deal with certain essentials. Audrey Lim has made a clear case for Go as a language for raw beginners here: https://www.youtube.com/watch?v=fZh8uCInEfw The thing about Javascript is, it has to be confronted one way or another, at some point in time or another, if one is interested in web-development. My main thought is that as a first programming langauge, a raw beginner is pretty much left hacking through a jungle of not-quite definitive resoureces. Python has been long adopted by academia, so there are many excellent introductions, and there are langauges such as Scheme, Lisp, Haskell, Smalltalk, Logo due to often being thought of as "teaching languages" have many an excellent teachings. Also, the Ruby community went over and above in providing a wide variety of materials. Elixir looks so nice and clean but it is very young, and the community cannot compete in terms of raw teaching resources, and Phoenix is proabably quite easy to get into with those with significant web-development experience. What "very small projects to solve simple problems" do you have in mind that Go allows one to easily do that other langauges do not? The basic argument for Go--as put forth by Audrey Lim above--is that it is a relatively simple and clean language that forces the beginner to face certain CS fundamentals early. e.g. runes and how strings work for, and pointers. I was thinking along the lines that Go being a relatively simple and clean language combined with its significant standard library presents unique opportunities for learning by reading significant code that does significant stuff, something like being utterly immersed with the imperative programming paradigm, but not having to learn assmebly, though I have not even began to dabble myself. What I am looking at though is this bottom-up approach might really help to have a clear conceptual model of web-development, where you are essentially bulding up everything with your bare-hands, so web-development in Golang might be a useful first step as there are courses that teach web-developement with no "magic". My own particular biaseses tend to lead to a functional first approach though, which would be learning from the top-down as opposed to Go's bottom-up approach. But as I said before, there are so many variables at play in the choice of langauge, that it is for the individual to weigh their own choices relative to their own puproses, where the words of more experiences people is merely a guide and not a subsitution for one's own thinking. |
|
I often return to the question of "Which Programming Language?" 💭 But when it comes to building Web Applications with that require a "Backend" (Server), https://www.slant.co/topics/1565/~best-server-side-programming-languages in 2018 I would still recommend learning/using That said, I don't think anyone can "escape" learning Evan Czaplicki's recent
ConclusionFor a complete beginner this is "order" you should learn things:
Once you have covered the basics of the first 3 languages, |
|
@nelsonic You write informative posts! Thanks for giving the benefit of your experience! |
|
Only thing I would add is that the what to learn part of the equation is significantly easier than the how; in that some people will have processes --most likely unconscious--that determine how they go from newbie to ninja (to use the modern internet hyperbolic parlance!) relatively efficiently. For example, the McMaster Outreach program spoken of by Czapliki, the one that allowed children with no experience to get started with Elm was dependent on specially created materials which are much more effective teaching/learning tools than the everyday programming language tutorial. |
|
@YvesMuyaBenda totally! Writing beginner tutorials which get people up-and-running with a language/concept is time consuming but hugely worthwhile. |
|
@nelsonic You the man! The effort you put into helping others is commendable! |
|
@nelsonic What do you think of this diagram as a model of learning/teaching/documenting?: For myself the diagram fine-tunes the process of learning in software development described by Edabit Also, since producing effective materials for starters is time-consuming and labour intensive, then I think the above process has two applications:
The advantages for for the first application is that starters are best in a position to create materials for other starters, creating documentation as they learn. The advantage for 2, is that the incremental approach allows a more experienced developer to break down the task into small, not so time-consuming steps, creating usable documentation that grows incrementally. Also, if the troubleshooting step includes testing, then one would get incrementally growing documentation that gets tested, reviewed, troubleshot, etc at each incremental step, similar to what is considered good practice in software development (small increments that are tested). Oh and since one proposes an exercise first, one has a kind of TDD cycle applied to learning/teaching/documenting, which would have a use of allowing the person to practice the mindset in an entirely different context than in using software tools. I need to run some experiments myself, but that is the gist of my thoughts! |
|
@YvesMuyaBenda good diagram. I would add an optional "show examples of end result" and clarify why learning the new increment is useful either in itself or as part of the grander project. |
|
@nelsonic Sure, I was thinking of it mostly as a good skeleton to structure the overall process. Oh, and it actually provides a process to read technical books, and turn them into docs, or read docs and turn them into learning materials! |
|
Here is another version of the diagram, giving more details: Source: http://www.troubleshooters.com/tpromag/200101/200101.htm |
Today there's a lot of new languages, what would you choose?
The text was updated successfully, but these errors were encountered: