DEV Community: Vadim Atamanenko

The Future of Artificial Intelligence: Trends and Implications for Software Engineers

Vadim Atamanenko — Tue, 07 Mar 2023 19:00:00 +0000

Artificial Intelligence (AI) is one of the fastest growing fields in computer science and software engineering. It has the potential to transform numerous industries by automating processes, making predictions, and providing insights. AI is also a rapidly evolving field, with new trends and technologies emerging regularly. In this article, we will explore some of the current and future trends in AI, their implications for software engineers, and some of the leading experts in the field.

Current Trends in AI:

Natural Language Processing (NLP): NLP is a subfield of AI that deals with the interaction between computers and human language. NLP has become increasingly important in recent years with the growth of chatbots, voice assistants, and automated content creation.
Deep Learning: Deep learning is a subset of machine learning that involves the use of neural networks with multiple layers. This technology is particularly useful for tasks that involve large amounts of data, such as image and speech recognition.
Robotics: Robotics involves the use of robots to perform tasks that are typically performed by humans. AI is crucial for robotics because it allows robots to adapt to their environment and perform complex tasks.
Explainable AI: Explainable AI (XAI) is a field that seeks to make AI more transparent and understandable. XAI is important for applications such as healthcare, where it is essential to understand how decisions are made.

Implications for Software Engineers:

The growth of AI has significant implications for software engineers. Software engineers will need to be familiar with AI technologies and be able to integrate them into their applications. They will also need to understand the ethical and societal implications of AI, such as bias and privacy concerns.

Top 5 Leading AI Experts:

Yoshua Bengio: Bengio is a computer scientist and AI expert who is known for his work on deep learning. He is one of the pioneers of deep learning and has received numerous awards for his contributions to the field.
Fei-Fei Li: Li is a computer scientist and AI expert who is known for her work on computer vision. She is the founder of AI4ALL, a nonprofit organization that seeks to increase diversity and inclusion in AI.
Andrew Ng: Ng is a computer scientist and AI expert who is known for his work on deep learning and online education. He is the founder of Coursera, an online learning platform that offers courses in AI and other fields.
Yann LeCun: LeCun is a computer scientist and AI expert who is known for his work on convolutional neural networks (CNNs). He is the director of AI research at Facebook and has received numerous awards for his contributions to the field.
Demis Hassabis: Hassabis is a computer scientist and AI expert who is known for his work on reinforcement learning. He is the founder and CEO of DeepMind, a company that develops AI technologies for a variety of applications, including healthcare and gaming.

Conclusion:

AI is a rapidly evolving field with numerous applications and implications for software engineers. As AI continues to grow and evolve, software engineers will need to keep up with the latest trends and technologies to remain competitive in the job market. By staying informed and continuing to learn, software engineers can take advantage of the many opportunities that AI has to offer.

10 Must-Have Tools for Swift iOS Development: Boost Your Productivity Today

Vadim Atamanenko — Tue, 07 Feb 2023 08:15:32 +0000

As an iOS developer, having the right tools can greatly enhance your productivity and the quality of your work. With the increasing popularity of Swift, a programming language developed by Apple, there has been a surge of tools specifically designed for iOS development. In this article, we will be discussing the top 10 tools for iOS developers using Swift, including their technical details and a simple explanation to help you understand their purpose and usage. Whether you're a seasoned iOS developer or just starting out, these tools are sure to make your development process smoother and more efficient. So without further ado, let's dive in!

Here are the top 10 tools for iOS developers using Swift:

Xcode

The official integrated development environment (IDE) for iOS, macOS, tvOS, and watchOS development.

CocoaPods - A dependency manager for Swift and Objective-C Cocoa projects.

Alamofire - An HTTP networking library written in Swift.

Realm - An open-source object database management system for mobile devices.

SwiftLint - A tool for maintaining a consistent coding style in Swift projects.

Sketch - A digital design tool for user interface and user experience design.

Fastlane - A continuous delivery platform for iOS and Android apps.

Fabric - A mobile platform with modular kits for crash reporting, analytics, and beta testing.

GitHub - A web-based hosting service for version control repositories.

Stack Overflow - A question-and-answer community for programmers to share their knowledge and learn from each other.

These tools are some of the most widely used by iOS developers and can greatly enhance your development process. Whether you're working on a small personal project or a large enterprise application, these tools can help you get the job done more efficiently and effectively.

Environment Objects & SwiftUI Styles

Vadim Atamanenko — Mon, 26 Dec 2022 09:46:43 +0000

SwiftUI environments and styles are the two pillars of Apple's official framework (declarative structure). Despite this, when SwiftUI was first launched, using them together resulted in a guaranteed application crash.

In particular, the crash happened when we used @EnvironmentObject inside our style definition: when is it safe to use them together? Let's find out.

Example

Meet FSStyle, a button style that expects an environment object FSEnvironmentObject:

class FSEnvironmentObject: ObservableObject {
  @Published var title = "tap me"
}

struct FSStyle: ButtonStyle {
  @EnvironmentObject var object: FSEnvironmentObject

  func makeBody(configuration: Configuration) -> some View {
    Button(object.title) { }
  }
}

Based on the definition, we expect everything to work as long as we inject the environment object at some point before applying the style. For example:

struct ContentView: View {
  @StateObject var object = FSEnvironmentObject()

  var body: some View {
    Button("tap me") {
    }
    .buttonStyle(FSStyle())
    .environmentObject(object)
  }
}

..and yet if we ran this code on any version of iOS prior to 14.5, it was guaranteed to fail 100% of the time with a Fatal error: No ObservableObject of type FSEnvironmentObject found..

It fails as soon as an environment object is used inside the makeBody(configuration: ) method, and both the definition of the object and the execution of makeBody(configuration: ) are irrelevant.

There are two main ways to work around the bug: either style it to match DynamicProperty(many thanks to Lin Qing Mo for the tip!), or return a View in the makeBody (configuration: ) method and have that View read the environment object.

Now that we have seen what the problem is, let's find out in which iOS versions and styles this error occurs.

Test setup

We want to find out which versions of iOS are safe to use all possible styles (not just button styles). We can create a small test app and run it on all versions of iOS that support SwiftUI and get results.

Continuing with the ButtonStyleexample, here is the complete application:

import UIKit
import SwiftUI

@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate { }

class SceneDelegate: UIResponder, UIWindowSceneDelegate {
  var window: UIWindow?
  var object: FSEnvironmentObject = FSEnvironmentObject()

  func scene(
    _ scene: UIScene, 
    willConnectTo session: UISceneSession, 
    options connectionOptions: UIScene.ConnectionOptions
  ) {
    if let windowScene = scene as? UIWindowScene {
      let window = UIWindow(windowScene: windowScene)
      let contentView = ContentView().environmentObject(object)
      window.rootViewController = UIHostingController(rootView: contentView)
      self.window = window
      window.makeKeyAndVisible()
    }
  }
}

struct ContentView: View {
  var body: some View {
    Button("tap me") {
    }
    .buttonStyle(FSStyle())
  }
}

struct FSStyle: ButtonStyle {
  @EnvironmentObject var object: FSEnvironmentObject

  func makeBody(configuration: Configuration) -> some View {
    Button(object.title) { }
  }
}

class FSEnvironmentObject: ObservableObject {
  @Published var title = "tap me"
}

The application consists of a single screen that contains our test component/style.

A few notes:

we're using the UIKit lifecycle because we want to run tests on iOS 13 as well
we don't use @StateObject on the environment object because this property wrapper is only for iOS 14+
the only difference between testing ButtonStyle and other styles is defining the FSStyle and ContentView body, everything else remains the same

CI/CD setup

We will be testing twelve versions of iOS, from iOS 13.0 to iOS 14.5, and all eight styles that support customization.

Testing each combination by hand would be quite difficult, instead we can let the CI/CD provider do all the hard work for us. Any CI/CD setup will do, here's how the different versions of Xcode/iOS were distributed for this study:

macOS 10.14
iOS 13.0, Xcode 11.0
iOS 13.1, Xcode 11.1
iOS 13.2, Xcode 11.2
macOS 10.15
iOS 13.3, Xcode 11.3.1
iOS 13.4, Xcode 11.4.1
iOS 13.5, Xcode 11.5
iOS 13.6, Xcode 11.6
iOS 13.7, Xcode 11.7
iOS 14.0, Xcode 12.0.1
iOS 14.1, Xcode 12.1
iOS 14.2, Xcode 12.2
iOS 14.3, Xcode 12.3
macOS 11.4:
iOS 14.4, Xcode 12.4
iOS 14.5, Xcode 12.5

Results

Since the test application has only one screen that immediately displays the component under test, all that is needed to pass the test is to launch the application and not immediately crash. Here is the result:

💥 = crash, ✅ = passed. *Style available since iOS 14.

Let's summarize:

all styles except ButtonStylesupport @EnvironmentObject as of iOS 14.0
since iOS 14.5 all styles including ButtonStylesupport @EnvironmentObject

Conclusions

The reason why styles + @EnvironmentObject was not supported from the start is likely to remain inside the SwiftUI command, however this could have been intentional:

Looking at how standard SwiftUI styles are applied, in addition to the few parameters passed through Configuration, most of the mutable components come from EnvironmentValues, such as @Environment (\.IsEnabled), @Environment (\.font) and @Environment (\.controlProminence).

Unlike @EnvironmentObject, EnvironmentValues has been supported (no crash!) since iOS 13.0, so I recommend them when adding dynamics to our custom styles.

Whether this was a mistake or intentional, as an SDK vendor, it's important for us to disambiguate and clarify such scenarios for developers.

To the best of my knowledge, this has not been documented anywhere and has not been covered in any release notes: if the developers have allowed it, it is in the framework.

Another place where this could be a problem is in View modifiers, however both EnvironmentValues and @EnvironmentObject are supported (without the 💥) from iOS 13.0.

Localized Error Meanings in Swift Practice

Vadim Atamanenko — Sat, 17 Dec 2022 05:14:25 +0000

How many times have we looked at this code:

do {
  try writeEverythingToDisk()
} catch let error {
  // ???
}

or this one:

