At #WWDC22, Apple announced this new feature and I already gave information about it and it’s details are in the previous article here: Live Activities in iOS16

Apple announced the updates which contains details of this great feature yesterday(07.27.2022) and let’s focus on the details, together, as promised :)

I will put whole project link at github at the end of the article.

Prerequisites

• Xcode 14 beta 4: Download Xcode 14 beta (6.97 GB)
• Beta 4 of iOS 16

Let’s create an app

I prepared this process for you starting with figma. I designed a new view for the Live Activity that we will use. Example project will be about the CI CD pipelines that we have on AppCircle. Appcircle is an easy-to-setup mobile CI/CD platform with testing and store deployment which I like most. So, instead of doing same food delivery application, having another perspective for this feature will be better, I think.

Think about the processes of ours on the AppCircle. When a state of a pipeline was changed, we want to let user know about it with giving build id.

You can check the design freely here. And a sneak peak from the design which is about the states that we will display.

To see whole blog post, you can check it on AppCircle

I prepared a recap for you about Xcode updates newly announced at #WWDC22.

I love practical improvements and this year there are several improvements for us which will speed up the development and quality so that I wrote this article in the practical improvements perspective.

This content does not contain updates on Swift, SwiftUI and other stuff. If you are here to check them, I will kindly ask you to check these links of my friends below:

• What’s new on Swift?
• What’s new on UIKit?
• What’s new on SwiftUI

AppIcon 🎉

Then; As I an iOS developer, when I create a new application for the whole users, I still prefer to use https://makeappicon.com . Thanks to the team because it helped me a lot for the last 5 years. It’s logic is to upload an image of your logo with 1024x1024 size and it sends the all images for iOS and Android icons in to my e-mail. There are also another plugins on Figma to cover this needs.

Now; I am sorry to drop using this tool because Apple announced brand new support on Xcode. All you need to do is to add 1024x1024 file in Xcode and select Single Size under Devices at AppIcon. That’s all:)

Source Editor Updates

Pinning Code Structure in the source editor

Then; while I develop some new cool features or fixing a bug I was using scroll up and down to get where I was at.

Now; Apple added a new feature called Code Structure on the editor which shows you directly where you are as a scope. Great, right? Simple but sharp. Also you can enable it.

To toggle this behavior, use “Show: Code structure while scrolling” in Xcode’s Text Editing preferences.

To read more, you can visit original post on AppCircle!

Merhabalar,

Son iki haftam, hayatıma güzel anılar bırakan, daha önceden yapmadığım/yapamadığım farklı etkinliklerde bulunduğum verimli bir süreç olarak yerini aldı. Her şey ahmet yalcinkaya’nın bir gün bana gelip, “Kanka bir etkinlikte konuşmacı olarak yer almak ister misin?” demesiyle başlamıştı :) İlk başta heyecandan ne diyeceğimi bilemedim ama kısa süre sonra da neden olmasın diyerekten ilk kez konuşmacı olma şansını yakalamış oldum.

Bahsi geçen konuşma, sevgili Uğur Umutluoğlu ‘nun düzenlediği “devnot mobile day” etkinliğiydi. O gün için etkinliğe yaklaşık 1 aydan fazla süre vardı. Bu etkinliğe katılma kararımın gazıyla gerek kendisi gerek içindeki güzel insanları pek sevdiğim NSIstanbul’da da yapılacak olan teknik sunum için de yerimi ayırttırdım. O da yetmez gibi bir de çok güzel gençlerin zamanlarından, hayatlarından feragat ederek organize ettikleri GDGTekirdağ etkinliği için de “cfp” ımı doldurdum ve orası için de konuşmacı olarak rezervasyonumu yaptırmış oldum :)

Daha öncesinde şirket içinde kendi aramızda yaptığımız etkinlikler dışında herhangi bir topluluk önüne çıkıp böyle bir etkinlik yapma fırsatım olmamıştı. O nedenle de yaşadığım heyecan boğazımı düğüm düğüm yapmıştı. Topluluk önünde çıkıp konuşmak için cidden bir cesaret gerekiyor. Sizi izleyen parlak parlak gözler, anlattıklarınızı dinleyen insanlar, sizden birşeyler almaya çalışan gençleri gördükten sonra da altına girdiğim bu yükün ne kadar da keyifli olduğunu öğrenmiş oldum.

