20 ms·

Why did we ever think a student's first programming language didn't matter?

• bognition 5y ago
  Interesting, as someone who loves math learning programming as an extension of math made a lot of sense. It also explains why other people I know struggled to learning to program in the same setting, but later we’re able to thrive given a different curriculum.
  • drewcoo 5y ago
    Then you may as well also ask "why did we ever think the kind of math you learned first didn't matter?" It's a ridiculous straw man, deals with symptoms instead of problems, and leads to an "everyone has an opinion" situation beyond any usefulness.
  • smasher164 5y ago
    This applies beyond introductory programming. We faced this in our university's Machine Learning course. The same course was taught both to students from the engineering school, which requires a certain number of math courses (Linear Algebra, Calculus, etc.), and in the general college, which had much fewer requirements. The professor was forced to stay surface-level on the math, so the coursework was a task of glueing together code from scikit-learn. Unfortunately, the exams were much easier if you had the mathematical intuition.
• deleted 5y ago
  [deleted]
• lisper 5y ago
  The biggest problem with the first language is that a student has nothing to compare it to, and so naturally comes away thinking that the design decisions in that language are a reflection of some deep underlying truth, that this language is The Way Things Should Be Done rather than a product of its time and particular goals of its designers. When I was a wee coder I thought BASIC was the bee's knees. I don't think that any more, but it was a painful series of transitions until I discovered Lisp and never looked back.
  • FpUser 5y ago
    I started with machine codes. Followed by ASM, Turbo Pascal, C/C++. I played with BASIC but quickly dismissed it as it would greatly limit of what I could do (I was hooking computers to devices using high speed parallel bus and processing data in real time). No college. I was studying physics in university. All my programming experience I got by looking at docs and somebody else's codes. Of course every once in a while I would use something like Matlab to solve my little problems and when I switched to develop software for living I also used many other languages. Now I mostly free to choose whatever tools I see fit and usually stick to 3 - C++ for backends, Delphi/Lazarus for desktops and JavaScript for web front ends. Occasionally use C when I have to do firmware. I played up to my gills with many scripting languages like Python. Personally I found that on any project of decent size they do not speed up development at all. The performance loss of the end product however is monumental.
  • garmaine 5y ago
    This is an argument for teaching intro programming with Scheme.
    • username90 5y ago
      No, it is an argument for teaching intro programming in C so they better understand what operations a computer is capable of doing. When you are used to C most other languages feels like a library that automates tedious tasks rather than something alien, you are well aware of the things needed to happen in the background so that the code you write in other languages can do what it does.
      • garmaine 5y ago
        C imparts a very specific architecture onto your code. Scheme is more of a blank slate upon which many different paradigms can be taught.
        • b5n 5y ago
          I've never looked under the hood of a `cdr` implementation but I feel pretty confident in saying that it's likely to be an incremented pointer most of the time. Learning C (and even a little ASM), gives a better understanding of the underlying layers. I think that provides a great foundation for learning a scheme, and then branching out from there.
• chrisaycock 5y ago
  Given the ever-increasing amount of automation in the economy, I believe that programming (of one form or another) is going to become a skill as important as writing. Everyone learns how to write in school, even though only a few become novelists or journalists. Similarly, everyone will learn to code even though only a few will become data scientists or software engineers. Programming for non-professionals looks a lot more like Excel than Python. I imagine the trend will continue where deceptively simple interfaces allow people to automate routine tasks. Those interfaces might get more expressive languages, but most programs will be at most a dozen lines long. That's the kind of language I think we should start with. We can worry about more detailed CS topics for the students who actually specialize in that.
  • fendy3002 5y ago
    True. Even if someone only understand truth table, excel formula and some mathematical operations (max, min, ceil floor avg, mod, root, pow), they can be very useful to support any companies.
    • username90 5y ago
      Another big reason is that it is so much easier to write powerful software for programmers than non programmers. So at some point it will be easier for the world to teach program to everyone and have that as a baseline than trying to put ever more programmers building specialized programs for non programmers.
  • throwawayboise 5y ago
    It has been a pipe dream of some since the 1960s that "everybody" would program computers in the future. It hasn't happened and won't happen. Most people simply don't have the patience for it.
    • pelario 5y ago
      I'm sure a century or two the same was said for reading and writing.
• smasher164 5y ago
  From the PL theory front, when confronted with the idea that languages shouldn't necessarily assume prior mathematical knowledge, even some well-known researchers simply shrug and say "I can't do anything about that." And those same people will also criticize more popular/accessible languages on the grounds that they lack features from their favorite pet language based in some mathematical footing. The hypocrisy is real. It is definitely a real problem. If your field has confined itself in formalism without a consideration for HCI, you are doing yourself harm. Not only is the transfer of knowledge to industry and other domains harder, you miss out on equivalent but more accessible ways of expressing the same ideas.
