SwiftUI 4 and the new NavigationStack in iOS 16 are an excellent solution for pushing views into the navigation hierarchy. However, if your app still needs to support iOS 15, you need to relay on NavigationView. To write a simple navigation hierarchy with couple of views check the following code block, make sure not to add multiple Navigation Views in the same view hierarchy, as this can cause weird glitches, even though it may compile and run.

struct FirstView: View {
    var body: some View {
        NavigationView {
            VStack {
                NavigationLink(destination: SecondView()) {
                    Text("Go to Next")
                }
            }
            .padding()
        }
    }
}

truct SecondView : View{
    var body: some View{
        ZStack{
            VStack{
                //use navigation link without navigation view
                NavigationLink(destination: ThirdView()) {
                    Text("Next View")
                }
            }
        }
    }
}

struct ThirdView : View {
    var body: some View{
        ZStack{
            VStack{
                Text("Third View")
            }
        }
    }
}

The NavigationView in SwiftUI provides default back button behavior, which makes it easy to navigate back to the previous view in the navigation hierarchy. However, if you want to use a custom back button, you can use the Environment key path of the presentationMode to dismiss the current view.

@Environment(\.presentationMode) var presentationMode

	Button {
         presentationMode.wrappedValue.dismiss()
    } label: {
         Text("Back to Home")
    }

When you have a list of data with a large number of items and you use NavigationLink to navigate to a second view that depends on it, there can be performance issues. Initializing the second view with a large number of items can take a significant amount of time and can lead to a slow and laggy user experience. This can be especially problematic on older devices or devices with limited resources.

 List{
    ForEach(0..<50){ j in
            NavigationLink(destination: SecondView(selectedItem: j)) {
                    Text("Go to Next \(j)")
                    }
            }
     }

To mitigate this issue, you can use techniques such as lazy loading to load only the data that is needed for the current view. This can help reduce the amount of time and resources required to initialize the second view, and can result in a smoother and more responsive user experience.

Here's an example of how you could implement lazy Navigation Link with simple hack

@State var showSecondView : Bool = false
@State var nextItem : Int = 0
    
    var body: some View {
        NavigationView {
            VStack {
                
                List{
                    ForEach(0..<30) { i in
                        HStack {
                            ZStack{
                                Color.white
                                Text("Go to Next \(i)")
                            }
                        }.onTapGesture {
                            showNextView(item: i)
                        }
                        
                    }
                }
            }
            .padding()
            .background(
                //Instead of creating navigation link inside loop, use invisible Navigation Link with isActive Binding
                NavigationLink(destination: SecondView(selectedItem: nextItem), isActive: $showSecondView, label: { EmptyView() })
                
            )
        }
    }
    
    private func showNextView(item : Int){
        nextItem = item
        showSecondView.toggle()
    }

It's always a good practice to avoid deprecated APIs, as they may have reduced functionality or be removed in future releases. However, sometimes you may need to target older or legacy devices, and in these cases, you may need to find a workaround.

In the context of navigation in SwiftUI, if your app needs to support older versions of iOS, such as iOS 15, you may need to use the deprecated NavigationView component. However, if you only need to support iOS 16 and above, it's recommended to use the new NavigationStack, as it provides improved functionality and performance.

As an iOS engineer, I was thrilled to attend the iOSConfSG conference in Singapore for the sixth consecutive year. After two years of virtual events due to COVID-19, it was a special experience to be able to attend in-person and meet with fellow developers from around the world. This year's event included a workshop and conference, providing a wealth of information and opportunities to learn and network.

The event began with an awesome workshop led by Daniel Steinberg on new Swift Async/Await framework.

Tunde Adegoroye followed this up with a session on using StoreKit2 to integrate in-app purchases.

The conference then moved on to the all-new iOS 16 weather API, presented by Betty Godier.

Martin Mitrevski delivered an excellent presentation on Swift's performance and Pradnya Nikam spoke about the performance in drawing shadows in Swift.

Erin Weigel discussed new era and R&D topics for developers, and Jordi Bruin shared his 2-2-2 method for developing multiple iOS apps simultaneously.

Day two of the conference was equally exciting. Mikaela Caron kickstarted the conference by delivering her speech about app data and cloud solutions. Paul Hudson, the well-known Swift guru, explained how Swift and iOS Development are affected by the man vs AI game. Omar Khaled shared his experiences with handling traffic in high-demand applications and Danijela Vrzan demonstrated how to add dynamic links to iOS apps. Vincent Pradeilles led an interactive quiz session to engage the audience, and Antoine van der Lee shared tips and tricks to get the most out of the Swift language.

Tim Oliver led an awesome discussion on the importance of sharing knowledge as content creators and Masahiko Funaki showed the importance of using CI/CD for iOS Development. Anya Traille brought some ideas on how to match colors, gradients, and images to our apps, and Donny Wals further explained the depth of Swift concurrency. Before the end of the conference, Priyal Porwal showed how to integrate brand-new Live activities into iOS 16-ready apps. Lastly, Adam Bell discussed some common mistakes and ways to avoid them to improve app responsiveness.

In addition to the technical sessions, the conference also provided an opportunity to network and make new friends at the after-party. It was a great way to unwind after a long day of learning and discussing the latest in iOS development.

Overall, my experience at the iOSConfSG conference was incredibly valuable. I was able to learn from some of the best minds in the industry and stay up-to-date on the latest trends and technologies in iOS development. I would highly recommend this conference to any iOS developer looking to enhance their skills and knowledge."