revising

Question 1

spring-boot

Answer 1

java framework for web-app development

Question 2

thread

Answer 2

a complete unit of execution in a process;
threads share code, resources, memory, runtime details, state of process…;

“like a process but within a process” ?

Question 3

wrapper classes

Answer 3

a way to use data types as objects;
int myInt = 5 -> Integer myInt = 5;

use when working with arrays/iterables, since they can only store objects/instances not raws;

use when intializing something with the value “null” to avoid a compile error

Question 4

JRE

Answer 4

java runtime environment;
runs on top of OS providing everything a program needs to run:
- classloader for required classes
- verifier to ensure code is accurate
- interpreter

Question 5

JDK

Answer 5

java development kit; implements specification / provides software for working with Java applications

Question 6

in a suitably complex system,

Answer 6

there is a certain irreducible number of errors; any attempt to fix observed errors results in the introduction of other errors

Question 7

microservice architecture

Answer 7

an architectural style in which the system is constructed from communicating microservices; each microservice runs in its own container, usually in cloud based systems

Question 8

AJAX

Answer 8

Asynchronous JavaScript and XML

Question 9

react; single responsibility principle

Answer 9

react is commonly used in combination with HTML and CSS, but each language only serves one responsibility:

HTML for presenting information and structure;
CSS for style of information;
JavaScript for interactions/data

Question 10

ECMA6 is dynamically typed;
variables can…
the interpreter…

Answer 10

Dynamically-typed languages are those (like JavaScript and most others) where
- variables can hold any type of value at any time,
- the interpreter assigns/checks types when code is executed, not during compilation

Question 11

const

Answer 11

defines a constant reference to a value, not an unchanging value; use const to declare a new variable, array or function

Question 12

hooks

Answer 12

functions that:
- add state to a function component (useState)
- run code at specific times (useEffect)

allow one to “hook into” react features from function components; allows one to use react without classes

Question 13

architectural influences

Answer 13

nonfunctional product characteristics;
product lifetime;
software reuse;
number of users;
compatibility;

these all affect how the software is built

Question 14

nonfunctional product characteristics

Answer 14

security, performance; things that are necessary for a good product, but not the focus of the product.

Question 15

influence of software reuse

Answer 15

reusing large components from other products saves time and effort, but this constrains architectural choices: design must fit around the software that is being used

Question 16

influence of number of users

Answer 16

performance will be affected by the number of users at once; build a system that can be scaled easily

Question 17

influence of software compatibility

Answer 17

allows users to adopt product on a different system; limits architectural choices such as database used

Question 18

maintainability-performance tradeoff

Answer 18

a maintainable system is made of small parts that can be easily changed, but if many components are communicating with each other, the software will run slower

Question 19

how to best design security

Answer 19

• a series of layers so an attacker has to get through all of them before the system is penetrated;
• implement as separate components so that if one is attacked the others remain;
• use different technologies in different layers so it’s harder to breach each one

Question 20

security vs usability

Answer 20

• layered security means users have to remember information that would be used to protect their data, slowing down their interaction with the system;
• it’s best to use an architecture that doesn’t enforce unnecessary measures
• use architecture that provides helper components that reduce the load on users

Question 21

redundancy

Answer 21

components detect failure -> switch the operation to another component when failure is expected (circuit breakers are a good example);
implementing redundancy increases time and cost of development and adds complexity, possibly introducing bugs

Question 22

architectural design questions

Answer 22

how should the system be organized?; how should components be distributed and communicate with each other?; what technologies should you use in building the system and what components should be reused?

Question 23

design guidelines / best practices

Answer 23

single responsibility for each component;
coherent interfaces that change rarely;
avoid duplicating functionality

Question 24

abstraction

Answer 24

focus on essential elements of a system or component without concern for details;
reduce complexity (of system / UI) so you can
- isolate changes
- improve maintainability

Question 25

decomposition

Answer 25

analyzing large-scale components and representing them as finer components*; localizing relationships into the same module, reducing shared dependencies and using local data when possible

