Trivia Flashcards

Question

What are pure/impure functions?

Answer 1

Pure functions have no side effects - the return value depends solely on arguments. If you call pure function w/ same set of arguments, you will get same return value - they are predictable. They do not modify the values passed to them. Impure may call the database or network, may have side effects, may overwrite values passed to them.

Answer 2

Functions invoked using the new keyword are called constructor functions. So what does the new keyword actually do? 1. Creates a new object. 2. Sets the object’s prototype to be the prototype of the constructor function. 3. Executes the constructor function with this as the newly created object. 4. Returns the created object. If the constructor returns an object, this object is returned.

Answer 3

- GET is used to request data from a specified resource. - Note that the query string (name/value pairs) is sent in the URL of a GET request - GET requests can be cached - GET requests remain in the browser history - GET requests can be bookmarked - GET requests is only used to request data (not modify) - POST is used to send data to a server to create/update a resource. - The data sent to the server with POST is stored in the request body of the HTTP request https://www.w3schools.com/tags/ref_httpmethods.asp

Answer 4

When using PUT, it is assumed that you are sending the complete entity, and that complete entity replaces any existing entity at that URI. In the above example, the PUT and PATCH accomplish the same goal: they both change this user's email address. But PUT handles it by replacing the entire entity, while PATCH only updates the fields that were supplied, leaving the others alone. https://stackoverflow.com/questions/28459418/rest-api-put-vs-patch-with-real-life-examples

Answer 5

When an event happens on an element, it first runs the handlers on it, then on its parent, then all the way up on other ancestors. https://javascript.info/bubbling-and-capturing

Answer 6

- sessionStorage (as the name suggests) is only available for the duration of the browser session (and is deleted when the tab or window is closed) - it does survive page reloads - if the data you are storing needs to be available on an ongoing basis then localStorage is preferable to sessionStorage - although you should note both can be cleared by the user so you should not rely on the continuing existence of data in either case - The data stored in localStorage and sessionStorage can easily be read or changed from within the client/browser so should not be relied upon for storage of sensitive or security-related data within applications - cookies can be trivially tampered with by the user, and data can also be read from them in plain text - As cookies are used for authentication purposes and persistence of user data, all cookies valid for a page are sent from the browser to the server for every request to the same domain - this includes the original page request, any subsequent Ajax requests, all images, stylesheets, scripts, and fonts. For this reason, cookies should not be used to store large amounts of information. Typically cookies are used to store identifying tokens for authentication, session, and advertising tracking. The tokens are typically not human readable information in and of themselves, but encrypted identifiers linked to your application or database. https://stackoverflow.com/questions/19867599/what-is-the-difference-between-localstorage-sessionstorage-session-and-cookies

Answer 7

The idea is that if we have a lot of elements handled in a similar way, then instead of assigning a handler to each of them – we put a single handler on their common ancestor. https://javascript.info/event-delegation

Answer 8

Cross-site Scripting (XSS) refers to client-side code injection attack wherein an attacker can execute malicious scripts (also commonly referred to as a malicious payload) into a legitimate website or web application. In order for an XSS attack to take place the vulnerable website needs to directly include user input in its pages. An attacker can then insert a string that will be used within the web page and treated as code by the victim’s browser. https://www.acunetix.com/websitesecurity/cross-site-scripting/

Answer 9

1. ES5 only had “function-level scope” (i.e. you wrap code in functions to create scope) and caused a lot of issues. ES6 provides “block”-level scoping(i.e curly-braces to scope) when we use “let” or “const” instead of “var”. 2. In ES5, “this” can vary based on “where” it is called and even “how” it is called. With the ES6 fat arrow function, lexical “this” a feature that forces the variable “this” to always point to the object where it is physically located within. 3. In ES5, “arguments” acts like an Array (i.e. we can loop over it), but is not an Array. So, all the Array functions like sort, slice and so on are not available. In ES6, we can use a new feature called “Rest” parameters. It’s represented with 3 dots and a name like …args. Rest parameters is an Array and so we can use all the Array functions. 4. Conceptually, there is no such thing as a “Class”(i.e. blueprint) in JS like it is in other OO languages like Java. But people for a long time have treated the “function” (aka “function constructors”) that creates Objects when we use the “new” keyword as Classes. ES6 brings a new syntax that’s common in various programming languages. 5. https://medium.freecodecamp.org/5-javascript-bad-parts-that-are-fixed-in-es6-c7c45d44fd81

Answer 10

Cross-site Request Forgery (CSRF) will only be effective if a victim is authenticated. When the malicious link that we mentioned earlier is clicked, the attacker may direct the victim to their own malicious web application that will execute a script that will in turn trigger the victim’s browser to send an illegal request. https://www.acunetix.com/websitesecurity/csrf-attacks/

