Xcode 8 includes many new features and improvements such as: 1. Increased security, accessibility, and usability. 2. Support for Swift 3 and a migration tool to help move to Swift 3. 3. New source editor extensions that allow developers to manipulate and navigate code. 4. Improved debugging tools including a better view debugger and memory debugger. 5. Enhanced code signing that makes management easier.

1. What’s New in Xcode 8.0
Xcode 8 includes overall quality improvements as well as extensive new features.
● Security. Increased Xcode.app security due to runtime library validation
● Readability. New SF Mono font and updated syntax highlighting themes
● Downloading. Smaller download size and faster installation for App Store
downloads
● Accessibility. Enhanced accessibility in core Interface Builder workflows, and
throughout Xcode
● Usability. Xcode and Interface Builder improvements throughout to increase
performance and reduce memory use
● Reference. Faster, more space-efficient, easier-to-read documentation
1. Swift 3.0
Projects created with Xcode 8 use Swift 3 by default. Fortunately, Xcode 8
includes a build setting that gives developers the ability to stick with Swift 2,
Swift 2.3 to be precise.
This means that you can choose when you want to migrate a project to Swift
3. To configure a target for Swift 2.3, open the target's build settings and set
Use Legacy Swift Language Version to Yes.
Xcode 8 also includes a migration tool that helps you migrate a project to
Swift 3.

2. 2. Source Editor Extensions
One of the most surprising features was the introduction of source editor
extensions. Developers have been asking for a native plugin architecture for
many years. Source editor extensions are a first good step in that direction.
There is a lot to like about extensions for Xcode, but Apple emphasizes that
extensions are currently focused on manipulating and navigating the contents
of the source editor hence source editor extensions. Xcode 8 even includes a
template to help you get up to speed.
Another benefit extensions have over plugins is security. You can sign and
distribute extensions using your developer account. Apple also mentioned
that you can use the Mac App Store for distributing extensions. This is a great

3. option if you are interested in making some money with the extensions you
make.
3. Debugging
View Debugging
View debugging is much more powerful in Xcode 8. Reliability has improved
and debugging ambiguous or unsatisfiable layouts is much easier thanks to
an improved view debugger that displays runtime issues.
Runtime issues? That's right. Xcode 8 introduces runtime issues in addition to
buildtime issues. If you run into Auto Layout issues at runtime, Xcode shows
you the issue as a runtime issue in the Issues Navigator on the left. This is a
very welcome addition.
Memory Debugging

4. Xcode 8 also sports a pretty impressive memory debugger for tracking down
memory leaks and retain cycles.
4. Code Signing

5. Code signing is a necessary evil for developers interested in Apple's
platforms. Fortunately, Apple isn't burying its head in the sand. Even veterans
are struggling with code signing issues from time to time. During this year's
Platforms State of the Union, Apple even made fun of its own Fix Issue button
that rarely fixed the issue and sometimes made things even worse.
Code signing issues should be a thing of the past with Xcode 8. For every
target, you can check a checkbox that tells Xcode to manage code signing on
your behalf. This option is enabled by default for new projects. When checked,
Xcode manages certificates, provisioning profiles, and application identifiers
for you.

6. 5. Other Improvements and Enhancements
San Francisco Mono
If you enjoy working with beautifully crafted software, then you may enjoy
Apple's new San Francisco Mono font that ships with Xcode 8. It is a
monospaced variant of San Francisco and blends in neatly with the system
font of macOS.
Line Highlighting
Did you notice that the current line is highlighted in the above screenshot?
That is another welcome enhancement Apple added to Xcode 8. I currently
use Backlight for Xcode to achieve the same effect in Xcode 7. I guess I no
longer need that plugin in Xcode 8.

7. Code Completion for Images
Speaking of ditching third party plugins, I currently use Kent Sutherland's
excellent KSImageNamed plugin to enable code completion for images in
Xcode. I won't be needing that plugin when I switch to Xcode 8 as this feature
is now built into Xcode.
6. Documentation
Developers spend an inordinate amount of time browsing and reading
documentation. Good documentation goes a long way and Apple's
documentation is excellent. Browsing the documentation is a different story.
The new documentation format looks gorgeous and the documentation
browser is fast and easy to use. Apple also consolidated the documentation
for its platforms, resulting in a much smaller memory footprint.

9. 7. Asset Catalogs
Expressive messaging feature support (“Stickers”)

10. 8. Source Control
● Updated version editor:
● – Improved support for unversioned files
● – Change tracking across file renames in Git
● – File renames in navigator correctly renamed in Git
● – Full Unicode support for filenames in Git
● – New diff count and stepper to ease moving through diffs
● – Simplified file listings show changes in both flat and hierarchical views
● Support for Subversion 1.9
● Improved clone performance for large projects in Git when using Xcode Server
● Faster log and blame views
● Faster SCM status for files
9. Storyboards
● New User Interface.