Question 26

layers of functionality (UAABD/T)

Answer 26

UI (HTML to collect input, JavaScript for actions); Authentication; Application-specific functionality; basic shared services, database + transaction management

Question 27

Authentication + UI management layer

Answer 27

includes components for user authentication and web page generation

Question 28

base shared service layer

Answer 28

this layer establishes services used by the application layer

Question 29

database and transaction layer

Answer 29

provides services such as transaction management and recovery; may not be required if the application doesn't use a database

Question 30

architectural design principles - what should programmers keep in mind?

Answer 30

REAPM replaceability, extensibility, age-appropriate, programmability, minimum work

Question 31

replaceability

Answer 31

the list of applications shouldn't be hard-wired into the system; users should be able to replace applications in the system with alternatives; users can mod your system

Question 32

extensibility

Answer 32

users + system admin should be able to create their own versions of the system

Question 33

programmability

Answer 33

it should be easy to make one's own applications by linking existing applications in the system; similar to extensibility

Question 34

services

Answer 34

stateless components -> can be replicated and migrate from one computer to another or accessed through the internet; service-oriented architecture is easier to scale and is resilient to failure

Question 35

what is a thread

Answer 35

a path through a running program; independent path through a process; assigned path by the OS

Question 36

circuit breaker

Answer 36

typically in microservices, can be in servers; if a service stops working, the circuit breaker overrides efforts to call that service again and instantly returns errors. after a cooldown time, the breaker allows a few test requests to see if the service is working again. repeat until it passes the test requests.

Question 37

SOLID: L

Answer 37

Liskov's principle: subclasses should replace classes without breaking the program

Question 38

SOLID: I

Answer 38

Interface segregation; each interface should only have one responsibility

Question 39

SOLID: D

Answer 39

dependency inversion principle; high level and low level modules should depend on abstractions; details should depend on abstractions, not the other way around

Question 40

spring-boot

Answer 40

a server system / framework; built on maven or another project manager, generally done in java;

Question 41

maven

Answer 41

build system for software/servers

Question 42

tomcat

Answer 42

heavy-use web server for running java applications

Question 43

thymeleaf

Answer 43

template engine for HTML; has its own namespace + sublanguage of HTML

Question 44

declarative language

Answer 44

state what the result should be, not how it should be reached

Question 45

imperative language

Answer 45

must state steps to clarify how one wants something achieved

Question 46

functional testing

Answer 46

test the program on a larger scale than unit tests; tests the entire system

Question 47

privacy

Answer 47

keeps personal data from being seen by unauthorized parties

Question 48

availability threats

Answer 48

an attacker attempts to deny access to the system for legitimate users

Question 49

pros of dynamically typed programs

Answer 49

faster, flexible

Question 50

cons of dynamically typed programs

Answer 50

errors occur at runtime; harder to maintain large codebases; slower performance

Question 51

useState

Answer 51

adds state to a function component

Question 52

useEffect

Answer 52

run code at specific times

Question 53

switching between asynchronous tasks

Answer 53

import asyncio async def my.task(n): > print(f"my.task: starting{n}") > await asyncio.sleep(n) # non-blocking delay sync def sequential_main( ) : > await my task ( 3 ) > await my task ( 1 ) async def gather_main( ) : > await asyncio.gather( my_task ( 3 ) , my_task ( 1 ) ) -- - import asyncio - async is a keyword for this function telling it to wait for other tasks to run for n seconds - "await" to run both tasks in order, wait for each to finish before moving on - call several tasks at once, not synchronous

Question 54

await asyncio.sleep(n) is what?

Answer 54

non-blocking delay; run something else, then check if this finished execution

Question 55

declarative react example: return JSX display

Answer 55

import { useState } from "react"; export default function App() { const [count, setCount] = useState(0); return ( >

> {count > 5 ? Yeah! : Click away...}

> setCount(c => c + 1)}>Increment

); } -- - import useState hook - define App, which can be exported from the file to move elsewhere - const [count, setCount] = useState(0); - return JSX display