Speaking JavaScript - Githubissues

rrgayhart commented 8 years ago

Discuss Speaking JavaScript, especially following chapters here:

Chapter 3: The Nature of JavaScript Chapter 15: Functions Chapter 16: Variables: Scopes, Environments, and Closures Chapter 17: Objects and Inheritance

Some questions to start discussion:

Which sections were interesting?
Which sections did you totally skim?
Do you think the reading was valuable?
Which topics were notably confusing?

stevepentler commented 8 years ago

https://gist.github.com/stevepentler/7e7097291fb32cc8ab31

ToniRib commented 8 years ago

https://gist.github.com/ToniRib/4b7c95c88438f458a024

SteveOscar commented 8 years ago

https://gist.github.com/SteveOscar/5b62a638bc61dc30149f

ShannonPaige commented 8 years ago

Which sections were interesting?

Chapter 3 - "you can directly create objects, without creating an object factory (e.g., a class) first."
Chapter 15 - named function expressions and self-recursion
Chapter 15 - handling too few or too many parameters, and naming parameters
Chapter 17 - If a property doesn't exist yet, setting it creates it.
Chapter 17 - When to use bracket vs string notation on keys

Which sections did you totally skim? None. This is all very interesting and I read every word multiple times. :) J/K - I scanned the Environments section of Chapter 16 and a lot of 17.

Do you think the reading was valuable? No, it was too hard to follow.

Which topics were notably confusing?

Chapter 15 - Confused about hoisting, and knowing when it's better to use function expression vs function declaration
Chapter 16 - IIFEs. Nasty looking, and what's up with the trailing parameters?
Chapter 16 - Global objects
Chapter 17 - Strict mode of functions and why we would/wouldn't use them
Chapter 17 - Prototyping inheritance and data sharing
Pretty much all of Chapter 17

brantwellman commented 8 years ago

https://gist.github.com/brantwellman/445c48b6f49d69e99eff

GregoryArmstrong commented 8 years ago

Which sections were interesting?

Functional declarations & hoisting. Interesting difference between JS and Ruby, where something can be defined later in the code but used earlier on.
You can add / delete object attributes at will, and also make attributes immutable. Which sections did you totally skim?
Scoping. It seems to work quite similarly to Ruby's scoping, so I skimmed until I found something new / different / interesting.
Most of Chapter 17. I read it, but not much sinks in. It's like being told what a hammer looks like, feels like, and that I can swing it, and then setting me loose in a construction site. Where do I swing the hammer? Why might I want to swing the hammer? What's the end goal? Without hands-on experience using these types of things as theyre introduced it's all just a session of reading the different sections going "Oh, alright. Yep, I guess that makes sense. Cool you can do that thing that I have no reference about." Do you think the reading was valuable?
I think it will become very valuable soon, but without hands on experience trying to do some of these things the reading is just sort of a laundry list of stuff you can do, but we dont have the context or experience yet to make sense of it all. Which topics were notably confusing?
Prototyping. It seems similar to regular Ruby inheritance, cant tell if it's really all that different or not.
'Use strict'
Silent failing of code. Why is this a thing? It's like CSS is bleeding its way into my regular code! Madness!