Protocol-Oriented Programming with Swift

Notify me when the book’s added

Build fast and powerful applications by exploiting the power of protocol-oriented programming in Swift
About This BookThe only book that shows how to harness the power of Protocol-Oriented Programming in Swift to build real-world applications,Get familiar with the protocol focused approach of application development,Increase the overall productivity and performance of applications with Protocol Oriented Programming.Who This Book Is ForThis book is for Swift developers who want to learn and implement protocol oriented programming in their real world applications.
What You Will LearnThe difference between Object-Oriented programming and Protocol-Oriented programmingThe difference between reference and value types and when to use eachHow we can leverage tuples to reduce the complexity of our codeWhat are protocols and how to use themHow to implement protocol extensions to create a very flexible code baseHow to implement several design patterns in a Protocol-Oriented approachHow to solve real world design issue with protocol oriented programmingIn DetailAt the heart of Swift's design is an incredibly powerful idea: protocol-oriented programming. Its many benefits include better code maintainability, increased developer productivity and superior application performance. The book will teach the reader how to apply the ideas behind the protocol oriented programing paradigm to improve the code they write.
This book will introduce the readers to the world of protocol-oriented programming in Swift and will demonstrate the ideas behind this new programming paradigm with real world examples. In addition to learning the concepts of Protocol Oriented programming, it also shows the reader how to reduce the complexity of their codebase using protocol extensions. Beginning with how to create simple protocols, readers will learn how to extend protocols and also to assign behaviors to them.
By the end of this book readers will be able to harness the power of protocol-oriented programming to build real world applications.
Style and approachIn its latest release of Swift, Apple has introduced Protocol Extensions as a new feature at the heart of Swifts design making Swift 2 a protocol-oriented language. Protocol oriented programming being a less explored OOP paradigm, there is little guidance on hot to take advantage of protocol extensions in real-world applications. In addition to offering an in-depth coverage of protocol oriented programming and its concepts, this book also explains how a developer can leverage these features to build powerful, real-world applications

Programming Mobile Devices Computers

This book is currently unavailable

235 printed pages

Original publication: 2016
Publication year: 2016
Publisher: Packt Publishing

Related booksAll

Quotes

Enzohas quoted6 years ago
The observer pattern is used to implement distributed event handling where an observer type is notified when an event occurs within another type. The observer pattern allows groups of objects to cooperate with one another with few dependencies between them. This pattern is so widely used that you have probably come across it many times if you have developed applications using any modern UI framework such as Cocoa or Cocoa Touch.
- Like
- Comment
- Share
  Facebook
  Twitter
  Copy link
- Report this
Enzohas quoted6 years ago
The strategy pattern is really good for setting the algorithms to use at runtime, which also lets us swap the algorithms out with different implementations as needed by the application. Another advantage of the strategy pattern is that, we encapsulate the details of the algorithm within the strategy types themselves and not in the main implementation type.
- Like
- Comment
- Share
  Facebook
  Twitter
  Copy link
- Report this
Enzohas quoted6 years ago
The strategy pattern is pretty similar to the command pattern in that they both allow us to decouple implementation details from our calling type and also allow us to switch the implementation out at runtime. The big difference is, the strategy pattern is intended to encapsulate algorithms. By swapping out an algorithm, we are expecting the object to perform the same functionality but in a different way.
- Like
- Comment
- Share
  Facebook
  Twitter
  Copy link
- Report this