11. ● Connect button action
● Autoresizing be come back
● “Use size classes” -> “Use Trait Variations”

12. 10. When change from Xcode 7.3 to Xcode
8.0
● Can not connect two button to one action function if one in two is created on swift 2.x
and don’t convert current source to swift 3.0
● Error 308: Facebook SDK
11. What’s new in iOS 10?
● Widgets on the Search screen and Home screen.
A widget provides timely, useful information or
app-specific functionality without the need to
open an app. In the past, people added widgets to
Notification Center for quick access. Now, people
add widgets to the Search screen, which is
accessed by swiping to the right on the Home

13. screen and the Lock screen. You can also show a widget above the quick action
list that appears when people use 3D Touch to press your app icon on the Home
screen. The design and behavior of widgets has also changed. Be sure to review
and update your existing designs accordingly. See Widgets.
● Integration with Messages. Apps can integrate
with Messages by implementing a messaging
extension that appears below a conversation in
Messages and lets people share app-specific
content with friends. Apps can share text,
photos, videos, stickers, and even interactive
content, such as an in-message game. See
Messaging.
● Integration with Siri. Apps can integrate with Siri
and let people use their voice to perform specific
types of app-specific actions, such as making
calls, sending messages, and starting workouts.
See Siri.

14. ● Expanded Notifications. You can enhance
notifications with an expanded detail view that
opens when people use 3D Touch to press your
notification or swipe your notification down on an
unlocked device. Use this view to give people
quick access to more information about a
notification and the ability to take immediate
action without leaving their current context. See
Notifications.

15. 12. What's new in Swift 3.0
12.1. All function parameters have labels unless you
request otherwise
- In Swift 2.x and earlier, method names did not require a label for their
first parameter, so the name of the first parameter was usually built into
the method name. For example:
- Several other basic types of foundation have also dropped the "NS"
prefix, so you'll now see UserDefaults, FileManager, Data, Date, URL
URLRequest, UUID,NotificationCenter and more.
12.2. Omit needless words

16. - Another huge raft of breaking changes in Swift 3, because it means that
method names that contain self-evident words now have those words
removed.
12.3. UpperCamelCase has been replaced with
lowerCamelCase for enums and properties
- Although syntactically irrelevant, the capital letters we use to name
classes and structs, properties, enums, and more have always followed
a convention fairly closely: classes, structs, and enums use
UpperCamelCase (MyStruct, WeatherType.Cloudy), properties and
parameter names use lowerCamelCase (emailAddress, requestString).
- Example :
● XCPlaygroundPage.currentPage becomes PlaygroundPage.current
● button.setTitle(forState) becomes button.setTitle(for)

17. ● button.addTarget(action, forControlEvents) becomes
button.addTarget(action, for)
● NSBundle.mainBundle() becomes Bundle.main()
● NSData(contentsOfURL) becomes URL(contentsOf)
● NSJSONSerialization.JSONObjectWithData() becomes
JSONSerialization.jsonObject(with)
● UIColor.blueColor() becomes UIColor.blue()
● UIColor.redColor() becomes UIColor.red()
- At the same time enum cases are also changing, moving from
UpperCamelCase to lowerCamelCase. This makes sense: an enum is a
data type (like a struct), but enum values are closer to properties.
However, it does mean that wherever you've used an Apple enum, it will
now be lowercase
- Example :
● .System becomes .system
● .TouchUpInside becomes .touchUpInside
● .FillStroke becomes .fillStroke
● .CGColor becomes .cgColor

18. 12.4. Swifty importing of C functions
- Swift 3 introduces attributes for C functions that allow library authors to
specify new and beautiful ways their code should be imported into Swift.

19. 12.5. Verbs and nouns
● When the operation is naturally described by a verb, use the verb’s
imperative for the mutating method and apply the “ed” or “ing” suffix to
name its nonmutating counterpart.
Mutating Nonmutating
x.sort() z = x.sorted()
x.append(y) z = x.apending(y)
● Prefer to name the nonmutating variant using the verb’spast
participle(usually appending “ed”):
/// Reverses `self` in-place. mutating func reverse()
/// Returns a reversed copy of `self`. func reversed() -> Self ...
x.reverse() let y = x.reversed()
● When adding “ed” is not grammatical because the verb has a direct
object, name the nonmutating variant using the verb’s present
participle, by appending “ing.”
/// Strips all the newlines from `self` mutating func
stripNewlines()
/// Returns a copy of `self` with all the newlines stripped. func
strippingNewlines() -> String ... s.stripNewlines() let oneLine =
t.strippingNewlines()
● When the operation is naturally described by a noun, use the noun for
the nonmutating method and apply the “form” prefix to name its
mutating counterpart.
Nonmutating Mutating
x = y.union(z) y.formUnion(z)
j = c.successor(i) c.formSuccessor(&i)