General

Question 1

How to get .p12?

Answer 1

tylko osoba która go tworzy ma klucz prywatny i to ona musi Ci go dać z własnego keychaina

Question 2

Coordinator key points

Answer 2

The coordinator pattern organizes flow logic between view controllers. It involves a coordinator protocol, concrete coordinator, router protocol, concrete router and view controllers.
The coordinator defines methods and properties all concrete coordinators must implement.
The concrete coordinators know how to create concrete view controllers and their
order.
The router defines methods all concrete routers must implement.
The concrete routers know how to present view controllers.
The concrete view controllers are typical view controllers, but they don’t know about other view controllers.
This pattern can be adopted for only part of an app or used across an entire application.

Question 3

Avoid making real networking calls in your unit tests by mocking

Answer 3

URLSession and URLSessionDataTask.

Question 4

Do TDD for GET requests easily by breaking them into several smaller tasks:

Answer 4

calling the right URL, handling HTTP status errors, handling valid and invalid responses.

Question 5

How to test Networking Client?

Answer 5

Create URLSession and URLSessionDataTask mocks
Inject them to your Client
Test how Client behave under your cases and situations

Test for:
calling the right URL
handling error responses
test for deserialising models
test for Dispatching to a response queue

Question 6

Save completion vs call completion after another request

Answer 6

Call completion you use when you are also waiting for some completion

save completion to pass data later in your test

Question 7

There are two ways you can create a mock network client in Swift:

Answer 7

1. You can create a mock by subclassing DogPatchClient and overriding each of its methods. This works, but you may accidentally make real network calls if you forget to override a method. You may also cause side effects, such as caching fake network responses.
   You can create a network client protocol and depend on this instead of DogPatchClient directly.
2. You can create a mock object by implementing it. In turn, you eliminate the possibility of making real network calls or causing side effects. Nice! The main downside of this approach is that you must create an extra type for the protocol. However, this is usually very quick and easy to do.

Question 8

you should create a mock network client using a

Answer 8

protocol instead of subclassing-and-overriding.

Question 9

What you should add to your network client protocol?

Answer 9

You shouldn’t add implementation details.

A consumer doesn’t need to know how you constructed its dependency; they only need to know the behavior the dependency provides. This, in turn, defines which methods and properties go into the protocol.

Question 10

Testing flow

Answer 10

Create mocks for dependencies your SUT
Create a test for initialization
Start testing from easer to more complex tasks
After each test see what I can refactor

Question 11

There are two different types of cryptography

Answer 11

symmetric cryptography, and asymmetric cryptography.

Question 12

“use Keychain Access to export your identity, and you wanted to format it in a .cer (certificate) format,

Answer 12

you’d only be exporting the public key.

Question 13

to properly export the full identity from keychain

Answer 13

you must use the PKCS12 format (.p12) to properly export the full identity, private key and all

But be careful: whoever has the private key can assume the full identity for that company, at least from Apple’s perspective

Question 14

What are Entitlements

Answer 14

Embedded in (almost) every compiled application is a set of entitlements: again, this is an XML string embedded in the application saying what an app can and can’t do. Other programs will check for permissions (or lack thereof) in the entitlements and grant or deny a request accordingly. Think of the capabilities section found in Xcode.

Question 15

Attach debugger entitlement

Answer 15

get-task-allow entitlement

Question 16

What provisioning profiles include?

Answer 16

public x509 certificate, the list of approved devices as well as the entitlements all embedded into one file

TeamIdentifier
Entitlements
IsXcodeManaged
Name
ProvisionedDevices
DeveloperCertificates
AppIDName

Question 17

Certificate it’s like

Answer 17

public key in security

Question 18

Public key cryptography is based on the premise that there are two keys

Answer 18

: one key for encrypting, and one key for decrypting.

Question 19

Public key

Answer 19

public key is something that you can share freely.

Question 20

Private key

Answer 20

You can think of the private key like an actual key that you have to protect and keep safe

Question 21

Dynamic frameworks vs static frameworks

Answer 21

A dynamic framework is a bundle of code loaded into an executable at runtime, instead of at compile time

Examples in iOS include UIKit and the Foundation frameworks. Frameworks such as these contain a dynamic library and optionally assets, such as images.

There are numerous advantages to electing to use dynamic frameworks instead of static frameworks. The most obvious advantage is you can make updates to the framework without having to recompile the executable that depends on the framework.

Question 22

An initializer must assign a value to every single stored property that

Answer 22

does not have a default value, or else you’ll get a compiler error. Remember that optional variables automatically have a default value of nil.

Question 23

Throw failure vs optional nil

Answer 23

By using throwing initializers you can not only indicate failure, but also indicate a reason by throwing specific errors.

Nil has no reason

Failable initializers are much simpler though, since you don’t need to define an error type and you can avoid all those extra try? keywords.

Question 24

designated initializer is just a fancy term for

Answer 24

a non-delegating initializer.

Question 25

designated initializers] are responsible for

Answer 25

providing initial values to all non-optional stored properties declared without a default value

Question 26

Override all of a superclass’s set of designated initializers in order to

Answer 26

re-inherit the superclass’s set of convenience initializers.

Question 27

When overriding a superclass designated initializer, you can either make it

Answer 27

a designated initializer or a convenience initializer

Question 28

Conditionally Conforming to a Protocol

Answer 28

where

Question 29

Providing Default Implementations for protocols

Answer 29

Protocol requirements with default implementations provided by extensions are distinct from optional protocol requirements. Although conforming types don’t have to provide their own implementation of either, requirements with default implementations can be called without optional chaining.

Question 30

Give instances what they

Answer 30

only needed

Restrict to only read functionality

Question 31

