Jimmy Kimmel roasted Travis Kelce as newly minted billionaire Taylor Swift&#x27;s &quot;broke boyfriend&quot; after the Kansas City Chiefs tight end signed a $34 million contract extension.

Jimmy Kimmel roasts Travis Kelce as billionaire Taylor Swift's 'broke...

In a statement Thursday, UMG said the new licensing deal would lead to the return of its artists&#x27; music to TikTok.

Taylor Swift and Drake's label UMG strikes new licensing deal with TikTok to end spat

The culture is finally making it OK for men to confess how her music really makes them feel.

Taylor Swift scenes in The Fall Guy and The Bear are making space for male fans.

603 votes, 51 comments. 2.3M subscribers in the TaylorSwift community. A subreddit for everything related to Taylor Swift

r/TaylorSwift on Reddit: Taylor Swift’s “I Can Do It With A Broken Heart” becomes the fastest non-single to surpass 100 million streams in Spotify history. It surpasses her own “Lavender Haze”

Over the last day, a look at two more of Taylor Swift&#x27;s going out looks in Las Vegas surfaced on social media. Swift opted for minidresses. See each.

New Photos Show Taylor Swift Wearing 2 Minidresses in Las Vegas

Taylor Swift&#x27;s &quot;Down Bad&quot; debuts at No. 2 on the Hot 100, adding to her 10 tunes that peaked just shy of No. 1 and tying Drake&#x27;s record for near-misses.

Taylor Swift Ties Drake For A Record No Musician Really Wants

Flashback: UMG, which represents Taylor Swift, Drake and other top artists, let its contract with TikTok expire on Jan. 31 and pulled its music from the service after failing to reach a deal.

Taylor Swift, Drake label Universal Music Group returns to TikTok with new deal

A new photo shared to Instagram shows Taylor Swift and Travis Kelce enjoying date night at Toca Madera following Patrick Mahomes&#x27; 15 and Mahomies Foundation Golf Classic gala in Las Vegas on April 27.

Taylor Swift and Travis Kelce's Date-Night Style Nods to 2 of Her Songs — Can You Spot the Easter Eggs?

Licensing deal resolves months-long dispute that had record label Universal pulling its artists&#x27; music off the video platform.

TikTok and Universal resolve feud, putting Taylor Swift, other artists back on video platform - CBS News

Taylor Swift first attended the Met Gala in 2008 and made her most recent appearance at the event in 2016. Here are all the outfits she&#x27;s worn.

All of Taylor Swift's Met Gala looks, ranked from least to most iconic

Our developer first platform partners with large and niche service provider across the shipping value chain stitching them into one easy to use comprehensive solution

Swift

Evolution of Localization in Swift: From Strings to String Catalogs

সুইফটে স্থানীয়করণের বিবর্তন: স্ট্রিং থেকে স্ট্রিং ক্যাটালগ পর্যন্ত

Entwicklung der Lokalisierung in Swift: Von Strings zu String-Katalogen

Evolución de la localización en Swift: de cadenas a catálogos de cadenas

Evolution de la localisation dans Swift : des chaînes aux catalogues de chaînes

स्विफ्ट में स्थानीयकरण का विकास: स्ट्रिंग्स से स्ट्रिंग कैटलॉग तक

Swift におけるローカリゼーションの進化: 文字列から文字列カタログへ

Swift 지역화의 진화: 문자열에서 문자열 카탈로그로

Evolução da localização em Swift: de strings a catálogos de strings

Эволюция локализации в Swift: от строк к каталогам строк

Swift'de Yerelleştirmenin Evrimi: Dizelerden Dize Kataloglarına

Sự phát triển của bản địa hóa trong Swift: Từ chuỗi đến danh mục chuỗi

Swift 本地化的演变：从字符串到字符串目录

JSON in Swift: What You Need to Know

Memory management in Swift is based on automatic reference counting (ARC), which means that an object exists in memory as long as there is at least one strong reference to it. After that, ARC initiates the object deallocation mechanism, depending on the number of existing weak and unowned object references, the deallocation mechanism will be different. However, in addition to ARC, Swift also supports manual memory management. In this article, I will tell you what are the ways to work with memory that provide create/read/update/delete (CRUD) operations and much more. 1. Pointers Manual memory management can be implemented based on pointers. Pointer types vary depending on the need for unsafe memory access. The data type is: Pointers to a piece of memory without an explicit type. Returns the number of bytes. Usually contains in the name; Raw Pointers with an explicit type are specified during initialization as a generic parameter. contain in the name; Does not Raw Variability is distinguished by: Pointers to a memory area with the possibility of changing it. The name contains ; Mutable Pointers to a piece of memory without the possibility of changing it. The name contain ; does not Mutable The number of elements is distinguished by: Pointers that operate on an array of elements. The name contains ; Buffer Pointers that operate on a single element. The name contain ; does not Buffer In total, all possible combinations of pointers look like this: ; UnsafePointer<T> ; UnsafeMutablePointer<T> ; UnsafeBufferPointer<T> ; UnsafeMutableBufferPointer<T> ; UnsafeRawPointer ; UnsafeMutableRawPointer ; UnsafeRawBufferPointer ; UnsafeMutableRawBufferPointer 2. Creating objects Let’s consider the creation of objects in the example of UnsafePointer. var x: Int = 10
let unsafePointer = UnsafePointer<Int>(&x) Because is an immutable pointer, it can only be initialized by passing it an already initialized object directly. UnsafePointer You can get information about the memory area stored at a given pointer as follows: unsafePointer.pointee // printed 10 Consider the creation of objects in the example of . Unlike , this pointer can be initialized before information is written to the memory area. UnsafeMutablePointer UnsafePointer let size = MemoryLayout<Int>.size

