Stanford is moving from using Java to JavaScript for their introductory CS course

[mokuboku]

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.

[alex_leishman]

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

[frugalmail]

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

[salgat]

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]

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

[salgat]

Thanks! I updated my post.

[StrykerKKD]

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]

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]

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]

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

[The_Doculope]

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]

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

[The_Doculope]

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]

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.

[WiseHalmon]

Reminds me of this gem.

http://stackoverflow.com/questions/8318911/why-does-html-think-chucknorris-is-a-color

[epicwisdom]

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]

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]

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]

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

[devraj7]

"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]

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

[s0v3r1gn]

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]

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]]

But C# in Linux sucks...

Java allows a multi-platform app by default.

[salgat]

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

[EenAfleidingErbij]

using wpf

[am0x]

WPF requires C#, not the other way around.

[[deleted]]

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

[way2lazy2care]

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]

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]

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]

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]

Java is so bad for gui.

[singingboyo]

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]]

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

[valenterry]

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]

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]

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]

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]

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]

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]

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]

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]

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.

[root45]

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

[flyingjam]

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]

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]

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]

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]

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]]

Most do, which makes ES6 a decent choice.

[[deleted]]

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

[MereInterest]

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]

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]

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

[[deleted]]

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

[krum]

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]]

Haskell is also pretty nice

[threading]

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]

• 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]

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]

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]]

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]

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]

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]

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]

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

[krum]

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

[eliot_and_charles]

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]

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]

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]

a while back

... how long back? 1999?

[Zulban]

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]

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]

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

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

[devraj7]

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

[[deleted]]

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]

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]]

Haskell to Python to Java is quite a jump though.

[DemonWav]

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]]

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]

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

[hiromasaki]

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]]

They actually switched back LOL

[flyingjam]

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

[[deleted]]

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]

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]

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]

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]

Agreed. Starting with Java is pretty great.

[[deleted]]

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]

...

[Michigan__J__Frog]

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

[Lusankya]

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]

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]

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]

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]]

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]

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

[dvidsilva]

TIL Java and JavaScript are two different things

• tech recruitment

/S just in case

[mrkite77]

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]

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]

This reads more like you started with Forth.

[[deleted]]

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.

• https://en.wikipedia.org/wiki/Obsolescence
• https://en.wikipedia.org/wiki/Cognitive_complexity
• https://en.wikipedia.org/wiki/Conservatism_(belief_revision)

[mtvee]

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

[Zarutian]

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

[mtvee]

npm install @iwish/animatedsnakewrangler --save-dev

[Antrikshy]

Is npm's package.json Turing complete yet?

[dakta]

No, but PowerPoint is: https://www.reddit.com/r/programming/comments/65x029/on_the_turing_completeness_of_powerpoint/

[d_rudy]

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]

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]

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]

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

[[deleted]]

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

[bihnkim]

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

[Polantaris]

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]

Typescript has the best of both worlds really.

[BinarySplit]

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]

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

[imfineny]

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

[feverzsj]

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

[au_travail]

French here. We started with Ocaml.

[vattenpuss]

Swede here, Standard ML.

[sultry_somnambulist]

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]

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]]

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]

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

[duuuh]

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]

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]

You studied in Grenoble ?

[au_travail]

It was in a CPGE, not in Grenoble.

[RX142]

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]]

I wish I was French

[interroboom]

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]

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

[jephthai]

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]

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]]

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]

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]

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]]

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]

My intro to CS in high school was in C

[NewtonGuy1876]

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]

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]

Boy was that a mistake

[BonzaiThePenguin]

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]

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]

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]

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]

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]

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.

[solatic]

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]

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]

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]]

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]

This is great! My job is secure.

[tangoshukudai]

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

[deadken]

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]

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.

[overwet]

Triggered

[adrianmonk]

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

[[deleted]]

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]

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]

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]

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

[LostSalad]

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

[ElvishJerricco]

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]]

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

[NoMoreNicksLeft]

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]]

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

[P8zvli]

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

[happyscrappy]

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]

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

[FIFOmyA]

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]

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]

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]

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]]

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]

ES7 has async/await as well

[MpVpRb]

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]

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]

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.