İlk sunumumu NSİstanbul ile gerçekleştirdiğimiz etkinlite, Protel’in ofisinde yaptım. Orada fastlane’in ne olduğunu, ne amaçla kullandığımızı ve hangi durumlarda bizim için vazgeçilmez olabileceğini anlattım. İlgili sunumuma şuradan ulaşabilirsiniz;

Fastlane+BuildConfgs@iOS

Sonraki etkinliğimiz ise Tekirdağ’daki GDGDevFest idi. GDG deki tüm arkadaşlara bir kez daha en içten dileklerimle teşekkür ediyorum. Cumartesi gününün tümünü de etkinliğe ayırıp gelen üniversiteli arkadaşlarımı da ayrıca tebrik ediyorum. Yollarını çizmek için şimdiden kendilerine bu tip yatırımlar yapmaları bence takdire şayan. Orada ise genel olarak firebase’i anlattım. Mobil geliştirici birinin gözünden uygulama geliştirme sürecinde bize ne faydaları olduğunu da yaşadığım deneyimler üzerinden paylaştım.

What's new, Firebase?

Son olarak da, devnot mobile day’de Swift 4.0 ve iOS 11 ile  ‘ın mobil dünyaya yön verebilecek ARKit, CoreML, Face ID gibi yeni teknolojilerini anlattım. O gün de gayet keyifli ve verimli geçti benim açımdan. İlgili sunumuma da burdan ulaşabilirsiniz;

iOS11&Swift4

Bir topluluğa karşı yapacağım sunumlarda hedefim, sunum bittiğinde detayları merak eden, anlattıklarımı gerçek hayatında kullanacağına dair bana geribildirimler veren arkadaşlarımın çıkmasıydı ki ne mutlu öyle de oldu :) Bir çok yeni arkadaş kazandım. Sektöre yeni girecek ya da girmiş en azından bir kaç kişiyi de doğru yönlendirme şansım olduysa daha da ne mutlu bana :)

Paylaşmak gerçekten güzel. Paylaşacağımız zaman işimizi ciddiye alıp yaptığımız araştırmalar ve hazırlıklar bizi, anlattıklarımız ise dinleyenleri geliştiriyor. Özellikle bizim kendi sektörümüzdeki bildiğini anlatmayı seven abilerimize, kardeşlerimize büyük saygı duyuyorum. Buna niyetlenip de bir türlü harekete geçemeyenleri de mutlaka sahneye davet ediyor ve sosyal mesajımı da yazımın resmi olarak kullandığım “do something great” ile vermiş oluyorum sanırım. Benim yaptığım “great” mi bilmem ama seninki olabilir…

Yazıyı beğendiyseniz alkışlayıp ve paylaşıp daha çok kişinin okumasını sağlayabilir ve beni de mutlu edersiniz :)

Sağlıkla kalın..

I was at Firebase Dev Summit ’17. I met amazing people and Firebase team was very helpful and cheerful. Thanks for that event at Amsterdam. Btw, I had the opportunity to visit Amsterdam city which is very very beautiful. Local people were amazing. Trip was really amazing for my team except for the turbulence of the ✈️ :D

We planned our trip for 4 days which started on Saturday(28th of October) and ended at the event night. For 3 days we toured Amsterdam, drank local beers and tried local places like Omelegg, Cannibale Royal and some more. You should try them. 🍺

And let’s start to talk about the event with a real question! 😈 😇

Will Google close Firebase?

No. At least not, for now :D Google, please do not close it. I love it ❤️.

So what’s new?

🎉 Crashlytics is now a part of Firebase!

Crashlytics saves you troubleshooting time by intelligently grouping crashes and highlighting the circumstances that lead up to them.

It is very useful to track your apps’ crashes just in time. It also helps the user to deploy and distribute their applications using own tool called Beta. Also, there is a page which you can inspect your app retentions, engagements and more. If you didn’t use it already, you should take a look at it. If you need any help, please let me know that I can help you. (My twitter acc)

🎉 A/B Testing Support!

A/B testing can help you find the optimal wording and presentation by testing message variants on selected portions of your user base.

🎉🎉 Predictions! (beta)

Firebase Predictions uses the power of Google’s machine learning to create dynamic user groups based on users’ predicted behavior.

Machine Learning? Users’ predicted behaviors? Making more money? :) There is a whole new world to dive deeper.

You can also read Candost’s post here to learn more about Predictions.

🎉 Cloud Firestore! (beta)

Flexible, scalable database for mobile, web and server development from Firebase and Google Cloud Platform.

NoSQL. The best advantage of Expressing Queries over Firebase Realtime DB!

