Midterm Flashcards

(66 cards)

1
Q
CLASS
---
memberVaribles
---
\+ \_\_\_\_\_\_
# \_\_\_\_\_\_
- \_\_\_\_\_\_
A

+ public
# protected
- private

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
2
Q

Empty Triangle

A

Derived from

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
3
Q

Empty Diamond

A

Aggregation - the diamond has the line as a part. The part may be shared with other wholes.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
4
Q

Solid Diamond

A

Composition - the diamond has the line as a part. Lifetime of part controlled by whole.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
5
Q

Simple line with line arrow

A

Navigation. Can reach arrow from line.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
6
Q

Open Close Principle

A

Open for extension, closed for modification. That is, we can extend behavior without modifying existing code.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
7
Q

Single Responsibility Principle

A

Every module should have responsibility over a single part, and that responsibility should be entirely encapsulated by the class.

Consider: who is likely to ask for changes in the code?

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
8
Q

Interface Segregation Principle

A

Many client specific interfaces are better than one general purpose interface.

Interfaces should belong to clients, not to libraries or hierarchies.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
9
Q

Git: Working Directory

A

Where code resides, even after saving.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
10
Q

Git: Staging Area

A

Where you put code before committing. Can pool only some of the many files in your working directory, or all.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
11
Q

Git: Local Repository

A

Where committed code is stored - code that is tested and believed to be valid.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
12
Q

Git: Shared/Remote Repository

A

Where code is stored after pushing - code that should be integrated with team’s code for sharing.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
13
Q

Git: Master

A

Trunk from which all branches derive. Only merged into master in larger chunks (ie a release).

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
14
Q

Git: Release

A

Ready or getting ready to ship to customers.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
15
Q

Git: Develop

A

Where teams check in tested, working code, but not enough changes or improvement to release.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
16
Q

Git: Features

A

Where features can be isolated and focused on, thus reducing opportunity for meddling up unrelated code.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
17
Q

Git: Hotfixes

A

Fix shit quick. Added to development and shipped products.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
18
Q

Git: Origin

A

Remote, shared repository.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
19
Q

Git: HEAD

A

Where a branch thinks the next code merge or checkin should occur.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
20
Q

Git: Origin/Master

A

Remote branch where the source code of HEAD always reflects a production-ready state.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
21
Q

Git: Origin/Develop

A

Remote branch where the source code of HEAD always reflects a state of latest delivered development changes for the next release.

Where automatic nightly builds are from.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
22
Q

Specification

A

Defining the system. What should it do? How should it behave? What high-level data does it use? What should it look like (reqs)?

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
23
Q

Development

A

Define organization of system (architecture), implementing and building.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
24
Q

Validation

A

Does it meet the customer’s needs? Are they motivated to buy the product?

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
25
Verification
Does it meet the specifications? Are its fruits accurate?
26
Evolution
Change to meet customer's needs.
27
Waterfall
Output of one stage is input of next stage. Plan-driven. Tends to generate a lot of documentation. Main drawback: difficulty of accommodating changes. Time is money!
28
Agile
Focus on code over design. An iterative approach that delivers working software quickly, and allows rapid evolution. individuals > processes working software > documentation customer collab > contract negotiation change > plan
29
Agile Scrum Steps
1) Plan objectives and features of products. 2) Spring cycles. 3) Closure. Documentation and demos.
30
Agile: Product Planning
Done by product owner. Long-range activity.
31
Agile: Release Planning
Usually done by product owner, team, and other stakeholders. Done before any sprints.
32
Agile: Spring Planning
Team commits to highest ranked product/release backlog items. Facilitated by scrummaster.
33
Agile: Product Backlog
Ranked list of feature requests. Ideally broken down into user stories.
34
Agile: Release Backlog
Subset of product backlog features that will go into next release.
35
Agile: Sprint Backlog
List of user stories and their tasks to complete during a sprint.
36
Liskov Substitution Principle
Subtypes must be substitutable for their base types.
37
Dependency Inversion Principle
Abstractions should not depend on details. Cars and Mustangs can depend on vehicles. Professors and students can depend on users.
38
3 Injected Dependency Methods
1) Constructor Injected. Constructor parameter takes object. 2) Setter Injected. Specific member function (setService) takes object. 3) Interface injected: simply implements some interface's method.
39
Dependency Injection
One object supplies the dependencies of another object.
40
Dependency
Object that can be used (i.e. a service).
41
Injection
Passing of a dependency (service-providing object) to a dependent object (client).
42
Circular object references make dependency injection ______.
impossible
43
Planning Poker
An estimation and planning technique using cards to allow a team to reach a consensus.
44
Required: In-Depth Review
Circular Logic
45
Required: In-Depth Review
Dependency Injection
46
T/F: Abstract classes allow fully-coded default methods, whereas interfaces do not.
T
47
Abstract classes can be instantiated.
F - Unlike interfaces, they allow hardcoded methods, but like interfaces, they cannot be instantiated. They require subclasses to extend and instantiate.
48
Abstract classes allow subclass to share common methods and members.
T
49
Interface
A description of all the members/methods a subclass must have in order to exist as that interface idea.
50
Facade Design Pattern
Easy to use and understand "face" of a larger series of modules. Simplifies and hides the complexity of software body.
51
Decorator Pattern
Allows you to modify the behavior of a single OBJECT, rather than the whole CLASS. This leaves the other object instances unmodified.
52
Continuous Integration
The art of merging small units of code into the main branch frequently, as opposed to larger units of code infrequently.
53
What 2 main types of input should unit tests test for within a program?
Normal input, abnormal input.
54
What are Apache Ant and Gradle?
Software tools to automate the build process. Similar to Make tool in Unix, but implemented in Java and requires the Java platform.
55
What are Chocolatey and Homebrew?
Tools to manage the installation and update of software. Primarily executed via command line, though GUIs are available.
56
Name the points of the development triangle.
Cheap, fast, good.
57
What commands show the hidden GIT directory?
Go to repository. On unix type: ls -a cd .git ls -lt
58
Git Directory - Description
Text entered in description when repository was created.
59
Git Directory - config
Main git config file; keeps options for project, such as remotes, push configs, tracking branches and more.
60
Git Directory - COMMIT_EDITMSG
Message in last commit.
61
Git Directory - HEAD
Holds reference to current branch. Tells git what to use as parent for next commit.
62
Git Directory - FETCH_HEAD
Short-lived reference to track what was just fetched from remote repository.
63
Git Directory - Index File
Staging area between working directory and repository. When you create a commit, what is committed is what is in the index file, NOT the working directory. Prolly moved to index file after "git add." Binary file.
64
Git Directory - Objects Folder
Where the data of your git objects are stored - all contents of the files you have ever checked in, commits, trees, tag objects.
65
Git Directory - Hooks Folder
Contains shell scripts for invoking git commands.
66
Git Directory - Log Folder
Stores changes made in repository.