• Jtsummers 5y ago
  Georgia Tech around the year 2000 required most new students to take CS 1301/1311/whatever number course. It was, at one point, taught with a Pascal-derived pseudocode (incredibly unpopular, though I liked it quite a bit). Then they switched to Scheme (using SICP?) which was a fantastic catastrophe, major cheating scandal the first year. The TAs were not prepared (most had not taken it themselves and many/most were only sophomores or juniors with insufficient experience or time to teach themselves). Then they switched to Python (?), I don't know what they used after that because by then anyone I still knew at the school was beyond the freshman classes, most having graduated. At the same time they had the Scheme-based course (and possibly before, but I know at this point) they also offered a MATLAB-based introduction for non-CS/CMPE/EE students (EE and CMPE had to take the first 2 or 3, respectively, CS courses with the CS majors as part of their degree program). This MATLAB course was targeted more towards ME, AE and other majors who really just needed something that let them write programs to solve problems in their domain. Many of them did much better. The problems assigned were better motivated for them and they were able to apply it within their broader course of study or internships or research work. That a first course should be appropriate to the desired outcome for the students seems obvious, I'm rather surprised there's much debate around this topic.
  • taeric 5y ago
    This feels like a narrative in need of hard evidence. I was there at what I assume was the tail end of this in 1997. My gut was cheating was no worse then it had been, but they had automated systems for the first time. Some of it was so silly that I was accused of cheating in the C course for using and citing the hashtable implementation from the assigned textbook. On just talking to the graders and professor, they dropped it and were amused that anyone used the book. For the other sciences, they would shake up the rules on how to capitalize figures. Idea being that cheaters would use last year's rules. Or, lazy people would just not pay attention..
    • Jtsummers 5y ago
      The cheating came out in the Scheme class, specifically. It was something like 150 students caught. It was not a general cheating scandal in the first CS course over the years. My comment was very clear about this, I did not imply cheating was a problem elsewhere (may have been, I wasn't aware of any issues though). It wasn't really overblown, it was a problem with that course. The instructors and TAs were grossly unprepared to teach hundreds of freshman a semester in a language they (the instructors and TAs) weren't familiar with that was fundamentally harder (especially for an arbitrary student rather than those actually interested in the topic) than what was done before. The rest of my comment was about appropriateness of the first course to the students and their objectives. MATLAB being a much better first language for the engineering majors than the general CS requirement provided.
• carapace 5y ago
  I think you should teach assembly language first, and then build a few simple high-level langauges on top of that. I suspect it would prevent a lot of mental dross from forming.
  • werber 5y ago
    I’m primarily a front and developer and I wish that was the way I went. When I work in even basic back end code now I feel unprepared. I highly doubt I’ll ever write assembly code and if someone was to ask me to I would essentially face plant
    • lupire 5y ago
      there's no need or special value in learning assembly first. you can learn it after.
      • werber 5y ago
        I agree completely, for me, writing code is a way to get money and a tool to bring ideas to life and I haven’t found an idea in my head that needed it
  • alejohausner 5y ago
    I agree. At the very least, teach assembly in the first term, at the same time as students are learning a high level language. If you know assembly, you can understand why arrays exist in C ( because CPUs have base-and-offset addressing), why records exist (same reason), what pointers are (assembly is pretty much about pointers), why ints are different from floats (ADD vs FADD) and so on, how functions are called (system stack). Absolutely. My first year of programming we took both Fortran and IBM assembly. It all made a lot more sense, and still does.
    • nsonha 5y ago
      We have dedicated classes in computer architecture to learn all the things you mention, it's not the job of a programming language to teach them to you When I first learn C in highschool the asign statement was what bugged me the most because I had already has a math background at that point so statements such as x = x + 1 made no sense, and even in natural science general, the idea that you can "asign" new intrinsic property to a thing is very unintuitive. 20 years later mutablity is the exact idea that I have to unlearn everyday. My point is all these languages and learning hierarchy were made up by people like us, and in an era when frankly, they had no idea where this field was headed. We should not just blindly think because they're written in a book and sound important, that students should be condescendingly reminded about them in programming languages while they're trying to learn to solve real-world problems.
• travisgriggs 5y ago
  My first not-quite-languages were Logo and then a smattering of autolisp (I didn't learn near enough to know much to do with it). First real programming that followed was Fortran, eventually on a Cray with threading extensions. And then a fork in the road leading to both C and Smalltalk-80 in parallel. I don't feel like this specific heritage affected how I learned programming. But then, I was mostly self taught with a generous amount of solicited input from older engineers and contractors I worked with/around (looking back, I'm a bit self conscious and just how annoying young me probably was--I did try to load balance at least). So maybe this article doesn't resonate much with me because it comes from the realm of common computer science pedagogy. In fact, my first "college programming classes" were a year or so later, two classes in C that all mechanical engineering students at BYU had to take. I was able to wow my peers by making a faster sieve of erastones than others. And then for the "chose your own project", I used Smalltalk 80 to model quantities with units and a symbolic algebraic equation modeler/evaluator including a graphic visuallier that could plot arbitrary equations like PV = nRT -- the TA marked off points because my code didn't include enough comments even though the next closest program was a Fortran piece that prompted for a few values and it then spit out the correctly interpolated u, h, or s values from the steam tables. Needless to say, my impression of computer science pedagogy in the early to mid 90s wasn't that great. My take away was not so much what language was first, but who I learned from first.
• empressplay 5y ago
  If a student has trouble transferring their knowledge of programming fundamentals from one language to another, it seems far more likely they didn't really understand them to begin with, which is a failure of teaching and testing, not some sort of 'limitation' in the student.
  • wyager 5y ago
    > If a student has trouble transferring their knowledge of programming fundamentals “Programming fundamentals” isn’t the same from language to language. It’s inconceivable that a student who learned to program with python would develop the same type of fundamental understanding as a student who used C (to develop an understanding of memory-level APIs) or Haskell (to develop an understanding of type and semantic theories). > which is a failure of teaching and testing, not some sort of 'limitation' in the student. This is a bold claim. I don’t think everyone can understand computer science.
    • Retric 5y ago
      I think you’re vastly overestimating programming fundamentals. Every language can do some form of if then else be it machine code with goto’s or purely functional. Ask someone to find the absolute value of a number and they should be able to quickly figure out something that works in a new language. The basics of programming are not about being correct so much as not being lost.
      • josephg 5y ago
        > Every language can do some form of if then else Uh, not exactly. I had a really hard time learning prolog because it doesn't really have if-then-else. Haskell is missing the idea of something happening after something else. Stack languages don't have variables. And so on - there's a lot more to programming than python. There's a big class of popular structured / OO languages which are quite similar (C, JS, Python, Java, etc). But they certainly aren't "every language". Not by a long shot. And even amongst those languages there's huge variety in how the grain of the languages shape the code we write. I was talking to a grizzled old programmer at a conference a few years ago about the performance of java vs C. He said in some benchmarks he did the performance was almost identical. I got him to show me his code - and sure enough, he wrote java as if it were C. He was using native java arrays everywhere and basically everything was a primitive variable, in huge classes acting more as buckets for code than anything else. His code was unrecognisable as java because he was still writing C, just with a different syntax. > The basics of programming are not about being correct so much as not being lost. The basis of programming is expression. The most idiomatic way to express yourself in each language is very different. Its as much cultural as it is syntactic.
• sgtnoodle 5y ago
  I learned qbasic, graphing calculator basic, and visual basic more or less on my own. I learned C++ in a mediocre way from the AP course in high school. In university, C++ was the most common language outside of low level architecture courses. I picked up python pretty quickly to make rapid progress on student projects. I pretty much use some combination of C, C++ and python for everything. I had to use java for a robotics course, and it wasn't too hard to pick up the differences. I'm going to have to pick up rust in the next few months for work. Reading through the reference manual, it's going to be a bit painful to rewire my brain. So far none of the concepts seem alien, though, just a bit weird.
• sjg007 5y ago
  It’s unfortunate that CS curriculums lean so heavily on math and proofs.
  • rgoulter 5y ago
    I think it's worth distinguishing between "Computer Science" and "Programming". One of the motivating examples in the OP is "conversational programmers". OP defines that as people who want to be able to have conversations about programming stuff, but won't program. -- For those people, sure, assuming heavy technical/math background when teaching programming isn't helpful. But many topics in Computer Science heavily rely on applying math. (3D rendering, Computer Vision, Machine Learning).
    • sjg007 5y ago
      This is no different than engineering.
      • formerly_proven 5y ago
        Then study computer engineering instead of computer science.
• tmaly 5y ago
  I think it is possible to teach concepts like variables, loops, conditionals regardless of the language.
  • lupire 5y ago
    What about monads and term rewriting?
  • username90 5y ago
    What about pointers? They are fundamental to data structures, and languages which doesn't clearly show the difference between pointers and values makes understanding data structures much harder, as many data structures relies on multiple pointers pointing to the same data and that simply doesn't make sense if you seem them as separate values.
    • sovok_x 5y ago
      That depends on purpose of the teaching. If you want to teach them basics what the thread starter mentioned is enough. If you want the deeper understanding you should teach them how it boils down to machine code or add a bit of Assembly to the menu. It explains pointers and other such things pretty well.
    • patrick451 5y ago
      I think this is a good point. You can implement a linked list in python, but, in my opinion, unless you already understand pointers, it's rather confusing. Doing it in c makes everything explicit.
  • AnimalMuppet 5y ago
    I don't know about that. It might be harder to teach loops in Haskell, APL, or Prolog than it is in some more conventional languages.
• deleted 5y ago
  [deleted]
• throwawayboise 5y ago
  I started with BASIC in middle school on a TRS-80, then bought a TI/99-4A when I was in high school. At university it was a mishmash. Every course was different. PL/1, Pascal, Modula-2, FORTRAN, Scheme, C, assembler were in the mix. I'm not sure it matters, but I think most people would do best learning a simple imperative language like BASIC or Python to start. I didn't really "get" Scheme/LISP functional programming until after I graduated, but now it's my favorite style and Erlang is my favorite language.
• jrm4 5y ago
  Because it's healthier than the opposite, which invariably is going to be someone's very strong but completely unverifiable opinion. It probably does, but for a long time, it was hard to tell exactly why. Now, however...ha, just kidding. It's still the same.
• duxup 5y ago
  I feel I see folks sweat their first language a lot. IMO it is more important to try and find out if programming is even something they REALLY want to do. The language maybe better selected for what they might want to ....do. My first language was C, in a classroom where someone read from the book and then you were on your own. I dropped out of school (for other reasons) and 20 years later I got back into programming via web development. I wish I had a different experience in school.
  • andai 5y ago
    Most people don't want to program in C, and I think my high school programming course (which used C) did more harm than good in that regard. The only students who got anything out of it had already taught themselves programming on their own! I came back to C later and enjoyed learning it properly, but it is very much not a gentle introduction into the world of programming for the average person!
    • duxup 5y ago
      Yeah C actually seems very interesting ... now. The context very much counts as far as when / how You learn things IMO.
• saurik 5y ago
  Leaning the second language is certainly hard, but learning your fifth or sixth language or so becomes easier? Hopefully? At least if you put forth any effort or interest I would think? If anything, I feel like the biggest trap people fall into is assuming they know a lot of languages when they really just know a lot of Algol-descendants... you should make sure to spend time really building something meaningful at least once in at least Haskell, Erlang, and a Lisp (and a lot of others, but if you haven't worked in those three... have you really programmed? truly?). My story: I have been programming since I was a little kid, having used mostly stuff like Logo and BASIC for years; after spending a bunch of time with Visual Basic I kept failing to learn C. In high school I took a course on some slideshow programming system whose name is escaping me right now, and then one on Pascal. OMG Pascal was hard for me: I made flash cards to try to learn the keywords, and I was struggling. There was something concurrent I was doing with simple JavaScript, which seemed to be going OK-ish. I then started taking a second course in Pascal--an AP class--but by this point it had all clicked: I had been programming at that point--even writing software for local companies sometimes (in Visual Basic)--for like 8 years and I finally got it. The teacher noticed, and since I was only a junior he said I shouldn't bother continuing in Pascal: I'd help him learn C++ and co-teach the class the next year with him, and take the AP test in C++. That was... over 20 years ago now? I now feel like I can just learn any language almost immediately. I remember being in the audience when Apple announced Swift: I was looking at the slides and thinking "ok, I see what they are doing here: this is like Objective-C crosses with Scala but with some of the syntax of Ruby... I bet I could program in this". I spent the next day playing with it and had already befriended the Swift compiler people as I was finding tons of bugs, and then I gave a talk on Advanced Swift Internals two days later across the street at AltConf. I personally feel like this kind of mental process is "teachable". I thereby sometimes have gotten to teach a course at UCSB (I have sometimes been hired as a "1/8th lecturer" or something like that to do this) on programming languages, where I try to take students through the breadth and depth of syntax and semantics, rather than just focusing on a couple examples. Sometimes we look at a semantic and how it evolved, sometimes a syntax and how it got reused, and sometimes a use case and how various languages tried to support it. By the end of the course I expect you to "know" none of the languages, but to hopefully be able to quickly use any of them with some examples. The big project for the class is to design and implement your own "esoteric" language. FWIW, I "thereby" personally am still in camp "it doesn't (exactly) matter"... as long as it inspires the student! Which I actually think is what this author is kind of getting at (and so I actually do agree with them) with that paragraph about "what about a student who X"... a lot of teachers seem to think "learn this toy thing and you will be able to eventually learn anything", but the toy is boring and doesn't do anything the student wants to work on and by the end of the entire experience you are lucky if they did any of the work at all. It is like teaching someone to play some horrible sounding musical instrument using example pieces that the student doesn't enjoy listening to with the goal of establishing enough musical theory and experience that they can learn a second instrument / style some day and eventually get good enough to do what they wanted. It is just unrealistic? I was able to get as good at the languages I was able to largely because they were useful to me... and honestly, that Pascal wasn't was probably part of what made it so hard :/.
• deleted 5y ago
  [deleted]
• random-string 5y ago
  The first language is incredibly important and I normally recommend javascript for the following reasons - it's /highly/ accessible (any computer with a browser can compile and run javascript - you just need to get your browser to load the file) - it shares a lot of its syntax with C-Style languages (which makes transference to other languages much easier - it's 'relaxed' on how it enforces rules (now, this is contentious, should a learner be allowed to get away with mistakes that will haunt them later, or should a learner be hobbled and forced to be precise from the get-go, IMO the former is easier for people to upskil with than the latter) - it's (currently) got commercial value (that is, you can get a job with javascript on your CV)
  • speedgoose 5y ago
    I think JavaScript is a bit too advanced though and some mistakes are quite difficult to explain, such as the scopes and event functions, or the relatively invisible typing system. For example, Reddit is full of beginners making fun of JavaScript because concatenating a number and a string using the + operator produces a concatenated string and not a sum number. However to reduce the complexity, it's possible to restrict students to a subset, using eslint and one or two plug-ins. I like eslint-plugin-unicorn to restrict my co-workers.
  • _huayra_ 5y ago
    The relaxed rule enforcement is very difficult for beginners to understand. After one has experience with other languages, we kinda understand that every language is gonna have at least one crufty WTF corner, but beginners will become really confused at the behavior like the infamous "Wat talk" [0] demonstrates. Even Python has some quirks beyond the usual monkeypatching madness that can occur, e.g. with regards to name scoping. I'm honestly not sure what could fit here that isn't a LISP dialect (which I think is pedagogically the right choice, but is usually impractical unless one is sure that one wants to do "hardcore" CS stuff, vs. using coding as merely a tool in another field). [0] https://www.destroyallsoftware.com/talks/wat https://www.destroyallsoftware.com/talks/wat
• caseysoftware 5y ago
  After graduation, I fought my undergrad to switch the CS 101 course from Java to Python for the simple reason that public static void main() has a huge number of concepts built in and "just trust us, we'll cover that later" is a terrible excuse. Edit: Even now, years later, I still got them in the wrong order. Arg.
  • lupire 5y ago
    That's a bit silly reasoning. Processing is Java but doesn't have public static void main. Python has a the beginners problem that a small error won't block compile but will make the program behave on completely bizarre ways.
  • simplify 5y ago
    I'm not sure that's a good reason. Handling "just trust us, we'll cover it later" is as essential skill when learning anything, especially things related to programming.
  • ineedasername 5y ago
    Yeah, ignoring that might be okay in a course like "Programming for non-CS Majors", but I'd expect better from an actual CS program where understanding the foundations of the language you're working with are important. I remember the same exact thing from Java, and similar "magical words" that weren't explained but I was simply told had to be there. Learning for/while/do loops and variable assignment and all of that is fine for a programming course, but the first semester of a CS course shouldn't just be sticking a fahrenheit to Celsius converter or a string reversal or simple sorter in between magic words and symbols.
  • kaba0 5y ago
    I disagree. Other than the already mentioned points in replies, static typing and failing at compile time with a helpful error is really important. Runtime errors are much harder to interpret and debug - it is a skill they will have to learn later on, but inferring runtime state at a given point is arguably harder than doing so statically.
• mberning 5y ago
  I can’t imagine how many people switched majors or dropped out due to having something like Java foisted upon them in their 100 level CS classes. I have been using it off and on professionally for 15 years and I am always floored when I have to introduce somebody to Java and a Java codebase. Even something as simple as knowing which version to install requires a lengthy exposition. Do I need the JRE or JDK? What about J2SE. Or do I need J2EE? Should I use adopt (a dumb name itself) or maybe coretto? Who knows.
• lupire 5y ago
  Author is showing confused thinking, by conflating "first" with "only". Teaching a new programmer less than 2 language paradigms warps their brain into limited view of what is possible. Even learning JS + HTML, or Spreadsheet + Bash/PowwrShell, with good instruction, should be enough to instill the key idea that languages are abstractions and there are radically different languages for different problem domains, and you should find ones that fits the applications you are interested in.
  • lucb1e 5y ago
    I would argue that in the context of this topic, HTML is not a useful second language. It's a completely different tool, closer to markdown or, heck, Word documents than an alternative way of programming. (I see your general point, though. Just this combo I'm not sure is the best example.)
• ineedasername 5y ago
  We might be able to teach a lot more people about programming if we don’t expect students to know mathematics first I'd like to know where the author thinks mathematical learning can stop. In the US we live in a society where people will say with a smile, as though it was a badge of honor, "Oh I can't do math, I always hated it in school." I'm sure the author isn't talking about that level of learning and would still want a reasonable degree of knowledge for all people, but their opinion on what that should be would be would be interesting in this context.
• mackwell 5y ago
  My anecdotal experience: Me in an incredibly dull Java class in college: This is awful! I dreamed of making computers do interesting things, but it turns out programming sucks and is mind numbingly boring to learn! (I eventually dropped out and went on a different path) Learning Python on my own 20 years later from various free online resources: This is incredible! I can make computers do anything and it all makes sense! What else can I learn?!? For me, having both the right starter language and the right form of resources were required for it work out (ingesting lessons via video as I am curious about a certain topic works infinitely better than a classroom).
• jollybean 5y ago
  One thing that doesn't seem to be called out and that's the 'overhead' of a language i.e. compilation, libraries, resources etc. - vs - a simple opportunity to teach basic programming principles and algorithms. Python and Javascript have very low barriers to entry for the overhead (it can get complicated but for small programs it's easy). You can use those to teach a lot of basic things. In my own education we started with C/C++ and we were all drowning in pointers 80% of the time, the actual course material was pedantic. What Uni tends to not focus on very well is just teaching the real, applicable basics of a language, with some good professional 'best practices' and students can spend years wasting their time trying to get things to compile, lost in bad manpages etc.. Start with something 'very light' and for everything else - provide a short 101 course for languages of instruction which focus on the practical mechanics of the language and nothing else. Those courses might even be taught by professional developers, outside of the regular kind of pedagogy. It feels 'not very academic' but that's the reality of the discipline. If you want to teach architecture, and expect students to 'build buildings' ... you need to teach them properly how to use the hammer, nails, measuring tape - even if that in and of itself is not particularly academic.
• TrackerFF 5y ago
  First language should focus on getting started. Python works perfectly fine for this. Startup is minimal, students can start writing functional code within minutes. Subsequent languages should match the content and focus of their classes (i.e C for Data Structures and Algorithms, C/C++/Rust for Systems Programming, Java / C# / C++ for OOP classes, Haskell/Clojure/etc. for Functional Programming classes , etc)
• shannifin 5y ago
  "Matter" to what end? That is, if you do not have a specific goal in mind when learning a language, then of course it doesn't matter. On the other hand, if your ultimate goal is to learn a myriad of languages so that you can jump around fields, then of course it matters, as you will likely have difficulty learning advanced concepts without understanding the basic ones. (Just as you would likely not dive into calculus without understanding algebra.) > We don’t have to make programming about mathematics. I also don't understand the article's interest in decoupling programming from math; that seems like trying to have physics without math or philosophy without logic. The power of the field is founded on math; you can't just sidestep around it and gain its power at the same time.
  • truenamenofame 5y ago
    >I also don't understand the article's interest in decoupling programming from math It's an unfortunate side effect of America's long acceptance of anti-intellectualism. And people like this perpetuate it by coddling Americans who were somehow allowed to get through high school without even a basic understanding of the fundamentals of math. I am also a victim of this defeatist way of thinking, and have worked hard to appreciate math and learn it on my own to undo the trauma instilled in me by math teachers who simply taught formulas for us to remember to pass tests that we immediately cleared from our memory afterward.
    • shannifin 5y ago
      I had some math teachers who either did not understand math very well themselves and just regurgitated text books, or just didn't know how to teach it well (which, to be fair, can be challenging). But the article states near the end: > Conversational programmers struggle to find resources that help them learn because so many of them require a focus on the logic and mathematics, but we are developing approaches to help conversational programmers learn without the math. We might be able to teach a lot more people about programming if we don’t expect students to know mathematics first I'm just not sure that's a great (or entirely workable) idea. Embrace the math! That said, I don't think one has to learn the math first; you can learn math and programming at the same time. In fact, it is perhaps easier to learn math when you have a concrete programming context to apply it to. I taught myself the basics of algebra by teaching myself BASIC in elementary school, years before I had a clue what "algebra" was. By the time I was taking algebra classes, it was a breeze. (Calculus on the other hand....)
• code_duck 5y ago
  It wasn’t my first programming language, but I declined to attend a college programming course in Pascal because I thought Pascal was outdated and I wanted to learn JavaScript. It was 1997, and it seemed like the future to me. The teacher told me I should just learn Pascal and the same principles apply, but I felt like I didn’t want to waste my time and mental space on a language I wasn’t going to use. I probably should have done it anyway as I didn’t end up getting seriously into development until 2008.
• lowbloodsugar 5y ago
  I think the mistake in teaching languages is to start students with a blank page. I learned by typing in code from a magazine, and thus started from a working program to tinker with. So, when my then 9-yr-old son wanted to learn, we spent a weekend hacking the Minecraft code. We did the first change together: making it so the Endermen didn't kill you for looking at them. Then I left him to it. By the end of the weekend he was flying around on the Ender dragon.
• foxes 5y ago
  Declarative languages are then the natural choice. Instead of reasoning about arbitrary control flow semantics you can just think about what your program is actually meant to be doing. Then if you need to zoom in later and manipulate state/control flow directly that’s a new paradigm to learn.
• aaronchall 5y ago
  I learnt BASIC mostly by myself when I was in elementary school (because programming computers must be cool, and I was sure I could do it). I self-taught myself computing concepts all my life. I self-taught myself Python (in earnest) while in MBA school (because I believed spreadsheets needed to die and Python would be a good spreadsheet killer). I've been teaching Python to other students in the last few years. It's usually their first programming language (if not, R probably was). I've always believed in being a computer language polyglot, if only to be able to communicate with others from other languages and to learn what those languages have to teach us, but I'm also of the opinion that one should stick to one's strengths. I would agree that we should think the initial programming language doesn't matter - if we're simply looking at whether we can communicate or translate fundamental mathematics of computation. However, when a student is an adult trying to get immediate value from the learning (instead of the gratification of increasing pure knowledge, like I did) their choice of language matters greatly. My first recommendation to anyone asking me is of course Python, due to broad applicability (which means learning one time a language that can be used to scrape the web, provision a restful API, or do complex data analysis), license (free to use), cross-platform compatibility (MacOS, Windows, Linux), popularity (which leads to ease of getting help), all leading to a good reputation for readability and maintainability (which is encouraging broad industry adoption meaning more jobs for Python programmers). Of course, for specific applications, the recommendation may be different, such as JS or TypeScript for front-end development, or C or Rust for low-level programming, or Lisp, Elm, or Haskell for functional programming in their respective domains. Further, Haskell and Elm have greatly informed my approach to object oriented programming - I feel like they have made me better and made my Python more robust and straightforward. I didn't learn them first though. In retrospect, I feel like I could have easily learnt them first. I wonder how I would look at my Python if I had done so - what would indeed be different? I don't know. But I do know, for pragmatic purposes, first programming language does matter greatly.
• mikewarot 5y ago
  My first programming language was solder. I learned it in 6th grade. My second was BASIC, which I learned 5 years later. I'm old, and I've been around the block quite a few times... I can tell you what was in those fields before they become subdivisions. I tend to go off on tangents sometimes. Teaching isn't about knowing the one right way... teaching is about giving people information that relates to their existing knowledge base. In the language of RF Design, it's about impedance matching. If you want to turn out Rust programmers, it's probably a bad choice to teach them COBOL first. BASIC would be less bad. The closer the languages are in terms of impedance, the easier it is likely to be to transit between them. Tangent: Bear in mind that in RF Design, impedance is only a complex number, in a person's mind, there are an infinite number of dimensions, you'll never get a consistent number. Tangent: Teaching someone BASIC on a machine with 2K of RAM is also radically different that teaching someone QBASIC with megabytes of RAM and a hard drive. The constraints are different, the language itself has differences. Tangent: Non Von Neuman systems like Verilog, FPGAs, solder, and Excel are valid tools as well.
• Animats 5y ago
  Even MIT abandoned Scheme and SICP and switched to Python. There's a beautiful elegance to that approach. It gives a sense of the mathematical foundation of computer science. It's not that useful for building large programs from off the shelf libraries, which is what almost everybody does today. At one time, computer science required a good understand of what's in Vol. 1 of Knuth. That's not in much demand any more. Just about everything in there you now get from a well-debugged library. There are people who still write hash tables, and they're serious hash table theorists. I'm impressed with how good hash table technology is today. You can get over 90%+ fill and near-constant time. But only a few people today need to know about that.
  • prydt 5y ago
    Where can one find those hash table theorists? (Just curious, that sounds really interesting actually)
    • anonymoushn 5y ago
      I wrote some hash tables at an automated trading firm. They were really only suitable for our exact access pattern though. Usually you find people like this making libraries or programming language runtimes I guess.
    • mftb 5y ago
      I don't know if you'd call him a theorist, but I think this gentleman maintains GHashTable and I found his posts comparing/benchmarking widely used hash tables really informative and entertaining: https://hpjansson.org/blag/2018/07/24/a-hash-table-re-hash/ https://hpjansson.org/blag/2018/07/24/a-hash-table-re-hash/
    • Animats 5y ago
      https://probablydance.com/2017/02/26/i-wrote-the-fastest-hashtable/ https://probablydance.com/2017/02/26/i-wrote-the-fastest-has...
      • prydt 5y ago
• glangdale 5y ago
  It's my feeling that articles like this are evergreen, simply because the demands on a "first programming language" are contradictory and excessive. Depending on who you ask, a first programming language (I'll say 1PL to reduce repetition of the phrase) should do one or more of the following: 1) Be practically useful even if the student drops computer science immediately. 2) Be low-level enough to teach the fundamentals of what's really going on with the machine. 3) Be high-level enough to teach the fundamentals of true computer science. 4) Be stringent enough to allow the users to learn precision in their programming. 5) Be lax enough to allow the users to not get bogged down in endless boilerplate. 6) Be in common usage to help ensure immediate practical users for the language. 7) Be an exotic to avoid turning the first year and a half of CS courses into a competition to see who spent the most of their formative years messing with computers. 8) Bonus round: claim that the 1PL is a bogus fixation and instead the learners should learn several different languages. The problem with all these arguments is that they are all sorta-kinda true, but the consistent application of even a few of them result in a learning load that would result in the first year of computer science (or some "intro to programming" course) being not so much a major but a 2-3 year full time job carried out to the exclusion of all else. It might make a lot more sense to think not about the 1PL but how the 2ndPL, 3rdPL, etc. are introduced and when. Instead of overloading the 1PL with a host of contradictory and pretentious goals, maybe we teach people the basics of programming as quickly as possible and move on? For my part, I think the experience of the 1PL should be focused on usability and fun. I'm not really a fan of the whole Java thing for reasons not germane to this, but "Processing" really had a whiff of what was fun about messing around with Commodore 64 BASIC back in the day. Maybe that's more important than making sure that the language in which everyone adds up columns of numbers and prints an invoice for some fucking stupid imaginary warehouse application properly inculcates everyone into the One True Way of Thinking About Computing, whether that's being close to the hardware, or being able to write metacircular interpreters, or be a service course for some miserable engineering department. The fact is, most of these first-year courses are dull, miserable and unappealing.
  • mhuffman 5y ago
    Slightly related, I am having great success with using Processing as a first language for my young child. The fact that it is very visual and easy to make "pretty things to look at" while still being pretty powerful made the onboarding a lot easier then something like JavaScript or Python. As a bonus, it is close enough to (Java, C, etc.) that the move to a next language should be pretty straightforward.
• robomartin 5y ago
  In my opinion the best sequence looks something like this: - Machine language (not assembler) — Assembler for a couple of different architectures (i.e: Von Neumann vs. Harvard, CISC vs RISC, etc) - Forth (written from scratch with one of the above) - C - LISP - APL - C++ I think of everything else beyond these mostly as C/C++ cousins or derivatives. With languages like Javascript and Python it’s far more about learning the libraries than a massively different programming paradigm. Learning each of the languages is my list —in the suggested sequence— will provide someone with a deep understanding of different ways to solve problems with computers.
  • mjevans 5y ago
    The machine an assembler should probably be taught together. Where possible either emulations of real chips, programmable logic simulated chips, or real chips should be used. I recall the class which used a 6800 derivative in one of my college courses had a _very_ well written developer's spec manual for it. Complete with a (large) table that showed the logical relationship between the binary value of an instruction and the assembly mnemonic. Today that might be RISC-V. 'x86' and ARM should also be used, and at least a taste of very constrained systems for super cheep stuff and very low level state machines for components would help round out the package. Forth should be a semester project for one of the classes. This should include some practical case where either a manually clocked serial link, a set of dip switches and memory transfer captures, or some other constrained input method (maybe that 'boot sector forth' I recall seeing recently?) are used to trickle the core into RAM and then add higher level instructions. This might also include a small boot blob that inits the platform and opens an external data link; a useful example for subsystems.
    • robomartin 5y ago
      The intent behind making a distinction between machine language and assembler is because one can offer a deeper understanding of what actually goes on at the lowest level of computing. The way I would prefer to teach machine language would be to start from scratch. This means you would create and define a simple set of instructions in the context of an equally simple 4 bit processor the students would build on a breadboard out of simple chips. And, yes, the microcoded instructions would be coded by hand using a diode matrix. I truly believe such an exercise has enough value that it should be the starting point of a real education in computer science. From there it's on to assembler on preexisting processors. The reason Forth follows assembler on my list is that you can easily bootstrap Forth from scratch on any processor. Building the language from scratch is, again, to repeat myself, a worthwhile exercise. You would use assembler to get started and then switch to the embryonic Forth to build upon that. At some point you write your own code editor in Forth. From there there are a number of interesting applications (PID motor controller?) that could be implemented with the language you just built from scratch. C offers an entry point into a world of languages that look and feel like C. It provides a tool that is close to the hardware, yet high level enough to allow for much greater freedom of expression. Doing arrays in Forth is a very hands-on proposition. In C it's pretty easy. Once you are good with C you can easily pick-up languages like Javascript and Python. Not the same thing but you "speak" the same words to the computer to achieve pretty much the same thing. A "while" loop and an "if" conditional are the same incantations. LISP opens the mind to an entirely different paradigm. It is well worth learning. The same is the case for APL. I don't think of these languages as "career level" languages. That may have been the case ages ago. No longer the case. However, the perspective gained is invaluable. As we try to solve more and more complex problems the limiting factor might very well become our ability to express ideas for a computer to solve these problems. Having the perspective of languages such as LISP and APL makes someone realize there are other valuable approaches to solving problems computationally. Finally, C++, well, it's the entry point into object-oriented programming. This, BTW, was pretty much my path through computing. I can't complain.
• nindalf 5y ago
  There’s a lot of folks in this thread who’ve shared their personal experience with learning and teaching programming languages. Some attempt to generalise this experience into principles of how much the first language matters and how to choose it. It would move the conversation forward if people were up front about which metric they’re trying to move. For example, here are two equally valid pedagogical goals that are in tension with each other - helping everyone become a programmer (no dropouts) and making sure every programmer meets some pre-defined criteria (strong understanding of memory layout or type theory or ability to build products). If your pre-defined criteria includes understanding of type theory, you might start with Haskell. Certainly all surviving members of your starting cohort would succeed according to your criteria, but this is only success if you didn’t mind people dropping out. Conversely, a language like python might help fewer students drop out, but they might have “weaker fundamentals” for some definition of that. So let’s be clear about what success looks like. Let’s state a hypothesis for success and which metrics we’ll use to measure that. Let’s verify that hypothesis by offering the teaching approach to similar groups and interpreting the results. We can do better than “I was taught like xyz, and I’m successful now and so that was definitely the right approach”. Lastly, some people in this thread claimed that anyone can become a programmer if the teaching is good enough. On this, I’d like to paraphrase fictional food critic Anton Ego - “only now do I understand what was meant by the motto ‘Anyone Can Cook’. Not everyone can become a great artist, but a great artist can come from anywhere.”
  • ganzuul 5y ago
    On discovering that I used to think in a functional manner before learning to program I wish I had begun with Haskell. Things which seemed like obvious things to try didn't work in C++ 98 so I 'learned' that my thinking was wrong and bad... I remember discovering the possibility for tail call elimination and being disappointed that it did not work. Lets keep the standardized tests with the standardized humans: absent.
  • tkgally 5y ago
    > “I was taught like xyz, and I’m successful now and so that was definitely the right approach”. For what it's worth, the same reasoning can be heard in other fields. I work in foreign-language education, and debates about the best way to learn another language—memorize vocabulary and grammatical rules? move to a country where the language is spoken? watch a lot of movies in the language?—often reduce to competing personal success stories. Teachers who have taught a foreign language using a particular method often come to believe that their method is the best, even though they are usually unable to measure the actual long-term outcomes for their students. It may be just too discouraging to be uncertain about the effectiveness of what one does to make a living, so teachers become advocates for whatever approach they happen to use.
• havkom 5y ago
  Especially nowadays when ppl learn some specific JavaScript framework, think they know how to best do stuff (because the framework is hyped), and then the learning curve stagnates.
• inglor_cz 5y ago
  My first language (from approx. 16 to 20) was Pascal. I did not like it and I still fail to see its putative suitability for programming beginners. The syntax is so unlike other languages that I might have been better off learning C outright.
  • qayxc 5y ago
    > The syntax is so unlike other languages that I might have been better off learning C outright. Hm. Ada and Eiffel have very similar syntax to Pascal and Ada is used in various industries.
• vishnugupta 5y ago
  Only yesterday I commented on a related thread I commented[1] thus which lead to a long subthread. It all depends on the first couple of language that one learns and how they are learnt and taught. 10-15 years ago people would find it hard to grok Python's functional concepts. But as it began to be taught as the first language in universities and those graduates join the working population you see how it's super natural for them to grok Python. That said, in a professional environment, one should be able to pickup ~70% of proficiency in 6-8 months if they aren't constrained by crazy timelines. This is based on my own experience. [1] https://news.ycombinator.com/item?id=27639687 https://news.ycombinator.com/item?id=27639687
• TazeTSchnitzel 5y ago
  Dijkstra famously argued it was better for new students to learn Haskell than Java. https://www.chrisdone.com/posts/dijkstra-haskell-java/ https://www.chrisdone.com/posts/dijkstra-haskell-java/
• virgulino 5y ago
  "The tools we use have a profound (and devious!) influence on our thinking habits, and, therefore, on our thinking abilities. ... It is practically impossible to teach good programming to students that have had a prior exposure to BASIC: as potential programmers they are mentally mutilated beyond hope of regeneration. The use of COBOL cripples the mind; its teaching should, therefore, be regarded as a criminal offence." - How do we tell truths that might hurt? Edsger W.Dijkstra, 18 June 1975 https://www.cs.virginia.edu/~evans/cs655/readings/ewd498.html https://www.cs.virginia.edu/~evans/cs655/readings/ewd498.htm...
• Closi 5y ago
  Taking specific languages out of it, I think some characteristics of a good starter language could be: * Simple Syntax - I think it's important for this to be a 'typed' language rather than blockly-style as otherwise people find it hard to transition after. It's important to learn typing in syntax otherwise that's a band-aid that's harder to rip off after. * Mix of dynamic and static typing - On the other hand, words like 'integer', 'string', 'for' e.t.c. confuse people who are starting. A good starter language would allow people to dynamic type and then encourage them to static type in the future, getting them used to the terms. * Very helpful error messages. * Standard functions that support drawing simple stuff to screen (I'm looking at you python - how hard is it to draw a circle for a beginner! Beginners want to break out of the terminal quickly). Would love to hear everyone else's thoughts!
  • mbo 5y ago
    What do you think of https://www.pyret.org/ https://www.pyret.org/?
    • Closi 5y ago
      Super cool, but also difficult to start for total beginners! I suspect this is aimed more at people who can already program and want to learn functional programming, rather than people who have never programmed, but I might be wrong!
• diegoperini 5y ago
  Which language you start is not as important as whether that language is used by your teacher on a daily basis. One thing you don't want is a teacher with outdated notes.
• odiroot 5y ago
  My parents sent me to a "computer course" when I was around 8-9, to stop me from messing with all the electronic equipment at home (and sometimes getting electric shock). I was always fascinated with machines and taking them apart. The course turned out to be surprisingly worth it! Since it had kids up to 15yo or so (I may have been the youngest), they introduced some advanced topics. I quickly picked up HTML (with Netscape and Notepad) and at the end they even taught us C in a UNIX environment (we worked on IBM terminals). I'm really glad and thankful I had a chance to learn C that early. I have been taught Pascal, Java, C++ before reaching Uni years but I have always appreciated the compactness of C and compared every other language to it. Discovering Python on my own in high school was like a eureka moment for me. It was the first time since my primary school C episode that I felt "home" with another language.
• Kenji 5y ago
  Because it doesn't.
• weirdkerneldev 5y ago
  My father is a CS person, but he barley can code. I spent lot of years learning programming through tutorials and none of them worked, because I lacked critical thinking skills and abstract reasoning. I believed in miracles. I believed in illogical things. I was bad at Maths. I however didn't stop. I took a critical thinking class and become an atheist three years after. I was to able to see things differently after that. Still, it was not enough to be able to program, but certainly boosted speed. I took a Python class. I was able to understand basic concepts of programming. It's still not enough because I can't make something real world. I was looking at real world Python projects but they are hard to read and has obscure short names. Then, I spent my time understanding what an API is. I found bubble.is and there I used my skills to build a real world app and made some money. I moved to Outsystems and there I boosted my understanding on a lot of concepts. I started to feel that I was like ready but afraid to swim into a real programming language. I got angry one day. I wanted to build an API in real world language. So, I googled and found a result for express.js I hated Javascript because a lot of people hated it in online. But I started to copy paste express.js example it on my machine and modified it according my needs. I felt relief. I finally started real world programming with Javascript. I made a lot of money with JS for 6 months. I then discovered about C++ and the static typing world. I went to learn C++ despite people telling me you should learn C before learning C++ I got understanding about pointers and memory management, compilers after learning C++ I then moved to embedded space where I did a OS and kernel from scratch. That's my journey and of course I'm still learning Maths. Actually, learning critical thinking & programming helped me to see what Maths really is. I'm studying basic algebra and going thru a lot of concepts right now.
• teekert 5y ago
  As a biologist I learned to program at 34, it was using Python (pandas and seaborn) in Jupiter notebooks. I mainly did data science in the beginning. I can tell you this worked extremely well for me. I could make small steps, add text and output variables and graphs constantly as I “developed”. It took me quite some time to shift to a full vscode flow, I kept going back to notebooks. I’ve become more of a software developer now but for data science (that which I learned in Excel and Origin) I still go back to the notebooks.
  • wirthjason 5y ago
    There’s many different styles of programming. Excel and Jupyter notebooks are a kind of “end user computing”. Programs developed in those environments often need a lot of refactoring to get turned into “software” (by some arbitrary definition). However these programs are incredibly useful for the business ideas they explore. To put it another way, using Notebooks with pandas is a great way to wrote biology programs. Using Notebooks to write pandas is a terrible way to write software.
    • teekert 5y ago
      Yeah I found this out indeed, by transitioning from data science to software development, there was an interesting time in between where I couldn’t let go of the notebook concept but I now certainly have. That said, the notebooks got me started in programming and did so in a way that I experienced as very gentle and with a flattened learning curve. I guess that was my point.
• btilly 5y ago
  Dijkstra in https://www.cs.virginia.edu/~evans/cs655/readings/ewd498.html https://www.cs.virginia.edu/~evans/cs655/readings/ewd498.htm... has various quotes that apply here. The most applicable is, "It is practically impossible to teach good programming to students that have had a prior exposure to BASIC: as potential programmers they are mentally mutilated beyond hope of regeneration." But do not forget, "The use of COBOL cripples the mind; its teaching should, therefore, be regarded as a criminal offence."
  • jefftk 5y ago
    On the other hand my team recent was taking about what languages we started with, and about 1/4 of us started with Basic. Seemed to recover ok!
    • nesarkvechnep 5y ago
      That’s your own opinion.
      • jefftk 5y ago
        I'm not claiming Basic is the best language, or that it doesn't matter what language you start with, but "practically impossible" is clearly way off.
        • alanbernstein 5y ago
          I think you need to know how many students were introduced to programming with a course in Basic, and gave up programming, to make that claim. Not that I necessarily agree with the quote.
    • peoplefromibiza 5y ago
      I've started with BASIC as well, in the 80s, on a C64 Dijkstra was right: I've wasted a lot of time unlearning BASIC to re-learn, if I wasn't exposed to BASIC at all I could have learnt from scratch a proper modern programming language/paradigm
• bluenose69 5y ago
  This seems to be a natural evolution of a new field. At the start, the goal of teaching is to produce highly-skilled graduates who can contribute greatly to the task at hand. During that phase, there's no problem with a high drop-out rate, and no need to "sell" the discipline by extending its reach. This is basically an exponential phase. Later on, as faculty slots fill up, a steady state can be reached, in which the supply of graduates meets the demands of the community. That's when things get extended, and the goal can start to shift from turning out highly-skilled graduates with narrow focus to simply educating. Every university has a psychology department that has huge classes. Students in those thousand-seat classes are not going on to become psychologists; they are enriching their experience of life. And the dividing line between what they are learning and what they could learn in grade 10 is very thin, so this kind of material can also be taught in high school. Again, those 15-year olds are not destined to work in psychology, any more than they are destined to work in history, literature, or all the other fascinating courses that are being offered to them. It looks as though the author is suggesting that education in computing is entering this state, in which there is very little probability of the student becoming a professional. And, in that scenario, I agree fully with the theses of the article. But I still think there is a place for the old system of teaching a language and expecting that some of the students will go on to contribute at the cutting edge. It's great to have classes on photoshop and the like, but there is a question about what they ought to be called. Perhaps CA (computer applications) is a better acronym than CS for that student in sixth grade. Using the same title for everything that happens to involve using computers is a mistake, not least because it gives students an incorrect impression of the pathways they might want to follow.
• alkonaut 5y ago
  When I arrived at university we had to do a Haskell course first. I didn’t realize it at the time because it just felt backwards, but it was a great “reset” of the minds of everyone like me who had done C64 Basic and Pascal. It also served as a great equalizer in the class when some people had never programmed while some of us had done it for 15 years. The Haskell course put everyone on an equal footing.
  • aardvark179 5y ago
    Likewise, but ML rather than Haskell.
    • fanf2 5y ago
      yeah but even so, some of us learned ML before arriving :-)
  • throwaway2037 5y ago
    "When I arrived at university" -- Usually 18 years old. Then: "while some of us had done it for 15 years" -- I'm confused. Are some people learning to program a 3 years old? This is breaking new records for HN exceptionalism.
    • alkonaut 5y ago
      University is often 19 or 20 here (mandatory military service!) but obviously there is no upper limit; some in my class had done it for 15 years (possibly more, we had people with existing careers, but they were older than me). I was 20 and had programmed for ~12 years at the time. Obviously zero years professionally.
      • throwaway2037 5y ago
        Great point about mandatory military service. I did not consider it. In Korea, you can go after you university.
• MeinBlutIstBlau 5y ago
  I mostly had Java as well as these: Basic web stuff MSSQL C and C++ Bash Intel Assembly Overall I'd say a little bit of everything is good for a CS student. Don't keep them hooked on one thing for too long. Not that students will be using C/C++ or assembly upon graduation most likely, but then are just another tool. I just wish we learned more about REST and doing CRUD operations. That took me a long time with my internship for it to "click" on what was happening.
• chiefalchemist 5y ago
  It's not only what to teach but how to teach it, as well as who is doing the teaching. For example, I typically do better with reading than watching video. But it also depends on the subject matter. Ultimately, when it comes to education / teaching / learning one size does not fit all.
• moron4hire 5y ago
  The current state of programming instruction in universities is abysmal. The way that universities do it right now, you get some super basic instruction in one, maybe two languages, and then are left to fend for yourself for everything else. Either actually teach programming or don't bother at all. With mathematics, a student entering a math degree program is expected to have taken several math courses in high school. Students take placement exams to determine if they need remedial courses, but in general, you'll need to have taken algebra, trigonometry, geometry, and maybe a level of calculus. But for computer science, we don't do any placement testing. Everyone goes into the same Java 101 course. And it's often the same course that everyone else in the college are taking as a gen-ed requirement. Yes yes, insert any Dijkstra quote you want. I've read a lot of his papers. He was a professional troll. We need to stop holding him up as a paragon of computer science instruction. He did some great work in algorithms, but the dude is not the role model we should be pushing. For as much as people like to parrot "computer science is as much about computers as astronomy is about telescopes", at least a telescope is conceptually quite easy to understand. A computer is a vastly more complex beast. Imagine trying to teach mathematics with students who don't even know the basics of the symbolic representation that algebra teaches. Such a student would fundamentally lack the tools necessary to succeed in a math program. But with computer science, we have students who don't know how to use their computers as tools. They only know how to use the software that other people have written and probably not even all that well. Even though "computer science is not about computers", being able to effectively use the tools of the field is still a necessary prerequisite. So either shift the expectation to students having to learn the basics of programming on their own completely, or introduce a course of remedial programming classes in a variety of paradigms. But this purgatory of holding students hands through essentially nothing more than learning how to use the terminal and run a compiler, with only the most basic of procedural programming scattered on top, then throwing them in the deep end, that has to stop.
• airhead969 5y ago
  The ethics of academia requires that computer science shouldn't become a factory pumping-out sausages by the millions by whatever means necessary. Perhaps a prerequisite of the major would be demonstrable knowledge of 2+ programming languages that exist in nearly orthogonal domains. I think low-level to high-level, with the right amount of history, is the best way build rather than relying on mysterious abstractions below. Microcode, assembly, C or Fortran, are the fundamentals CS graduates should be required to have or the accreditation bodies aren't doing their jobs. Also: If you can teach monads, you're a great lecturer. If you're Sean Davis from UC Davis, you are/were a great lecturer. A great lecturer of technical minutiae both has an expressive personality and explains concepts as simply as possible using learning aids such as analogies, examples, and diagrams.
• ksec 5y ago
  So many has ( and hasn't changed ) in the past 50 years of computing. I mean look at C++ today, and pick any programming language in the 70s. Another point is, are we really taking about programming language on the surface, its syntax? Or programming language as its whole ecosystem with library, tools, edge case and best practice. The former, arguably is very very easy. The latter is very very hard.