switch result {
case .failure(let error):
  // ???
}

and asked themselves the question:

“How can I extract information from this error?”

The problem is that the error probably contains a lot of information that could help us. But obtaining this information is often not easy.

To understand the reason for this, let's look at the ways we have at our disposal to attach information to errors.

New: LocalizedError

In Swift, we pass errors according to the Error protocol. The LocalizedError protocol inherits it, extending it with some useful properties:

errorDescription
failureReason
recoverySuggestion

Compliance with the LocalizedError protocol instead of the Error protocol (and ensuring that these new properties are implemented) allows us to augment our error with a lot of useful information that can be passed at runtime (the NSHipster weblog covers this in more detail):

enum MyError: LocalizedError {
  case badReference

  var errorDescription: String? {
    switch self {
    case .badReference:
      return "The reference was bad."
    }
  }

  var failureReason: String? {
    switch self {
    case .badReference:
      return "Bad Reference"
    }
  }

  var recoverySuggestion: String? {
    switch self {
    case .badReference:
      return "Try using a good one."
    }
  }
}

Old: userInfo

The well-known NSError class contains a property - a userInfo dictionary, which we can fill with whatever we want. But also, this dictionary contains several predefined keys:

NSLocalizedDescriptionKey
NSLocalizedFailureReasonErrorKey
NSLocalizedRecoverySuggestionErrorKey

You may notice that their names are very similar to the LocalizedError properties. And, in fact, they play a similar role:

let info = [ 
  NSLocalizedDescriptionKey:
    "The reference was bad.",
  NSLocalizedFailureReasonErrorKey:
    "Bad Reference",
  NSLocalizedRecoverySuggestionErrorKey:
    "Try using a good one."
]

let badReferenceNSError = NSError(
  domain: "ReferenceDomain", 
  code: 42, 
  userInfo: info
)

It looks like LocalizedError and NSError should be basically the same, right? Well, therein lies the main problem.

Old meets new

The point is that the NSError class conforms to the Error protocol, but not to the LocalizedError protocol. In other words:

badReferenceNSError is NSError        //> true
badReferenceNSError is Error          //> true
badReferenceNSError is LocalizedError //> false

This means that if we try to extract information from any arbitrary error in the usual way, it will only work properly for Error and LocalizedError, but for NSError, only the value of the localizedDescription property will be reflected:

// The obvious way that doesn’t work:
func log(error: Error) {
  print(error.localizedDescription)
  if let localized = error as? LocalizedError {
    print(localized.failureReason)
    print(localized.recoverySuggestion)
  }
}

log(error: MyError.badReference)
//> The reference was bad.
//> Bad Reference
//> Try using a good one.

log(error: badReferenceNSError)
//> The reference was bad.

This is rather annoying, because our NSError class object is known to contain information about the cause of the failure and a suggestion for correcting the error, registered in its userInfo dictionary. And this, for some reason, is not shown through the LocalizedError match.

New becomes old

At this point, we can get frustrated by mentally imagining a lot of switch statements trying to sort by type and by the presence of various properties in the userInfo dictionary. But don't be afraid! There is an easy solution. It's just not very obvious.

Note that the NSError class defines convenience methods for retrieving the localized description, failure reason, and recovery suggestion in the userInfo property:

badReferenceNSError.localizedDescription
//> "The reference was bad."

badReferenceNSError.localizedFailureReason
//> "Bad Reference"

badReferenceNSError.localizedRecoverySuggestion
//> "Try using a good one."

They are great for handling NSError, but they don't help us extract those values from LocalizedError...or is it?

It turns out that the Swift Error language protocol is connected by the compiler to the NSError class. This means we can turn an Error into an NSError with a simple cast:

let bridgedError: NSError
bridgedError = MyError.badReference as NSError

But what's even more impressive is that when we cast a LocalizedError this way, the bridge works properly and wires up localizedDescription, localizedFailureReason, and localizedRecoverySuggestion, pointing to the appropriate values!

So if we want a consistent interface to extract localized information from Error, LocalizedError, and NSError, we just need to cast everything to NSError without hesitation:

func log(error: Error) {
  let bridge = error as NSError
  print(bridge.localizedDescription)
  print(bridge.localizedFailureReason)
  print(bridge.localizedRecoverySuggestion)
}

log(error: MyError.badReference)
//> The reference was bad.
//> Bad Reference
//> Try using a good one.

log(error: badReferenceNSError)
//> The reference was bad.
//> Bad Reference
//> Try using a good one.

✌️

Info.plist missing in XCode 13

Vadim Atamanenko — Sun, 11 Dec 2022 11:15:26 +0000

When you create a new SwiftUI project in Xcode 13, you may find that it does not have an Info.plist file. Why is this happening?

Xcode 13 Project Templates

First of all, this change only affects projects created in Xcode 13. If you open a project created in Xcode 12 or earlier with Xcode 13, this will not affect Info.plist.

Project Storyboard

Creating a new iOS project using Storyboard in Xcode 13 will also create an Info.plist:

If we click on info.plist to see the contents, you'll notice that this file is somewhat unusual:

It only has some default settings for the Application Scene Manifest where multi-windows are disabled. But where are the rest of the settings?

SwiftUI Project

The change will be more noticeable if you create a new SwiftUI project. You will notice that there will be no Info.plist file in the project navigator (or on disk) at all:

Also note that the SwiftUI template no longer uses the start screen storyboard.

What is going on here?

As far as I know, this was not mentioned at WWDC21 and the only documentation on this seems to be the Xcode 13 release notes.

Projects based on multiple templates no longer require configuration files such as permissions and Info.plist files. Set up common fields in the info tab of the target and create parameters in the project editor. These files are added to the project when using additional fields. (68254857)

The idea seems to be to create a complete Info.plist for the target at project build time, and create the project's Info.plist file only for changes you make other than the defaults.

Changing information settings

Some Xcode templates, such as the SwiftUI template, do not create an Info.plist in the source project. You can still make changes using the Info tab for target settings:

After the changes are made, Xcode adds an Info.plist file to the project and it appears in the project navigator. For example, if I add some App Transport Security options in the Info tab:

Xcode creates an Info.plist file containing just these App Transport settings:

We can then change the setting anywhere, and in theory Xcode keeps the two sets of settings in sync.

I say theoretically, because in practice problems can arise. For example, if I edit the Info settings in the project navigator, Xcode does not update the settings in the Info tab for the target to reflect the changes I made. I need to close and reopen the project for it to update. Let's hope this is a beta bug that will be fixed before the final release (FB9397345).

Build Settings

To add to the confusion, there are also some Info.plist settings that only show up in the build settings for the target. Basically these are the settings you change on the General tab for the target, such as supported orientations and launch screen:

