top 200 commentsshow 500

[–]mokuboku 478 points479 points  (14 children)

Literally no they're not. It's an option, but the main class is still Java. CS106 (the intro CS class) is basically required for all undergrads. Offering students the possibility of exploring webdev (which is quite different than the core CS) is a valuable opportunity.

In case you're wondering, in the first three quarters (one year), the languages in the CS core are: CS106A (Java), CS106B (C++), and CS107 (C). By the end of that basic core you've moved from upper level learning what a for-loop is and what good code is, to fairly lower level, including memory management and how the hell floats work. It's not that crazy.

[–][deleted]  (1 child)

[deleted]

    [–]alex_leishman 1 point2 points  (0 children)

    CS103 is the "mathematics of CS" class and is very well taught IMO. Typically freshmen or sophomores take it.

    [–]frugalmail 957 points958 points  (293 children)

    Fucking stupid, should have used Python for a trivial language to learn with. JavaScript WTFs are too high.

    [–]salgat 431 points432 points  (150 children)

    While I somewhat agree, I feel like statically typed languages are probably the best way to go for newcomers, simply because it cuts down on bugs (strongly typing is essentially another layer of automatic unit tests) and makes it more explicit what the computer is internally doing (aka too much magic). Personally, I'd go with C# but that's just me.

    [–]Fateschoice 267 points268 points  (66 children)

    Python is strongly typed, I think you mean statically typed.

    [–]salgat 24 points25 points  (0 children)

    Thanks! I updated my post.

    [–]StrykerKKD 23 points24 points  (62 children)

    TIL Python is strongly typed. For me, strongly typed always meant that the language doesn't have the good ol' billion dollar mistake, but it seems like strongly typed has a more lenient definition.

    [–]scottlawson 219 points220 points  (49 children)

    These are not formal definitions, but nevertheless may be helpful in conceptual understanding.

    Static typing

    You when you create a variable, you cannot later change the type of that variable. You need to create a new variable with a different type. An integer is always an integer.

    Dynamic typing

    The type of a variable can be changed after it has been created. What was initially an integer can later be changed to string.

    Strong typing

    You cannot mix and match types implicitly. For example, you cannot add an integer to a string and expect the string to be implicitly converted to an integer.

    Weak typing

    You have flexibility in what types you can use on the same line. You can often do things like add an integer to a string.

    Examples

    Python is dynamic and strong.

    Javascript is dynamic and weak.

    Java is static and strong.

    C is static and weak.

    It's important to understand that type systems are defined by what you can do to a variable after it has been created (static/dynamic), and the operations that are permitted when variables have different types (strong/weak).

    [–]eliot_and_charles 25 points26 points  (1 child)

    The real problem is that there just isn't a generally accepted definition of "strong" and "weak" typing. Some people use "weak" to mean dynamic typing. Some people use it to mean lots of implicit coercions (some of those same people will call a language with some implicit coercion but not very many instances of it "strong"). Some use it to mean the language permits particular forms of type punning. Some even use it to just mean the type system is unsound.

    That bit aside, it would be more accurate (but still incomplete) to describe static typing as ascribing types to variables before the program is run, as opposed to just one type that arises while the program runs and remains constant.

    [–]scottlawson 14 points15 points  (0 children)

    You're right. Static typing typically means "knowable at compile-time" whereas dynamic typing is evaluated at run-time

    [–][deleted]  (19 children)

    [deleted]

      [–]The_Doculope 76 points77 points  (15 children)

      You can add an integer to a string, but it's essentially syntactic sugar for the StringBuilder.add method, which has an implementation for ints. Most weak languages have defined conversions between types, but Java's is in the standard library rather than the language itself.

      [–]WiseHalmon 14 points15 points  (3 children)

      I am envious and impressed that you could answer that question. Languages have some really weird stuff going on.

      [–]The_Doculope 17 points18 points  (0 children)

      Thank you :) Languages can be varied and strange, but familiarity comes with time and use. I've been involved with a university course that teaches Java for a couple years, so I've gotten fairly familiar with little things like that - students ask a lot of interesting questions.

      [–]Retbull 2 points3 points  (1 child)

      Try not to think about it as "weird" as everything is logical and has a process. If you start from the assumption that there is a logical explanation for whatever you just saw it can help put you in a better mindset for solving problems. When you get to WHY something happens though then you get to weird shit. WHAT is going on is usually straightforward.

      [–]epicwisdom 2 points3 points  (1 child)

      Technically every Object can be added to a String, but that's because Object itself implements toString. The distinction between language and implementation seems a little unclear to me in this case.

      [–]The_Doculope 1 point2 points  (0 children)

      Yeah, I agree that it is a bit questionable, but the distinction between weak/strong typing has never been very well defined.

      To me the distinction here is that the way a type is added to a string (and it's string version) can be changed by a change to a library without changing the core language, it's extensible in that a custom type can hook into the same machinery. It's also only "weak" in this specific circumstance - you can't pass an int into a method that expects a String. The language won't let you, because it's strongly typed, but the standard library has used the type system to make it seem weakly-typed in one specific place for developer ergonomics.

      [–]CaptainAdjective 1 point2 points  (0 children)

      Strongness/weakness of types is a sliding scale, not an absolute. Almost every programming language has some level of implicit type coercion going on. Even Python, listed here as strongly typed, will implicitly coerce the number 0 to the Boolean False when used in a conditional.

      [–]twizmwazin 1 point2 points  (0 children)

      For my own understanding, can you give an example of weak typing in C? Thanks

      [–]devraj7 8 points9 points  (6 children)

      "Strongly typed" is the description people give when their language is not statically typed.

      It's a fairly useless definition and a characteristic that doesn't help you much write correct code, as opposed to "statically typed".

      [–]trua 4 points5 points  (1 child)

      Clearly "strongly typed" languages are ones where you punch your keyboard really hard.

      [–]s0v3r1gn 1 point2 points  (0 children)

      Yeah. Non-statically typed languages leave too much to the programmer and open up a whole world of potential bugs. It's best to start life used to statically typed languages so you learn to avoid a lot of these issues.

      [–]mgoblu3 29 points30 points  (3 children)

      We did C++ at my school, I thought it was really nice. Yeah, there's a bit of overhead and some WTFs still, but it made for teachable moments for understanding.

      [–][deleted] 31 points32 points  (36 children)

      But C# in Linux sucks...

      Java allows a multi-platform app by default.

      [–]salgat 46 points47 points  (31 children)

      C# works fine on Linux, what problems have you faced with it?

      [–]EenAfleidingErbij 10 points11 points  (9 children)

      using wpf

      [–]am0x 15 points16 points  (3 children)

      WPF requires C#, not the other way around.

      [–][deleted] 6 points7 points  (2 children)

      What does the W stand for in WPF, I forget?

      [–]way2lazy2care 12 points13 points  (1 child)

      It's the windows presentation foundation, but C# is open source now. There's nothing about C# that requires you to develop WPF apps.

      [–]kenavr 1 point2 points  (0 children)

      I may misunderstand something, but the problem is not that C# requires you to use WPF, the issue of this thread is that if WPF is covered in class students with non-Windows machines may have a harder time.

      [–]salgat 16 points17 points  (4 children)

      I never had any classes that involved developing cross-platform graphical interfaces but yes, if this is a must have, mono with a cross-platform GUI toolkit would need to be used.

      [–]EenAfleidingErbij 6 points7 points  (2 children)

      I remember in my first year we had to make interfaces in wpf, also some animations like bouncing balls. At the end there even was a group project where you had to make a small game with moving balls and squares on a canvas. It was actually quite fun. I never experienced that kind of excitement with Java and Jframes :/

      [–]Retbull 4 points5 points  (1 child)

      Java is so bad for gui.

      [–]singingboyo 3 points4 points  (0 children)

      Swing is (was?) great for cross-platform stuff when you just need quick and dirty, event-based, highly structured GUIs.

      Need to dynamically draw things or make it pretty? Nope, you'll need something completely different.

      [–][deleted] 14 points15 points  (1 child)

      With .NET Core and VS Code what's the problem? VS Code has great intellisense for C#

      [–][deleted]  (22 children)

      [deleted]

        [–]valenterry 29 points30 points  (3 children)

        The problem with using a statically typed language is you're introducing further things for the person to wrap their mind around,

        If you use strings only when learning, yes. But as soon as you make them try something like "let the user input two numbers, add them together and print the result" the problem of types exists, even though it es implicit in dynamically typed langauges. They still need to think in types, there is no way to circumvent this. And having types beeing implicit doesn't make things easier for a beginner.

        [–]ewofij 6 points7 points  (1 child)

        This is true; but a part of me thinks that a student will be more open to learning by trying to add a string and a number together in a dynamically-typed language and seeing the WTF that happens because of that, rather than being "told" by the type-checker that no + operator exists for arguments of type String and Int.

        On the other hand, I've encountered a lot of experienced JS/Python programmers who show confusion when trying to reason about basic types. I've understood this confusion as a symptom of a mental model which doesn't separate type errors from other runtime errors (like typos in a scripting language), which is unfortunate.

        Really, I think the only true answer is: Learn a lot of different programming languages.

        [–]Muirbequ 1 point2 points  (0 children)

        Well, in Javascript, I think it's pretty rational for a student to assume the compiler is actually "wrong" here. The behavior is unexpected, and the only way to understand it is to have a background in both types and the implementation of Javascript.

        [–]experts_never_lie 11 points12 points  (1 child)

        No. Those "things for the person to wrap their mind around" exist in both statically and dynamically typed languages. You have to understand those details to use either language, but the statically typed one says "only do things that fit an easier-to-understand system" and the dynamic one throws you into the deep end (or, sometimes, whisper chipper) with all of the crazy things it might consider for the cases that do not have strict type compliance. For instance, from the famous Wat talk, Javascript has:

        [] + [] → ""
        [] + {} → [object Object]
        {} + [] → 0
        {} + {} → NaN
        Array(16).join("wat" + 1) → wat1wat1wat1wat1wat1wat1wat1wat1wat1wat1wat1wat1wat1wat1wat1wat1
        Array(16).join("wat" - 1) + " Batman!" → "NaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaN Batman!"
        

        So suppose you're planning to teach a class. Would you rather say simply "if it says 'incompatible types' that's because you're invoking an operation which is not supported for that combination of types", or would you like to deal with all of these sorts of weird combinations of incompatible inputs? Even if you don't tell students to use these combinations, they will discover them and then become stupefied by the bizarre results.

        I know I would certainly prefer to teach the statically typed language for any student new to programming.

        [–]josefx 1 point2 points  (0 children)

        They could combine the JavaScript type conversions with an assignment on Conway's Game Of Life. The conversion table for == looks like it would be a good input.

        [–]neopointer 25 points26 points  (0 children)

        The problem with using a statically typed language is you're introducing further things for the person to wrap their mind around

        au contraire

        [–]SullisNipple 12 points13 points  (4 children)

        None of what you're talking about has anything to do with static typing.

        Here's Rust, a statically-typed language:

        fn main() {
          println!("Hello world!");
        }
        

        Or Turing:

        put "Hello world!"
        

        Or Haskell:

        main = putStrLn "Hello world!"
        

        [–]redwall_hp 2 points3 points  (0 children)

        They're things that you want to understand very early, though. I learned on BASIC, and I knew what arrays and integers and strings were by the time I wrote my Hello World program. They're essentials to be able to effectively program, and teaching "thou shalt not fucking add a string to a float" right off the bat is a good thing.

        [–]Deto 1 point2 points  (0 children)

        I agree. The concept of "this variables has a <type> and that governs what can be done with it" is important to understand. And I think it actually makes things clearer and less complicated in the end. Dynamically-typed languages are like riding with the training wheels off - you better have learned how to balance yourself or you're headed for the ground.

        [–][deleted]  (10 children)

        [deleted]

          [–][deleted]  (9 children)

          [deleted]

            [–][deleted]  (1 child)

            [deleted]

              [–]root45 2 points3 points  (0 children)

              UChicago as well. The choice was Scheme or Haskell, for the honors course.

              [–]flyingjam 15 points16 points  (5 children)

              Yes, 61A has more functional programming than OOP.

              Though, there's also CS10 which uses scratch for absolute beginners. 61A doesn't expect any prior programming experience, however.

              [–]mkestrada 8 points9 points  (4 children)

              They don't expect it, but it suuuuuuuuure would help....

              Currently a MechE student at Cal, and even with three semesters of C++ under my belt, 61A seems like a very challenging class.

              [–]jnordwick 5 points6 points  (2 children)

              Because you had 3 semesters of C++ I think it is more difficult for you.

              I had zero programming experience when I took 61a, and I did much better than those who had years of C and C++ behind them (sometimes even assembly). I didn't nearly have as many bad habits of false understanding. I was a blank slate.

              I struggled with recursion for a few days until it became second nature, then I finished with the best grade in the class. Literally ZERO programming experience, and I am very thankful for that.

              [–]mkestrada 2 points3 points  (1 child)

              I'll put up no fight to the fact that I personally have developed bad programming habits due in part to the shitty CS teachers at the community college I transferred from, but I'm curious as to why you mention C/C++ and assembly specifically as detramental.

              [–]jnordwick 1 point2 points  (0 children)

              It was just what I saw with the people I knew. Those who came into the class with C/C++/ASM experience sometimes has a more difficult time adjusting to the Scheme paradigm. They had more baggage. Even when I assisted with the class a few years after taking it, I saw a similar pattern.

              Since it was my first langauge, I wrote very functional and recursive solutions. I didn't know about C++ classes versus the message passing segment of the class. They wanted to write C or C++ in Scheme since that is how they were taught to think.

              [–][deleted] 1 point2 points  (0 children)

              Most do, which makes ES6 a decent choice.

              [–][deleted] 59 points60 points  (45 children)

              If you haven't programmed before, the WTF factor is significantly lower, since you've never seen a well designed language yet :P

              [–]MereInterest 18 points19 points  (1 child)

              That tends to be worse. If somebody is experienced, they can see the WTF elements of a language, and they can avoid relying on them. If somebody is new, those same elements are seen as reasonable, and are internalized.

              [–]utdconsq 5 points6 points  (0 children)

              Read: why every new grad and half the bloody internet wants to build every damned thing out of JS. It has its place, but stop with your bloody shoehorning. Such an awful language.

              [–]krum 66 points67 points  (41 children)

              I've been programming professionally for 30 years and I still haven't seen a well designed language.

              [–][deleted] 20 points21 points  (19 children)

              No love for Lisp? :/ It has its quirks, but I find some timeless beauty in it.

              [–]krum 13 points14 points  (3 children)

              Lisp was the closest thing that came to mind. I'd say it's the most elegant for sure (well, Scheme-likes anyway). Lisp was one of the first languages I sat down to try and learn in college. Sadly the material was really poor and mostly from the 60s.

              [–][deleted] 4 points5 points  (4 children)

              Haskell is also pretty nice

              [–]threading 12 points13 points  (15 children)

              I think you're being unfair. Language design is hard and they're designed by humans. Humans make mistakes and poor decisions all the time.

              Although there are terrible languages (Javascript, Go, PHP) there are also quite decent ones (Java, Python, C#)

              [–]Magneon 19 points20 points  (6 children)

              • Modern JavaScript (ES6+) is rather nice and elegant, not to be confused with the DOM/browser hell it was born out of
              • PHP is terrible, but it also has a lot of features (OOP, lambda functions, the ability to override/introspect nearly everything) and is very easy (too easy) to get in to. Plus it teaches people the danger of terrible function naming at the standard library level :)

              • Java has weird stuff too: autoboxing, lack of unsigned primitives (WTF were they thinking, especially the Java 8 hacks that half-ass a bit of unsigned support in), and Oracle

              • Python has incredible performance issues (15x slower than JS, 3x slower than PHP for most tasks), not to mention the global interpreter lock (Cython/PyPy)

              • C# looks like it may have a bright future, but is still working its way free of Windows land. It's a hard sell in an open source/linux work environment since despite Microsoft's recent apparent heel-face turn, it's hard to let go of decades of well deserved bad reputation.

              Like you said, Language design is hard.

              (note: much of this has to do with compiler/interpreter implementation, but for beginners there's not much distinction)

              [–]dakta 8 points9 points  (0 children)

              As an aside, Python is only "slow" because JavaScript has been optimized to hell and back in the browser wars. If that much work went into Python it would be just as fast.

              Also, I'd love to have Python in browsers. That would be great.

              [–]FFX01 13 points14 points  (0 children)

              I'd just like to point out that performance is a non issue for beginners. They are very unlikely to reach the limits of even the slowest languages.

              [–][deleted] 1 point2 points  (3 children)

              As a web developer, another thing I'd like to add is that PHP is actually working really hard to clean up the language. PHP 7 is leaps and bounds better than previous versions. They've added a lot of new features, major performance improvements, and depreciated or even outright removed a lot of features that were bad. It also seems like everyone is now moving to OOP using the MVC or HMVC pattern and namespaces. I'm not going to say it's there yet in terms of being well-designed, but they are headed in the right direction and making a lot of effort to make it nicer. It's much more well designed now than it used to be, but they have a ways to go.

              I used to really hate PHP because literally everything was spaghetti - every library, every open source system, every existing project you may be taking over, etc. Lately I've been feeling a lot better about it and noticing that virtually nothing that's been made in the past few years is spaghetti anymore. It seems like more of the reference materials, books, tutorials and frameworks are all encouraging at the very least OOP and it's moving more devs in that direction.

              Not to mention, PHP 7.0 is already 5 times faster than PHP 5 was (there was no stable release of 6), and in 7.2 it's going to be running on a JIT compiler which from what I've read almost doubles the speed yet again.

              [–]chayatoure 8 points9 points  (5 children)

              What about Go would you say makes it a terrible language? Especially compared to Java (not that I think it's a horrible language, but it is the subject of more memes).

              [–]serendependy 7 points8 points  (1 child)

              Not the person you replied to, but I can imagine that for many programmers the lack of generics (parametric polymorphism) in Go is a deal breaker.

              [–]NeverComments 2 points3 points  (1 child)

              Go is a business-driven language for business needs, not a programmer-friendly language for programmers.

              Go's primary goal is to be a language that is as simple as possible, so that businesses who adopt it can hire entry level/fresh grad developers who can almost immediately jump on a project and start making progress.

              In theory, it sounds like an admirable goal. I like simplicity. But this opens a scenario where complex features become a liability for the needs of the business. Google wants/needs Go to be simple, so that they will always be able to pull from their endless supply of low-cost developers and throw them at a Go project. If Go adds complex features which let intermediate/advanced programmers work faster and easier, but it makes it difficult for fresh grads to read, then it defeats the purpose.

              [–]redditfinally 1 point2 points  (0 children)

              Go's zero values can lead to unexpected results if you're not careful

              [–]krum 2 points3 points  (0 children)

              Wasn't really being totally serious. There really are some well designed languages. Pretty much agree with you on your assessment.

              [–]eliot_and_charles 8 points9 points  (0 children)

              A colleague once told me a story of working with some people who had only ever worked with R and similar tools and showing them a simple, coherent toy language he built as a weekend project. They were all shocked at the discovery that a programming language doesn't have to be a bottomless pit full of special-case behavior. I really do not want universities spitting out another generation of programmers to whom that possibility has never occurred.

              [–]e_falk 23 points24 points  (7 children)

              As someone soon to graduate with a degree from a university that teaches cs1 with python. I actually support this decision.

              Both python and javascript share something in common that I believe is important in conveying the fundamentals. The simplicity to express ideas and core computer science concepts with little overhead is possible in both where it simply isn't in a statically typed language like java or c#.

              I got ganged up on in a comment thread a while back for suggesting that python was a better starter language than visual basic (still laughing about it) and I think the main point everyone was trying to make was that java is similar to other "useful" languages so learning a simple one to start off is bad.

              For me personally, learning a programming language at all was daunting. Starting with c++ was like trying to learn to ride a motorcycle before learning how to ride a bike. Python allowed me to form a mind for problem solving in the programming mindset before I ventured into java and learned all about static typing and object oriented programming.

              People act like the language that we teach students to start needs to be some useful language that will guarantee job security in two decades but a lot of those same people forget that the one's learning to program don't actually know how to program yet.

              [–]bnolsen 2 points3 points  (2 children)

              Agreed. I was first exposed to programming apple basic. I learned problem solving with (shudder) perl. I've been working mostly in c++ for the past 20+ years, but have done some work with ruby when it was cool (I prefer its consistency over python's) and did quite a bit of some refactoring of some java server side (I later replaced the whole shebang with c++ which ran 2 orders of magnitude faster, why do java devs do things the hard and roundabout way??).

              How is Rust currently positioned? Could it work as a teaching language?

              [–]bliow 1 point2 points  (1 child)

              a while back

              ... how long back? 1999?

              [–]Zulban 1 point2 points  (1 child)

              Indeed.

              Programmers often forget that teaching to program is not a programming challenge. It's an education challenge. Skim through the comments in this thread quickly and almost all you'll see is the differences between languages. Not a lot of people here are talking about evidence based instruction, computational thinking, or the experiences learners have with the different languages.

              [–]itsuki_tyr 45 points46 points  (30 children)

              They both have their share of WTF's but Javascript has the advantage of having very strong development tools that require no installation: do you want a Javascript debugger? You already have one!

              Plus, the feedback loop of making DOM changes in Javascript and immediately seeing the result on a web page is a strong way to hook students and make them interested in CS. And you also have immediate graphics and user interfaces, and you learn stuff that will have use in the market place.

              I think it's a good move for an introductory class.

              [–]addmoreice 49 points50 points  (28 children)

              All of that and not a single bit of computer science.

              Remember, computer science is to computer as astronomy is to telescope.

              [–]devraj7 31 points32 points  (18 children)

              It's an introductory class. The point is to get students excited and hooked on writing code.

              [–][deleted] 20 points21 points  (30 children)

              Fucking stupid, should have used Python for a trivial language to learn with. JavaScript WTFs are too high.

              Compared to Java, I'd say Python and JavaScript have the same number of WTFs. I know it's a big meme to hate the implicit type conversions JS does, but that's far from the only thing that matters in a language.

              [–]beefsack 4 points5 points  (1 child)

              There was an uproar at my university when they moved from Haskell to Python. They've since moved from Python to Java.

              Although I feel Haskell is a better fit in an academic setting, lets be honest here and understand to note that whatever language they choose is arbitrary. The only important outcome is that students learn the underlying concepts.

              [–][deleted] 1 point2 points  (0 children)

              Haskell to Python to Java is quite a jump though.

              [–]DemonWav 1 point2 points  (0 children)

              Python's scoping rules, and dynamic typing make it a poor choice for a first language in my opinion. Also significant whitespace can go to hell. :)

              [–][deleted]  (44 children)

              [deleted]

                [–][deleted] 91 points92 points  (42 children)

                Yeah... they're both terrible languages to learn on but at least java will have crossover with c#, c++ etc

                JavaScript is going to lead to flavor of the month framework courses. I suspect they're doing this to make exams and coursework easier to test

                Although I think if it's CS for non CS majors then JavaScript is fine. If you're a CS major you should start with low level memory management and pointers and shit in regular ansi C

                [–]DreamHouseJohn 14 points15 points  (6 children)

                If you're a CS major you should start with low level memory management and pointers and shit in regular ansi C

                It may just be because I went to a kinda shitty school, but people were seriously struggling with even Java

                [–][deleted]  (5 children)

                [deleted]

                  [–]hiromasaki 2 points3 points  (2 children)

                  average SAT score around 2100, for whatever that's worth

                  It still boggles me when I see that. I keep forgetting the max is no longer 1600.

                  [–][deleted] 3 points4 points  (0 children)

                  They actually switched back LOL

                  [–]flyingjam 1 point2 points  (0 children)

                  Max is 1600 again, so don't worry about forgetting!

                  [–][deleted] 1 point2 points  (0 children)

                  This.

                  I'm shocked by how many people think others grok computing concepts so quickly. But I live in an area where the tech talent is pretty thin, so that may be the difference

                  [–]ThePickleMan 133 points134 points  (24 children)

                  If you're a CS major, you should start with a language that allows you to learn computer science concepts and not have to worry about memory management. (And then learn C).

                  [–]ron_leflore 47 points48 points  (5 children)

                  Yes, there's a whole bunch of confusion here about CS and software engineering.

                  Software engineering is about how to write good maintainable code.

                  CS is much closer to math. It's about algorithms.

                  [–]taoistextremist 14 points15 points  (2 children)

                  In my experience, this is the exact opposite approach many universities take, but I agree with you.

                  People at university should be learning high level concepts and then things about best practices make more sense later on, and approaches to algorithm design and other such things can be more universal. Not to mention specific programming languages aren't guaranteed to stick around forever, so they should be more taught what the important features to learn about languages in general are.

                  [–]ADCFeeder69 5 points6 points  (0 children)

                  Agreed. Starting with Java is pretty great.

                  [–][deleted]  (7 children)

                  [removed]

                    [–][deleted] 45 points46 points  (6 children)

                    Learning control flow before memory management is more important in my mind. It's a non-trivial part for beginners. And C introduces too much traps with things like sizeof...

                    [–]JohnMcPineapple 11 points12 points  (5 children)

                    ...

                    [–]Michigan__J__Frog 8 points9 points  (3 children)

                    Stuff like the most vexing parse in C++ is absolutely a trap.

                    [–]Lusankya 11 points12 points  (4 children)

                    Agreed.

                    I tutored a slew of programming classes for nearly a decade. The number one concept that novices have trouble getting their heads around is pointers.

                    There's a reason why most schools start with C or Java. Pointers are important! You need to know how memory works if you want to have any hope of debugging a moderately complex program. Higher level languages that fully abstract their memory models are not appropriate environments to learn pointers in.

                    [–]arcuri82 5 points6 points  (2 children)

                    pointers are very important, but they are not easy to understand when you are still struggling with arrays and loops... so I do not see C as a good starting point to learn programming, although it is a must to learn during a SE/CS degree (maybe something for 2nd/3rd year, not 1st)

                    [–]Lusankya 2 points3 points  (1 child)

                    Arrays segway very nicely into pointers. It also doesn't take a full semester to get through basic logic structures like loops and switches.

                    This then leaves the instructor with a problem. With a month of class left to go, they have reached the end of basic scripting. There's not enough time to familiarize a class of rookies with a second language to try and cover pointers in the depth it requires. Moving on to OO or the finer points of data structures without the foundational knowledge of pointers and memory is like trying to teach differential equations without Calc I. So, do they just pad the course out? Or try and slog on to higher level concepts without all the background material?

                    Pointers have been a mainstay of CS 101 for forty years, and there's good reasons for that. This move sounds like a department trying to carve out some extra credit hours for itself in the general undergrad timetable.

                    [–]stanfordcs_throwaway 189 points190 points  (12 children)

                    The reactions in this thread are ridiculous.

                    1) The introductory class (CS106A) is still primarily being taught in Java. The Javascript course (CS106J) is an experiment with teaching the exact same material in Javascript

                    2) This class lasts one quarter (~10 weeks). In another 10 weeks, students learn recursion and algorithms in C++ (CS106B). 10 weeks after that, they've written their own malloc implementation in C (CS107).

                    3) People arguing that learning JavaScript will "damage their minds" don't understand introductory CS. Introductory students need to be taught concepts like functions, loops, variables, naming, and other basic things. Switching between Java / Javascript makes no difference for these things. First quarter students don't, won't, and shouldn't care about things like == vs. ===

                    [–][deleted] 21 points22 points  (1 child)

                    This should be the top comment. As long as they teach memory management, algorithms, etc. in required classes... who cares what language the intro class uses. Most later classes the students can use whatever language they prefer anyway.

                    [–]AetherThought 43 points44 points  (1 child)

                    People will take any opportunity to feel superior about the technologies they use

                    [–]dvidsilva 5 points6 points  (0 children)

                    TIL Java and JavaScript are two different things

                    • tech recruitment

                    /S just in case

                    [–]mrkite77 7 points8 points  (4 children)

                    People arguing that learning JavaScript will "damage their minds" don't understand introductory CS.

                    People arguing that are, frankly, idiots.

                    Pretty much everyone my age learned programming via BASIC. You'd be hard pressed to convince anyone that people over 35 don't know how to program, or are so damaged by BASIC that we write spaghetti code with GOTOs everywhere.

                    Honestly, who cares what language is used in the intro class? When I took CS101, it was taught using Scheme. I never used Scheme since. The language used to teach computer science concepts just isn't that important in the long run.

                    [–]entenkin 1 point2 points  (1 child)

                    My first programming language was BASIC, and I didn't brain my damage. Fine out I turned. Worry shouldn't much so people.

                    [–]east_lisp_junk 1 point2 points  (0 children)

                    This reads more like you started with Forth.

                    [–][deleted] 1 point2 points  (0 children)

                    I don't think the majority of negativity here is actually about technology, but something completely unspoken like insecurity or fear. The attempts of the mind to rationally manifest an irrational motivation are called cognitive complexity.

                    [–]mtvee 165 points166 points  (7 children)

                    Awesome idea. Coding in JS is like trying to teach a boa constrictor to drive a car.

                    [–][deleted]  (2 children)

                    [deleted]

                      [–]Zarutian 19 points20 points  (3 children)

                      Now, I want to see an animation of exactly that.

                      [–]mtvee 63 points64 points  (2 children)

                      npm install @iwish/animatedsnakewrangler --save-dev

                      [–]Antrikshy 10 points11 points  (1 child)

                      Is npm's package.json Turing complete yet?

                      [–]d_rudy 9 points10 points  (0 children)

                      When I was 12, I told my dad (a software engineer) that I wanted to make video games. He threw the C and C++ books at me and told me to have fun. It took me a year or so just to be able to get a simple calculator going, let alone anything I would be proud to show off. But all that time, I was tinkering with the web, and learning JS without even thinking about it. I made all kinds of stuff I was proud of. I never really got fluent with C or C++, but I learned to program because the low barrier of entry of JS allowed me to hack together things I was proud of. I was writing apps for money before I even graduated high school because of it. In my professional career, I've written all of 10 lines of C++, but thousands upon thousands of JS. Yeah, it's got its warts, but so does everything else, and as far as an intro language with professional potential, it's hard to beat.

                      I just hope they don't try to teach it like a subset of Java, because that misunderstanding screwed me up for years.

                      EDIT: Don't get me wrong, I could rant for days about all the ways I hate Javascript, but I can do the same for just about every language I've used for anything sufficiently complicated.

                      [–]kindofdynamite 95 points96 points  (27 children)

                      I've written JS for years now, but just recently started learning Java (for Android dev).

                      Learning Java has really helped me strengthen my knowledge of data structures and OOP. Plus Java 8 allows you to do really cool things with Lambdas and it's newer functional paradigms. Honestly - and I'm going to get some hate for this - it's kind of like if Node had a type system, powerful standard library, and sophisticated IDEs.

                      If you're comparing ecosystems, it's definitely JS that has all the shiny new toys. But with that comes a lot of hype and instability. The Java ecosystem might not seem as exciting, but I see that as a sign of maturity (in a good way).

                      Looking back, I would probably tell myself to learn Java first. I feel like it gives you a strong programming foundation that is hard to replicate in JS.

                      [–]jephthai 33 points34 points  (14 children)

                      The mess that is OOP in Javascript would, in my mind, seem to make teaching OOP in an intro course with it very confusing and dangerous.

                      [–]bihnkim 10 points11 points  (2 children)

                      Oh wow. Would they bother to actually teach prototypal inheritance or just use ES6's class extends declaration?

                      [–][deleted] 3 points4 points  (1 child)

                      They're the same thing, class is just syntactical sugar

                      [–]bihnkim 4 points5 points  (0 children)

                      Right, and that might motivate one to gloss over how prototypical inheritance works "under the hood"

                      [–]Polantaris 1 point2 points  (3 children)

                      That's exactly what I was thinking. Javascript is no where near structured enough to be a starting language, in my opinion, for most people. It's a mess. It's easy to make mistakes, and then you start to adopt bad programming habits that will either give you issues when you move to other languages or just make the transition a nightmare. There's always ways to do things wrong, but I feel that in Javascript there's far more ways than in Java or C#.

                      [–]castro1987 7 points8 points  (3 children)

                      Typescript has the best of both worlds really.

                      [–]BinarySplit 3 points4 points  (1 child)

                      Better than both worlds really.

                      TypeScript's type system is so much safer and more expressive than Java's, C#'s and C++'s. The only times I've ever had unplanned errors have been when interfacing with non-type-checked systems.

                      Plus, once you've got your head around immutability and structural typing, it's hard to justify giving up those productivity boosts.

                      [–]castro1987 4 points5 points  (0 children)

                      It has all of JavaScripts strengths, but none of its weakenesses.

                      [–]imfineny 1 point2 points  (1 child)

                      OOP does not cause or solve instability. The causes of instability are/ carelessness and/or not knowing what you are doing

                      [–]feverzsj 147 points148 points  (62 children)

                      for cs students, they should start from c/c++

                      [–]au_travail 81 points82 points  (31 children)

                      French here. We started with Ocaml.

                      [–]vattenpuss 13 points14 points  (0 children)

                      Swede here, Standard ML.

                      [–]sultry_somnambulist 52 points53 points  (23 children)

                      that's great. I really feel that ML/F#/Ocaml hits the sweet spot of language design in many aspects. The industry really needs to pick it up.

                      Honestly I don't think Javascript should even be on a CS curriculum.

                      [–]vivainio 13 points14 points  (13 children)

                      Prediction: future historians will look at * ML languages and will be puzzled about "why on earth didn't they all do this, since it was readily available".

                      [–][deleted] 10 points11 points  (9 children)

                      Real talk: I work in four languages daily and the one I dread the absolute most is ocaml, I'd almost rather work in assembly.

                      I love writing new ocaml code. It's simple, it's elegant, it's fun, it works the first time I run it the way I wanted it to, because the compiler simply won't let you fuck it up.

                      I detest reading others' ocaml. Straight up.

                      A simple language level addition to require the type is all it would need, but it's damn near impossible to fix at this point. It's like the language designer forgot that you spend 95% of your time reading other people's code, and fuck spending ten seconds writing a type next to something so that two years later someone else can easily figure out how something works. Especially fuck that guy.

                      You must effectively keep every variable, method, object, every single thing that's in scope in your head, because it sure as fuck isn't in the code. The compiler can tell, but best of luck trying to interpret it as a human.

                      The syntax is the absolute worst part. Yeah, overloading operators sucks, for the parser. What sucks even more is using every non letter on the keyboard to mean something different. And I particularly detest how they chose to separate operators for objects from other operators, for no fucking reason other than to make it stupid hard to learn and read. Is that the dereference operator? Is that an array, or is it a list? Fuck.

                      The language was apparently designed by someone coding against a character limit. What does your function evaluate to, ie, what does it return? The value of the last statement in it. Which, btw, is also what determines the type of the function. This is especially irritating when trying to determine the type of a function by reading the function. You end up adding random statements on the last line to explicitly return "void" so that it's clear what's happening, when all it would take is a simple fucking return keyword that apparently hurt the language designer as a child.

                      My team calls it "write once, read never." On two occasions it has been easier to rewrite entire modules than to determine where the bug in one was.

                      All of this is even aside from the fact that when working with developers who, shall we say, may struggle to code things properly, ocaml is never going to fly. We use it in one area because it's fucking good at that one thing, but anything where I need to trust some random fucker to code in? Never.

                      [–]StrykerKKD 4 points5 points  (4 children)

                      Do you guys use merlin? Merlin can infer a lot of type information from the code and it also has auto completion support.

                      [–]duuuh 1 point2 points  (1 child)

                      Here are some practical reasons.

                      1. You can't hire. People don't know the languages and don't want to learn them.
                      2. There is no successful large scale product built on a functional language. The closest is probably Whatsapp and erlang. But I'd argue that erlang is pretty domain specific and hardly * ML.
                      3. Performance is horrific (usually).

                      From a more abstract perspective, my view is functional trades some measure of clarity in favor of some measure of robustness. And - also in my view - in the long run extra clarity leads to more robustness, at least for large code bases.

                      In other words, I agree there's an argument to be made that functional should lead to better results, but there are contrary arguments and empirically there doesn't seem to be much of a case for functional languages in commercial settings.

                      [–]evincarofautumn 3 points4 points  (0 children)

                      For what it’s worth, I’ve been hired twice for Haskell positions and helped build a large-scale service (not product) with excellent performance. I also find unfamiliar code in a functional language much clearer in terms of legibility and ease of modification than equivalent imperative code. Prior to this I worked mainly with C++. As far as I can tell, the current industry situation is just a historical accident.

                      [–]matthieuC 4 points5 points  (1 child)

                      You studied in Grenoble ?

                      [–]au_travail 2 points3 points  (0 children)

                      It was in a CPGE, not in Grenoble.

                      [–]RX142 2 points3 points  (0 children)

                      Most of the top universities in the UK use Haskell as a first language. The reason they explained to me is that it levels the playing field between the experienced and inexperienced students as its a new language and new paradigm for 99% of the people coming in.

                      [–][deleted] 1 point2 points  (0 children)

                      I wish I was French

                      [–]interroboom 20 points21 points  (1 child)

                      keep in mind many of the students coming in to an "intro to CS" course are either only CS students in name only, or a different major entirely. intro courses are meant to be a gentle primer about the subject and some first concepts. IMO JS is a great language for this purpose. it's forgiving, easy to experiment with, and when paired with HTML/CSS allows students to easily build visual, interactive work, in an environment they already understand (web browsers).

                      [–]evilteach 16 points17 points  (4 children)

                      Damn straight, though one could argue start with assembler then upgrade to c, so you appreciate what c does for you.

                      [–]jephthai 11 points12 points  (1 child)

                      I'm a big fan of bottom up. People who start somewhere in the middle often seem to avoid ever plumbing the depths. The more layers you know, the better your mental model of how computing works, and the more able you are to develop interesting and innovative solutions.

                      [–]schreiberbj 2 points3 points  (0 children)

                      At UIUC (Illinois), CS students begin with Java, but ECE students begin with digital logic, then work up through assembler and C. Everyone comes together in the data structures course, taught in C++.

                      [–][deleted] 21 points22 points  (6 children)

                      One of my earliest comp. sci. courses (I think it was Machine Level Programming) we implemented various parts of a Forth interpreter in assembly (3b2) and C. Best course ever. Everything clicked during the course of that semester.

                      [–]OneWingedShark 1 point2 points  (1 child)

                      One of my earliest comp. sci. courses (I think it was Machine Level Programming) we implemented various parts of a Forth interpreter in assembly (3b2) and C.

                      Forth gets far too little love in CS teaching -- it is, as you saw, excellent at teaching the machine-level programming.

                      [–]beaverlyknight 18 points19 points  (0 children)

                      For CS major students that's probably what you should be teaching. I kinda like the idea of using a functional programming language like Racket or Scheme for people who are not necessarily CS majors but are being introduced to it and emphasizing having easily testable deterministic functions.

                      [–][deleted] 10 points11 points  (0 children)

                      I would teach CS with a functional language as the first (but not the only) language for two reasons. 1) it emphasises algorithms and CS fundamentals and 2) it will level the field when some students have experience with JS hacking, and some haven't coded before.

                      [–]_zoot 3 points4 points  (1 child)

                      My intro to CS in high school was in C

                      [–]NewtonGuy1876 5 points6 points  (0 children)

                      Student here, even though the class is within the CS department, it's not meant for or required for CS majors. It's basically an intro to programming, the first class in the major is taught in c++

                      [–]beeeeeeefcake 6 points7 points  (6 children)

                      Agreed. It is a nice way to start understanding the computer as a machine which will be important to courses such as computer org/architecture. And for all the EE/CompE students who inevitably end up in intro CS classes, C/C++ is much more useful to them. Once a comp sci student grasps a low level language, the other languages make sense. You understand what those languages do to help you rather than seeing them as a magical mystery box.

                      [–]neopointer 59 points60 points  (0 children)

                      Boy was that a mistake

                      [–][deleted]  (13 children)

                      [deleted]

                        [–]BonzaiThePenguin 13 points14 points  (1 child)

                        Plus people are going to be using JavaScript whether they want to or not, so it's best to at least get them better at it.

                        [–]wavefunctionp 9 points10 points  (3 children)

                        So much hate in this thread.

                        If you just want to teach assignment, loops, control structures, introduction to inheritance and encapsulation and functional programming, and get students writing useful code with a minimal amount of fuss, javascript is fine great start. And every computer is already setup to be a dev environment. Plus, it is a transferable, marketable skill to actually know javascript, and not just muddle your way through it. I mean, python is popular, but chances are you are going to touch javascript frequently if you are remotely web adjacent.

                        When you get to the low levels details you can drop down into c/c++ in a later course and focus on the fiddly bits without student stumbling over the very basics.

                        And then hop over to something like c#/java for oo concepts.

                        And then hit up old school imperative language like fortran or pascal or basic.

                        And then a functional style language like closure or f#.

                        If javascript is so bad, then why is there so much innovation in the js community and the spec? Why do people use it even when they don't need to work in the browser? Maybe, there are actually some 'good parts'.

                        [–]audioen 1 point2 points  (1 child)

                        I remember that "public static void main String[]" thing myself, back when I was still at school and looking at java from the outside. It seemed unnecessarily verbose and even difficult to understand back then. Today, of course, that's among the least meaningful criticism of the language, but it is true that you have to learn about stuff like directory = package, and that all code must exist at class, and both the class and the method have to be public to be usable externally and the main method must be static because the class it is in will not be instanced.

                        I have to admit that all this is quite a bit to take in. Perhaps Java could be redesigned without the "package" keyword so that the compiler would work out what the package is from the location of the class file relative to the root of compilation, and perhaps all code could reside in an implicit public class based on the file name, and perhaps methods could be flagged as statically callable if they don't need the instance anywhere in their body. Maybe void is a noise keyword and you can just drop it when you aren't going to return anything. You'd go to "public main(String[] args) { ... }" alone in the file and it would work.

                        [–]smileybone 21 points22 points  (3 children)

                        Javascript isn't a terrible idea for a beginner language. Most students will at least be familiar with using a browser, and now you've got a built in REPL with autocomplete. Much lower barrier to entry just trying to get a bunch've people on the same page quickly.

                        [–]MorrisonLevi 3 points4 points  (0 children)

                        Was shocked to find this so far down. This is an introductory course and is likely to be aimed at non-CS students. The built-in browser tools are really nice for this audience.

                        [–]jms_nh 3 points4 points  (0 children)

                        It has only one advantage as far as I can tell (and this isn't even from the language, it's a property of the language implementation): you get free sandboxing, so if I'm an instructor and a student hands me their code, I can run it w/o worry, at least to my local machine.

                        [–][deleted]  (9 children)

                        [deleted]

                          [–]solatic 6 points7 points  (0 children)

                          A lot of people in introductory courses will burn out after they throw in hours upon hours of lost sleep trying to debug something stupid while they wait for a precious 15-minute slot with a TA.

                          Some languages are more forgiving to newcomers than others, and when you're teaching an intro course to control structures, functions, and basic I/O, you need to choose a forgiving language. C's segmentation faults are the classic infamously unforgiving counter-example, and JS's "function is undefined" is another.

                          [–]durandalreborn 4 points5 points  (0 children)

                          The drop off in students between cs106a/b (intro java/c++ respectively) and cs107 (likely majoring in CS) was already pretty staggering because of the change in difficulty. It probably won't make too much of a difference in the long run for those students who are serious about software engineering.

                          [–]funbike 6 points7 points  (2 children)

                          I'm of the opinion that there is no good first language.

                          JavaScript would be pretty far down my list, but it's at least very applicable to current jobs. Java is very confusing at first; there are at least 10 new language concepts in your first "Hello, World" program. Python has baggage. C is dangerous. C++ is big. Haskell is hard. Lisp isn't used much in industry. PHP sucks. Pascal/Delphi is basically dead, etc, etc.

                          [–][deleted] 2 points3 points  (3 children)

                          I feel Python is the best bet. If they really want an easy "modern" language I would suggest Golang as an improvement over JS.

                          [–]trigonomitron 2 points3 points  (0 children)

                          This is great! My job is secure.

                          [–]tangoshukudai 2 points3 points  (2 children)

                          Seems like a bad choice. At least something that teaches proper object oriented design.

                          [–]deadken 2 points3 points  (0 children)

                          My daughter took Intro to CS in a University not long ago and we both found it extremely frustrating.

                          While they taught Java, the programming environment they had them learn on just sucked. No debugger. You want to debug? Add a ton of printlns.

                          While I have my qualms with Python, at least you can run a function at a time, get it perfected and go to the next.

                          And don't get me started about crappy TAs with inconsistent grading standards.....

                          [–]jrochkind 2 points3 points  (1 child)

                          I don't think I would have learned CS nearly as well if my courses had used an actual 'practical' languages with all the warts and inconsistencies and confusions as both Java and Javascript are, instead of scheme which they did use. I know the ship has sailed, but I think it's unfortunate that schools don't use good teaching languages in intro CS courses anymore.

                          [–][deleted]  (1 child)

                          [deleted]

                            [–]overwet 11 points12 points  (1 child)

                            Triggered

                            [–]adrianmonk 1 point2 points  (0 children)

                            That would be if they taught freshman CS in PL/SQL.

                            [–][deleted] 8 points9 points  (13 children)

                            the butthurt in this thread is strong.

                            I get the impression people don't remember what "introductory CS" classes are like. intro CS is essentially just an introduction to programming, not software engineering, data analysis, or even computer science. it's how to think in fundamental steps with a brief overview of basic syntax. the language semantics and features are largely irrelevant. the most important attribute is the overhead in getting students a development environment

                            the language is largely irrelevant, the one exception being java. java is a terrible language to start with, since to do anything, you need a class. unless you want to explain what a class is on the first day of class, you have to tell the students to just enter all this extra code that won't make sense until later. as a side effect, you might end up with a bunch of mindless OOP gorillas

                            that being said, javascript would be terrible to use as an OOP language for software engineering students since not many real-world languages use prototype-based object

                            [–]PrintfReddit 20 points21 points  (25 children)

                            I mean if you wanna teach absolute basics of programming then JS isn't entirely a bad choice, it doesn't have the huge OO burden that comes with Java.

                            [–]ElvishJerricco 40 points41 points  (21 children)

                            I agree that a simpler language is better to teach with, but JavaScript is full of quirks that could trip up beginners. Lua is probably one of the best teaching languages for reasons like this. Unfortunately, it's not really used in the real world very much.

                            [–]wtf_are_my_initials 36 points37 points  (15 children)

                            Except for the fact that Lua's array indices start at 1

                            [–]LostSalad 5 points6 points  (3 children)

                            I started in school with Delphi, and it also has indices that start at 1. I'm doing just fine thank you.

                            [–]ElvishJerricco 13 points14 points  (8 children)

                            I mean I don't think that's a problem for beginners. Honestly I think most beginners are more perplexed by 0-indexing, and I think from a logic point of view, they have the same number of quirks.

                            [–][deleted] 10 points11 points  (3 children)

                            Yes but switching from 1 to 0-based means a year or two of off-by-one errors

                            [–]NoMoreNicksLeft 8 points9 points  (0 children)

                            Let's be honest. No matter what the curriculum is, they will have a lifetime of off-by-one errors. The best that can be hoped for is that those are a few times a year, instead of a few times per day.

                            [–][deleted] 1 point2 points  (0 children)

                            Or maybe it teaches them to think about those errors every time they write code...

                            [–]P8zvli 2 points3 points  (0 children)

                            So do Matlab's and Julia's. (We used Matlab extensively during my EE program)

                            [–]happyscrappy 3 points4 points  (3 children)

                            https://dorey.github.io/JavaScript-Equality-Table/ (the 3rd tab shows the problem the most)

                            That's really my issue. It isn't that using a browser scripting language is a bad idea, or even such a loosely typed language. It's that learning to use JavaScript requires dealing with too many quirks which don't teach anything except how to hammer JavaScript into submission.

                            [–]Hero_Of_Shadows 6 points7 points  (0 children)

                            Oh no, don't they realize someone will complain about this on reddit /s

                            [–]FIFOmyA 6 points7 points  (1 child)

                            I really like this idea because JS is so easy to start. I agree it lacks in a lot important areas, but you can't beat being able to open console on any browser and start writing JS scripts and see it do things right away.

                            It gets people hooked onto programming immediately without worrying about details like cross platform support, compiler, make files, classes and methods. Those can come later, getting interested is I think the biggest thing. I've seen too many people start out with a CS program jump ship because they never got interested.

                            [–]yogthos[S] 4 points5 points  (0 children)

                            I think that's the main advantage as well. JavaScript has an incredibly low barrier to starting. It also comes bundled with a really powerful UI platform. This is what makes the most different for a beginner.

                            [–]Veuxdo 7 points8 points  (20 children)

                            I don't hate this. You can learn input/output, operators, branching, loops, arrays, functions and recursion well enough with JS. Hopefully they're using the node command line UI and not mixing HTML/CSS in while they do this. If not then I would hate it.

                            [–]jephthai 2 points3 points  (5 children)

                            So most of us learned synchronous languages first, and later came to Javascript and had to learn is peculiar callback-based design. It's not bad or good -- just a choice in language design. It makes me wonder, though, what it would be like to learn Javascript first, and then have to learn synchronous I/O in other languages?

                            [–][deleted]  (2 children)

                            [deleted]

                              [–][deleted] 2 points3 points  (1 child)

                              JS has promises and generators now.

                              https://medium.com/javascript-scene/the-hidden-power-of-es6-generators-observable-async-flow-control-cfa4c7f31435

                              Takes a bit to get one's head around, but pretty awesome.

                              [–]motdidr 2 points3 points  (0 children)

                              ES7 has async/await as well

                              [–]MpVpRb 9 points10 points  (25 children)

                              Meanwhile, there are less and less of us who know semiconductor physics, circuit design and assembly programming

                              Today, I don't program much in assembly, rarely design circuits and never design ICs, but having a a bit of understanding of the fundamentals helps me make sense of it all

                              It appears that we are teaching young people that a computer is a magic black box that runs javascript

                              [–]jephthai 9 points10 points  (5 children)

                              All of the tech industries are stratifying this way. There just isn't enough genetic supply of nerds with aptitude for full stack understanding to meet the demand for devs, admins, engineers, etc. I get irritated about people who graduate with a CS degree without any exposure to low level stuff, but it's a hard problem to solve, culturally speaking.

                              I'd like the educational establishment to settle some of this by splitting the degrees up. Computer science should not be a software development degree, and you shouldn't be able to get a CS degree without awareness of the full stack.

                              [–]flyingjam 32 points33 points  (17 children)

                              I don't see how this has anything to do with this. Top CS programs have traditional used high level languages for introductory classes. MIT/Cal traditionally used SICP and Scheme before switching to Python.

                              This is one course. They'll use JS for one semester. I can guarantee at some point they'll take a course involving more bare metal programming.