• Realtime Database is Firebase’s original database. It’s an efficient, low-latency solution for mobile apps that require synced states across clients in realtime.
• Cloud Firestore is Firebase’s new flagship database for mobile app development. It improves on the successes of the Realtime Database with a new, more intuitive data model. Cloud Firestore also features richer, faster queries and scales better than the Realtime Database.

You can check differences between them, here: Realtime DB vs Firestore

Conclusion

Firebase still continues to grow with the new features they add and improving existing ones. It also offers a very successful alternative for mobile developers who do not want to write backends. I personally use it on my side projects and I am very satisfied. I also recommend it to you.

If you like my post please free to clap or to add a comment below. You can also register your e-mail to my newsletter.

In this article, I will talk about what actually protocol oriented programming is. Because some of my friends think that, using more protocols is protocol oriented programming :) That’s not about using more protocols, that’s a new programming paradigm that is announced at Swift 2.0.

Protocols

Protocols are blueprint of methods, properties, and other requirements that suit a particular task or piece of functionality. It’s an interface. A powerful feature of Swift language.

// An example of a protocol
protocol TableCellProtocol {
    func cellButtonTapped()
}

Swift checks whether the requirements of the protocol are met for the classes it implemented at compile-time. So this allows developers to find out if there are any issues or bugs in code even before running the program. Also protocols brings more abstraction than classes do in swift.

“Don’t start with a class, start with a protocol.”

Tell me what Protocol Oriented Programming is

Above, I told you what protocol is. Protocol OP is a new approach for programming which you decorate your classes, structs or enums using protocols. Swift does not support multiple inheritance, therefore problem pops out when you want to add multiple abilities to your class. Protocol OP lets you to add abilities to a class or struct or enum with protocols which supports multiple implementations.

OOP should be enough?

Modelling abstractions using classes relies on inheritance. Subclasses will have the ability of their super classes. A subclass can override that ability, add specific one. OOP works perfect till you need another ability from another class. There is no multiple inheritance in Swift. But protocols serve as blueprints rather than parents. A protocol models abstraction by describing what the implementation types shall implement. This is the key difference between OOP and Protocol OP. And two other pros over OOP are here:

• Types can conform more than one protocol. This brings perfect flexibility.
• Protocols also can be extended and adopted by classes, structs and enums.

Talk is cheap, show me the code!

Below, I will create a weapon protocol, NOT class.

protocol Weapon {
    var name: String { get }
    var canFire: Bool { get }
    var canCut: Bool { get }
}
// You can create blueprints for vars and funcs. Creating a var in a // protocol lets your classes to conform that protocol with forcing // to define that variables. In this example, we force developer to // add name, canFire and canCut vars to weapon he/she created using // Weapon protocol

Then, consider we have 2 types of weapons; fireable, cuttable. We will use these abilities with weapon protocol to create weapons as we want.

protocol Fireable {
    var magazineSize: Int { get }
}

protocol Cuttable {
    var weight: Double { get }
    var steel: String { get }
}

We created abilities and our Weapon protocol. Lets create structs using all these.

struct LongSword: Weapon, Cuttable {
    let name: String
    let steel: String
    let weight = 7.2
    let canFire = false
    let canCut = true
}
// longsword is a weapon with ability to cut.

struct AK47: Weapon, Fireable {
    let name = "AK47"
    let magazineSize = 30
    let canFire = true
    let canCut = false
}
// ak47 is also a weapon with ability to fire bullets.

As you can see above, we decorated our structs using protocols. Protocols force us to conform to them and also we add the ability we want. But a problem occurred above which is about holding canFire and canCut abilities at our custom structs. What can we do to fix this? Answer is Protocol Extension :)

extension Weapon {
    var canFire: Bool { return self is Fireable }
    var canCut: Bool { return self is Cuttable }
}

Then, please remove all canFire and canCut variables from AK47, Longsword and Weapon Protocol. Using “return self is Fireable” saves us from setting another instance var and make our protocols flexible to use via protocol extensions.

And please add these to your playground to see how that works:

let longclaw = LongSword(name: "Longclaw", steel: "Valyrian")
longclaw.canCut // true
longclaw.canFire // false
longclaw.name

let ak47 = AK47()
ak47.canFire  // true 
ak47.canCut // false

What? Extending Protocols? Inheritance?

Yip yip. Protocols are extendable. Lets see it in an example:

