Full stack interview

Interview Prep for full stack software development.

Difference between an Interface and Abstract Class

An interface is a blueprint of a class that does not implement any methods but provides a template allowing for abstraction and allows objects to be treated as the same interface type allowing for polymorphism. An Abstract class is similar to an interface but has some concrete or defined methods that allow subclasses to inherit some of the same implementations.

Inner vs Outer Join

An inner Join only will display rows in which the data matches in BOTH tables. In the case of no match no row for that entry will be present. An outer Join brings all rows from the first (left) , second (right) or both leaving null for any value not matched in second table.

Mock Framework

A mock framework is a tool used to mock objects when unit testing. This can be useful to isolate the component being tested and avoid having to mock multiple dependcies. EX mocking redux store while front end testing built into Jest. Ex. Mock Service worker for API mocking intercepting requests.

Query framework

Query Frameworks like LINQ (.NET) offer a more unified syntax to speed up production of queries and allow for mapping database tables to objects in the application.

Extension Method

An extension method is a way to extend the functionality of an object without having to create a derived type or

Dependency Injection

Dependency Injection is used to implement inversion of control by allowing class dependences to be injected from outside rather than being created within the class itself. Making thing more Modular and making unit testing with mock functions easier.

IOC

1.) services are registered with the IOC container which specifies how they should be instantiated and their lifetimes.

2.) when a service is required the appropriate service and lifetime is injected

3.) three lifetimes of .Net services Transient- a new instance for every time the service is called Scoped- a single per scope (Ie. web request) Singleton - a single instance is created for application

Array vs List

Arrays- are fixed size, faster access to elements , better when performance is critical

Lists- are dynamically sized, slower access to elements, better methods

Handling Large load times for data sets

1.) server-side pagination to limit number of results handled by the front end

2.) Caching- limiting repeated calls

3.) lazy loading

Component vs service in spring boot

1.) component annotation indicates that this is a generic bean that does not fit the typical service, controller, Repository roles

2.) service- indicates that the class is contains business logic and is a part of the service layer.

Overload vs Override

Overload: when methods have same name but different parameters

Override: when you reimplement a method of the same name in the base class for a derived class. must use virtual key word in base class and override in derived class

How does a browser get Information

1.) Browser sends HTTP request to DNS resolver with url and other metadata

2.) DNS resolver converts the url to a IP address if this not cached this is sent to a DNS server to retrieve the IP address associated with the domain name

3.) Browser then establishes a connection with the web server at the IP address

4.) browser sends an HTTP request for all required resources associated with the URL

5.) Browser then parses the HTML and renders the DOM as it makes any requests for linked resources (CSS, javaScript, Images)

Rest API

(Representational State Transfer Application Programming Interface)

1.) stateless- every request from client must include all information to complete a request. Client information is not cahed on the server.

2.) client and server are seprated to help with flexibility and scalability

3.) unifrom interface: uses HTTP request to complete requets. JSON

TDD

Relies on repetition of a very short development process. First right test based around functionality, see it fail because functionality does not yet exist, write just enough code for test to pass , run all tests, refactor code, repeat .

Solid principles

1.) Single responsibility- each class should have a single responsibility

2.)open/closed principle- code should be open to extension and closed modification

3.)Liskov substitution principle- sub classes should be able to stand in for super classes to promote reliable polymorphism

4.) interface segregation- advocates for specific interfaces over highly generic interfaces

5.) depdency inversion principle- high level modules should not depend on low level modules, rather on interfaces and abstract classes

Authentication vs Authorization

Authentication is determining who the user is and Authorization is determining what permissions that user has.

call bind and apply

Call- passes the this context of an object to a function as a parameter

Apply- works similarly but arguments are passed as an array

Bind- passes the context of this to a function and returns a variable that can be called later with the object context

Garbage collection

compiled vs interpreted