Answer 11

1. First, the code in try {...} is executed. 2. If there were no errors, then catch(err) is ignored: the execution reaches the end of try and then jumps over catch. 3. If an error occurs, then try execution is stopped, and the control flows to the beginning of catch(err). The err variable (can use any name for it) contains an error object with details about what’s happened. https://javascript.info/try-catch

Answer 12

AJAX = Asynchronous JavaScript And XML. AJAX is a technique for accessing web servers from a web page. AJAX allows web pages to be updated asynchronously by exchanging data with a web server behind the scenes. This means that it is possible to update parts of a web page, without reloading the whole page. How AJAX works: 1. An event occurs in a web page (the page is loaded, a button is clicked) 2. An XMLHttpRequest object is created by JavaScript 3. The XMLHttpRequest object sends a request to a web server 4. The server processes the request 5. The server sends a response back to the web page 6. The response is read by JavaScript 7. Proper action (like page update) is performed by JavaScript https://www.w3schools.com/xml/ajax_intro.asp

Answer 13

The lifecycle of an HTML page has three important events: - DOMContentLoaded – the browser fully loaded HTML, and the DOM tree is built, but external resources like pictures and stylesheets may be not yet loaded. - load – the browser loaded all resources (images, styles etc). - beforeunload/unload – when the user is leaving the page.

Answer 14

An origin is defined by the scheme, host, and port of a URL. For example, if a document retrieved from http://example.com/doc.html tries to access the DOM of a document retrieved from https://example.com/target.html, the user agent will disallow access because the origin of the first document, (http, example.com, 80), does not match the origin of the second document (https, example.com, 443). https://developer.mozilla.org/en-US/docs/Web/Security/Same-origin_policy

Answer 15

Variables (var) and functions declared inside another function cannot be accessed by any of the enclosing scopes — they are function-scoped. Variables declared inside a block-scope, such as if statements and for loops, can be accessed from outside of the opening and closing curly braces of the block. let and const are block-scoped alternatives for variable declaration. A common misconception is that const is immutable. It cannot be reassigned, but its properties can be changed!

Answer 16

Cross-Origin Resource Sharing (CORS) is a mechanism that uses additional HTTP headers to tell a browser to let a web application running at one origin (domain) have permission to access selected resources from a server at a different origin.

Answer 17

Strict mode makes it easier to write "secure" JavaScript. Strict mode changes previously accepted "bad syntax" into real errors. As an example, in normal JavaScript, mistyping a variable name creates a new global variable. In strict mode, this will throw an error, making it impossible to accidentally create a global variable. https://www.w3schools.com/js/js_strict.asp

Answer 18

https://javascript.info/rest-parameters-spread-operator

Answer 19

https://sqlbolt.com/lesson/select_queries_order_of_execution

Answer 20

SQL: structured way of storing data using tables with columns and rows. Reasons to use: ur data is structured and unchanging. NoSQL: nonstructured data stored in a document. Reasons: u have large volumes of data that's little to no structure https://www.upwork.com/hiring/data/sql-vs-nosql-databases-whats-the-difference/

Answer 21

https://javascript.info/bind

Answer 22

http://www.sql-join.com/sql-join-types/

Answer 23

Horizontal scaling means that you scale by adding more machines into your pool of resources whereas Vertical scaling means that you scale by adding more power (CPU, RAM) to an existing machine. An easy way to remember this is to think of a machine on a server rack, we add more machines across the horizontal direction and add more resources to a machine in the vertical direction. https://stackoverflow.com/questions/11707879/difference-between-scaling-horizontally-and-vertically-for-databases

Answer 24

A Function Expression is created when the execution reaches it and is usable from then on — it is not hoisted. A Function Declaration can be called both before and after it was defined — it is hoisted. https://medium.freecodecamp.org/the-definitive-javascript-handbook-for-a-developer-interview-44ffc6aeb54e

Answer 25

Simple values (also known as primitives) are always assigned by value-copy: null, undefined , boolean, number, string and ES6 symbol. Compound values always create a copy of the reference on assignment: objects, which includes arrays, and functions. To copy a compound value by value, you need to make a copy of it. The reference does not point to the original value. https://medium.freecodecamp.org/the-definitive-javascript-handbook-for-a-developer-interview-44ffc6aeb54e

Answer 26

There are 7 built-in types: null, undefined , boolean, number, string, object and symbol https://medium.freecodecamp.org/the-definitive-javascript-handbook-for-a-developer-interview-44ffc6aeb54e

Answer 27