let unsafeMutablePointer = UnsafeMutablePointer<Int>.allocate(capacity: size)
unsafeMutablePointer.pointee = 5 Now, through the pointee property, you can read and write the allocated memory area. Since we are working with the data type, the capacity area was chosen taking into account the required size of the . Int MemoryLayout You can deallocate a memory area and a pointer to it as follows: unsafeMutablePointer.deallocate()
unsafeMutablePointer.deinitialize(count: 1) Consider the creation of elements in the example of . Since this pointer is mutable and without explicit typing, it is enough to allocate a memory area for an object and then write data to it. In this case, all operations for this pointer occur byte by byte without a specific data type. UnsafeMutableRawPointer let unsafeMutableRawPointer = UnsafeMutableRawPointer.allocate(byteCount: size, alignment: alignment) // 6000006E44F0
unsafeMutableRawPointer.storeBytes(of: 32, as: Int.self) // 6000006E44F0
unsafeMutableRawPointer.load(as: Int.self) // printed 32 The method allows you to read a memory area with a given data type. The method allows you to write to the allocated memory area. At the same time, because of the lack of binding to a specific data type, you can easily put and read data with a completely different type into the allocated area: load storeBytes unsafeMutableRawPointer.initializeMemory(as: String.self, to: "123") // 6000006E44F0
unsafeMutableRawPointer.load(as: String.self) // printed “123”
unsafeMutableRawPointer.deallocate() The address was the number 32 with the data type , but we rewrote it to the string , hello Python. 6000006E44F0 Int "123" 3. Copying In addition to standard CRUD operations, pointers also support copying memory from one address to another. let size = MemoryLayout<Int>.size
let alignment = MemoryLayout<Int>.alignment

let unsafeMutableRawPointer1 = UnsafeMutableRawPointer.allocate(byteCount: size, alignment: alignment)
unsafeMutableRawPointer1.storeBytes(of: 32, as: Int.self) // 32

let unsafeMutableRawPointer2 = UnsafeMutableRawPointer.allocate(byteCount: size, alignment: alignment)
unsafeMutableRawPointer2.storeBytes(of: 40, as: Int.self) // 40

unsafeMutableRawPointer2.copyMemory(from: unsafeMutableRawPointer1, byteCount: size)
unsafeMutableRawPointer2.load(as: Int.self) // 32 Two pointers were created for different memory locations containing the numbers 32 and 40. Thanks to , we were able to copy information from one memory location to another. At the same time, the use of the method allows one-time copying, preserving the further independence of memory sections with different addresses. copyMemory copyMemory 4. Binding It is also possible to bind two different pointers: let unsafeMutableRawPointer3 = UnsafeMutableRawPointer.allocate(byteCount: size, alignment: alignment)
unsafeMutableRawPointer3.storeBytes(of: 32, as: Int.self)

let unsafeMutableRawPointer4 = unsafeMutableRawPointer3.bindMemory(to: Int.self, capacity: size)
unsafeMutableRawPointer4.pointee // 32

unsafeMutableRawPointer3.storeBytes(of: 40, as: Int.self)

unsafeMutableRawPointer4.pointee // 40 Thanks to , both pointers point to the same memory location and will catch all changes, regardless of which pointer they are written to. bindMemory 5. Collections To allocate an area of memory for an array using , the area for each element of the array will be allocated first: UnsafeMutableBufferPointer let array: [Int] = [5, 6, 7, 8, 9]
let elementPointer = UnsafeMutablePointer<Int>.allocate(capacity: array.count)
let arrayPointer = UnsafeMutableBufferPointer(start: elementPointer, count: array.count) Let’s fill in the previously allocated area. The offset between memory locations of different elements will be provided by the method. advanced(by: Int) for (index, value) in array.enumerated() {
 elementPointer.advanced(by: index).pointee = value
} In addition to writing, method also helps when reading a specific array element by ordinal index: the advanced(by: Int) elementPointer.advanced(by: 4).pointee // 9 supports to read and write array elements by ordinal index: UnsafeMutableBufferPointer subscript[index] arrayPointer[4] = 5
elementPointer.advanced(by: 4).pointee // 5
arrayPointer.deallocate() On this, the article comes to an end. I will talk about other types of manual memory management, such as , in the next article. Unmanaged objects Don’t hesitate to contact me on if you have any questions. Also, you can always . Twitter buy me a coffee Also published . here

Memory Management in Swift: Pointers, Object Creation, Copying, Binding, and Collections