Recursive Enumerations

Answer 31

A recursive enumeration is an enumeration that has another instance of the enumeration as the associated value for one or more of the enumeration cases. You indicate that an enumeration case is recursive by writing indirect before it, which tells the compiler to insert the necessary layer of indirection.

Question 32

you should think of memory management from the perspective

Answer 32

of object ownership and object graphs.

Question 33

Choosing Between Structures and Classes

Answer 33

Use structures by default.

Use classes when you need Objective-C interoperability.

Use classes when you need to control the identity of the data you’re modeling.

Use structures along with protocols to adopt behavior by sharing implementations.

Use Structures When You Don’t Control Identity

Question 34

Choose Structures by Default

Answer 34

Use structures to represent common kinds of data. Structures in Swift include many features that are limited to classes in other languages: They can include stored properties, computed properties, and methods. Moreover, Swift structures can adopt protocols to gain behavior through default implementations. The Swift standard library and Foundation use structures for types you use frequently, such as numbers, strings, arrays, and dictionaries.

Using structures makes it easier to reason about a portion of your code without needing to consider the whole state of your app. Because structures are value types—unlike classes—local changes to a structure aren’t visible to the rest of your app unless you intentionally communicate those changes as part of the flow of your app. As a result, you can look at a section of code and be more confident that changes to instances in that section will be made explicitly, rather than being made invisibly from a tangentially related function call.

Question 35

stack

Answer 35

More efficient when allocating and deallocating data.
Stacks store value types, such as structs and enums.

Data stored in the stack is only there temporarily until the function exits and causes all memory on the stack to be automatically deallocated.

Makes memory lookup and access very fast from how well it is organized.
The most frequently reserved block is the first to be freed.

Question 36

Concurrency vs Parallelism

Answer 36

Parallelism is about doing work at the same time.

Concurrency is about the option to do work at the same time.

Question 37

The great advantage of Dispatch Queues is, that it changes your mental model of concurrent programming. how?

Answer 37

Instead of thinking in threads, you consider it as blocks of work pushed onto different queues, which is a lot easier.

Question 38

You should never try to call the methods of an RunLoop object

Answer 38

running in a different thread, as doing so might cause unexpected results.

Question 39

Synchronisation in swift @synchronized

Answer 39

let serialQueue = DispatchQueue(label: "com.test.mySerialQueue") 
serialQueue.sync { // code }

Question 40

What avoid to store in Controllers?

Answer 40

we should try as hard as possible to avoid storing state in Controllers

Question 41

Controller is like a

Answer 41

Controller is Mediator

Question 42

or when you notice a lot of business logic settling down in Controllers, consider

Answer 42

wrapping those Model objects in a Facade which will hide the complexity and implementation details.

Question 43

People often neglect the logic part and make their Models data-only objects which are then manipulated

Answer 43

by Controllers keeping all the logic, with the consequence that Models become thin and Controllers become fat.

Question 44

Don’t try to use MVC as one single structural design pattern but rather

Answer 44

as a guideline for good application architecture, or a set of design patterns which can solve some of our problems.

Question 45

Background modes cases

Answer 45

Play audio: The app can continue playing and/or recording audio in the background. - Ask for permission

Receive location updates: The app can continue to get callbacks as the device’s location changes. - Ask for permission

Perform finite-length tasks: The generic “whatever” case, where the app can run arbitrary code for a limited amount of time. -

registerBackgroundTask() tells iOS that you need more time to complete whatever it is that you’re doing in case the app moves to the background

Background Fetch: Get updates to the latest content scheduled by iOS.

Question 46

Perform finite-length tasks: The generic “whatever” case, where the app can run arbitrary code for a limited amount of time. how to Configure?

Answer 46

◦ registerBackgroundTask() tells iOS that you need more time to complete whatever it is that you’re doing in case the app moves to the background

Question 47

Background Fetch: Get updates to the latest content scheduled by iOS. how to configure?

Answer 47

AppDelegate.swift and add the following to application(_:didFinishLaunchingWithOptions:):

you must implement application(_:performFetchWithCompletionHandler:). Add that now to AppDelegate:

Question 48

Explain SOLID

Answer 48

Single Responsibility Principle
Open/closed Principle
Liskov Substitution Principle
Interface Segregation Principle
Dependency Inversion Principle

Question 49

Single Responsibility Principle

Answer 49

One class should only have one responsibility

Question 50

What is ETC principle

Answer 50

Think what is Easier To Change when write code

Question 51

Open/closed Principle

Answer 51

Open for extension: You should be able to extend or change the behaviors of a class without efforts.
Closed for modification: You must extend a class without changing the implementation.

Question 52

Liskov Substitution Principle

Answer 52

objects in a program should be replaceable with instances of their subtypes without altering the correctness of that program.

Question 53

Interface Segregation Principle

Answer 53

many client-specific interfaces are better than one general-purpose interface

Question 54

Dependency inversion principle

Answer 54

one should “depend upon abstractions, [not] concretions.

Question 55

DI vs IoC

Answer 55

IoC is a generic term meaning rather than having the application call the methods in a framework, the framework calls implementations provided by the application.

DI is a form of IoC, where implementations are passed into an object through constructors/setters/service lookups, which the object will ‘depend’ on in order to behave correctly.

IoC without using DI, for example would be the Template pattern because the implementation can only be changed through sub-classing.

DI Frameworks are designed to make use of DI and can define interfaces (or Annotations in Java) to make it easy to pass in the implementations.

IoC Containers are DI frameworks that can work outside of the programming language. In some you can configure which implementations to use in metadata files (e.g. XML) which are less invasive. With some you can do IoC that would normally be impossible like inject an implementation at pointcuts.