Search Your Question

iOS 15 Release date , features - All answers related to iOS 15

iOS 15 Release date , features

FAQ for iOS 15

Q. Which is latest iOS version?
A. iOS 15 is latest iOS Version.

Q. What is iOS 15 release date?
A. iOS 15 is released on 20 September, 2021 worldwide.

Q. Is there any version after iOS 15 ?
A. iOS 15.1 beta version is released on 21 September, 2021.

Q. What is iOS 15 release date in India?
A. iOS 15 is released on 20 Sepember, 2021 in India.

How to install iOS 15 now

Step 1: Goto settings menu in iPhone

Step 2: Scroll down and tap on General

Step 3: Check if iOS 15 update is there or not.

Step 4: If yes, tap on the Download option displayed on the screen.

Step 5: Apple also provides the option to install the update while you are asleep. Select the best-suited option and install the iOS 15 update.

Once the iOS 15 update is installed, your iPhone will boot up. It will take some time due to update size is almost 3 GB. Before starting with the installation process, below are a few tips to keep in mind.

Tips to keep in mind before installing iOS 15

–Connect your iOS Device with stable high speed wifi.

–As iOS 15 update is almost 3 GB update, keep such space in memory

–Installation will take around half an hour. So keep your iOS device in charging mode.

Important features in iOS 15 updates for daily usse

  • Facetime

iOS 15 includes a new features for FaceTime. It will help apple to compete with other online meeting service like JioMeet, Zoom, Microsoft Team, etc.

Features in Facetime:
Spatial Audio support
Portrait mode for videos
Grid view for videos
Join FaceTime calls from the web on Android and Windows
FaceTime links
SharePlay for sharing content during FaceTime, including screen sharing, music, and more

  • Messages

Apple has also announced new features for Messages, including new ways to easily access content that people send you. Shared Stacks will bring over content from Messages to Photos app.

  • Notifications

Notification design is changed and anyone can choose to view summary.
When you enable DND, your status will be shown to other people via the Messages app
Notification design has been changed with large icons.
You can set different “Focus” status that change your Home Screen, notification preferences, and more.

  • Photos

Photos app now includes OCR capability. Due to this, it enables covert from image to text with artificial intelligence.
Photos can also be searched in spotlight. So it can be easily searched.

  • Weather

The Weather app has been revamped with lots of new data.
Layout design of the Weather app changes based on the weather in your current location.

  • Safari

iOS 15 brings a completely new design to Safari. Controls are brought to the bottom of the screen so that they are easier to reach with one hand.

There is a new, compact tab bar that floats at the bottom of the screen so that users can easily swipe between tabs, and it also contains a Smart Search field. Tab Groups allow users to save their tabs in a folder and sync across the iPhone, iPad, and Mac. In addition, there is a new tab overview grid view.

Users can simply pull down a web page to refresh it and there is now support for voice search. Safari also gains a customizable start page and mobile web extensions for the first time.

These are some important features that normal users can see changes. Otherwise apple has changed in many in-built application but it is not daily use for every people.

If you have any doubt or any question related iOS 15 release, please comment on box below.

What is push notification payload maximum size?

Apple Push Notification service (APNs) refuses a notification if the total size of its payload exceeds the following limits:

  • FCM - 2 Kb
  • VOIP Notification - 5 kb
  • For all other remote notification - 4 kb

What is trailing closure?

 If the last parameter to a function is a closure, Swift lets you use special syntax called trailing closure syntax. Rather than pass in your closure as a parameter, you pass it directly after the function inside braces.

To demonstrate this, here’s our travel() function again. It accepts an action closure so that it can be run between two print() calls:

func travel(action: () -> Void) {

    print("I'm getting ready to go.")


    print("I arrived!")


Because its last parameter is a closure, we can call travel() using trailing closure syntax like this:

travel() {

    print("I'm driving in my car")


In fact, because there aren’t any other parameters, we can eliminate the parentheses entirely:

travel {

    print("I'm driving in my car")


Trailing closure syntax is extremely common in Swift, so it’s worth getting used to.

Difference between method and function

Methods belong to classes, structs, and enums, whereas functions do not.

Methods always belong to a data type, they have a concept of self that functions do not. This is a special value passed in by Swift, and it refers to whatever instance the method was called on.

Swift uses the same keyword, func, for both functions and methods.

Difference between type method and Instance method?

Type Method: We can call the method using Struct, Class, or Enum name. The method can be static or Class for making such methods. Static method can not be override but class method can be override.

Instance Method: We can call normal method using making instance of strcut or class. This methods are called instance method.

Difference between Swift and Objective C


01Swift is a general-purpose, high-level programming language which is highly concerned about safety, performance.Objective C is an general purpose language which is considered as superset of C language it was designed in an aim of providing object-oriented capabilities.
02.It was developed by Chris Lattner with eventual collaboration with other programmers at Apple.It was developed by Brad Cox and Tom Love at their company Stepstone.
03.It was influenced by Objective C, Rust, Ruby, Python.It was influenced by C and Smalltalk.
04.Swift was first appeared on the year 2014.Objective C was first appeared on the year 1984.
05.Swift is static type.Objective C is dynamic type.
06.Swift is apache licensed open source project.Objective C is licensed under General Public License.
07.It only have classes.It has both Structs and classes.
08.It was designed for building apps for iOS, Mac, Apple TV and Apple Watch.Objective C was designed to be smalltalk messaging features.
09.Swift polymorphism does not exist directly.Polymorphism in Objective C exist directly in compile time.
10.It uses true and false values.It uses YES and NO values and also BOOl.
11.Swift has multiple types of templates than Objective C.Objective C has lacks of templates than Swift.

What is remote config in firebase

Change the behavior and appearance of your app without publishing an app update, at no cost, for unlimited daily active users.

Firebase Remote Config is a cloud service that lets you change the behavior and appearance of your app without requiring users to download an app update. When using Remote Config, you create in-app default values that control the behavior and appearance of your app. Then, you can later use the Firebase console or the Remote Config backend APIs to override in-app default values for all app users or for segments of your user base. Your app controls when updates are applied, and it can frequently check for updates and apply them with a negligible impact on performance.

What is KVO?

Key-value observing is the ability for Swift to attach code to variables, so that whenever the variable is changed the code runs. It’s similar to property observers (willSet and didSet ), except KVO is for adding observers outside of the type definition.

KVO isn’t terribly nice in pure Swift code, because it relies on the Objective-C runtime – you need to use @objc classes that inherit from NSObject, then mark each of your properties with @objc dynamic.

For example, we could create a Car class like this:

@objc class Car: NSObject {

    @objc dynamic var name = "BMW"


let bmw= Car()

You could then observe that user’s name changing like this:

bmw.observe(\, options: .new) { car, change in

    print("I'm now called \(")


That asks BMW to watch for new values coming in, then prints the person’s name as soon as the new value is set.

To try it out, just change the car's name to something else: = "Mercedese"

That will print “I’m now called Mercedese.”

Although KVO is unpleasant in pure Swift code, it’s better when working with Apple’s own APIs – they are all automatically both @objc and dynamic because they are written in Objective-C.

However, one warning: even though large parts of UIKit might work with KVO, this is a coincidence rather than a promise – Apple makes no guarantees about UIKit remaining KVO-compatible in the future.

What is Protocol Oriented Programming?

Protocol-Oriented Programming is a new programming paradigm ushered in by Swift 2.0. In the Protocol-Oriented approach, we start designing our system by defining protocols. We rely on new concepts: protocol extensions, protocol inheritance, and protocol compositions.

In Swift, value types are preferred over classes. However, object-oriented concepts don’t work well with structs and enums: a struct cannot inherit from another struct, neither can an enum inherit from another enum. 

On the other hand, value types can inherit from protocols, even multiple protocols. Thus, with POP, value types have become first-class citizens in Swift.

Pillars of POPs

Protocol Extensions
Protocols serve as blueprints: they tell us what adopters shall implement, but you can’t provide implementation within a protocol. What if we need to define default behavior for conforming types? We need to implement it in a base class, right? Wrong! Having to rely on a base class for default implementation would eclipse the benefits of protocols. Besides, that would not work for value types. Luckily, there is another way: protocol extensions are the way to go! In Swift, you can extend a protocol and provide a default implementation for methods, computed properties, subscripts, and convenience initializers. In the following example, I provided default implementation for the type method uid().

extension Entity {
    static func uid() -> String {
        return UUID().uuidString
Now types that adopt the protocol need not implement the uid() method anymore.

struct Order: Entity {
    var name: String
    let uid: String = Order.uid()
let order = Order(name: "My Order")
// 4812B485-3965-443B-A76D-72986B0A4FF4

Protocol Inheritance

A protocol can inherit from other protocols and then add further requirements on top of the requirements it inherits. In the following example, the protocol Persistable inherits from the Entity protocol I introduced earlier. It adds the requirement to save an entity to file and load it based on its unique identifier.

protocol Persistable: Entity {
    func write(instance: Entity, to filePath: String)
    init?(by uid: String)
The types that adopt the Persistable protocol must satisfy the requirements defined in both the Entity and the Persistable protocol.

If your type requires persistence capabilities, it should implement the Persistable protocol.

struct PersistableEntity: Persistable {
    var name: String
    func write(instance: Entity, to filePath: String) { // ...
    init?(by uid: String) {
        // try to load from the filesystem based on id
Whereas types that do not need to be persisted shall only implement the Entity protocol:

struct InMemoryEntity: Entity {
    var name: String

Protocol inheritance is a powerful feature that allows for more granular and flexible designs.

Protocol Composition

Swift does not allow multiple inheritances for classes. However, Swift types can adopt multiple protocols. Sometimes you may find this feature useful.

Here’s an example: let’s assume that we need a type that represents an Entity.

We also need to compare instances of a given type. And we want to provide a custom description, too.

We have three protocols that define the mentioned requirements:

If these were base classes, we’d have to merge the functionality into one superclass; however, with POP and protocol composition, the solution becomes:

struct MyEntity: Entity, Equatable, CustomStringConvertible {
    var name: String
    // Equatable
    public static func ==(lhs: MyEntity, rhs: MyEntity) -> Bool {
        return ==
    // CustomStringConvertible
    public var description: String {
        return "MyEntity: \(name)"
let entity1 = MyEntity(name: "42")
let entity2 = MyEntity(name: "42")
assert(entity1 == entity2, "Entities shall be equal")

This design not only is more flexible than squeezing all the required functionality into a monolithic base class but also works for value types.

Difference between compact map and Flat map

Compact Map :

Use this method to receive an array of nonoptional values when your transformation produces an optional value.

let scores = ["1", "2", "three", "four", "5"]

let mapped: [Int?] = { str in Int(str) }
// [1, 2, nil, nil, 5] - Two nil values as "three" and "four" are strings.

let compactMapped: [Int] = scores.compactMap { str in Int(str) } 

// [1, 2, 5] - The nil values for "three" and "four" are filtered out. 

Flat Map :

Use this method to receive a single-level collection when your transformation produces a sequence or collection for each element.

Map vs FlatMap
let scoresByName = ["Henk": [0, 5, 8], "John": [2, 5, 8]]

let mapped = { $0.value }
// [[0, 5, 8], [2, 5, 8]] - An array of arrays

let flatMapped = scoresByName.flatMap { $0.value }
// [0, 5, 8, 2, 5, 8] - flattened to only one array

CompactMap vs FlatMap

Used on a sequence and having a transformation returning an optional value, use CompactMap. If not, either map or flatMap should give you the results you need.