Introduction Hi, everyone, my name is Maksim Nechaev. I'm a Senior iOS developer at Snoonu, and also the founder of my own startup. Like many other developers, I've written a lot of apps and features on UIKit. All the global projects I've worked with have been on it. And no wonder because it is the most common set of UI elements if we talk about . Along with UIKit, we should immediately mention layout via constraint. Often, we used SnapKit to simplify this task and write more minimalistic code. iOS development But times were changing, and a new, trendy, and hip SwiftUI framework appeared on the horizon. At first, it was shunned. They looked at it with derision. Maybe it even made sense at first because SwiftUI had huge limitations and shortcomings. We couldn't do 50% of what we could do with UIKit. But years later, SwiftUI has become more powerful, so much so that many companies don't even look at UIKit when starting new projects. Why is that? It's because SwiftUI has a declarative layout style, uses convenient and fast reactive elements, and building any screen complexity takes from 30 minutes to two hours, while on UIKit, you would have spent at least a day. And what is time for business? We all know time is money. So, the first thing SwiftUI is already doing right now is saving money for businesses. Let's go deeper. What else is great about SwiftUI? The ease of creating animations. Yes, yes, if you imagine a cool app with 60+ frames per second that responds smoothly to taps, buttons shrink with animation, screens pop out of the right side of the screen, everything happens in beautiful and pleasing (for UX) animations, all of this is very quick and easy to do inside SwiftUI. You can do a lot of this in UIKit, too, to tell you the truth. But spend a lot more effort and time. I hope I'm doing well in convincing you that SwiftUI is ready for full production development and that you should be learning it right now. That's why, with my first article on this topic, I'd like to touch upon the SwiftUI View lifecycle. How a "view" is created, where it is stored and how it is updated, I would like to talk about it all in this article. Let's get started! SwiftUI View vs UIView Let's start with the fact that UIView is created once in most cases. After that, we simply update its data. A SwiftUI View can be redrawn and created dozens of times within a single screen. This is very well illustrated in the following image. You may notice that when we use UIViewRepresentable, a structure that helps us use UIView inside SwiftUI, we create it once. But further, to update it, we pull updateUIView and update it as many times as needed. SwiftUI View is created many times, while UIView is created once. Storing data in SwiftUI View Let's take a look at ways to store data inside a . After all, you're probably already thinking, how do you store data if the View is constantly being recreated and redrawn? SwiftUI View In total, we can divide it into . three parts . Let and var, the classic use of data. First . @State and @StateObject. Already more SwiftUI approach Second . @Enviroment and @EnviromentObject Third Let Absolutely classic usage; we can create some kind of constant that we pass externally and use inside our structure. struct CustomView: View {
    let text: String

    init(text: String) {
        self.text = text
    }

    var body: some View {
        Text(text)
    }
} The only thing to keep in mind here is that usually, when we create a constant, we assume that it will not change. The situation here is that when is changed and redrawn, the constant can be changed. That is, it can be "bound" to the objects being changed. CustomView text Var This is where it gets interesting. What if we want to change a variable inside a structure? We have always done it in a very simple way, if we talk about classes in UIKit. var text: String Let's imagine that we have made our text a variable. It seems that now we can change it. But no, Swift won't let us do that. Structures are more capricious and rigid than classes, and even more so in SwiftUI. There is only one way to try to change text, and that is to create a mutating function. But unfortunately, we will get an error here, too. It will look like this: "Cannot use mutating member on immutable value.” In general, the idea with an ordinary var in the structure is very doubtful, and you should think ten times why you should do it. After all, SwiftUI has other cool tools for working with values, which we will talk about next. State The situation with the State is fundamentally the opposite. It can and must be used inside structures if we want to work with the value and change it somehow. struct CustomView: View {
    @State private var text: String

    var body: some View {
        Text(text)
    }
    
    func changeText() {
        text = "Hello, World!"
    }
} That is, if we create a structure with some local variables to which we tie local logic, we should use , so that all internal Views that use this value will be updated. Everything will work correctly, but... there is always a "but". What if we want to set the value externally? @State For example, like this struct CustomView: View {
    @State private var text: String

    init(text: String) {
        self.text = text
    }

    var body: some View {
        Text(text)
    }
} Do you think it will work, and in what cases? To be fair, it will work, but only when we set the first value. When we set all subsequent values, only the first one will be displayed inside the . body Here, it is important to realize that does not live as long as View does. That is, when we create inside View, we can change it inside View as many times as we want. The view will be updated and redrawn, but the local value will be stored. But if at the same time we try to set new values for through the initializer, they will be simply ignored. @State @State @State What is the output here? should be used only for saving and updating local data, but not those passed externally to the structure. @State StateObject Now, let's talk about using StateObject. In general, we use to set some kind of ViewModel for our screen. That is, we pair it with a class that obeys the ObservableObject protocol. It works very similarly to , with one exception: it is created after the first initialization of the structure. That is, while could somehow be passed to to put the first value, won't work. It will be deleted from memory after the initializer is called and will be created again. @StateObject @State @State init @StateObject Environment Let's move on to the consideration of . This property modifier is used to access data that is passed down the view hierarchy. Unlike , which is used to control the state of an object within a single view, allows you to access data that is shared by the entire application or a specific part of it. @Environment @StateObject @Environment Let's say you have some value that needs to be available in many places in your interface, such as custom settings or a design theme. Instead of passing this value through all levels of the hierarchy, you can use for easier access. @Environment When you mark a property in your SwiftUI view as ,SwiftUI automatically looks up the value of that property in the nearest matching context and provides it to you. If the value changes, SwiftUI also automatically updates the views that use that value. This makes a very powerful tool for managing data in SwiftUI. @Environment @Environment Example of use: struct ContentView: View {
    @Environment(\.locale) var locale: Locale

    var body: some View {
        Text("Current localization: \(locale.identifier)")
    }
} EnvironmentObject Now, let's break down . This property modifier is used to inject dependencies into SwiftUI views. Unlike , which is designed to access system settings or values defined at the application level, is used to pass and use user data between views. @EnvironmentObject @Environment @EnvironmentObject When you use , you expect the object to be provided by the parent views. This allows you to create more modular and easily scalable applications because your views do not depend on specific implementations of their dependencies. Instead, they dynamically retrieve the necessary objects from their environment. @EnvironmentObject Example usage of : @EnvironmentObject class UserSettings: ObservableObject {
    @Published var score = 0
}