The first thing you need to be aware of is the + operator. This is a tricky operator because it works for both number addition and string concatenation. But, the *, / , and -operators are exclusive for numeric operations. When these operators are used with a string, it forces the string to be coerced to a number. https://medium.freecodecamp.org/the-definitive-javascript-handbook-for-a-developer-interview-44ffc6aeb54e

Answer 28

In a browser it is named “window”. It does two things: Provides access to built-in functions and values, defined by the specification and the environment. For instance, we can call alert directly or as a method of window. Provides access to global Function Declarations and var variables. We can read and write them using its properties. https://javascript.info/global-object

Answer 29

http://wlowry88.github.io/blog/2014/08/20/linked-lists-in-ruby/

Answer 30

1. A “producing code” that does something and takes time. For instance, the code loads a remote script. 2. A “consuming code” that wants the result of the “producing code” once it’s ready. Many functions may need that result. 3. A promise is a special JavaScript object that links the “producing code” and the “consuming code” together. The “producing code” takes whatever time it needs to produce the promised result, and the “promise” makes that result available to all of the subscribed code when it’s ready. https://javascript.info/promise-basics

Answer 31

The backbone of an HTML document are tags. According to Document Object Model (DOM), every HTML-tag is an object. Nested tags are called “children” of the enclosing one. The text inside a tag it is an object as well. All these objects are accessible using JavaScript. https://javascript.info/dom-nodes

Answer 32

We think of data types first, then think of actions associated with those data types. Principles: 1. Encapsulation: only methods of the Cat class should be able to read/write class fields, no other class or code should be able to do this. 2. Inheritance sometimes classes may overlap (they may have same properties). If Cat inherits from Mammal and Mammal inherits from Animal, Cat gets all attributes of Mammal and Animal. Everything inherits from Object. 3. Abstraction: Applying abstraction means that each object should only expose a high-level mechanism for using it. This mechanism should hide internal implementation details. It should only reveal operations relevant for the other objects. 4. Polymorphism: polymorphism gives a way to use a class exactly like its parent so there’s no confusion with mixing types. But each child class keeps its own methods as they are. https://medium.freecodecamp.org/object-oriented-programming-concepts-21bb035f7260

Answer 33

an operation offered as an interface that stands alone in the model. In other words, a service is an action, not a thing. And instead of forcing the operation into an existing object, we should encapsulate it in a separate, stateless service. - When forcing logic into a domain object is awkward because these use-cases often involve rules outside the responsibility of any single object. Also prevents a controller from being too complicated. https: //www.engineyard.com/blog/keeping-your-rails-controllers-dry-with-services https: //blog.carbonfive.com/2012/01/10/does-my-rails-app-need-a-service-layer/

Answer 34

SOLID is a set of principles developed for object oriented programming. S - Single-responsiblity principle: A class should have one and only one reason to change, meaning that a class should have only one job. O - Open-closed principle: Objects or entities should be open for extension, but closed for modification. This simply means that a class should be easily extendable without modifying the class itself. L - Liskov substitution principle: every subclass/derived class should be substitutable for their base/parent class. I - Interface segregation principle: a client should never be forced to implement an interface that it doesn't use or clients shouldn't be forced to depend on methods they do not use. D - Dependency Inversion Principle: Entities must depend on abstractions not on concretions. It states that the high level module must not depend on the low level module, but they should depend on abstractions. https: //scotch.io/bar-talk/s-o-l-i-d-the-first-five-principles-of-object-oriented-design https: //blog.bitsrc.io/solid-principles-every-developer-should-know-b3bfa96bb688

Answer 35

Multi: - stateless -> request is done when page is done loading. Nothing to manage on client side. - simpler to build - SEO Single: - perceived to be faster (better UX) - all javascript is loaded so can potentially browse offline

Answer 36

Ruby acts like pass by value for immutable objects, pass by reference for mutable objects https://launchschool.com/blog/object-passing-in-ruby

Answer 37

Ruby Modules are similar to classes in that they hold a collection of methods, constants, and other module and class definitions. Modules are defined much like classes are, but the module keyword is used in place of the class keyword. Unlike classes, you cannot create objects based on modules nor can you subclass them; instead, you specify that you want the functionality of a particular module to be added to the functionality of a class, or of a specific object. Modules stand alone; there is no "module hierarchy" of inheritance. Modules is a good place to collect all your constants in a central location. Modules serve two purposes: - First they act as namespace, letting you define methods whose names will not clash with those defined elsewhere. - Second, they allow you to share functionality between classes - if a class mixes in a module, that module's instance methods become available as if they had been defined in the class. http://rubylearning.com/satishtalim/modules_mixins.html

Answer 38

I use iterm and MAC OS. My preferred editor is VS Code.

Trivia Flashcards

(66 cards)