You can change these options on the General tab, Info tab, or Build Settings (but they don't appear in the Info.plist file you see in the project navigator).

The Packaging section of the build settings allows you to disable Xcode's creation of the Info.plist file (more on this in a moment):

Backward compatibility

The Xcode 13 project format is not backward compatible with Xcode 12. If you create a project in Xcode 13, you cannot open it with Xcode 12. Apple mentions this in the release notes:

New projects created with Xcode 13 use the new version of the project. Using new projects with an older version of Xcode requires changing the project version in the file inspector, as well as manually migrating the configuration options for Info.plistand the permissions you can now specify in the target's build options. (77344653)

To make a project compatible with Xcode 12, change the project format in the Xcode File Inspector:

You also need to manually revert to the non-Xcode generated Info.plist file, otherwise you will lose your settings when you create the project with Xcode 12. Copying each setting manually from the Info tab is labor intensive. You may find it easier to start with the default Info.plist created in Xcode 12 and add any changes to it.

Finally, in Xcode 13, disable the creation of the Info.plist file in the build settings:

Use Async / Await in SwiftUI

Vadim Atamanenko — Mon, 05 Dec 2022 16:33:31 +0000

Convert your SwiftUI app to take advantage of Swift's new multithreading mechanism and see what's going on underneath the colorful shell.

Software version
Swift 5.5, iOS 15, Xcode 13

Swift 5.5 has a bright new threading framework to help you write safe code faster. To help everyone get started, Apple provided a bunch of videos and code examples at WWDC 2021. There is a summary of what they cover at the end of this tutorial.

Twitter has exploded, and the usual actors (actors - this concept will be discussed later in the article) have already published several instructions. This tutorial is similar to the micro version of Swift concurrency: Update a sample app from WWDC. You'll take small steps to transform a much simpler application to learn how async/await and actors help you write safer code. To help you decipher Xcode error messages and protect you from inevitable future API changes, you'll learn what's going on under the bright surface.

The note
You will need Xcode 13. This tutorial was written using beta 1. If you want to run it on an iOS device, Xcode 13 must be running iOS 15 beta. For your Mac, Big Sur will do. If you have a Mac [partition] running the Monterey beta, you can try running your code there if it doesn't work in Big Sur. You should be comfortable using SwiftUI, Swift, and Xcode to develop iOS apps.

Let's get started

Create a new Xcode project using the SwiftUI interface and name it WaitForIt.

In ContentView.swift, replace the body content with this code:

AsyncImage(url: URL(string: "https://files.betamax.raywenderlich.com/attachments/collections/194/e12e2e16-8e69-432c-9956-b0e40eb76660.png")) { image in
  image.resizable()
} placeholder: {
  Color.red
}
.frame(width: 128, height: 128)

In Xcode 13 beta 1 you get this error:

Do not click any of the Fix **buttons! Go to the landing page and change the **Deployment Info from iOS 14.0 to iOS 15.0:

Return to ContentView.swift. If the error message is still present, press Command-B to build the project.

Launch Live Preview to see the image for the video “SwiftUI vs. UIKit”:

Okay, this was just a quick check to fix this Xcode crash and also show you the new SwiftUI AsyncImage view. Okay, right?

Before you get started on a real WaitForIt application, take a close look at how Swift's new threading fixes problems with the old GCD threading.

Old and new multithreading

The old GCD threading has several problems that make it difficult to write applications that use threading safely.

Multithreading Swift provides the necessary tools to split work into smaller tasks that can run concurrently. This allows tasks to wait for each other to complete and allows you to efficiently manage the overall progress of a task.

Pyramid of Doom (Pyramid of Doom)

Swift APIs like URLSession are asynchronous. Methods are automatically dispatched to a background queue and immediately return control to the calling code. The methods take a completion handler and call delegate methods. Finalization or delegation code that accesses UI elements must be sent to the main queue.

If a completion handler calls another asynchronous function, and that function has a completion handler, it's hard to see the exit in the resulting pyramid of doom. This makes it difficult to check the correctness of the code. For example, this code example from Meet async/await in Swift at WWDC loads data, creates an image from the data, and then displays a thumbnail of the image. Error handling is special because completion handlers cannot throw errors.

func fetchThumbnail(
  for id: String,
  completion: @escaping (UIImage?, Error?) -> Void
) {
  let request = thumbnailURLRequest(for: id)
  let task = URLSession.shared
    .dataTask(with: request) { data, response, error in
    if let error = error {
      completion(nil, error)
    } else if (response as? HTTPURLResponse)?.statusCode != 200 {
      completion(nil, FetchError.badID)
    } else {
      guard let image = UIImage(data: data!) else {
        completion(nil, FetchError.badImage)
        return
      }
      image.prepareThumbnail(of: CGSize(width: 40, height: 40)) { thumbnail in
        guard let thumbnail = thumbnail else {
          completion(nil, FetchError.badImage)
          return
        }
        completion(thumbnail, nil)
      }
    }
  }
  task.resume()
}

The sequence of operations is much easier to see with async/await, and you can take advantage of Swift's robust error handling mechanism:

func fetchThumbnail(for id: String) async throws -> UIImage {
  let request = thumbnailURLRequest(for: id)
  let (data, response) = try await URLSession.shared.data(for: request)
  guard (response as? HTTPURLResponse)?.statusCode == 200 else {
    throw FetchError.badID
  }
  let maybeImage = UIImage(data: data)
  guard let thumbnail = await maybeImage?.thumbnail else {
    throw FetchError.badImage
  }
  return thumbnail
}

Data Races

When multiple tasks can read or write object data, data races are possible. A data race occurs when one task pauses while another task writes and exits, then the sleeping task resumes and overwrites what was written by the previous task. This creates inconsistent results.

In an app using legacy multithreading, Xcode can detect data races if you enable the Thread Sanitizer runtime diagnostic in your app's Runscheme. You can then implement a sequential queue to prevent concurrent access.

Swift's new multithreading model provides the Actor protocol to prevent concurrent access to object data. Subjects also allow you to structure your application into code that runs on the main thread and code that runs on background threads, so the compiler can help you prevent concurrent access.

Thread Explosion/Starvation (stream explosion/starvation)

In GCD, the basic unit of work is the thread. If your code queues a lot of read/write tasks, most of them should sleep while they wait. This means that their threads are blocked, so the system creates more threads for the next tasks. If each task also puts a completion handler on a different queue, this creates even more threads. Each blocked thread holds the stack and kernel data structures so that it can be resumed. A blocked thread may be holding resources that another thread needs, so the thread is blocked.

This is an explosion of threads: the system is overloaded with many times more threads than there are cores to process them. The scheduler has to allocate time to hundreds of threads, which results in a lot of context switches. All this slows down your application and may even starve some threads so they never run.

Tasks and continuations

In Swift multithreading, the basic unit of work is the task. A task executes tasks sequentially. To achieve multithreading, a task can create child tasks. Or you can create tasks in a task group.

The system knows that these tasks are related, so it can manage due dates, priority, and cancellation flags for all tasks in a task tree or group. This makes it easier to check for and respond to cancellation status, thus avoiding issue leaks. If it is important to respond immediately to cancellation, you can write a function with a cancellation handler.

If a task is suspended, it releases its thread and saves its state in the continuation. Threads switch between continuations instead of context switching.

Threads switch between continuations.

The note
This image is taken from the WWDC session of Swift concurrency: Behind the scenes
The awaitkeyword marks the point of suspension, and the async frame on the heap stores the information it needs when it resumes.

Ideally, the number of threads never exceeds the number of cores. There is a shared pool of threads and a runtime contract whereby each thread will do its job. Your code maintains this contract by using await, actors, and task groups to make dependencies visible to the compiler.

Joke Service

Enough theory! It's time to convert simple loading to using async/await.

The starter folder contains JokeService.swift. Add this file to WaitForIt.

JokeService is an ObservableObjectthat sends a request to an API that returns a random Chuck Norris joke. I adapted this code from the sample application in Combine: Asynchronous Programming with Swift. The request element specifies the category of developers, so all the jokes have a technical flavor. Warning: Some of these jokes are a little cruel.

The JokeServicepublishes the joke and its isFetchingstatus. Its fetchJoke() method uses the standard URLSession.shared.dataTask with a completion handler. If something goes wrong, it prints an error message with either a dataTaskerror or an "Unknown error". In the case of "Unknown error", it does not provide information on whether the problem was in the data or in the decoder.

Minimal error handling

Reliable error handling is one of the main reasons for using async/await. The data task completion handler cannot throw errors, so if it calls a generating function such as JSONDecoder().decode(_:from:), it must handle any errors that are thrown.

Usually they take the easy way out and just ignore the error. This is what the starter file does:

if let decodedResponse = try? JSONDecoder().decode(Joke.self, from: data)

Previous versions of Xcode offer this as a fix if you just write try and don't wrap it in do/catch. This means: just assign nilif the function throws an error.

Delete ? to see what's going on:

Xcode is now taking a tougher stance: no more helpful suggestions for simple fixes.

But ? still works here so bring it back.

Show me a joke!

To get the joke, open ContentView.swift and replace the content of the ContentViewwith this:

@StateObject var jokeService = JokeService()

var body: some View {
  ZStack {
    Text(jokeService.joke)
      .multilineTextAlignment(.center)
      .padding(.horizontal)
    VStack {
      Spacer()
      Button { jokeService.fetchJoke() } label: {
        Text("Fetch a joke")
          .padding(.bottom)
          .opacity(jokeService.isFetching ? 0 : 1)
          .overlay {
            if jokeService.isFetching { ProgressView() }
          }
      }
    }
  }
}

Launch Live Preview and click the button. This has a nice effect with opacity and ProgressView() to indicate that a fetch is in progress.

Concurrent Binding (parallel binding)

Okay, the old way works, so now you're going to convert it to the new one.

Comment out URLSession up to and including .resume().

Add this code below isFetching = true

async let (data, response) = URLSession.shared.data(from: url)

The new data(from:) URLSession method is asynchronous, so you use async let to assign the return value to the (data, response) tuple. These are the same dataand responsethat dataTask(with:) provides to its completion handler, but data(from:) returns them directly to the calling function.

Where is the error that dataTask(with:) throws? You'll find out soon - stay tuned!

The following errors and suggested fixes appear:

The errors are similar: you can't call an async function within a synchronous function. You must tell the compiler that fetchJoke() is asynchronous.

Both fixes are the same, so click on either one. This gives you:

func fetchJoke() async {

Like throws, the asynckeyword appears between the closing brace and the opening curly brace. You will interrupt throwsagain soon.

Back to async let: this is one way to assign the result of data(from:) to the tuple (data, response). This is called concurrent binding because the parent task continues executing after the child task is created to run data(from:) on a different thread. The child task inherits the priority and local values of the parent task. When the parent task needs to use dataor response, it suspends itself (releases its thread) until the child task completes.

Parent and child tasks run at the same time.

async wait

The verb for asyncis await, just like the verb for throwsis try. You try the throwing function and wait for the async function.

Add this line of code:

await (data, response)

And there's a missing error here that dataTask(with:) passes to its completion handler: data(from:) throws it. So, you should use try await:

try! await (data, response)

The note
The keywords must be in that order, *not *await try.

You're not really going to use this code, so don't bother catching bugs. It's just a chance to see what's going on.

What is happening is amazing:

An immutable value can only be initialized once.

This is surprising because the Explore structured concurrency in Swift video says, “And don't worry. Reading the result value again will not recalculate its value."

The note
Looks like it's a tuple error. You can wait for data or a response, but not both.

Go ahead and accept the suggested fix to change letto var:

Hm! Think back to your early days learning Swift, when Xcode kept saying, "You can't do that here." Maybe it's a beta bug. It doesn't matter in this case, because between calling data(from:) and processing what it returns, there is no other code to execute.

Sequential Binding (serial binding)

Instead, you will use another binding: sequential binding.

Replace two lines with this piece of code:

let (data, response) = try? await URLSession.shared.data(from: url)

Unlike async let, calling data(from:) in this way does not create a child task. It is executed sequentially as a job in the fetchJoke() task. While it waits for a response from the server, this job suspends itself, releasing the task thread.

The data(from:) tasks are suspended.

But there's a problem:

Xcode refuses to understand try? here.

You'll try the lazy way, but this time it won't work in Xcode, even if you use nil union to specify a nil tuple:

let (data, response) = 
  try? await URLSession.shared.data(from: url) ?? (nil, nil)

No, you have to do the right thing. First, remove the ? and ?? (nil, nil):

let (data, response) = try await URLSession.shared.data(from: url)

Error handling options

You have two options for handling errors caused by data(from:). The first is to bite the bullet and deal with it right away with do/catch:

do {
  let (data, response) = try await URLSession.shared.data(from: url)
} catch {
  print(error.localizedDescription)
}

An easier(?) option is to make fetchJoke() throw:

func fetchJoke() async throws {

These keywords must be in the order listed - throws async does not work:

asyncmust come before throws.

Now fetchJoke() simply propagates the error to everyone who calls fetchJoke(). This is the button in the ContentView, where Xcode is already complaining about fetchJoke() being asynchronous:

fetchJoke() is asyncand returns: Do something!

So what's now? You cannot mark anything in a ContentViewas async.

Create an unstructured task

Luckily, you can create an asynchronous task in a button action. Replace Button { jokeService.fetchJoke() } label: { with this piece of code:

Button {
  async {
    try? await jokeService.fetchJoke()
  }
} label: {

You create an asynchronous task with async { }. Since it is asynchronous, you need to wait for it to complete. Because it throws, you should try to catch any errors. Xcode allows you to use try? here, or you can write a do/catch statement.

The note
The syntax for creating a task will change to Task { ... } in a future beta release.

This is an unstructured task because it is not part of the task tree. The async let task that you created in fetchJokes() is a child task of the task that fetchJokes() runs on. A child task is bound to the scope of its parent task: the fetchJokes() task cannot complete until its child tasks have completed.

An unstructured task inherits the actor, priority, and local values of its origin, but is not limited in scope. Canceling the original task does not signal an unstructured task, and the original task can be completed even if the raw task is not completed.

Creating an unstructured task in a non-async context looks just like DispatchQueue.global().async, only with less input. But there is a big difference: it runs on the MainActorthread with userInteractivepriority when the main thread is not blocked.

You can specify a lower priority with asyncDetached:

Specify a priority for an individual task.

But it will still run on the main thread. More on this later.

Joke decoding

Return to JokeService.swift to finish writing fetchJoke(). If you thought throwing was the easier option, let's see what you think after this section.

Since fetchJoke() throws, it passes on any error thrown by data(from:) to the calling function. You can also take advantage of this mechanism and throw other errors that may occur.

Errors thrown by the calling function must comply with the Errorprotocol, so add this code above the JokeServiceextension:

enum DownloadError: Error {
  case statusNotOk
  case decoderError
}

You are creating an enumeration of the possible errors that fetchJoke() might throw.

Then add this piece of code to fetchJoke():

guard 
  let httpResponse = response as? HTTPURLResponse,
  httpResponse.statusCode == 200   // 1
else {
  throw DownloadError.statusNotOk
}
guard let decodedResponse = try? JSONDecoder()
  .decode(Joke.self, from: data) // 2
else { throw DownloadError.decoderError }
joke = decodedResponse.value   // 3

Using guardallows you to pass your specific errors to the calling function.

You check the response status code and throw statusNotOkif it's not 200.
You decode the response and throw a decoderErrorif something goes wrong.
You assign the decoded jokevalue.

The note
You always have the option of catching an error, including those caused by data(from:), instead of throwing one.

Now where to set isFetchingto false? This Publishedvalue controls the button's ProgressView, so you want to set it even if fetchJoke()throws an error. Throwing an error causes fetchJokes() to exit, so you still need to set isFetchingin the defer statement before any possible early exit.

Add this line right below isFetching = true;

defer { isFetching = false }

MainActor

If Xcode has tweaked you a lot, you might feel a little uncomfortable. Publishedvalues update SwiftUI views, so you can't set Publishedvalues from a background thread. To set Publishedto isFetchingand joke, a dataTask(with:) completion handler is dispatched to the main queue. But your new code doesn't bother to do that. Will you get main thread errors when you run the application?

Try it. Build and run in the simulator. No, there are no mainstream errors. Why not?

Because you used async { } to create the fetchJoke() task in the button action, it's already running on the MainActorthread with UI priority.

Actor is a Swift multithreading mechanism that allows you to make an object thread-safe (thread-safe). Like Class, it is a named reference type. Its synchronization mechanism isolates its shared mutable state and does not guarantee concurrent access to that state.

MainActor is a special Actor that represents the main thread. You can think of this as just using DispatchQueue.main. All SwiftUI views run on the MainActorthread, just like the flat task you created.

To see this, place a breakpoint anywhere in fetchJoke(). Make a build and run, then click the button.

fetchJoke()runs on the main thread.

Yes, fetchJoke() runs on the main thread.

What if you lower the priority? In ContentView.swift in button action change async { to this:

asyncDetached(priority: .default) {

The note
The syntax for this parameter will change to Task.detached in a future beta release.

Build and run. Click on the button:

fetchJoke() is still running on the main thread.

You lowered the priority to the default, but this does not move the task to the background queue. The task is still running on the main thread!

The note
It looks like it's a coincidence. The video Explore structured concurrency in Swift says that a detached task doesn't inherit anything from its source, so it shouldn't inherit from the MainActor thread. A future beta release of Xcode may provide this.

Change the code back to async {.

To move asynchronous work from the main thread, you need to create an actorthat is not MainActor.

Actor

Actors allow you to structure your application into actors on background threads and actors on the main thread, just like you now create a model, view and view model files. The code in actor (lowercase, not MainActor) is running on a background thread. So you just need to move the async part of fetchJoke() to a separate actor.

In JokeService.swift, remove the breakpoint and add this piece of code above the JokeService:

private actor JokeServiceStore {
  private var loadedJoke = Joke(value: "")

  func load() async throws -> Joke {
  }
}

You create an actorwith a Jokevariable and initialize it to an empty string, then write a load() stub where you move your loading code. This method resets loadedJokeand also returns Joke, so you don't need the Joke property for this simple example, but you probably need it for more complex data.

Then create a JokeServiceStoreobject in the JokeService(in a class, not an extension):

private let store = JokeServiceStore()

Now move the urlcode from JokeServiceto JokeServiceStore:

private var url: URL {
  urlComponents.url!
}

private var urlComponents: URLComponents {
  var components = URLComponents()
  components.scheme = "https"
  components.host = "api.chucknorris.io"
  components.path = "/jokes/random"
  components.setQueryItems(with: ["category": "dev"])
  return components
}

Then move the loading code from fetchJoke() to load() leaving only two isFetchinglines in fetchJoke():

// move this code from fetchJoke() to load()
let (data, response) = try await URLSession.shared.data(from: url)
guard
  let httpResponse = response as? HTTPURLResponse,
  httpResponse.statusCode == 200
else {
  throw DownloadError.statusNotOk
}
guard let decodedResponse = try? JSONDecoder().decode(Joke.self, from: data)
else { throw DownloadError.decoderError }
joke = decodedResponse.value

JokeServiceStorehas a Jokeproperty, not a Stringproperty, so replace the last line with the following code:

loadedJoke = decodedResponse
return loadedJoke

Instead of retrieving just the value from the decodedResponse, you set the Jokeproperty and also return that Jokeinstance.

Now call load() in fetchJoke():

let loadedJoke = try await store.load()
joke = loadedJoke.value

Build and run.

A joke appears, but you have purple warnings:

Posting changes from background threads is not allowed.

Add a breakpoint inside load() and in fetchJoke() in isFetching = true, let loadedJoke = ... and joke = loadedJoke.value;

Setting breakpoints.

Click the button again, then watch the threads by clicking Continue program execution after each dot:

fetchJoke() runs on the main thread but goes to a background thread.

The first two lines of fetchJoke() are executed on the main thread because view is calling it. The load() is then run on a background thread, as it should be. But when execution returns to fetchJoke() it is still on a background thread. You need to do something to make it run on the main thread.

@MainActor

The code that sets the Publishedvalue must run on the MainActorthread. When fetchJoke() did all the work and you called it from a Button in an unstructured task, fetchJoke() inherited MainActorfrom Buttonand all of its code was running on the MainActorthread.

Now fetchJoke() calls load() which runs on a background thread. fetchJoke()still runs on the main thread, but when load() completes, fetchJoke() continues to run on the background thread.

fetchJoke() should not rely on MainActorbeing inherited from Button. You can mark a class or function with the @MainActor attribute to indicate that it should run on the MainActorthread.

The note
If you mark a class as @MainActor, any calls from outside MainActormust be await, even if it's a method call that exits immediately. A method that does not refer to any mutable state may drop the MainActorwith the nonisolatedkeyword.

Add this line above func fetchJoke() throws {

@MainActor

Compile and run again and hit breakpoints:

fetchJoke()runs on the main thread after load() completes.

The first three points are the same as before, but now fetchJoke()runs on the main thread after load() completes.

When fetchJoke() calls load() , it pauses, freeing up the main thread for UI tasks. When the download completes, fetchJoke() runs again on the main thread, where Publishedis allowed to be set.

Your work is done here! Try converting your own SwiftUI projects: take it slow, make small changes, and try to keep the app buildable after each change.

Optional: Asynchronous View Modifiers

SwiftUI now has (at least) two view modifiers that expect their action to call an async function.

Create a new SwiftUI View file named RefreshableView.swift and replace the contents of RefreshableView with the following:

@StateObject var jokeService = JokeService()

var body: some View {
  List {
    Text("Chuck Norris Joke")
      .font(.largeTitle)
      .listRowSeparator(.hidden)
    Text(jokeService.joke)
      .multilineTextAlignment(.center)
      .lineLimit(nil)
      .lineSpacing(5.0)
      .padding()
      .font(.title)
  }
  .task {
    try? await jokeService.fetchJoke()
  }
  .refreshable {
    try? await jokeService.fetchJoke()
  }
}

This view is a Listbecause refreshable(action:) only works on scrollable views.
The task modifier performs its action when the view appears. The type of its action parameter is action - @escaping() async -> Void. It creates a task to run the action so you don't need it.
The type of the actionparameter of the refreshablemodifier is the same. It must be asynchronous. When applied to a scrollable view, the user can drag down to refresh its content, and it displays a refresh indicator until the asynchronous task completes.

Launch Live Preview. The joke comes up:

The joke appears when the view is loaded.

The note
It's actually an O(N) complexity algorithm.

Pull down to get another joke. You may need to pull down quite far.

If you want to run this version in the simulator or device, open WaitForItApp.swift and change ContentView() to RefreshableView() in the WindowGroupclosure.

In this tutorial, you converted a simple SwiftUI app from the old GCD threading implementation to the new Swift threading implementation using async/await, unstructured task, actor, and @MainActor.

24 Quick Tips for Xcode

Vadim Atamanenko — Sun, 27 Nov 2022 10:46:14 +0000

XCode is a huge program, and if you can even use a couple of tricks to make your work more efficient, you can save a few hours every week. In this article, I want to introduce you to 24 Xcode tips that will help you code faster, create better tests, and navigate large projects more efficiently—I'm sure there's something for everyone!

1. Generation of class initializers

Swift can synthesize memberwise initializers for structures, but not for classes. Luckily, XCode can generate code for us: select your class name, then go to the Xcode menu and choose Refactor> Generate Memberwise Initializer. Ready!

2. Redefining the environment

When building software, it's important to make sure your application works for everyone. A great way to do this is to use XCode's Environment Overrides panel, which allows you to configure dynamic type size, accessibility options, and appearance in one place.

3. Choice of code blocks

You probably already know that you can click after any opening { or closing } brace to have XCode highlight the corresponding brace, but another good tip is that you can double-click on a brace to select the entire block of code, which it contains.

4. Checking our spelling

XCode can check spelling and even understands that camelCaseNames should be treated as separate words. Go to the XCode menu and select Format> Spelling and Grammar > Check Spelling While Typing and Xcode will check your code for typos.

5. Correction of all problems

If you have a Swift file that contains a lot of errors, you can use XCode hints to try and fix the errors one by one. But a faster way is to go to the menu and select Fix All Issues to apply all the fixes at once. (Make sure and double-check what changes have been made!).

6. Deleting search results

When you search using XCode's search navigator, you can click to view individual results and make any changes you want. But when you're done, I recommend that you press Backspace to remove that search item from the results so you can see what results are left to check.

7. Resuming the SwiftUI Canvas

This is the easiest tip I know, but it will save you time if you don't already know it. Whenever you see the preview auto update pause on the SwiftUI canvas, press Opt+Cmd+P to resume the preview. Or use Opt+Cmd+Return to completely hide the canvas.

8. Simulator tiling

If you often switch from XCode to the simulator, place them next to each other. With the simulator active, go to the menu window and select Tile Window To Right Of Screen, then select Xcode on the left. Adjust the position.

9. Autocomplete Extension

XCode has great code completion built in, but sometimes when you're scrolling through the options, you may find that the names are too long to fit. Luckily, you can just grab the edge of the autocomplete popup and drag it as wide as you want!

10. Fast switching breakpoints

Breakpoints are great for debugging - place them by selecting the line number, or remove them by right-clicking and choosing Delete Breakpoint. You can also remove one by dragging it, but a quick way is to use Cmd+\ to toggle the breakpoint on the current line.

11. Test Order Randomization

Sometimes the output of one test affects the input of another. XCode has a solution: go to the Product menu, hold down the Option button, then click Test. On the Info tab, click Options, then check the Randomize Execution Order checkbox to run the tests in a different order each time.

12. Jump bar filtering

Jump bar in XCode (Ctrl-6) is the best way to quickly navigate through long files, allowing you to see all the properties and methods in your file. For longer files, start typing with the jump bar open and Xcode will filter them out - a trick that also works for device selection.

13. Interface file generation

Often you want to get an idea of how some code works. If you press Ctrl+Cmd+Up, XCode will create a generated interface showing properties, function signatures, and comments. If you click it again, XCode will take you to the tests for that file, if they exist.

14. Quickly add comments

One of my most used XCode keyboard shortcuts is Cmd+/ to toggle comments on the current line or selection, but another useful one is Option+Cmd+/ - press it just before a method to have Xcode generate a documentation comment, including its options.

15. Find files faster

As your projects grow, it becomes more and more difficult to use the project navigator to find something. There are two solutions, one is to right-click on any group of files and select Sort By Name to sort them alphabetically, and the other is to type in the filter box at the bottom.

16. Display initial changes at runtime

XCode can process source changes right in its editor. To try it, turn on Show Source Control Changes in XCode Preferences and then make your changes. You'll see a blue bar on the left, but if you click on it and select Show Change, Xcode will show you the old and new inline code.

17. Search code on the minimap

The XCode minimap helps us view long files - turn it on in the Editor> Minimap menu. When you hover your mouse over it, the mini-map tells you the name of the method you've completed. You can also hold Cmdto show the names of everything and then click on the name to jump to it.

18. Rerun the last test

It often happens that bad tests have been written, especially when using TDD. Luckily, XCode has a keyboard shortcut to run only the last test, which is faster than running everything: Ctrl+Opt+Cmd+G. John Reed has a special name that makes it easier to remember: "Smash Go!"

19. Remapping useless keys

Some great keyboard shortcuts (like Shift+Cmd+O for quick opening) sit next to useless keyboard shortcuts (Shift+Cmd+P when you want to type code). It only takes a few seconds to remove useless keys, and you can even remap shortcuts like Cmd + P to resume SwiftUI preview.

20. Improve your searches

All headings in the XCode search navigator can be changed: Find can be "Replace", Text can be a link or regular expression, and Containing can be a match, start, etc. You can also click the magnifying glass to view recent searches - when choosing one of them, it repeats.

21. Change code indentation

If you've copied the code from somewhere else, then there's a good chance you'll paste something with the wrong indentation. XCode can fix this with one shortcut: select the code you want to fix, then press Ctrl+I to change its indentation.

22. Testing in-app purchases

You can test in-app purchases without App Store Connect. Create a new StoreKit config file and add your IAP. Now go to the Product menu, hold down the Option key and press Run. On the Options tab, change the StoreKit configuration and you will now use the test IAP.

23. Explore build options

There are plenty of settings to control how XCode builds your code, but it's hard to remember what they all do. Luckily, you can select one and use the Quick Help inspector to view the documentation for most of the options, or Option-click and double-click to get the built-in help.

24. Pin preview

Canvas is a great way to preview layouts as you work, but it's harder to use when one view is split into multiple files. To make things easier, use the pin below to keep the current preview active, allowing you to change one file while previewing another.

Create Better code with Swift Algorithms

Vadim Atamanenko — Sun, 20 Nov 2022 13:03:15 +0000

The Swift Standard Library includes types and functions to quickly and efficiently solve common code problems, but it doesn't cover everything. Therefore, for more complex tasks, we often need to use Swift algorithms: Apple's on-demand algorithms and data collection package, with the source code tuned for performance and flexibility.

A great time to see at the upcoming Advent of Code 2021 how Swift Algorithms can help you write faster, simpler, and safer code. There is functionality to create unique sequences, divide them, select multiple random elements, compress them, etc. And most of them return new types of sequences, highly optimized, more efficient than reducing everything to a simple array.

Apple also said that Swift Algorithms provides an opportunity to study the problems and solutions of algorithms before translating them into the main standard library: you get better code today, and see what the standard library can become in the future. Isn't it great?

Best of all, adding Swift Algorithms to your Xcode project only takes a few minutes: go to File, select Add Packages, select Apple Swift Packages, then select "swift-algorithms" and click Add Package. Now just add import Algorithms to your code and you're done!

In this article, I'm going to highlight just a few of what Swift Algorithms can already do, focusing on nine specific algorithms that I find most useful. Let's get started...

Sequence chain

If you have two arrays of data and want to iterate over both of them, you can write something like this:

let names1 = ["Jane", "Elizabeth", "Mary", "Kitty"]
let names2 = ["Daphne", "Eloise", "Francesca", "Hyacinth"]

for name in names1 + names2 {
    print(name)
}

This will print all eight names, but in doing so we had to create a new temporary array by concatenating names1and names2together. In this case, this is not a problem, but if your arrays were much larger, it would be quite expensive.

Swift Algorithms has a solution called chain() it creates a new sequence by concatenating two others without doing any further distributions. Here's what it looks like:

for name in chain(names1, names2) {
    print(name)
}

Behind the scenes, chain() keeps references to your two existing sequences and just effectively chains their iterators together so that when one ends, another begins.

This works with other types of sequences too, so we can check exactly if a value is in two different ranges:

let tooLow = 0...20
let tooHigh = 80...100
let outOfBounds = chain(tooLow, tooHigh)

let value = 35
print(outOfBounds.contains(value))

What's more, this works for any type of sequence, so we can link a range and an array:

let reservedSeats = 0...50
let unavailableSeats = [61, 68, 75, 76, 77, 92]
let disallowed = chain(reservedSeats, unavailableSeats)

let requestedSeat = 39
print(disallowed.contains(requestedSeat))

Splitting sequences

Have you ever wanted to split a sequence into equal parts, or perhaps based on certain criteria? Swift Algorithms provides several flavors of split functions that do just that: they are extremely efficient at turning complex, error-prone work into single-line code.

As an example, we could create an array of students with names and grades as letters like this:

struct Student {
    let name: String
    let grade: String
}

let results = [
    Student(name: "Taylor", grade: "A"),
    Student(name: "Sophie", grade: "A"),
    Student(name: "Bella", grade: "B"),
    Student(name: "Rajesh", grade: "C"),
    Student(name: "Tony", grade: "C"),
    Student(name: "Theresa", grade: "D"),
    Student(name: "Boris", grade: "F")
]

Using Swift Algorithms, we could split this array of results based on the scores, and then neatly print them out:

let studentsByGrade = results.chunked(on: \.grade)

for (grade, students) in studentsByGrade {
    print("Grade \(grade)")

    for student in students {
        print("\t\(student.name)")
    }

    print()
}

It will automatically create a new fragment whenever the value being checked changes, so you need to be careful if your value jumps around. In the code above, all student grades are displayed in order - two "A"s together, as well as two "Cs", so this is not a problem. But if we need to split the array by taking student names, we must first sort them to make sure the initial letters are grouped together:

let studentsByName = results.sorted { $0.name < $1.name }.chunked(on: \.name.first!)

for (firstLetter, students) in studentsByName {
    print(firstLetter)

    for student in students {
        print("\t\(student.name)")
    }

    print()
}

There is an alternative fragmentation method that allows us to split the sequence by the number of elements in each fragment. For example, we could pair our students like this:

let pairs = results.chunks(ofCount: 2)

for pair in pairs {
    let names = ListFormatter.localizedString(byJoining: pair.map(\.name))
    print(names)
}

It will print "Taylor and Sophie", "Bella and Rajesh", and "Tony and Teresa", but since "Boris" does not have a match, it will be a one-piece fragment.

Be careful: data fragmentation will return a slice of the array, not an array, because that's more efficient. This means that if you try to read indices like 0 and 1 for our pair, you will run into a problem. So avoid code like this:

let pairs = results.chunks(ofCount: 2)

for pair in pairs {
    if pair.count == 2 {
        print("\(pair[0].name) and \(pair[1].name) are working together")
    } else {
        print("\(pair[0].name) is working alone")
    }
}

If you definitely want an array and not a slice of an array, transform each element before the loop, like this:

let pairs = results.chunks(ofCount: 2).map(Array.init)

Random sampling
One of my favorite features of Swift Algorithms is the randomSample(count:) method and its analog randomStableSample(count:), both of which are improved forms of randomElement() and vice versa select N random non-repeating elements.

Of the two methods, randomSample(count:) is the fastest and works on all sequences. However, it doesn't preserve the order of your elements, so you'll end up with N random non-repeating elements in any order.

For example:

let lotteryBalls = 1...50
let winningNumbers = lotteryBalls.randomSample(count: 7)
print(winningNumbers)

If you specify a number equal to or greater than the number of elements in your sequence, the entire sequence will be returned, again in random order.

An alternative is randomStableSample(count:), which works a little differently. First, it only works with collections, because it needs to know how many elements it is sampling from, and is also slightly slower than randomSample(count:). However, it preserves the order of your elements, which can be useful:

let people = ["Chidi", "Eleanor", "Jason", "Tahani"]
let selected = people.randomStableSample(count: 2)
print(selected)

Walking in sequence

Swift Algorithms has added a new striding(by:) method that moves through a sequence in steps of a certain size, similar to stride(from:through:by), except that it works directly with sequences and is therefore much more efficient.

First, a simple example so that you can see the direct difference between the old and the new. This code prints all odd numbers from 1 to 1000:

let numbers = 1...1000
let oddNumbers = numbers.striding(by: 2)

for oddNumber in oddNumbers {
    print(oddNumber)
}

We can get the same result using stride(from:through:by:) like this:

let oddNumbers = stride(from: numbers.lowerBound, through: numbers.upperBound, by: 2)

The advantage of using striding() is that it works on more complex collections such as strings and array fragments. So we can efficiently extract parts of a string like this:

let inputString = "a1b2c3d4e5"
let letters = inputString.striding(by: 2)

for letter in letters {
    print(letter)
}

Lately I've been using this to handle the decryption of columnar transposition ciphers, where plaintext letters are spaced at fixed intervals in a string.

Finding Unique Items

Swift Algorithms has useful functionality for finding unique elements in a sequence, either based on their natural uniqueness (if your type is Hashable compliant) or using a function you specify.

Let's start with a simple example: you ask a group of people about their lucky number and get different answers. If you want to select each unique response, you can do this:

let allNumbers = [3, 7, 8, 8, 7, 67, 8, 7, 13, 8, 3, 7, 31]
let uniqueNumbers = allNumbers.uniqued().sorted()

for number in uniqueNumbers {
    print("\(number) is a lucky number")
}

If you need something a little more advanced, uniqued(on:) allows you to provide a function that takes one element from a sequence and returns a Hashable of whatever type you want to use in your uniqueness test. Using key paths as functions, we can write code to iterate through an array of cities and select only one city for each country:

struct City {
    let name: String
    let country: String
}

let destinations = [
    City(name: "Hamburg", country: "Germany"),
    City(name: "Kyoto", country: "Japan"),
    City(name: "Osaka", country: "Japan"),
    City(name: "Naples", country: "Italy"),
    City(name: "Florence", country: "Italy"),
]

let selectedCities = destinations.uniqued(on: \.country)

for city in selectedCities {
    print("Visit \(city.name) in \(city.country)")
}

In this situation, uniqued(on:) will always return the first unique element from multiple choices, so the above code will return Hamburg, Kyoto, and Naples.

Removing an optionality

The Swift standard library provides compactMap() to convert an element to some optional result, but then unwrap that optional and remove any nil's. However, it's common to think of compactMap { $0 } as a way of not doing a transformation, but just storing the optional expanded and removing steps, for example:

let numbers = [10, nil, 20, nil, 30]
let safeNumbers = numbers.compactMap { $0 }
print(safeNumbers.count)

This works, but Swift Algorithms offers an improved version called simply compacted():

let numbers = [10, nil, 20, nil, 30]
let safeNumbers = numbers.compacted()
print(safeNumbers.count)

Ok, a little less typing, but much clearer what you mean. The use of $0 in compactMap() has always seemed more of a workaround than intentional.

However, compacted() has another major advantage, which is that it is always lazy, not just when you request it. This way the deployment and removal process will only happen when you actually use it, which makes it much more efficient when you chain operations together.

Nested Loops Improvement

Nested loops allow us to iterate over one sequence every time we iterate over another, and Swift Algorithms provides a product() function that gives us extra control in a situation like this.

For example, if we have two arrays of people and games, we could use product() to iterate over each combination so that each person could play each game:

let people = ["Sophie", "Charlotte", "Maddie", "Sennen"]
let games = ["Mario Kart", "Boomerang Fu"]

let allOptions = product(people, games)

for option in allOptions {
    print("\(option.0) will play \(option.1)")
}

The loop will print: "Sophie will play Mario Kart", "Sophie will play Boomerang Fu", "Charlotte will play Mario Kart", "Charlotte will play Boomerang Fu" and so on.

The first parameter to product() can be any sequence because it loops once, but the second parameter must be a collection because it iterates many times. Of course, you can also provide the same collection for both options if you like, which means we can print out the full set of multiplication tables, like this:

let range = 1...12
let allMultiples = product(range, range)

for pair in allMultiples {
    print("\(pair.0) x \(pair.1) is \(pair.0 * pair.1)")
}

You might think that this is no better than using nested for loops, but the magic is that product() gives us a new collection that we can manipulate further. For example, we want to select 20 random questions from all possible multiplication tables, like this:

let range = 1...12
let questionCount = 20
let allMultiples = product(range, range).shuffled().prefix(questionCount)

for pair in allMultiples {
    print("\(pair.0) x \(pair.1) is \(pair.0 * pair.1)")
}

If you've been following closely, you may have noticed that we can just use randomSample(count:) instead of shuffling and prepending:

let allMultiples = product(range, range).randomSample(count: questionCount)

One slight downside to using product() right now is that it only works with two parameters, meaning that if you need to iterate over multiple collections, you'll have to nest calls to your product(). So we could make the world's most tedious Cluedo/Clue (detective game) game like this:

let suspects = ["Colonel Mustard", "Professor Plum", "Mrs White"]
let locations = ["kitchen", "library", "study", "hall"]
let weapons = ["candlestick", "dagger", "lead pipe", "rope"]
let guesses = product(product(suspects, locations), weapons)

for guess in guesses {
    print("Was it \(guess.0.0) in the \(guess.0.1) with the \(guess.1)?")
}

This is how my 8 year old plays, so not bad for just a few lines of code!

Sliding windows in sequence

Another one of my favorite additions to Swift Algorithms is the ability to read duplicate (overlapping) subsequences of the main sequence, which is great for things like calculating moving averages over a sequence.

If you just want all adjacent pairs, you can use the lazy adjacentPairs() method in sequence, like this:

let numbers = (1...100).adjacentPairs()

for pair in numbers {
    print("Pair: \(pair.0) and \(pair.1)")
}

However, for more advanced tasks, there is also a windows(ofCount:) method that allows you to control how big your sliding window should be. So we could make groups of 5 like this:

let numbers = (1...100).windows(ofCount: 5)

for group in numbers {
    let strings = group.map(String.init)
    print(ListFormatter.localizedString(byJoining: strings))
}

When it runs, it will print "1, 2, 3, 4 and 5", "2, 3, 4, 5 and 6", "3, 4, 5, 6 and 7" and so on. These are all subsequences of the original sequence, so again, this is super efficient.

I recently used the windows(ofCount:) method when decoding a Vigenère cipher because it allowed me to look through a huge string of letters and find all repeated substrings.

Minimum and maximum

Finally, Swift Algorithms offers advanced methods for calculating the minimum and maximum values in a sequence. You can provide your own test if you want, but if your sequence matches Comparable, you get the default test, with a < sign, like so:

let names = ["John", "Paul", "George", "Ringo"]

if let (first, last) = names.minAndMax() {
    print(first)
    print(last)
}

Methods are also provided for reading multiple highest and lowest values at the same time, for example:

let scores = [42, 4, 23, 8, 16, 15]
let threeLowest = scores.min(count: 3)
print(threeLowest)

Under the hood, the results will be sorted and padded at the beginning or end if you try to read more than 10% of the entire sequence, but otherwise it uses a faster algorithm, just doing the right thing automatically, like a lot of things in Swift Algorithms.

And that is not all!

I just touched on just a few of my favorites in Swift Algorithms.

To learn more, I recommend you visit the Swift Algorithms GitHub repository: https://github.com/apple/swift-algorithms. All of this is Swift open source, so you can explore it for yourself and see how Swift Algorithms squeeze so much out of their code.

Memory types in Swift

Vadim Atamanenko — Sun, 02 Oct 2022 15:13:34 +0000

Hey everyone, this time I propose to analyze the theoretical part and an equally interesting topic.

Let's talk about memory types in Swift. Let's start as we should from the very beginning, memory management is an important part of developing efficient applications, misusing it to problems ranging from slow loading to crashes.

There are three types of memory:

static
automatically
dynamic

A static type is responsible for allocating memory before the start of program execution; such memory is available throughout the entire program execution time in many languages. To allocate static memory objects, it is enough to declare its global scope.

Automatic type or stacking is the most basic. Arguments and local variables of the function are automatically allocated, as well as other meta information when the function is called, and memory is freed when it exits.

Dynamic type allocation of memory from the operating system as required by the application. The application can, if necessary, request additional memory from the operating system via the Locator or directly via a system call. An locator is a part of a program that requests memory in large chunks directly from the operating system through system calls, then gives this memory to the application piece by piece.

How is RAM used when running a program? When executing a program, it needs access to RAM to load its machine code for execution, store the value of variables and data structure, and load external modules needed to perform tasks. In addition to the place used to load its own code, the application uses two areas of RAM during operation, the stack on the basis of which automatic memory works and the so-called Heap, which is used for dynamic memory allocation.

Now let's talk more about these mysterious stacks and heaps.

So let's start with stacks.
The allocation of memory for the stack is determined when the program is compiled, access to it is very fast. The stack is organized in a Last In First Out (LIFO).

The stack can be visualized as a stack of books with which we are only allowed to interact with the topmost book, read it and put on a new one. All manipulations are performed with the top book in the stack, the book is added to the very top if you need to save the data, or taken from the top if the data needs to be read.

There are two main commands for working with stacks.

Push pushes data to the top of our stack of books and Pop gets the book from the top of the stack. Each function on the stack has its own place called a frame. When one function calls another, the latter always knows where to get its arguments at the end of the stack.

How does the function know where the end of the stack is? The processor has a special register for this, which finally stores the stack pointers and in most cases it is located closer to the end of the virtual memory and grows towards the beginning. Each thread of a multithreaded application has access to its own stack.

Stacks are used for value types, that is, for value types. If the size of a value type can be determined at compile time or if our value type does not contain a recursion of itself or is in a reference type then it will require stack allocation.

Now let's move on to Heap.

Heaps are used to dynamically allocate memory, you can think of a heap as a big bookcase where a needed book can be found using a specific instruction. After allocating memory, the program receives a pointer to the beginning of the allocated memory, which, in turn, must also be stored somewhere, in static, automatic, or also dynamic memory.

Ultra-high-level languages use dynamic memory as the main one. All or almost all objects are created in dynamic memory, and a pointer to these objects is kept on the stack or in static memory. Operations on the heap are somewhat slower than on the stack, since it requires an additional step to look up the data.

The heap is shared by all threads in an application due to its dynamic nature. The heap is more difficult to manage and causes most of all memory-related problems and errors. The heap is used for reference types.

When does heap partitioning happen differently? One option for when the Swift compiler will promote reference types to be placed on the stack is when their size is fixed or the lifetime can be predicted.

Also, the Swift compiler can box value types and allocate them on heaps in the following cases:

By following the protocol. In addition to resource allocation costs, additional memory leaks occur when the value type is stored in an existential container and exceeds three machine words in length.

An existential container is a generic container for a value of an unknown runtime type, small value types can be inlined in an existential container, larger ones are placed on the heap and referenced in the container's existential buffer. Also the second option when mixing a value type and a reference type. A regular reference to a class is stored in a struct, and a struct is a field of the class.

The third case is escaping closures. In the case where a value is stored on the stack and is captured by an escaping closure, then that value is copied to the heap so that it becomes available before the closure is executed.

And one more option is the inout parameter.

The inout parameters are passed to the entry point at address, the callee does not take ownership of the specified memory, the specified memory must be initialized when the function enters and exits.

So, we got acquainted with the types of memory and let's sum up some results.

Stacks store temporary data, method parameters and local variables. Each time we call a method on the stack, a new piece of memory is allocated, this memory is freed when the method exits. Stacks are specific to value types. Heaps store objects that have a lifetime. The heap is specific to reference types. The overhead of allocating and deallocating memory on the heap is much greater than allocating memory on the stack.

That's all I hope you liked this theoretical material, that's all.

How to Become an IT Thought Leader

Vadim Atamanenko — Sun, 04 Sep 2022 10:35:18 +0000

Influencer and Brand Advocate

Let's first understand what an opinion leader is and how he differs from an influencer and a brand advocate.
Most companies strive to attract a loyal audience and form a pool of regular customers who will appreciate not only the company and its products, but also worry and help this company develop.

A brand advocate is a loyal, passionate and devoted fan who is even better than in-house marketers at talking about your product, helping to promote it and achieve good results.
An opinion leader is a person who can influence the formation of the opinions of others and the general public, influence the emergence of trends, create or intensify discussion of various topics.

“If your product gets into the circle of discussions and topics covered by an opinion leader and a person starts promoting it, then he is both an opinion leader and a brand advocate.”

Collaboration with an opinion leader helps to effectively reach out to specific consumers, have the most fruitful impact on them and build trust between the audience and the brand.

An influencer is a person who spreads ideas or information in a particular environment.

“From the point of view of communication technologies and mechanics, an opinion leader and an agent of influence are practically the same thing.”

But an agent of influence is not necessarily an opinion leader. This is a person who can set the tone for communications and influence some action on the part of the target audience. Strengthen or reduce the influence of specific influencers, marketing messages and enable businesses to more effectively develop communication between the brand and the consumer.

Who can be an opinion leader

It is usually considered that opinion leaders are politicians, representatives of show business, creative professions, athletes, social activists or authorities in various fields of activity. But opinion leaders can also be ordinary people who influence the decisions of their relatives, friends and associates. For example, you can be an authority for your environment and, accordingly, influence their opinions.

Opinion leaders in social networks are bloggers, journalists (both professional and non-professional), as well as users who actively publish their own content that has an impact on the audience that reads it.

“The main feature of an opinion leader is the ability not only to broadcast information to a large audience, but also to really influence the opinions, actions, and behavior of specific people.”

Through their ability to get the message across, influencers can generate public outcry on a variety of issues, both in relation to certain products and in relation to certain situations.

Characteristics of an opinion leader

An opinion leader has the following qualities:

active life position;
an extensive network of social contacts online and offline;
the desire to disseminate useful information, bring value to their audience;
demonstrating your expertise;
confidence in the formation of microtrends;
the ability to raise various issues that cause a certain response from the audience;
strong involvement in the process of solving any problems.

An opinion leader influences through emotions or rational arguments, inspiring trust and response from people who find in his words and actions a correspondence with their internal problems and expectations.

How influencers can be useful for business

Attracting opinion leaders allows you to quickly convey certain information about the company, product, specific situation to the target audience.

People trust the leader of opinions, and sometimes imitate. He has real authority, his achievements are beyond doubt, and his competence in his field is not even disputed. The combination of these qualities makes an opinion leader an ideal tool for promoting various kinds of messages.

The important thing is that this is not only communication with the target audience, but also the opportunity to stimulate certain follow-up actions of this target audience:

purchase of a specific product;
resolving situations in relation to service problems;
getting good reviews about the product;
feedback at the stage of testing the product and its refinement;
opening up new opportunities for using the product.

An opinion leader values his usefulness to the audience. It can both negatively and positively influence the solution of various situations related to the brand. For example, to extinguish the negative impact of certain facts on the public, or, conversely, to strengthen.

“Interaction with opinion leaders is one of the important moments of brand interaction with the target audience. Business needs to find common ground with influential people and establish effective communications.”

Where to find influencers

To find influencers that will be useful for your business, you first need to analyze your target audience. During the evaluation, you will see where your target audience dominates, who they follow, what they read, what content they are interested in.

“Based on this analysis, you will be able to find those opinion leaders who are trusted by your target audience.”

The audience can be found in the circle of their immediate environment. You can go to specialized events where your target audience and experts who convey key information prevail. You will simultaneously see people broadcasting certain content and how your target audience reacts to certain opinion leaders.

Opinion leaders need to be searched on the Internet using simple monitoring or services that allow you to determine certain people by rating or interests.
Pay attention to the number of followers and their degree of involvement on the person's page.

In addition to followers, look at how people react to the influencer's posts. He doesn't have to write posts every hour, but the return on posts that have deep content should be very high.
Interview members of your target audience about the personalities they are interested in, whose opinion they value and whose recommendations they listen to. This is the easiest way to determine the points of influence on your target audience, and maybe give an answer with whom you should cooperate with in the future.
Interview experts in your field of activity, they will indicate to you people whom they trust and whose opinion they listen to. Often the interests of the target audience coincide with the opinions of experts.

You can use monitoring services that provide additional information about the number of subscribers and influencer ratings. If your target audience is very narrow, then it is important to sort either by key queries or by a specific topic of content that this or that influencer publishes.

How to negotiate and communicate effectively with opinion leaders

“Opinion leaders are people. And all communication with them is people to people, per-to-per.”

To work effectively with influencers, you need to build trust between a brand, a company representative and a certain person. These relationships are built on the principles of mutual benefit.

The advent of social media has made it easier to find, communicate, and connect with opinion leaders. But at the same time, no one canceled the element of trust. If for some reason you could not agree with the influencer you wanted to attract, find people in your environment who could recommend you and improve relations with the person.

This is an interpersonal relationship, so it is important to fine-tune communication. The further effectiveness of his interaction with your target audience depends on the opinion leader's perception of your company.
Try to be useful to a specific influencer and provide all possible information about your product or service. Give the product for testing so that the person knows exactly what you want to convey to the public.

At the same time, do not openly impose a product and do not focus solely on financial components and on the benefits of a particular opinion leader. It is important to build trust in you and your company, to identify the influencer's interest in interacting with your brand and product. If you do not achieve this, you will receive very dry feedback or communication that will be supported solely by financial motives and will not have the desired effect.

Options for cooperation with opinion leaders

There are three options for working with influencers:

financial motivation.
commodity-material relations.
free promotion of your product.

The third is solely the result of the formed trust, which depends on your personal communication. But here it is important to remember that "free cheese" may well be the expected "mousetrap". Especially when personal relationships collapse or when the opinion leader will have a completely different result than the one that was originally laid down in communication.

The most trivial way to interact with an influencer is money or paid posts. The mechanics are simple. You contact an opinion leader, agree on specific conditions, offer certain rewards for hidden or native advertising of products. If this does not contradict the life principles and moral character of the opinion leader, then you will achieve a result.
An important point is to give an understanding that a certain involvement in this communication must be obtained from the opinion leader.

“The more sincerely the opinion leader will talk about your product, the more the target audience will believe in this product and you will get a better result.”

The second option is inventory items that can be presented as a gift to an opinion leader. This can form a small, short human communication with your target audience.
Typically, this method is used in the fashion and lifestyle industry, where a gift is a small element of communication with the audience. An opinion leader can talk about his emotions when receiving a gift, share his impression about the product: what he liked, what he didn’t like.

At the same time, it is important that the process itself should be emotionally filled.

“The higher the emotion of the opinion leader himself, the stronger the effect will be achieved in the communication that the opinion leader develops.”

The third option is free promotion. If you are interesting and useful to the opinion leader, then it will not be difficult to persuade him to publish a post about your product.

Principles of working with opinion leaders

There are several principles of working with opinion leaders:

Define your target audience and see which people they trust. Start communicating with these influencers.
Choose quality leaders, don't chase stars with a huge number of followers. Perhaps they will treat you and your product with some condescension, showing their superiority. In communication with opinion leaders, trust and a certain friendly atmosphere are important. Start with less popular personalities.
Make everything beautiful. In communication with an opinion leader, the state that you cause in a person is also important. If he trusts you, treats you warmly, then the tone of communication with your target audience will also be permeated with these feelings.
Be sure to follow the opinion leaders.
Always be honest.
Don't place high hopes on them.

This is where communication is important. The more often you communicate with influencers, the better you understand them and can bring more trust and friendly notes into your relationship. Also, you must broadcast your attitude towards the influencer to his audience.

Alternatives to face-to-face communication with influencers

If it’s hard for you to personally communicate with specific opinion leaders, then services such as Publicfast (which was mentioned above) allow you to quickly and efficiently find your target audience.

You can register there under the name of the brand and start interacting with the audience you are interested in.

Instead of a conclusion

Opinion leaders are not dogma. This is a separate communication channel that will allow a business to be more effective on the Internet. By collaborating with influencers, you speed up the moment of delivering information and build trust. Influencers share their trust and translate it into a brand or business, which adds value to your product.

Top mobile app development trends in 2022

Vadim Atamanenko — Tue, 17 May 2022 03:57:19 +0000

In 2020, the number of unique mobile Internet users reached 4.28 billion, which means that more than 90% of the global Internet population used mobile devices to access the Internet. The trend of using mobile gadgets to access the Internet is gaining momentum, as evidenced by the active development of mobile networks, as well as the constant innovations that appear in mobile application development solutions.

In order to reach more consumers and improve the customer experience, more and more companies are choosing mobile apps based on the latest digital innovations. In this article, we'll take a look at the top mobile app development trends that will take off in 2022 and explain how they can help businesses thrive.

1). What types of mobile apps do you most commonly build now in 2022? (Hybrid, Native, etc.)

In recent years, the development of cross-platform solutions has become the future of mobile application development. Well-known companies such as Facebook, Pinterest, Alibaba and others are using this solution to improve their productivity.

Competition is growing every day in many areas, and if you have an idea for a startup, you need to quickly validate it. Creating native applications takes a lot of time and money, and the product may not be in demand. Therefore, it is worth making a choice in favor of cross-platform. Due to the common code base, developing your product for two platforms at once - iOS and Android - takes less time and budget. Plus, app updates happen from the inside — without the need to add a new version to the AppStore and GooglePlay.

We have already mentioned that cross-platform development is twice as fast as native development, but even parts of the React Native code can be integrated into ready-made native applications. So Instagram, originally developed natively, added push notifications and post promotion to its application.

2). What types of mobile app features are currently in high demand? (Payment gateway, security, search functions, etc.) Why?

At the moment, the following types of applications are being developed and upgraded quite often:

Internet of Things (IoT) application integration
Here's how mobile apps improve the Internet of Things:

provide a single centralized platform for multiple IoT devices;
simple control of the device, narrowing down a significant number of settings to 1-2 buttons;
provide increased security through access to a biometric application or two-factor authentication;
increases personalization, when each user of the mobile application can customize the IoT network according to their preferences;
allow you to manage IoT devices anywhere and anytime.

Development for wearable devices
Wearable devices are not a new invention in the gadget industry, however, their popularity will continue to grow in 2022. According to Statista, there were 722 million wearable devices in 2019, and its number is projected to be over 1 billion by 2022.

Augmented Reality (AR) and Virtual Reality
Augmented and virtual reality (AR and VR) are helping companies truly stand out and provide a new level of customer experience. Here's how companies are using AR/VR to improve their customer experiences:

contactless shopping - some companies, such as Gucci and Ikea, use layers of augmented reality so that customers can experiment with their products; they can try them on, like a new watch or makeover, or visualize the product they want to buy anywhere, like putting Ikea furniture at home to see if it fits;
immersive experience - when companies create VR/AR layers to better engage their customers in the interaction with their brand or product, for example, Coca-Cola came up with interactive features that customers play with on their smartphones;
improved personalization - customers can communicate with the brand in their own way, for example, L'Oreal invented a new men's fragrance called Only The Brave, and with the product they released a virtual reality world where users can experience how they behave in extreme conditions.

Companies are just starting to discover the potential of VR/AR technologies to enhance brands and marketing campaigns. However, the global augmented and virtual reality market is expected to grow by $125.19 billion between 2020-24.

Instant Apps
Instant Apps is another innovation in mobile development. This makes it easier to browse the contents of the app without having to install the app. This allows customers to quickly decide if they want to install a particular app on their phone, and it also helps businesses more easily introduce their content to potential customers.

As well as:
Beacon technology
Mobile commerce
Artificial Intelligence (AI)
Mobile wallets and mobile payments
Chatbots
Superior application security
Predictive Analytics
Applications on demand
Cloud Computing Integration

3). How important is mobile app maintenance after the first 12 months? Why?

Service and support in the first 12 months after a product launch is key, here during this period:

application bugs that were not taken into account at the initial stage are revealed.
new application features are being developed based on feedback from the first 300,000 users.
the rights to the application are transferred and transferred for support to the internal divisions of the company.

What is bad code and what to do about it

Vadim Atamanenko — Sun, 15 May 2022 06:04:06 +0000

What is code quality, how to improve it, and why sometimes good code is bad.

Bad code is like bad repair. It can work and even works, but it’s bad and not for long, it looks so-so and it’s not easy to fix something in it. It is chaotic, has an incomprehensible structure, and you won’t immediately understand what the author wanted to say.

Signs of poor quality code:

it is difficult to navigate in it;
parts that can be written in two lines are written in ten;
by the name of the function it is impossible to understand what it does (xyz, function, n);
if you add something to it, the rest will stop working.

What threatens a project with bad code

At first glance, bad code is not a disaster. The program works, isn't that the main thing? In fact, it brings many problems, especially in the long run. And that's why:

making changes to low-quality code takes a lot of time and is expensive, and over time, the price and duration only increase;
adding something new is also difficult;
code is unpredictable - you never know what will stop working and when;
team spirit falls if people have to work with such masterpieces ("Who wrote this at all?!").

As a result, the development speed is reduced, the timeline is lengthened, and the cost of changes is growing. If this is critical for the consumer or customer, then bad code can bury the project.

How to write good code

To write quality code, you need to know what it is. Here are its main qualities:

the code is easy to read, it has a clear structure, there is no confusion in it;
it is easily maintained: small changes do not cause a desire to write it again;
it can be expanded;
the code has been tested;
it is documented;
productive.

Comments are really very important to make the code easy to read. This will not only help other programmers when they work on your code, but also you in the future.

Here are five actions that improve the code.

1. Follow coding standards. This is one of the simplest and most important guidelines - when you agree with colleagues in advance how to format the code and how to act in some situations. Then the code written by different programmers will be visually similar: it will be easier for you to work with someone else's code, and vice versa. There are also generally accepted coding standards and even programming platforms that will tell you how to follow these standards. This is important both when working in a team and if you write code alone.

2. Refactoring. This is a reworking of the program code without changing its behavior. That is, first you have a creative process: you write so that the program works, and then you “clean up after yourself”, put the code in order, to the desired look. As a bonus, refactoring helps to rethink the architectural decisions of the program.

3. Typing. Let's explain with a real example. Players wrote to the developers of one game about problems, and then suddenly stopped. At first, the developers were delighted: everything is so cool that there are no problems. Later it turned out that the username had changed to a nickname in the game, and because of this, the feedback form stopped working: complaints were simply not sent. Typing (declaring a data type) will help avoid such errors and simplify maintenance and refactoring.

4. Code review. This is when you and a colleague check each other's code and give each other feedback. This practice helps to avoid stupid mistakes and thoughtlessness. In addition (and this is also important), you are aware of what the other person is doing, and you do not have to duplicate functions. A wonderful bonus - this method will help to gently adapt beginners.

5. Automatic tests we will talk about them in a little more detail. These are simple programs that run code with different parameters and check against already known results. What are the tests?

Unit test individual parts of the program.
e2e test the system as a whole.
Loaders check how well the program handles loads.
Screenshots compare before and after screenshots and react to changes.
Others: mutational, penetration…

With tests, you really need to be careful so that it doesn’t turn out that you spend hours looking for an error in the code, but the problem is in the tests themselves. Therefore, it is useful to write tests first, and then take on the code itself, when you have a clear structure and understanding in your head of what needs to be done and what you want to get.

There are other ways to improve the code (for example, pair programming). The best results can be obtained if you use several methods at once: this is more reliable.

When good code is bad

We've been talking so much about how important quality code is now, and now we're saying the opposite? Yes. Sometimes good, "correct" code isn't all that great.
The reason is very simple: in programming, unfortunately, you have to choose between quality and speed of work, and in some cases speed is more important.

To understand how important speed is, imagine two developers: John and Steve. One is thorough, pedantic, and the second is its complete opposite. Both came up with the idea to make some kind of product. John sat down, came up with the architecture and started to do it well and slowly. And has been doing it for six months now. Steve did everything in a month, with errors, bugs - but immediately launched it, found customers, made the second release... As a result, six months later, when John had just completed his wonderful product, Steve already has many users and the name of the product is already well known. And he fixed some of the bugs in the second release.

Moral of the story: sometimes it's more important to get to the market faster and occupy a niche than to do it perfectly.

How then to be? Bad code is bad, good code is not always good either ... The point is this:

Code quality is a parameter that
we change depending on the goal.

If you are writing an application for a bank, then you will spend a lot of time testing and developing, because a mistake can cost hundreds of thousands of dollars.

If you are making a landing page that simply tells about a temporary promotion and collects emails into a database, then speed is already important here. You know that once the promotion ends, your code will no longer be needed. There is no need to refine and maintain it, and other developers will not use it either - it is enough to write quickly and check that it works, the rest is not important.

These are the basic principles of creating quality code: do not forget about standards, look back at what you have already written, do not be afraid of feedback from colleagues and do not forget to test. But at the very beginning, it is worth weighing: quality is important to you now, or you need to finish development as soon as possible.