struct ContentView: View {
    @EnvironmentObject var settings: UserSettings

    var body: some View {
        Text("Score: \(settings.score)")
    }
} SwiftUI View Life Cycle Understanding the life cycle of a view in SwiftUI is key to creating efficient and well-performing applications. Let's explore this process in a detailed and interesting way. 1. Initialization ( ) Initialization Every SwiftUI View starts its life journey with initialization. This is when SwiftUI creates an instance of your view and sets up its initial state. It's important to realize that SwiftUI views are structures, meaning they are value types. When you create a view, you are actually creating a "snapshot" of it at this point in time. 2. State Update ( ) State Update After initialization, SwiftUI watches for changes in data that may affect your view. This data can include , , , , and . When one of these values changes, SwiftUI starts the process of updating the view. @State @Binding @ObservedObject @EnvironmentObject @Environment 3. Body Computation ( ) Body Computation In this step, SwiftUI calls the property of your view. is a computed property, and every time SwiftUI detects a change that affects the view, it recomputes . This process allows SwiftUI to determine which parts of the UI need to be updated. body body body 4. Rendering & Layout ( ) Rendering & Layout Once the body of the view has been computed, SwiftUI proceeds to the rendering and layout phase. In this stage, SwiftUI determines exactly how the interface elements should be arranged and rendered. This process involves calculating the dimensions, positions, and other layout aspects for each element on the screen. 5. View Activation ( ) View Activation This is a specific point in the lifecycle that relates to user interaction with the view. For example, it could be the activation of a text box or the appearance of a view on the screen. 6. Deinitialization ( ) Deinitialization The last step in the life cycle of a view is to deinitize it. When a view is removed from the SwiftUI view hierarchy, it is deinitialized. This is an important time to release resources or perform any cleanup. Important Points: : SwiftUI frequently recreates and reuses views. Therefore, it is important to avoid expensive operations in initializers and . Reuse body : SwiftUI is optimized to ensure that only the necessary parts of the interface are updated. This improves the performance and efficiency of the application. Efficiency Conclusions SwiftUI View is very different from the familiar UIView, but that's the point. SwiftUI is different, and that's a good thing. In this article, I tried to convey the essence of working with SwiftUI View as succinctly and clearly as possible because this is a key skill for a SwiftUI developer. You will come across it in every task, which means it's worth understanding it very deeply. You need to be conscious of what you are writing and creating. I wish everyone good luck on the path to becoming powerful developers. If you are reading this article, then you are already on the right path. Thanks for your time, bye everyone! Please respond to this article so I can write more useful material for you.

Understanding the SwiftUI View Lifecycle and Data Management

Protocol-oriented programming is one of the most powerful and flexible tools for competent composition and distribution of responsibility in Swift. In one of the previous articles, protocol-oriented programming was used to manage the state and build a safe sequence of state transitions without additional checks. If you have not read , then it is recommended to read as material that will show one of the ways to use this wonderful approach. the previous article In this article, we’ll explore another way to use protocol-oriented programming. As a bonus — we’ll write our extension for programming UI components in UIKit that mimics the experience. SwiftUI What is the task before us? As we all know, all graphical components in UIKit are direct descendants of UIView, each with its own unique properties. A protocol-oriented approach will help us to endow each of the heirs with their own unique properties while making it possible to combine these properties in case we want to use the properties of the parent and the properties of the child. In addition to the protocol-oriented approach, we will also use the design pattern to bring the SwiftUI declarative syntax experience to UIKit. Decorator Let’s start with the simplest. Select several basic UI classes with which we will start: — all graphical components are inherited from it UIView — all , and so on are inherited from it UIControl UIButton UISegmentedControl Final UI components like , , and so on UILabel UITextField The inheritance diagram can be seen below: Let’s start our task by creating an interface: protocol Stylable {} This protocol is the basis for all subsequent extensions for our case. Since all graphical components somehow inherit from to cover all components — it is enough to extend with this protocol: UIView UIView extension UIView: Stylable {} Some of the most used properties for customizing a are , , , , . Moreover, these properties are often used not only to configure the , but also for its descendants. UIView cornerRadius backgroundColor clipsToBounds contentMode isHidden UIView Let’s extend the possibilities of for all classes and their descendants: Stylable UIView extension Stylable where Self: UIView {
    @discardableResult
    func cornerRadius(_ value: CGFloat) -> Self {
        self.layer.cornerRadius = value

        return self
    }

    @discardableResult
    func backgroundColor(_ value: UIColor) -> Self {
        self.backgroundColor = value

        return self
    }

    @discardableResult
    func clipsToBounds(_ value: Bool) -> Self {
        self.clipsToBounds = value

        return self
    }

    @discardableResult
    func contentMode(_ value: UIView.ContentMode) -> Self {
        self.contentMode = value

        return self
    }

    @discardableResult
    func isHidden(_ value: Bool) -> Self {
        self.isHidden = value

        return self
    }
} Let’s check what this extension gave us: let customView = UIView()
    .backgroundColor(.red)
    .clipsToBounds(true)
    .cornerRadius(20)