// I extend Bombable protocol from Fireable. With this new protocol, // I wanted to add maxDistance feature.
protocol Bombable: Fireable {
    var maxDistance: Double { get }
}

// Then I create brand new Weapon, Howitzer
struct Howitzer: Weapon, Bombable {
    let name = "Howitzer"
    let magazineSize = 1
    let maxDistance = 1000 // in km
}
// So this extensibility made my code base more flexible. Consider, // I do not want maxDistance in Fireable but Bombable.

Conclusion

Many object-oriented programming languages are plagued with limitations surrounding the resolution of ambiguous extension definitions. Swift handles this quite elegantly through protocol extensions by allowing the programmer to take control where the compiler falls short.

Swift lets me to my apps using OOP, Protocol OP, Functional Programming. I think, this is the reason why most people love it and also hate it :) Because swift opens up so much space which prevents you from creating a coding standard. However, on the contrary, I am very pleased with swift because of these features offered by it.

Thanks for reading, feel free to comment. :)

Protocol Oriented Programming in Swift was originally published in NSIstanbul on Medium, where people are continuing the conversation by highlighting and responding to this story.

In this article, I want to show you there are many alternative ways of JSON serialization. They all have pros and cons but at least you should know a little about them.

What is serialization?

“In computer science, in the context of data storage, serialization is the process of translating data structures or object state into a format that can be stored or transmitted and reconstructed later.” There is also a deserialization concept which is reversing serialized data to our custom objects. I already wrote an article about it.

Where do we use serialization?

• Transferring data over the wire.
• Storing data.
• Remote procedure calls. (RPC)

JSON, XML, protobuf, YAML, BSON, MessagePack are examples for data serialization. I guess most known ones are JSON and XML in mobile application development. Most preferred using JSON than XML because JSON is more readable with less size.

JSON (JavaScript Object Notation): Its being readable for human and easy to parse and generate by machines is the reason why it is choosen most. But in my opinion, readable response formats is very important to check data types and that makes JSON one step closer. Swift has got lots of 3rd party libraries for serializing&deserializing JSON. You can check them here. And also in my previous article you can see some of examples of them.

// Simple JSON format example
{
    "name": "Ali Can"
    "surname": "Batur"
    "age": 29
}

XML (eXtensible Markup Language): Defines a set of rules for encoding documents in a format that is both human-readable and machine-readable. XML’s being illegible and complex, causes it less preferred. Also parsing it needs more effort than JSON and some others. You can find 3rd party parsers here. Also there is SDK (foundation) support for this here.

<person>
  <name>Ali Can</name>
  <surname>Batur</surname>
  <age>29</age>
</person>

protobuf (Google’s Protocol Buffers): “Protocol buffers are a flexible, efficient, automated mechanism for serializing structured data. You define how you want your data to be structured once, then you can use special generated source code to easily write and read your structured data to and from a variety of data streams and using a variety of languages. You can even update your data structure without breaking deployed programs that are compiled against the “old” format.” says Google. I think in the future, we will not need to write response model objects. One file for both API and client would be enough. Also  itself supports this technology here. I want to write a blog post just about protobufs. Let me hear your opinions about protobuf, pls :)

// Example content for an .proto file.
message Person {
   int32 age = 1;
   string name = 2;
   string surname = 3;
}

YAML (YAML Ain’t Markup Language) : YAML is a readable data serialization standard for all programming languages. No need for brackets nor quotes. Syntax supports relational data. Especially used for viewing / editing of data structures: such as configuration files, dumping during debugging. Here a YAML framework is.

- name: Ali Can
  surname: Batur
  age: 29
  devices: 
    - iPhone 7
    - Apple Watch Series 2
    - Macbook Pro

BSON (Binary JSON) : It’s a bin­ary-en­coded seri­al­iz­a­tion of JSON-like doc­u­ments. It also con­tains ex­ten­sions that al­low rep­res­ent­a­tion of data types that are not part of the JSON spec. JSON is a plain text format, and while binary data can be encoded in text, this has certain limitations and can make JSON files very big. BSON comes in to deal with these problems. You can find a library here.

MessagePack: It’s like JSON but fast and small. It’s another binary format serialization. It’s smaller than BSON, supports type-checking(static type). You can find a lib here.

Conclusion

In real life examples, JSON is the most choosen one for mobile app development to handle request-response data transfers. I also use JSON for all my projects, because it is being readable speeds up things I do. Other serializing formats are useful where they fits most. As an example, use YAML for your configuration file types. Althought JSON is very handy, I wonder protobuf most. I guess, it will give client-server architecture a new perspective. Btw, protobuf is not new, but I think it will be popular day-by-day.

