IPhone Operating System

Shreyas N B-01FE19BCS005

Abdul Azeez-01FE19BCS009

School of Computer Science and Engineering

KLE TECHNOLOGICAL UNIVERSITY

21 June 2021

18ECSC202 -OPERATING SYSTEM PRINCIPLES AND PROGRAMMING

Mrs. SHANTALA GIRADDI

Page 1 of 8
Table of Contents

abstract

1.Introduction

2.Background

2.1 Amiga’s Origins

2.2 The End of the Amiga Computer

3. Methodology

3.1 Memory management: memory model, and implementation details

4 Results and discussion..............................................................................................................8

5 Conclusions and recommendations..........................................................................................8

6 Acknowledgements..................................................................................................................8

7 References................................................................................................................................8

Appendix A: Place the title of appendix here..................................................................................9

Page 2 of 8
1 Introduction
iOS (formerly iPhone OS) is a mobile operating system created and developed by Apple

Inc. exclusively for its hardware. It is the operating system that powers many of the company's

mobile devices, including the iPhone and iPod Touch; the term also included the versions

running on iPads until the name iPadOS was introduced with version 13 in 2019. It is the world's

second-most widely installed mobile operating system, after Android. It is the basis for three

other operating systems made by Apple: iPadOS, tvOS, and watchOS. It is proprietary software,

although some parts of it are open source under the Apple Public Source License and other

licenses.Major versions of iOS are released annually. The current stable version, iOS 14, was

released to the public on September 16, 2020.. No devices were dropped, as all devices

supported by iOS 13 are able to run iOS 14.

2 Background

2.1 Origin- iPhone OS

In 2005, when Steve Jobs began planning the iPhone, he had a choice to either "shrink the Mac,

which would be an epic feat of engineering, or enlarge the iPod". Jobs favored the former

approach but pitted the Macintosh and iPod teams, led by Scott Forstall and Tony Fadell,

respectively, against each other in an internal competition, with Forstall winning by creating the

iPhone OS. The decision enabled the success of the iPhone as a platform for third-party

developers: using a well-known desktop operating system as its basis allowed the many third-

party Mac developers to write software for the iPhone with minimal retraining. Forstall was also

responsible for creating a software development kit for programmers to build iPhone apps, as

well as an App Store within iTunes

Page 3 of 8
2.2 The release of iPhone SDK and the success of iPhone OS

The operating system was unveiled with the iPhone at the Macworld Conference & Expo on

January 9, 2007, and released in June of that year. At the time of its unveiling in January, Steve

Jobs claimed: "iPhone runs OS X" and runs "desktop class applications", but at the time of the

iPhone's release, the operating system was renamed "iPhone OS" Initially, third-party native

applications were not supported. Jobs' reasoning was that developers could build web

applications through the Safari web browser that "would behave like native apps on the iPhone".

In October 2007, Apple announced that a native Software Development Kit (SDK) was under

development and that they planned to put it "in developers' hands in February". On March 6,

2008, Apple held a press event, announcing the iPhone SDK

The iOS App Store was opened on July 10, 2008 with an initial 500 applications available. This

quickly grew to 3,000 in September 2008, 15,000 in January 2009, 50,000 in June 2009, 100,000

in November 2009, 250,000 in August 2010, 650,000 in July 2012,1 million in October 2013,2

million in June 2016,and 2.2 million in January 2017.As of March 2016, 1 million apps are

natively compatible with the iPad tablet computer. These apps have collectively been

downloaded more than 130 billion times. As of 2021 there are more than 5 million apps on the

apple app store

2.3 iPhone OS to iOS

In June 2010, Apple rebranded iPhone OS as "iOS". The trademark "IOS" had been used by

Cisco for over a decade for its operating system, IOS, used on its routers. To avoid any potential

lawsuit, Apple licensed the "IOS" trademark from Cisco.

Page 4 of 8
3 Methodology

3.1 Memory management:

Memory management is very important in any application, especially in iOS apps

that have memory and other constraints.It refers to ARC, MRC, reference types,
and value types.This is a must know for every iOS developer! Memory leaks and app
crashes are all too common due to poorly managed memory in iOS apps.

Swift uses Automatic Reference Counting (ARC). This is conceptually the same thing
in Swift as it is in Objective-C. ARC keeps track of strong references to instances of
classes and increases or decreases their reference count accordingly when you assign
or unassign instances of classes (reference types) to constants, properties, and
variables. It deallocates memory used by objects which reference count got down to
zero. ARC does not increase or decrease the reference count of value
types because, when assigned, these are copied. By default, if you don’t specify
otherwise, all the references will be strong references.

One of the key concept of ARC that you need to be aware of is Strong Reference
Cycles. For a class instance to be fully deallocated under ARC, it needs to be free of all
strong references to it. But there is a chance that you could structure your code in
such a way that two instances strongly reference each other and therefore never let
each other’s reference count drop down to zero.

There are two ways of resolving this in Swift: weak references and unowned

references. Both of these approaches will assign an instance without keeping a strong
reference to it. Use the weak keyword for one and the unowned keyword for the other
before a property or variable declaration.

Page 5 of 8
Weak reference is used when you know that a reference is allowed to
become nil whereas unowned reference is used when you are certain that the
reference has a longer lifecycle and will never become nil. Since weak references can
have a value or no value at all, they must be defined as optional variables. An
unowned reference has to be defined as non-optional since it is assumed to always
have a value.

Strong Reference Cycle in Closures:

Another important concept is Strong Reference Cycle in Closures. When you use
closures within a class instance they could potentially capture self. If self, in turn,
retains that closure, you’d have a mutual strong reference cycle between closure and
class instance. This often occurs when you use lazy loaded properties for example. To
avoid it, you’d use the same keywords weak and unowned. When you define your
closure, you should attach to its definition a so called capture list.

Capture List:

A capture list defines how the closure would handle references captured in it. By
default, if you don’t use a capture list, everything will be strongly referenced. Capture
lists are defined either on the same line where the closure open bracket is or on the
next line after that. They are defined with a pair of square brackets and every element
in them has a weak or unowned keyword prefix and is separated from other elements
by a comma. The same thinking applies to a closure capture list as to variable
references: define a capture variable as a weak Optional if it could become nil’ and the
closure won’t be deallocated before then, and define a captured reference
as unowned if it will never become nil before the closure is deallocated.

3.2 PROCESS MANAGEMENT

Page 6 of 8
3.3 INTERPROCESS COMMUNICATION

Inter Process Communication (IPC) is a method that allows processes to send

each other messages and data. It is a form of communication available on

multiple multitasking platforms and implemented on various languages.

Processes are assigned independent spaces of memory. This prevents the

modification of other processes' variables and states, adding to the overall

security and stability of a program. This also disables direct communication

between programs. To address this, IPC allows different processes to

communicate between each other to send and receive information such as

notification flags or chunks of data. Depending on the kind of information to

be sent, different methods will be more appropriate for each situation.

Notifying that a process has finished a task would require just a flag to be

raised but sending an image would require each byte that composes the image

to be sent.

Some of the existing methods to implaement IPC on iOS

 CPDistributedMessagingCenter
 LightMessaging
 Unix sockets
 XPC
 Notifications
 libobjcipc
 CPDistributes

Page 7 of 8
Page 8 of 8