let customButton = UIButton()
    .backgroundColor(.red)
    .clipsToBounds(true)
    .cornerRadius(20)

let segmentedControl = UISegmentedControl(items: ["One", "Two"])
    .backgroundColor(.red)
    .clipsToBounds(true)
    .cornerRadius(20)

let scrollView = UIScrollView()
    .backgroundColor(.red)
    .clipsToBounds(true)
    .cornerRadius(20)

let textField = UITextField()
    .backgroundColor(.red)
    .clipsToBounds(true)
    .cornerRadius(20) As we can see, thanks to the extension, we can declaratively change properties not only for but also for its descendants. UIView Let’s move on to configuring the . For all of its descendants, one of the most used customizable things is tap, properties — , , . UIControl isEnabled tintColor isUserInteractionEnabled Let’s extend the possibilities of for all classes and their descendants: Stylable UIControl extension Stylable where Self: UIControl {
    @discardableResult
    func action(_ value: (() -> Void)?, event: UIControl.Event = .touchUpInside) -> Self {
        let identifier = UIAction.Identifier(String(describing: event.rawValue))
        let action = UIAction(identifier: identifier) { _ in
            value?()
        }
        
        self.removeAction(identifiedBy: identifier, for: event)
        self.addAction(action, for: event)
        
        return self
    }
    
    @discardableResult
    func secondAction(_ value: ((Bool) -> Void)?, controlEvent: UIControl.Event = .valueChanged) -> Self {
        let identifier = UIAction.Identifier(String(describing: controlEvent.rawValue))
        let action = UIAction(identifier: identifier) { item in
            guard let control = item.sender as? UIControl else {
                return
            }
            value?(!control.isTracking)
        }
        
        self.removeAction(identifiedBy: identifier, for: controlEvent)
        self.addAction(action, for: controlEvent)
        
        return self
    }
    
    @discardableResult
    func isEnabled(_ value: Bool) -> Self {
        self.isEnabled = value
        
        return self
    }
    
    @discardableResult
    func isUserInteractionEnabled(_ value: Bool) -> Self {
        self.isUserInteractionEnabled = value
        
        return self
    }
    
    @discardableResult
    func tintColor(_ value: UIColor) -> Self {
        self.tintColor = value
        
        return self
    }
} After the extension for , an additional customization option became available for all its descendants: Stylable UIControl let customButton = UIButton()
    .backgroundColor(.red)
    .clipsToBounds(true)
    .cornerRadius(20)
    .tintColor(.red)
    .action {
       print(#function)
    }
    .isEnabled(true)
    .isUserInteractionEnabled(true)

    
let segmentedControl = UISegmentedControl(items: ["One", "Two"])
    .backgroundColor(.red)
    .clipsToBounds(true)
    .cornerRadius(20)
    .tintColor(.red)
    .action {
       print(#function)
    }
    .isEnabled(true)
    .isUserInteractionEnabled(true) It is worth noting that when calling the action method using a class method, you should initialize this component lazily to ensure that the class (self) is initialized before the component is initialized. lazy var customButton = UIButton()
    .backgroundColor(.red)
    .clipsToBounds(true)
    .cornerRadius(20)
    .tintColor(.red)
    .action { [weak self] in
         self?.actionTest()
    }
    .isEnabled(true)
    .isUserInteractionEnabled(true)
    
private func actionTest() {
    print(#function)
} Let’s also extend with some of the most popular custom properties: UITextField extension Stylable where Self: UITextField {
    @discardableResult
    func text(_ value: String?) -> Self {
        self.text = value

        return self
    }

    @discardableResult
    func font(_ value: UIFont) -> Self {
        self.font = value

        return self
    }

    @discardableResult
    func textAlignment(_ value: NSTextAlignment) -> Self {
        self.textAlignment = value

        return self
    }

    @discardableResult
    func textColor(_ value: UIColor) -> Self {
        self.textColor = value

        return self
    }

    @discardableResult
    func capitalizationType(_ value: UITextAutocapitalizationType) -> Self {
        self.autocapitalizationType = value

        return self
    }

    @discardableResult
    func keyboardType(_ value: UIKeyboardType) -> Self {
        self.keyboardType = value

        return self
    }

    @discardableResult
    func isSecureTextEntry(_ value: Bool) -> Self {
        self.isSecureTextEntry = value

        return self
    }

    @discardableResult
    func autocorrectionType(_ value: UITextAutocorrectionType) -> Self {
        self.autocorrectionType = value

        return self
    }

    @discardableResult
    func contentType(_ value: UITextContentType?) -> Self {
        self.textContentType = value

        return self
    }

    @discardableResult
    func clearButtonMode(_ value: UITextField.ViewMode) -> Self {
        self.clearButtonMode = value

        return self
    }

    @discardableResult
    func placeholder(_ value: String?) -> Self {
        self.placeholder = value

        return self
    }

    @discardableResult
    func returnKeyType(_ value: UIReturnKeyType) -> Self {
        self.returnKeyType = value

        return self
    }
    
    @discardableResult
    func delegate(_ value: UITextFieldDelegate) -> Self {
        self.delegate = value

        return self
    }

    @discardableResult
    func atributedPlaceholder(
        _ value: String,
        textColor: UIColor,
        textFont: UIFont
    ) -> Self {
        let attributedString = NSAttributedString(
            string: value,
            attributes: [
                NSAttributedString.Key.foregroundColor: textColor,
                NSAttributedString.Key.font: textFont
            ]
        )

        self.attributedPlaceholder = attributedString

        return self
    }
} Thanks to this extension, customizing has become even easier. To customize the GUI, the methods of its parents are available, as well as its own methods: UITextField lazy var textField = UITextField()
     .placeholder("Placeholder")
     .textColor(.red)
     .text("Text")
     .contentType(.URL)
     .autocorrectionType(.yes)
     .font(.boldSystemFont(ofSize: 12))
     .delegate(self) It’s worth noting that, similar to capturing self in the ’s action method, assigning a delegate, also requires to be lazy-initialized. UIControl textField By analogy, the rest of the graphical components are expanded with properties that will be used for customization. As a bonus for my readers, I’ve compiled some of the most requested properties in this . You need to copy the files to your project; they are ready to use. repository Don’t hesitate to contact me on if you have any questions. Also, you can always . Twitter buy me a coffee Also published . here

Protocol-Oriented Programming and Modifying UIKit Components Mimicking SwiftUI

There are a sufficient number of ways to increase the speed of a project at runtime. Let’s look at the most popular of them: Limiting dynamic dispatch in classes Under the hood, any new class will use dynamic (table) dispatch. This is a price for the ability to be inherited, but if the class is not inherited, you can save a significant amount of resources. The prefix will turn your class into a statically dispatched object. final Before optimization: // parent class with dynamic table dispatch
class A {}
// child class with dynamic table dispatch
class B: A {} After optimization: // child class with static dispatch
final class B: A {} Examples of speed boost Parent class A: Subclass B: Final class B: Limitation of dynamic dispatch at methods A similar approach is used for class methods, but there are several options available: If your method is not used outside the class, feel free to use . private If you are going to protect your method from the possibility of override, use . final Both prefixes will turn your method into a statically dispatched method but with different scopes. Before optimization: // method with dynamic table dispatch
func method() {} After optimization: // private method with static dispatch
private func method() {}

// method with static dispatch cannot be override
final func method() {} Examples of speed boost Nonfinal method: Final or private method: Inline optimization One of the most curious and rarely used types of optimization. Inline optimization allows you to copy code calculations directly to the place where a given function is called without calling a method marked with inline, which reduces the number of method calls and works faster than static dispatch. Among the pitfalls, in order to force the compiler to call a method with inline optimization — it is necessary to mark the method not only but also @inlineable @inline(__always) not to mark methods that spend a large amount of resources on copying with these prefixes; there is a risk of filling the cache of all processor levels with calculations of these methods and, as a result, getting slower instead of speeding up. It is important Before optimization: // test method with multiple calling
func testMethod() {} After optimization: // inlinable test method with multiple calling
@inlinable
@inline(__always)
func testMethod() {} Examples of speed boost regular calling: inlined calling: Optimization in protocols Under the hood, protocols in Swift can be implemented for reference types and value types. Due to the fact that the memory management mechanism for reference types and value types are different, you can significantly speed up the compiler by limiting protocol adoption to reference types only. Before optimization: // can be adopted to reference types and value types,
// but value types adoption is unnecessarily
protocol Implementable {} After optimization: // can be adopted to reference types only
protocol Implementable: AnyObject {} Examples of speed boost creation array elements with a protocol for reference and value type creation array elements with protocol for reference type only Arrays was originally intended not only as a collection type for Swift, allowing elements of the same type to be stored sequentially, but also as a collection type providing compatibility with . Array NSArray In case the array is intended to store non-ObjC data types, it is recommended to use for more efficient operation of the array. ContagiousArray Before optimization: // creation array with NSArray interop
let array: Array<Int> = [1, 2, 3] After optimization: // creation array without NSArray interop
let fastArray: ContiguousArray<Int> = [1, 2, 3] Examples of speed boost: creation of : Array creation of : ContagiousArray Also published . here Don’t hesitate to contact me on if you have any questions. Also, you can always . Twitter buy me a coffee

Swift Runtime Optimization: Boosting Project Speed with Simple Techniques

If you're a Swift developer with a chatbot idea brewing in your mind, and you're keen on bringing it to life using your favorite programming language, then the simplest way to do so is by using Botter - an open-source, cross-platform framework. It leverages the power of Vapor in conjunction with platform-specific frameworks for swift and convenient cross-platform chatbot development. chatbot 🤓 Theory Botter enables you to receive and send text messages, media attachments, files, and commands for a high-quality user experience, all while using Swift - the native programming language for all Apple developers. Botter works in tandem with , which handles the server-side functions of your project. This powerful combination allows you to focus on what matters most - creating an engaging and effective chatbot. Vapor 🔥 Practice Next, I will demonstrate step by step how easy it is to write a simple chatbot using this framework: 👶 Setting Up Your Vapor Environment As I mentioned earlier, our project will be built on the foundation of Vapor. Therefore, we need to install it locally. You can do this by running the following command in your terminal: brew install vapor Now that we have Vapor installed let's create a new empty Vapor project. You can do this by running the following command: vapor new hello -n After running this command, a new project will be generated in the directory. The next step is to open the file in Xcode. You can do this by navigating to the project directory and opening the file with the following commands: /hello Package.swift cd ./hello
open Package.swift 🔀 Adding Dependencies To use Botter, we need to add it as an external dependency. Open your project's Swift Package Manager file and add the following line to the dependencies array: .package(url: "https://github.com/CoolONEOfficial/Botter.git", branch: "main"), Next, add Botter to the dependencies of your application by including the following line in the targets section of the same file: .product(name: "Botter", package: "Botter"), You can then try to build the project. This will ensure that Botter is correctly linked to your project and ready to use. 🏗️ Describing the Bot Logic In Botter, there are three entities that describe a chatbot: : interacts with the platform, for example, to send something, modify an existing message, etc. bot : retrieves data via webhooks. updater : processes the received data and passes it to you. dispatcher It's a good practice to wrap these entities in your own entity, like so: class EchoBot {
    public let dispatcher: Botter.Dispatcher
    public let bot: Botter.Bot
    public let updater: Botter.Updater

    public init(settings: Botter.Bot.Settings, app: Application) throws {
        self.bot = try .init(settings: settings)
        self.dispatcher = .init(bot: bot, app: app)
        self.updater = .init(bot: bot, dispatcher: dispatcher)
    }
} To subscribe to text messages from the user, you can refer to the : dispatcher dispatcher.add(handler: Botter.MessageHandler(filters: .all, callback: handleMessage)) And in the method, you can specify the return of the just-received message like this: handleMessage func handleMessage(_ update: Botter.Update, context: Botter.BotContextProtocol) throws {
    guard case let .message(message) = update.content else { return }

    guard let params = Botter.Bot.SendMessageParams(to: message, text: message.text) else { return }

    try bot.sendMessage(params, platform: message.platform.any, context: context)
} In the same way, you have the ability to receive other types of updates, such as receiving an image or clicking on a button sent earlier. 👷‍♂️ Configuring Your Bot To get your chatbot up and running, you'll need to specify platform-specific settings, such as the port and URL where the chatbot will be accessible, authorization keys, and so on. You can specify these in the file as follows: configure private func configureEchoBotter(_ app: Application) throws {
    let botterSettings = Botter.Bot.Settings(
        tg: tgSettings(app)
    )
    let bot = try EchoBot(settings: botterSettings, app: app)
}

func tgSettings(_ app: Application) -> Telegrammer.Bot.Settings {
    var tgSettings = Telegrammer.Bot.Settings(token: ””, debugMode: !app.environment.isRelease)
    tgSettings.webhooksConfig = .init(ip: "0.0.0.0", baseUrl: “”, port: 123)
    return tgSettings
} Each platform requires its own settings for chatbots to work. For instance, in the case of Telegram, you'll need a token, a URL, and a port for the chatbot. To get a token, you'll need to follow the steps in the official . You'll also need to set up your server to be accessible on the internet. This can be done using numerous services, such as . guide http://localhost.run/ Once all the parameters are specified, don't forget to call the bot configuration method in the body of the method: configure try configureEchoBotter(app) And start receiving updates from the platform: try bot.updater.startWebhooks(vkServerName: Constants.vkServerName).wait() If everything is specified correctly, upon launch, the chatbot should function and duplicate messages. For your convenience, I've uploaded the above example to a repository: https://github.com/CoolONEOfficial/echobot ⚙️ Advanced Bot Logic Examples Now that we've covered the basics let's delve into some more complex bot logic that you might find useful. 📝 Editing Sent Messages You can edit a message that has just been sent using the method as follows: editMessage try bot.sendMessage(params, platform: message.platform.any, context: context).map(\.first).optionalFlatMap { message in
    try! self.bot.editMessage(message, params: .init(message: "Other text"), app: self.app)!
} 🖼️ Attaching Images to Messages You can attach an image to a message by adding the parameter with an array of attachments. This can be media content or documents. Here's an example: attachments Botter.Bot.SendMessageParams(to: message, text: message.text, attachments: [ .init(type: .photo, content: .url("")) ]) 🔘 Adding Buttons to Messages You can add buttons to a message using the parameter: keyboard Botter.Bot.SendMessageParams(to: message, text: message.text, keyboard: [ [ Button(text: "Tap me", payload: "some data") ] ]) To handle button clicks, you should process them in the method, where the button's payload can be found in the parameter. handleMessage update ☁️ Deploying Your Bot In the previous steps, we managed to get the chatbot running locally, but where can you host it for continuous use? The good news is that the project supports both macOS and Linux, so you can take advantage of numerous PaaS services. You could start with Heroku or its alternatives, although due to port restrictions, you'll need to launch separate instances of the chatbot for each platform. However, a better solution for me was a dedicated macOS server from MacStadium, which doesn't impose such restrictions. 📚 Resources You can find even more examples of Botter in use in my , which utilizes all the capabilities of the framework. PhotoBot project If you're interested in delving deeper into the foundation of Botter-Vapor, I recommend the following resources: Official Vapor docs Server Side Swift with Vapor book Awesome Vapor 🏁 Conclusion We've walked through the steps of setting up and configuring a chatbot using the Botter framework and even touched on some advanced features. But this is just the beginning. The real magic happens when you start to experiment, innovate, and build something that's uniquely yours. Remember, every great chatbot started with a single line of code. And with Botter, you have a powerful tool at your fingertips that can make your chatbot dreams a reality. Whether you're looking to build a simple bot for fun or a sophisticated one for your business, Botter provides the flexibility and functionality you need. So why wait? The world of chatbots is at your fingertips. Dive in, start coding, and see where your creativity takes you. Your first chatbot could be just a few lines of code away. Your Chatbot Journey Begins Now! Happy coding, and remember - the only limit is your imagination! 🌈 Also published . here

Swiftly Starting Your Chatbot Journey: Building a Chatbot with Botter

With the release of iOS 17, introduces an exciting enhancement to that revolutionizes how we add markers on maps. With the new SwiftUI in iOS 17, you can easily customize markers to match your app's aesthetic and branding, allowing seamless integration with your overall user interface. Apple SwiftUI This article describes how to add and style map markers in iOS 17 with SwiftUI. Keep in mind that this is still in beta and can change. Add map markers In iOS 17, SwiftUI offers developers a range of versatile methods to add map markers. Let's check them out. The default way The default and most straightforward way to add a marker on the map in iOS 17 with SwiftUI is by passing a title and coordinate. With just these two essential pieces of information, developers can quickly create a marker that identifies a specific location on the map. Marker("Latvian Freedom Monument", coordinate: .marker) Showing with a custom image We can seamlessly place a marker on the map using a custom SVG image directly from the assets catalog. This enhanced functionality provides a convenient and organized approach to utilizing custom SVG images as map markers. Leveraging custom SVG images from the assets catalog empowers developers to create visually appealing and personalized map markers that effortlessly integrate with their app's overall design language, enabling a more cohesive and immersive user experience. Marker("Latvian Freedom Monument", image: "monument", coordinate: .marker) Using SF symbols SwiftUI on iOS 17 enables placing a marker on the map by leveraging the built-in SF Symbols library. SF Symbols provides a vast collection of scalable and customizable icons seamlessly integrating with Apple's user interface guidelines. No external image assets are needed, so we can easily access and incorporate many visually consistent and recognizable icons, such as pins, landmarks, or directional arrows. Marker("Latvian Freedom Monument", systemImage: "signpost.left.fill", coordinate: .marker) Using text monogram In iOS 17 with SwiftUI, an intriguing option to place a marker on the map is by utilizing monogram text. This approach allows developers to create visually appealing and personalized markers using a maximum of three characters. Marker("Latvian Freedom Monument", monogram: "LV", coordinate: .marker) Custom label The SwiftUI Label view approach allows developers to design and customize markers with rich textual information and accompanying icons or images. By leveraging the Label view, developers can easily combine a text element and an optional image or icon, allowing the creation of markers. Marker(coordinate: .marker) {
  Label("Latvian Freedom Monument", image: .monument)
} Change marker color We have the flexibility to change the tint color of map markers, allowing enhanced customization and visual consistency within their apps. By modifying the tint color, developers can seamlessly integrate the markers with their app's overall color scheme, branding, or design language. With SwiftUI's declarative syntax, adjusting the tint color of map markers is straightforward. .tint(.yellow) TL;DR In iOS 17 with SwiftUI, developers have various options for adding markers on the map. We can pass a title and coordinate for a simple marker, utilize custom SVG images from the assets catalog for personalized markers, leverage built-in SF Symbols for standardized and customizable markers, use monogram text for elegant and compact markers, or employ custom labels for markers with rich textual information. Additionally, developers can style the markers' tint color, ensuring visual consistency and app customization. These features empower developers to create visually engaging and personalized map experiences seamlessly integrating with their app's design. Also published here. Links Sample code MapKit Marker documentation

SWIFT

goswift.in

-- employees

Since n.d.

COMPANY RANKING

SWIFT

EVERGREEN INDEX #10569

Representing this company? Click here to claim and customize this page!

Swift WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!

SWIFT

goswift.in

-- employees

Since n.d.

COMPANY RANKING

SWIFT

EVERGREEN INDEX #10569

RELATED COMPANIESRANK

STORIES ABOUT SWIFT

Representing this company? Click here to claim and customize this page!

Swift WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!