Thanks for reading, feel free to comment.

Data serialization formats available in Swift was originally published in NSIstanbul on Medium, where people are continuing the conversation by highlighting and responding to this story.

In this article, we will learn what object mapping is and importance of it. Then we will compare different ways of mapping an object in Swift.

What is mapping?

“an operation that associates each element of a given set (the domain) with one or more elements of a second set (the range).” in terminology.

Where should we use mapping in real life?

Usually, when the request is completed, we receive the data in various formats. I choose JSON in examples below. These data formats should be converted to our models in our app. So that we will be able to use them as we want and in accordance with OOP. And those custom classes will let you code your model businesses in your custom classes.

Converting JSON to custom objects is necessary?

Yeap! Otherwise, you need to use them as dictionary, or some other data type. Which will make your app non-oop :)

Ways of mapping

There are many ways to map your objects.

Let’s start from the worst way, the non-mapping way :)

Swift’s basic way of mapping (Swift 3):

We have a person struct in the example above. First, we will add an init method to it.

init(with dictionary: [String: Any]?) {
  guard let dictionary = dictionary else { return }
  name = dictionary["name"] as? String
  surname = dictionary["surname"] as? String
  age = dictionary["age"] as? Int
}

Then map your object like this:

var data: Data = JSON.data(using: .utf8)!
let anyObj = try! JSONSerialization.jsonObject(with: data, options: .allowFragments)
let person = Person(with: anyObj!) // Maps here
label.text = person.name

If you need nilsafety, change models’ optional and set a default value:

var name: String?    ==>  var name: String!
var surname: String? ==>  var surname: String!
var age: Int?        ==>  var age: Int!
...
name = dictionary["name"] as? String ?? "" // default value
surname = dictionary["surname"] as? String ?? ""
age = dictionary["age"] as? Int ?? 0

Open source mapping tools

Here are nearly all object mapping tool list. But I will show you some of them below. (awesome-ios#JSON)

• tristanhimmelmans’ ObjectMapper

struct Person: Mappable {
    var name: String?
    var surname: String?
    var age: Int?

    init?(map: Map) {

    }

    mutating func mapping(map: Map) {
        name    <- map["name"]
        surname <- map["surname"]
        age     <- map["age"]         
    }
}
...
let person = Mapper<Person>().map(JSONString: JSONString)
// It also supports object to json
let JSONString = Mapper().toJSONString(person, prettyPrint: true)
// ObjectMapper also supports Alamofire(which I will write another blog about), Realm and a bunch of third parties.
// Mapping collections is also easy.

• utahiosmac’s Marshal

struct Person: Unmarshaling {
    var name: String
    var surname: String
    var age: Int

    init(object: MarshaledObject) throws {
        name = try object.value(for: "name")
        surname = try object.value(for: "surname")
        age = try object.value(for: "age")
    }
}
...
let people: [Person] = try json.value(for: "people") // A collection example

• hkellaway’s Gloss

struct Person: Decodable {

    let name: String?
    let surname: String?
    let age: Int?

    // MARK: - Deserialization

    init?(json: JSON) {
        self.name = "name" <~~ json
        self.surname = "surname" <~~ json
        self.age = "age" <~~ json    
    }

}

• JohnSundell’s Unbox

struct Person {
    let name: String
    let surname: String
    let age: Int
}

extension Person: Unboxable {
    init(unboxer: Unboxer) throws {
        self.name = try unboxer.unbox(key: "name")
        self.surname = try unboxer.unbox(key: "surname")
        self.age = try unboxer.unbox(key: "age")
    }
}
...
let person: Person = try unbox(dictionary: dictionary)

There are many more tools that can be used. I wanted to show you some of them as an example.

Conclusion

Using mapping brings you benefits:

• Domain Model Pattern usage.
• Less code
• Testability
• Reusability
• Single Responsibility. Dividing the model business

If you ask which one you are using, I will answer with ObjectMapper. Because I make my request calls with Alamofire, and ObjectMapper’s support for Alamofire is really useful. And also it supports realm objects which I choose to use for persistency. I plan to write a blog post about my service calls and mapping structure.

Please let me know if there is another really useful mapping tool you know with the benefits of it so that I can edit this post with that.

Object Mapping in Swift was originally published in NSIstanbul on Medium, where people are continuing the conversation by highlighting and responding to this story.