- Name 2 programming paradigms important for JavaScript app developers
- Prototype Inheritance(also: prototypes, OLOO as Objects linked to other objects);
-
Functional Programming (also: closures, first class functions, lambdas);
Functional Programming produces programs by composing mathematical functions and avoids shared state & mutable data.
- What is Functional Programming?
- Pure function / function purity;
- Avoid side-effects;
- Simple function composition;
- Features that support Functional Programming: first-class functions, higher order functions, functions as arguments/values;
- Examples of functional languages: Lisp, ML, Haskell, Erlang, Clojure, Elm, F Sharp, OCaml, etc;
- Difference between Classical inheritance and Prototypal Inheritance?
- Classical: Create tight coupling or hierarchies/taxonomies;
- Prototypes: mentions of concatenative inheritance, prototype delegation, functional inheritance, object composition.
- Class Inheritance: instances inherit from classes (like a blueprint — a description of the class), and create sub-class relationships: hierarchical class taxonomies. Instances are typically instantiated via constructor functions with the
newkeyword. Class inheritance may or may not use theclasskeyword from ES6. - Prototypal Inheritance: instances inherit directly from other objects. Instances are typically instantiated via factory functions or
Object.create(). Instances may be composed from many different objects, allowing for easy selective inheritance.
- What are the pros and cons of Functional Programming vs Object-Oriented Programming
- OOP Pros: It's easy to understand the basic concept of objects and easy to interpret the meaning of method calls. OOP tends to use an imperative style rather than a declarative style, which reads like a straight-forward set of instructions for the computer to follow.
- OOP Cons: OOP Typically depends on the shared state. Objects and behaviors are typically tacked together on the same entity, which may be accessed at random by any number of functions with non-deterministic order, which may lead to undesirable behavior such as race conditions.
- Functional Programming Pros: Using the functional paradigm, programmers avoid any shared state or side-effects, which eliminates bugs caused by multiple functions competing for the same resources. With features such as the availability of point-free style (aka tacit programming), functions tend to be radically simplified and easily recomposed for more generally reusable code compared to OOP. Functional Programming also tends to favor declarative and denotational styles, which do not spell out step-by-step instructions for operations, but instead concentrate on what to do, letting the underlying functions take care of the how. This leaves tremendous latitude for refactoring and performance optimization, even allowing you to replace entire algorithms with more efficient ones with very little code change. (eg., memorize, or user lazy evaluation in place of eager evaluation.) The computation that makes use of pure functions is also easy to scale across multiple processors, or across distributed computing clusters without fear of threading resource conflicts, race conditions, etc...
- Functional Programming Cons: Over exploitation of Functional Programming features such as point-free style and large compositions can potentially reduce readability because the resulting code is often more abstractly specified, more terse, and less concrete. Functional Programming has a much steeper learning curve than OOP because the broad popularity of OOP has allowed the language and learning materials of OOP to become more conversational, whereas the language of Functional Programming tends to be much more academic and formal. Functional Programming concepts are frequently written about using idioms and notations from lambda calculus, algebras, and category theory, all of which requires a prior knowledge foundation in those domains to be understood.
-
Summary:
- The trouble with the shared state, different things competing for the same resources, etc...
- Awareness of Function Programming's capability to radically simplify many applications.
- Awareness of the differences in learning curves.
- Articulation of the side-effects and how they impact program maintainability.
- Awareness that a highly functional codebase can have a steep learning curve.
- Awareness that a highly OOP codebase can be extremely resistant to change and very brittle compared to an equivalent Functional Programming codebase.
- Awareness that immutability gives rise to an extremely accessible and malleable program state history, allowing for the easy addition of features like infinite undo/redo, rewind/replay, time-travel debugging, and so on. Immutability can be achieved in either paradigm, but a proliferation of shared stateful objects complicates the implementation in OOP.
- When is classical inheritance an appropriate choice?
- Rarely, almost never, or never.
- A single level is sometimes OK, from a framework base-class such as
React.Component.
- When is prototypal inheritance an appropriate choice?
- Delegation (i.e., the prototype chain)
- Concatenative (i.e. mixins,
Object.assign()) - Functional (Not to be confused with functional programming. A function used to create a closure for private state/encapsulation)
-
Bouns:
- In situations where modules or functional programming don’t provide an obvious solution.
- When you need to compose objects from multiple sources.
- Any time you need inheritance.
- What does “favor object composition over class inheritance” mean?
- Avoid class hierarchies.
- Avoid brittle base class problem.
- Avoid tight coupling.
- Avoid rigid taxonomy (forced is-a relationships that are eventually wrong for new use cases).
- Avoid the gorilla banana problem (“what you wanted was a banana, what you got was a gorilla holding the banana, and the entire jungle”).
- Make code more flexible.
- What are two-way data binding and one-way data flow, and how are they different?
- Two-way data binding means that UI fields are bound to model data dynamically such that when a UI field changes, the model data changes with it and vice-versa.
- One-way data binding is a situation where information flows in only one direction, typically from a data source to the control. This has the effect of making the variable read-only from the user's perspective. Anything they do with the control won't affect the information it displays
- Data Binding, One-Time, One-Way & Two-Way
- 单向数据绑定和双向数据绑定的优缺点, 适合什么场景?
- 单项数据绑定、双向数据绑定及其原理(脏检查)
- What is asynchronous programming, and why is it important in JavaScript?
- Synchronous programming means that, barring conditionals and function calls, the code is executed sequentially from top-to-bottom, blocking on long-running tasks such as network requests and disk I/O.
- Asynchronous programming means that the engine runs in an event loop. When a blocking operation is needed, the request is started, and the code keeps running without blocking for the result. When the response is ready, an interrupt is fired, which causes an event handler to be run, where the control flow continues. In this way, a single program thread can handle many concurrent operations.
- User interfaces are asynchronous by nature and spend most of their time waiting for user input to interrupt the event loop and trigger event handlers.
- Node.js is asynchronous by default, meaning that the server works in much the same way, waiting in a loop for a network request, and accepting more incoming requests while the first one is being handled.
