Space Banana SpaceX's latest test flight of its Starship spacecraft carried a highly unusual payload into orbit: a single banana. Footage showed the interior of the behemoth rocket being adorned with one, lonely piece of fruit. It also conveniently puts the size of the spacecraft to scale.

Starship Shoots Into Orbit With Single Banana in Cargo Hold

SpaceX's latest test flight of its Starship spacecraft carried a highly unusual payload into space in its massive hold: a single banana.

Starship Shoots Into Space With Single Banana in Cargo Hold

Quarterly revenues of $2.92 billion beat the street view of $2.90 billion. The company reported a loss per share of $6.59, including a non-cash goodwill impairment loss for the Wine and Spirits business of $2.25 billion. The Beer business achieved solid mid-single-digit net sales growth while ...

Constellation Brands Beats On Q2 Earnings, Beer Business Achieved Solid Mid-Single-Digit Sales Growth

Google spent $2.7 billion to rehire AI expert Noam Shazeer, as part of a software licensing deal with his AI startup Character.

Desperate Google Paid $2.7 Billion to Get a Single AI Researcher Back

Elon Musk has had a longstanding crush on Taylor Swift, with his tweet suggesting he could impregnate her the latest in a long string.

Elon Musk Has Been Making Sad Attempts to Woo Taylor Swift for Years, and She’s Never Responded a Single Time

Single

single

This article outlines how to transition from singletons to dependency injection in a SwiftUI app with minimal effort. If you're here, you likely already know that you should avoid singletons with various of reasons like: Hidden Dependencies: Classes rely on singletons without explicit indicators, making it harder to track app dependencies and leading to unintended coupling.
Circular Dependencies: Singletons depending on each other can create cycles, leading to initialization deadlocks as instances wait for each other.
Testing Challenges: Using singletons complicates testing and SwiftUI previews since singletons can't easily be swapped for mocks. Lack of Flexibility: Singletons make it difficult to provide different implementations for different environments (e.g., live vs. mock versions for testing). And many others. Dependency Injection To overcome most issues we can use Dependency injection (DI). Using it, swapping in a new implementation becomes much easier, as components don’t rely on a single shared instance but on protocols that can be implemented in different ways. This promotes flexibility, easier testing, and adaptability as app requirements evolve. Constructor Injection Constructor injection is a straightforward technique for injecting dependencies by passing them through initializers. While effective, it often increases the size and complexity of initializers. A common challenge with constructor injection is passing dependencies through a deep UI hierarchy. If a dependency is only needed on a specific screen but must be passed down through multiple intermediary screens, this can quickly become cumbersome. One way to handle this is by using the Coordinator pattern, which centralizes navigation and manages dependencies more efficiently. Check out this article to learn how to make it. Why Not Use @EnvironmentObject? While @EnvironmentObject simplifies dependency sharing in SwiftUI, it has limitations: It only works with ObservableObject
It doesn’t allow using protocols for implementation switching.
It only works in SwiftUI views hierarchy
It only checks for service existence when accessed, increasing the risk of unintentional omissions in views. Dependency injection with property wrappers This is similar to the @EnvironmentObject solution where the dependency management happens inside of property wrappers, but without drawbacks. DependencyContainer This small library contains only a couple files, can be copied directly into your project or integrated via SPM. Please, make sure you put a star on it if you like it. Here is the link on GitHub. Let’s create an example of the service we need to pass as a dependency. As we are assuming that we are going to make a mock for testing, we need to implement our service as a protocol. Also we make it as ObservableObject, to review additional features of the framework. import Combine

protocol DataRepository: Actor, ObservableObject {
    
    func fetchData() async throws
}

actor DataRepositoryImp: DataRepository {
    
    func fetchData() async throws {
        // do real stuff
    }
}

actor DataRepositoryMock: DataRepository {
    
    func fetchData() async throws {
        // do mocked stuff
    }
} Defining a DI container Once integrated, you’ll set up a DI container to manage your services. Each service requires a unique key. You have no limitations in creating keys with the same service type. import DependencyContainer

extension DI {
    static let data = Key<any DataRepository>()
} Next let’s create a function for registering service in DI Container. extension DI.Container {
    
    static func setup() {
        register(DI.data, DataRepositoryImp())
    }
} Then, call this function at app startup. @main
struct ExampleApp: App {
    
    @MainActor final class AppState: ObservableObject {
        
        init() {
            DI.Container.setup()
        }
    }
    @StateObject var state = AppState()
    
    var body: some Scene {
        WindowGroup {
            MainView()
        }
    }
} Injecting Dependencies The actual injection is done with several property wrappers. The most common one is @DI.Static. You just need to pass a key we defined earlier. struct MainView: View {
    
    @DI.Static(DI.data) var data
    
    var body: some View {
        Color.clear.task {
            try? await data.fetchData()
        }
    }
} The points we need to make attention to: No Need to Specify Type. As you may have noticed we don’t need to write a type here, because Swift gets the type from the key.
It’s very convenient in case you start with a concrete type for your service and later decide to use a protocol to enable mocking. You only need to update the type in the key definition. This change propagates automatically without requiring updates to any code referencing that service. Dependency Existence Checked on Initialization. The property wrapper checks that the service exists when initialized. This helps prevent accidental circular dependencies, where services might try to reference each other. The framework enforces a clear initialization order, encouraging thoughtful dependency management and avoiding deadlocks. Additional property wrappers: @DI.Observed Use this in SwiftUI views when your service is ObservableObject. Views will be updated when the service is changed. struct MainView: View {
    
    //updates the view when data is posting objectWillChange
    @DI.Observed(DI.data) var data
    
    var body: some View {
        Color.clear.task {
            try? await data.fetchData()
        }
    }
} @DI.RePublished Should be used in ObservableObject. If your service is ObservableObject, the update will be republished further by the owner of the property wrapper. struct MainView: View {
    
    final class State: ObservableObject {
        
        // Republishes the data.objectWillChange to the State.objectWillChange
        // The view will be updated
        @DI.RePublished(DI.data) var data
    }
    
    @StateObject var state = State()
    
    var body: some View {
        Color.clear.task {
            try? await data.fetchData()
        }
    }
} In addition, if you have nested services you can use a key path in property wrappers. In this case the observing logic uses the service referenced by a keypath. @DI.Static(DI.data, \.innerService) var innerService

@DI.Observed(DI.data, \.innerService) var innerService

@DI.RePublished(DI.data, \.innerService) var innerService Mocking To swap out implementations for testing or previews, you have two options: Initialize with mocked dependency
MainView(data: .init(value: DataRepositoryMock())) Replace service with mock in DI Container
DI.Container.register(DI.data, DataRepositoryMock())
    
MainView() Conclusion This guide provides a straightforward approach to adopting DI using a DependencyContainer framework and moving away from singletons, enhancing flexibility, modularity, and testability in your iOS apps. This article outlines how to transition from singletons to dependency injection in a SwiftUI app with minimal effort. singletons dependency injection minimal If you're here, you likely already know that you should avoid singletons with various of reasons like: reasons Hidden Dependencies: Classes rely on singletons without explicit indicators, making it harder to track app dependencies and leading to unintended coupling. Circular Dependencies: Singletons depending on each other can create cycles, leading to initialization deadlocks as instances wait for each other. Testing Challenges: Using singletons complicates testing and SwiftUI previews since singletons can't easily be swapped for mocks. Hidden Dependencies: Classes rely on singletons without explicit indicators, making it harder to track app dependencies and leading to unintended coupling. Hidden Dependencies: Circular Dependencies: Singletons depending on each other can create cycles, leading to initialization deadlocks as instances wait for each other. Circular Dependencies: Testing Challenges : Using singletons complicates testing and SwiftUI previews since singletons can't easily be swapped for mocks. Testing Challenges Lack of Flexibility : Singletons make it difficult to provide different implementations for different environments (e.g., live vs. mock versions for testing). Lack of Flexibility And many others. Dependency Injection Dependency Injection To overcome most issues we can use Dependency injection (DI). Using it, swapping in a new implementation becomes much easier, as components don’t rely on a single shared instance but on protocols that can be implemented in different ways. This promotes flexibility, easier testing, and adaptability as app requirements evolve. Dependency injection protocols Constructor Injection Constructor Injection Constructor injection is a straightforward technique for injecting dependencies by passing them through initializers . While effective, it often increases the size and complexity of initializers. initializers A common challenge with constructor injection is passing dependencies through a deep UI hierarchy . If a dependency is only needed on a specific screen but must be passed down through multiple intermediary screens, this can quickly become cumbersome. deep UI hierarchy One way to handle this is by using the Coordinator pattern, which centralizes navigation and manages dependencies more efficiently. Check out this article to learn how to make it. Coordinator this article this article this article Why Not Use @EnvironmentObject ? Why Not Use @EnvironmentObject ? While @EnvironmentObject simplifies dependency sharing in SwiftUI, it has limitations : @EnvironmentObject limitations It only works with ObservableObject It doesn’t allow using protocols for implementation switching. It only works in SwiftUI views hierarchy It only checks for service existence when accessed, increasing the risk of unintentional omissions in views. It only works with ObservableObject ObservableObject It doesn’t allow using protocols for implementation switching. protocols It only works in SwiftUI views hierarchy views It only checks for service existence when accessed, increasing the risk of unintentional omissions in views. existence Dependency injection with property wrappers Dependency injection with property wrappers This is similar to the @EnvironmentObject solution where the dependency management happens inside of property wrappers , but without drawbacks. @EnvironmentObject property wrappers DependencyContainer DependencyContainer This small library contains only a couple files , can be copied directly into your project or integrated via SPM . couple files SPM Please, make sure you put a star on it if you like it. star Here is the link on GitHub . link on GitHub link on GitHub link on GitHub link on GitHub Let’s create an example of the service we need to pass as a dependency. As we are assuming that we are going to make a mock for testing, we need to implement our service as a protocol. Also we make it as ObservableObject , to review additional features of the framework. ObservableObject import Combine

protocol DataRepository: Actor, ObservableObject {
    
    func fetchData() async throws
}

actor DataRepositoryImp: DataRepository {
    
    func fetchData() async throws {
        // do real stuff
    }
}

actor DataRepositoryMock: DataRepository {
    
    func fetchData() async throws {
        // do mocked stuff
    }
} import Combine

protocol DataRepository: Actor, ObservableObject {
    
    func fetchData() async throws
}

actor DataRepositoryImp: DataRepository {
    
    func fetchData() async throws {
        // do real stuff
    }
}

actor DataRepositoryMock: DataRepository {
    
    func fetchData() async throws {
        // do mocked stuff
    }
} Defining a DI container Defining a DI container Once integrated, you’ll set up a DI container to manage your services. Each service requires a unique key. You have no limitations in creating keys with the same service type . DI container unique key. service type import DependencyContainer

extension DI {
    static let data = Key<any DataRepository>()
} import DependencyContainer

extension DI {
    static let data = Key<any DataRepository>()
} Next let’s create a function for registering service in DI Container. function extension DI.Container {
    
    static func setup() {
        register(DI.data, DataRepositoryImp())
    }
} extension DI.Container {
    
    static func setup() {
        register(DI.data, DataRepositoryImp())
    }
} Then, call this function at app startup . app startup @main
struct ExampleApp: App {
    
    @MainActor final class AppState: ObservableObject {
        
        init() {
            DI.Container.setup()
        }
    }
    @StateObject var state = AppState()
    
    var body: some Scene {
        WindowGroup {
            MainView()
        }
    }
} @main
struct ExampleApp: App {
    
    @MainActor final class AppState: ObservableObject {
        
        init() {
            DI.Container.setup()
        }
    }
    @StateObject var state = AppState()
    
    var body: some Scene {
        WindowGroup {
            MainView()
        }
    }
} Injecting Dependencies Injecting Dependencies The actual injection is done with several property wrappers. The most common one is @DI.Static . You just need to pass a key we defined earlier. injection common @DI.Static key struct MainView: View {
    
    @DI.Static(DI.data) var data
    
    var body: some View {
        Color.clear.task {
            try? await data.fetchData()
        }
    }
} struct MainView: View {
    
    @DI.Static(DI.data) var data
    
    var body: some View {
        Color.clear.task {
            try? await data.fetchData()
        }
    }
} The points we need to make attention to: attention No Need to Specify Type. As you may have noticed we don’t need to write a type here, because Swift gets the type from the key.
It’s very convenient in case you start with a concrete type for your service and later decide to use a protocol to enable mocking. You only need to update the type in the key definition. This change propagates automatically without requiring updates to any code referencing that service. No Need to Specify Type. As you may have noticed we don’t need to write a type here, because Swift gets the type from the key. It’s very convenient in case you start with a concrete type for your service and later decide to use a protocol to enable mocking. You only need to update the type in the key definition. This change propagates automatically without requiring updates to any code referencing that service. No Need to Specify Type. As you may have noticed we don’t need to write a type here, because Swift gets the type from the key. No Need to Specify Type. type It’s very convenient in case you start with a concrete type for your service and later decide to use a protocol to enable mocking. You only need to update the type in the key definition. This change propagates automatically without requiring updates to any code referencing that service. concrete type protocol Dependency Existence Checked on Initialization. The property wrapper checks that the service exists when initialized. This helps prevent accidental circular dependencies, where services might try to reference each other. The framework enforces a clear initialization order, encouraging thoughtful dependency management and avoiding deadlocks. Dependency Existence Checked on Initialization. The property wrapper checks that the service exists when initialized . This helps prevent accidental circular dependencies, where services might try to reference each other. The framework enforces a clear initialization order, encouraging thoughtful dependency management and avoiding deadlocks . Dependency Existence Checked on Initialization. initialized deadlocks Additional property wrappers: @DI.Observed Use this in SwiftUI views when your service is ObservableObject . Views will be updated when the service is changed. @DI.Observed ObservableObject struct MainView: View {
    
    //updates the view when data is posting objectWillChange
    @DI.Observed(DI.data) var data
    
    var body: some View {
        Color.clear.task {
            try? await data.fetchData()
        }
    }
} struct MainView: View {
    
    //updates the view when data is posting objectWillChange
    @DI.Observed(DI.data) var data
    
    var body: some View {
        Color.clear.task {
            try? await data.fetchData()
        }
    }
} @DI.RePublished Should be used in ObservableObject . If your service is ObservableObject , the update will be republished further by the owner of the property wrapper. @DI.RePublished ObservableObject ObservableObject struct MainView: View {
    
    final class State: ObservableObject {
        
        // Republishes the data.objectWillChange to the State.objectWillChange
        // The view will be updated
        @DI.RePublished(DI.data) var data
    }
    
    @StateObject var state = State()
    
    var body: some View {
        Color.clear.task {
            try? await data.fetchData()
        }
    }
} struct MainView: View {
    
    final class State: ObservableObject {
        
        // Republishes the data.objectWillChange to the State.objectWillChange
        // The view will be updated
        @DI.RePublished(DI.data) var data
    }
    
    @StateObject var state = State()
    
    var body: some View {
        Color.clear.task {
            try? await data.fetchData()
        }
    }
} In addition, if you have nested services you can use a key path in property wrappers. In this case the observing logic uses the service referenced by a keypath. key path observing logic @DI.Static(DI.data, \.innerService) var innerService

@DI.Observed(DI.data, \.innerService) var innerService

@DI.RePublished(DI.data, \.innerService) var innerService @DI.Static(DI.data, \.innerService) var innerService

@DI.Observed(DI.data, \.innerService) var innerService

@DI.RePublished(DI.data, \.innerService) var innerService Mocking Mocking To swap out implementations for testing or previews, you have two options: Initialize with mocked dependency
MainView(data: .init(value: DataRepositoryMock())) Initialize with mocked dependency MainView(data: .init(value: DataRepositoryMock())) Initialize with mocked dependency MainView(data: .init(value: DataRepositoryMock())) MainView(data: .init(value: DataRepositoryMock())) Replace service with mock in DI Container
DI.Container.register(DI.data, DataRepositoryMock())
    
MainView() Replace service with mock in DI Container DI.Container.register(DI.data, DataRepositoryMock())
    
MainView() Replace service with mock in DI Container DI.Container.register(DI.data, DataRepositoryMock())
    
MainView() DI.Container.register(DI.data, DataRepositoryMock())
    
MainView() Conclusion Conclusion This guide provides a straightforward approach to adopting DI using a DependencyContainer framework and moving away from singletons, enhancing flexibility, modularity, and testability in your iOS apps. DependencyContainer DependencyContainer DependencyContainer DependencyContainer

How to Stop Making Singletons in Swift: A Dependency Injection Guide

Breaking Free from the Evil Singleton TL;DR: Refactor singletons to reduce coupling Problems Addressed High coupling
Difficult testability
Multi-threading issues Related Code Smells https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-vii-8dk31x0?embedable=true https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-v-evj3zs9?embedable=true https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-v-evj3zs9?embedable=true Steps Identify the singleton
Locate all references to its getInstance() method
Refactor the singleton to a standard class
Inject it as a dependency Sample Code Before public class DatabaseConnection {
    private static DatabaseConnection instance;

    private DatabaseConnection() {}

    public static DatabaseConnection getInstance() {
        if (instance == null) {
            instance = new DatabaseConnection();
        }
        return instance;
    }

    public void connect() { 
    }
}

public class Service {
    public void performTask() {
        DatabaseConnection connection = DatabaseConnection.getInstance();
        connection.connect(); 
    }
} After public class DatabaseConnection {  
    // 1. Identify the singleton 
    public void connect() { 
    }
}

public class Service {
    // 2. Locate all references to its getInstance() method.
    private DatabaseConnection connection;

    // 3. Refactor the singleton to a standard class. 
    public Service(DatabaseConnection connection) {
        // 4. Inject it as a dependency.
        this.connection = connection;
    }

    public void performTask() {
        connection.connect(); 
    }
}

DatabaseConnection connection = new DatabaseConnection();
// You can also mock the connection in your tests

Service service = new Service(connection);
service.performTask(); Type [x]Semi-Automatic Safety This refactoring is safe when you update all references to the singleton and handle its dependencies correctly. Testing each step ensures that no references to the singleton are missed. Why Is the Code Better? Refactoring away from a singleton makes the code more modular, testable, and less prone to issues caused by the global state. Injecting dependencies allows you to easily replace DatabaseConnection with a mock or different implementation in testing and other contexts. Tags Coupling Related Refactorings https://maximilianocontieri.com/refactoring-007-extract-class?embedable=true See also https://hackernoon.com/singleton-pattern-the-root-of-all-evil-e4r3up7?embedable=true https://hackernoon.com/coupling-the-one-and-only-software-designing-problem-9z5a321h?embedable=true Credits Image by PublicDomainPictures from Pixabay This article is part of the Refactoring Series. How to Improve Your Code With Easy Refactorings Breaking Free from the Evil Singleton Breaking Free from the Evil Singleton TL;DR: Refactor singletons to reduce coupling TL;DR: Refactor singletons to reduce coupling Problems Addressed High coupling Difficult testability Multi-threading issues High coupling coupling Difficult testability testability Multi-threading issues Related Code Smells https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-vii-8dk31x0?embedable=true https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-vii-8dk31x0?embedable=true https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-v-evj3zs9?embedable=true https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-v-evj3zs9?embedable=true https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-v-evj3zs9?embedable=true https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-v-evj3zs9?embedable=true Steps Identify the singleton Locate all references to its getInstance() method Refactor the singleton to a standard class Inject it as a dependency Identify the singleton Locate all references to its getInstance() method getInstance() Refactor the singleton to a standard class Inject it as a dependency Sample Code Before public class DatabaseConnection {
    private static DatabaseConnection instance;

    private DatabaseConnection() {}

    public static DatabaseConnection getInstance() {
        if (instance == null) {
            instance = new DatabaseConnection();
        }
        return instance;
    }

    public void connect() { 
    }
}

public class Service {
    public void performTask() {
        DatabaseConnection connection = DatabaseConnection.getInstance();
        connection.connect(); 
    }
} public class DatabaseConnection {
    private static DatabaseConnection instance;

    private DatabaseConnection() {}

    public static DatabaseConnection getInstance() {
        if (instance == null) {
            instance = new DatabaseConnection();
        }
        return instance;
    }

    public void connect() { 
    }
}

public class Service {
    public void performTask() {
        DatabaseConnection connection = DatabaseConnection.getInstance();
        connection.connect(); 
    }
} After public class DatabaseConnection {  
    // 1. Identify the singleton 
    public void connect() { 
    }
}

public class Service {
    // 2. Locate all references to its getInstance() method.
    private DatabaseConnection connection;

    // 3. Refactor the singleton to a standard class. 
    public Service(DatabaseConnection connection) {
        // 4. Inject it as a dependency.
        this.connection = connection;
    }

    public void performTask() {
        connection.connect(); 
    }
}

DatabaseConnection connection = new DatabaseConnection();
// You can also mock the connection in your tests

Service service = new Service(connection);
service.performTask(); public class DatabaseConnection {  
    // 1. Identify the singleton 
    public void connect() { 
    }
}

public class Service {
    // 2. Locate all references to its getInstance() method.
    private DatabaseConnection connection;

    // 3. Refactor the singleton to a standard class. 
    public Service(DatabaseConnection connection) {
        // 4. Inject it as a dependency.
        this.connection = connection;
    }

    public void performTask() {
        connection.connect(); 
    }
}

DatabaseConnection connection = new DatabaseConnection();
// You can also mock the connection in your tests

Service service = new Service(connection);
service.performTask(); Type [x]Semi-Automatic [x] Semi-Automatic [x] Safety This refactoring is safe when you update all references to the singleton and handle its dependencies correctly. Testing each step ensures that no references to the singleton are missed. Why Is the Code Better? Refactoring away from a singleton makes the code more modular, testable, and less prone to issues caused by the global state. Injecting dependencies allows you to easily replace DatabaseConnection with a mock or different implementation in testing and other contexts. Tags Coupling Coupling Related Refactorings https://maximilianocontieri.com/refactoring-007-extract-class?embedable=true https://maximilianocontieri.com/refactoring-007-extract-class?embedable=true See also https://hackernoon.com/singleton-pattern-the-root-of-all-evil-e4r3up7?embedable=true https://hackernoon.com/singleton-pattern-the-root-of-all-evil-e4r3up7?embedable=true https://hackernoon.com/coupling-the-one-and-only-software-designing-problem-9z5a321h?embedable=true https://hackernoon.com/coupling-the-one-and-only-software-designing-problem-9z5a321h?embedable=true Credits Image by PublicDomainPictures from Pixabay PublicDomainPictures Pixabay This article is part of the Refactoring Series. How to Improve Your Code With Easy Refactorings How to Improve Your Code With Easy Refactorings

Refactoring 018 - How to Replace a Singleton

Authors:
(1) Dustin Podell, Stability AI, Applied Research;
(2) Zion English, Stability AI, Applied Research;
(3) Kyle Lacey, Stability AI, Applied Research;
(4) Andreas Blattmann, Stability AI, Applied Research;
(5) Tim Dockhorn, Stability AI, Applied Research;
(6) Jonas Müller, Stability AI, Applied Research;
(7) Joe Penna, Stability AI, Applied Research;
(8) Robin Rombach, Stability AI, Applied Research. Table of Links Abstract and 1 Introduction 2 Improving Stable Diffusion 2.1 Architecture & Scale 2.2 Micro-Conditioning 2.3 Multi-Aspect Training 2.4 Improved Autoencoder and 2.5 Putting Everything Together 3 Future Work Appendix A Acknowledgements B Limitations C Diffusion Models D Comparison to the State of the Art E Comparison to Midjourney v5.1 F On FID Assessment of Generative Text-Image Foundation Models G Additional Comparison between Single- and Two-Stage SDXL pipeline References G Additional Comparison between Single- and Two-Stage SDXL pipeline H Comparison between SD 1.5 vs. SD 2.1 vs. SDXL I Multi-Aspect Training Hyperparameters We use the following image resolutions for mixed-aspect ratio finetuning as described in Sec. 2.3. J Pseudo-code for Conditioning Concatenation along the Channel Axis This paper is available on arxiv under CC BY 4.0 DEED license. Authors: (1) Dustin Podell, Stability AI, Applied Research; (2) Zion English, Stability AI, Applied Research; (3) Kyle Lacey, Stability AI, Applied Research; (4) Andreas Blattmann, Stability AI, Applied Research; (5) Tim Dockhorn, Stability AI, Applied Research; (6) Jonas Müller, Stability AI, Applied Research; (7) Joe Penna, Stability AI, Applied Research; (8) Robin Rombach, Stability AI, Applied Research. Authors: Authors: (1) Dustin Podell, Stability AI, Applied Research; (2) Zion English, Stability AI, Applied Research; (3) Kyle Lacey, Stability AI, Applied Research; (4) Andreas Blattmann, Stability AI, Applied Research; (5) Tim Dockhorn, Stability AI, Applied Research; (6) Jonas Müller, Stability AI, Applied Research; (7) Joe Penna, Stability AI, Applied Research; (8) Robin Rombach, Stability AI, Applied Research. Table of Links Abstract and 1 Introduction Abstract and 1 Introduction 2 Improving Stable Diffusion 2 Improving Stable Diffusion 2.1 Architecture & Scale 2.1 Architecture & Scale 2.2 Micro-Conditioning 2.2 Micro-Conditioning 2.3 Multi-Aspect Training 2.3 Multi-Aspect Training 2.4 Improved Autoencoder and 2.5 Putting Everything Together 2.4 Improved Autoencoder and 2.5 Putting Everything Together 3 Future Work 3 Future Work Appendix Appendix A Acknowledgements A Acknowledgements B Limitations B Limitations C Diffusion Models C Diffusion Models D Comparison to the State of the Art D Comparison to the State of the Art E Comparison to Midjourney v5.1 E Comparison to Midjourney v5.1 F On FID Assessment of Generative Text-Image Foundation Models F On FID Assessment of Generative Text-Image Foundation Models G Additional Comparison between Single- and Two-Stage SDXL pipeline G Additional Comparison between Single- and Two-Stage SDXL pipeline References References G Additional Comparison between Single- and Two-Stage SDXL pipeline H Comparison between SD 1.5 vs. SD 2.1 vs. SDXL I Multi-Aspect Training Hyperparameters We use the following image resolutions for mixed-aspect ratio finetuning as described in Sec. 2.3. J Pseudo-code for Conditioning Concatenation along the Channel Axis This paper is available on arxiv under CC BY 4.0 DEED license. This paper is available on arxiv under CC BY 4.0 DEED license. available on arxiv

Additional Comparison between Single- and Two-Stage SDXL pipeline

Authors:
(1) Seokil Ham, KAIST;
(2) Jungwuk Park, KAIST;
(3) Dong-Jun Han, Purdue University;
(4) Jaekyun Moon, KAIST. Table of Links Abstract and 1. Introduction 2. Related Works 3. Proposed NEO-KD Algorithm and 3.1 Problem Setup: Adversarial Training in Multi-Exit Networks 3.2 Algorithm Description 4. Experiments and 4.1 Experimental Setup 4.2. Main Experimental Results 4.3. Ablation Studies and Discussions 5. Conclusion, Acknowledgement and References A. Experiment Details B. Clean Test Accuracy and C. Adversarial Training via Average Attack D. Hyperparameter Tuning E. Discussions on Performance Degradation at Later Exits F. Comparison with Recent Defense Methods for Single-Exit Networks G. Comparison with SKD and ARD and H. Implementations of Stronger Attacker Algorithms F Comparison with Recent Defense Methods for Single-Exit Networks The baselines in the main paper were generally the adversarial defense methods designed for multi-exit networks. In this section, we conduct additional experiments with a recent defense method, TEAT [7], and compare with our method. Since TEAT was originally designed for the single-exit network, we first adapt TEAT to the multi-exit network setting. Instead of the original TEAT that generates the adversarial examples considering the final output of the network, we modify TEAT to generate adversarial examples that maximizes the average loss of all exits in the multi-exit network. Table A3 below shows the results using max-average attack on CIFAR-10/100. It can be seen that our NEO-KD, which is designed for multi-exit networks, achieves higher adversarial test accuracy compared to the TEAT methods (PGD-TE and TRADES-TE) designed for single-exit networks. The results highlight the necessity of developing adversarial defense techniques geared to multi-exit networks rather than adapting general defense methods used for single-exit networks. This paper is available on arxiv under CC 4.0 license. Authors: (1) Seokil Ham, KAIST; (2) Jungwuk Park, KAIST; (3) Dong-Jun Han, Purdue University; (4) Jaekyun Moon, KAIST. Authors: Authors: (1) Seokil Ham, KAIST; (2) Jungwuk Park, KAIST; (3) Dong-Jun Han, Purdue University; (4) Jaekyun Moon, KAIST. Table of Links Abstract and 1. Introduction Abstract and 1. Introduction 2. Related Works 2. Related Works 3. Proposed NEO-KD Algorithm and 3.1 Problem Setup: Adversarial Training in Multi-Exit Networks 3. Proposed NEO-KD Algorithm and 3.1 Problem Setup: Adversarial Training in Multi-Exit Networks 3.2 Algorithm Description 3.2 Algorithm Description 4. Experiments and 4.1 Experimental Setup 4. Experiments and 4.1 Experimental Setup 4.2. Main Experimental Results 4.2. Main Experimental Results 4.3. Ablation Studies and Discussions 4.3. Ablation Studies and Discussions 5. Conclusion, Acknowledgement and References 5. Conclusion, Acknowledgement and References A. Experiment Details A. Experiment Details B. Clean Test Accuracy and C. Adversarial Training via Average Attack B. Clean Test Accuracy and C. Adversarial Training via Average Attack D. Hyperparameter Tuning D. Hyperparameter Tuning E. Discussions on Performance Degradation at Later Exits E. Discussions on Performance Degradation at Later Exits F. Comparison with Recent Defense Methods for Single-Exit Networks F. Comparison with Recent Defense Methods for Single-Exit Networks G. Comparison with SKD and ARD and H. Implementations of Stronger Attacker Algorithms G. Comparison with SKD and ARD and H. Implementations of Stronger Attacker Algorithms F Comparison with Recent Defense Methods for Single-Exit Networks The baselines in the main paper were generally the adversarial defense methods designed for multi-exit networks. In this section, we conduct additional experiments with a recent defense method, TEAT [7], and compare with our method. Since TEAT was originally designed for the single-exit network, we first adapt TEAT to the multi-exit network setting. Instead of the original TEAT that generates the adversarial examples considering the final output of the network, we modify TEAT to generate adversarial examples that maximizes the average loss of all exits in the multi-exit network. Table A3 below shows the results using max-average attack on CIFAR-10/100. It can be seen that our NEO-KD, which is designed for multi-exit networks, achieves higher adversarial test accuracy compared to the TEAT methods (PGD-TE and TRADES-TE) designed for single-exit networks. The results highlight the necessity of developing adversarial defense techniques geared to multi-exit networks rather than adapting general defense methods used for single-exit networks. This paper is available on arxiv under CC 4.0 license. This paper is available on arxiv under CC 4.0 license. available on arxiv

Evaluating NEO-KD Against Single-Exit Defense Methods in Multi-Exit Networks

Authors:
(1) Oleksandr Kuznetsov, Proxima Labs, 1501 Larkin Street, suite 300, San Francisco, USA and Department of Political Sciences, Communication and International Relations, University of Macerata, Via Crescimbeni, 30/32, 62100 Macerata, Italy (kuznetsov@karazin.ua);
(2) Dzianis Kanonik, Proxima Labs, 1501 Larkin Street, suite 300, San Francisco, USA;
(3) Alex Rusnak, Proxima Labs, 1501 Larkin Street, suite 300, San Francisco, USA (alex@proxima.one);
(4) Anton Yezhov, Proxima Labs, 1501 Larkin Street, suite 300, San Francisco, USA;
(5) Oleksandr Domin, Proxima Labs, 1501 Larkin Street, suite 300, San Francisco, USA. Table of Links Abstract and 1. Introduction 1.1. The Blockchain Paradigm and the Challenge of Scalability 1.2. State of the art 1.3. Our contribution and 1.4. Article structure 2. Conceptualizing the Problem 3. Our Idea for Optimizing Trees in Blockchain 4. Efficiency of adaptive Merkle trees 5. Algorithm for Merkle Tree Restructuring 6. Examples of Merkle Tree Restructuring Algorithm Execution and 6.1 Example 1: Restructuring a Binary Tree by Adding One Leaf 6.2. Example 1.1: Binary Tree Restructuring Through Leaf Node Swapping 6.3. Example 2.1: Restructuring a Non-Binary Tree by Adding a Single Leaf 6.4. Example 2.2: Restructuring a Non-Binary Tree Through Leaf Pair Swapping 6.5. Example 2.3: Restructuring a Patricia-Merkle Tree Fragment Through Leaf Pair Swapping 7. Path Encoding in the Adaptive Merkle Tree 8. Enhancing Verkle Trees Through Adaptive Restructuring and 8.1. Application of Adaptive Trees in Verkle Tree Technology 8.2. Technology and Advantages 9. Discussion 9.1. Our Contribution 9.2. Comparison with Existing Solutions 10. Conclusion and References 6.3. Example 2.1: Restructuring a Non-Binary Tree by Adding a Single Leaf In this example, we explore a non-binary tree where each node can have up to four children (m = 4), closely mirroring a simplified real-world scenario of Patricia-Merkle trees in the Ethereum blockchain. Let's assume the initial state of the tree is as shown in Figure 11.a, similar to the previous example. Also, let the newly added leaves and their probability distributions follow the pattern established in Example 1. These changes in probabilities are summarized in Table 5, which also lists the number of alternatives and the unique discrepancy value (1). Figures 21-30 depict the corresponding tree graphs. . The calculations of discrepancies in Table 5 show that the configuration of the restructured trees tends towards optimality by minimizing the average path length. Now, let's demonstrate the algorithm's operation in the mode of swapping positions between pairs of nodes, as in Example 1.1. This paper is available on arxiv under CC by 4.0 Deed (Attribution 4.0 International) license. Authors: (1) Oleksandr Kuznetsov, Proxima Labs, 1501 Larkin Street, suite 300, San Francisco, USA and Department of Political Sciences, Communication and International Relations, University of Macerata, Via Crescimbeni, 30/32, 62100 Macerata, Italy (kuznetsov@karazin.ua); (2) Dzianis Kanonik, Proxima Labs, 1501 Larkin Street, suite 300, San Francisco, USA; (3) Alex Rusnak, Proxima Labs, 1501 Larkin Street, suite 300, San Francisco, USA (alex@proxima.one); (4) Anton Yezhov, Proxima Labs, 1501 Larkin Street, suite 300, San Francisco, USA; (5) Oleksandr Domin, Proxima Labs, 1501 Larkin Street, suite 300, San Francisco, USA. Authors: Authors: (1) Oleksandr Kuznetsov, Proxima Labs, 1501 Larkin Street, suite 300, San Francisco, USA and Department of Political Sciences, Communication and International Relations, University of Macerata, Via Crescimbeni, 30/32, 62100 Macerata, Italy (kuznetsov@karazin.ua); (2) Dzianis Kanonik, Proxima Labs, 1501 Larkin Street, suite 300, San Francisco, USA; (3) Alex Rusnak, Proxima Labs, 1501 Larkin Street, suite 300, San Francisco, USA (alex@proxima.one); (4) Anton Yezhov, Proxima Labs, 1501 Larkin Street, suite 300, San Francisco, USA; (5) Oleksandr Domin, Proxima Labs, 1501 Larkin Street, suite 300, San Francisco, USA. Table of Links Abstract and 1. Introduction Abstract and 1. Introduction 1.1. The Blockchain Paradigm and the Challenge of Scalability 1.1. The Blockchain Paradigm and the Challenge of Scalability 1.2. State of the art 1.2. State of the art 1.3. Our contribution and 1.4. Article structure 1.3. Our contribution and 1.4. Article structure 2. Conceptualizing the Problem 2. Conceptualizing the Problem 3. Our Idea for Optimizing Trees in Blockchain 3. Our Idea for Optimizing Trees in Blockchain 4. Efficiency of adaptive Merkle trees 4. Efficiency of adaptive Merkle trees 5. Algorithm for Merkle Tree Restructuring 5. Algorithm for Merkle Tree Restructuring 6. Examples of Merkle Tree Restructuring Algorithm Execution and 6.1 Example 1: Restructuring a Binary Tree by Adding One Leaf 6. Examples of Merkle Tree Restructuring Algorithm Execution and 6.1 Example 1: Restructuring a Binary Tree by Adding One Leaf 6.2. Example 1.1: Binary Tree Restructuring Through Leaf Node Swapping 6.2. Example 1.1: Binary Tree Restructuring Through Leaf Node Swapping 6.3. Example 2.1: Restructuring a Non-Binary Tree by Adding a Single Leaf 6.3. Example 2.1: Restructuring a Non-Binary Tree by Adding a Single Leaf 6.4. Example 2.2: Restructuring a Non-Binary Tree Through Leaf Pair Swapping 6.4. Example 2.2: Restructuring a Non-Binary Tree Through Leaf Pair Swapping 6.5. Example 2.3: Restructuring a Patricia-Merkle Tree Fragment Through Leaf Pair Swapping 6.5. Example 2.3: Restructuring a Patricia-Merkle Tree Fragment Through Leaf Pair Swapping 7. Path Encoding in the Adaptive Merkle Tree 7. Path Encoding in the Adaptive Merkle Tree 8. Enhancing Verkle Trees Through Adaptive Restructuring and 8.1. Application of Adaptive Trees in Verkle Tree Technology 8. Enhancing Verkle Trees Through Adaptive Restructuring and 8.1. Application of Adaptive Trees in Verkle Tree Technology 8.2. Technology and Advantages 8.2. Technology and Advantages 9. Discussion 9. Discussion 9.1. Our Contribution 9.1. Our Contribution 9.2. Comparison with Existing Solutions 9.2. Comparison with Existing Solutions 10. Conclusion and References 10. Conclusion and References 6.3. Example 2.1: Restructuring a Non-Binary Tree by Adding a Single Leaf In this example, we explore a non-binary tree where each node can have up to four children (m = 4), closely mirroring a simplified real-world scenario of Patricia-Merkle trees in the Ethereum blockchain. Let's assume the initial state of the tree is as shown in Figure 11.a, similar to the previous example. Also, let the newly added leaves and their probability distributions follow the pattern established in Example 1. These changes in probabilities are summarized in Table 5, which also lists the number of alternatives and the unique discrepancy value (1). Figures 21-30 depict the corresponding tree graphs. . The calculations of discrepancies in Table 5 show that the configuration of the restructured trees tends towards optimality by minimizing the average path length. Now, let's demonstrate the algorithm's operation in the mode of swapping positions between pairs of nodes, as in Example 1.1. This paper is available on arxiv under CC by 4.0 Deed (Attribution 4.0 International) license. This paper is available on arxiv under CC by 4.0 Deed (Attribution 4.0 International) license. available on arxiv

Restructuring a Non-Binary Tree by Adding a Single Leaf

Recent Photo of HackerNoon Founder & CEO David Smooke. Tim Keary from Techopedia: Confidence in journalism is at an all time low, and artificial intelligence threatens to destabilize this further. Currently news publishers of all sizes are being forced to decide what role AI plays in the newsroom. Will they accept AI-generated content and headlines, how much AI use needs to be disclosed to readers, and will AI-generated news will take traffic away from human-written journalism? Techopedia reached out to David Smooke, founder and CEO of HackerNoon, a technology publisher with over 45,000 contributing writers and 4 million monthly readers, to find out how his organization is experimenting with AI, and to get his thoughts on how AI should be approached by journalists and news publishers. The Q&A provides a brief look at how HackerNoon is experimenting with AI in its operations, what the acceptable limits of AI’s role in the newsroom should be, Smooke’s thoughts on the The New York Times vs OpenAI lawsuit, and the future of human-written journalism. Smooke, from Colorado, founded HackerNoon in 2013, back when AI was still effectively confined to the dreams of Hollywood. Comments and formatting have been edited slightly for brevity. Tim Keary: As a journalist and the CEO of a news organization, what role do you think that AI should play in the newsroom? David Smooke: I’m more of  a writer and a product manager than a journalist. HackerNoon publishes all types of technology blog posts, like op eds, tutorials, interviews, columns, research papers, and some journalism. We’re building a community driven content management system, and there are many places where AI can assist writers, readers, and editors, such as through brainstorming new ideas, fixing grammar, or finding your next relevant story. Within our text editor, we have a custom ChatGPT layer for rewrites, a handful of image generation models, and leverage AI to generate summaries for the native character count per distribution channel. We use AI to make stories more accessible by making more versions of the story; for example we use Google AI to translate stories into foreign languages and generate audio versions of the blog post. As a consumer of news, when it comes to the newsroom specifically I would like journalists to research their stories with whatever the most advanced and relevant search technology or specific methodology that story calls for, but to never fully trust the AI, and always always verify. More specifically, what level of use is acceptable in your view, and what level of transparency is required? It’s not acceptable for content to be presented as human made when it was made by AI. Platforms should do what they can to indicate where and how AI contributed to the experience.  For example, we use emoji credibility indicators to indicate to the reader if AI assisted in the writing of the story. People on the internet should trust the author is who the site says the author is. Do you see AI-generated news sites as a threat to the future of human-written journalism? There are side effects from the mass production and mass consumption of AI generated content. Deep fakes create billions of views across social media. Platforms are getting better at detecting them and labeling them, but they are just easier than ever to make. When TUAW recently relaunched with newly AI generated content and accredited them to real humans that used to write there - it did not go over well. Writers don’t want that misattribution, and for blog posts, readers trust the content more if they trust the human on the other side of the screen. Many financial websites and tools have been using natural language processing and automation to dish out headlines in seconds because that information is important for investors. It's a speed and convenience thing vs. slower human input, but it's been going on for far longer than the generative AI boom we're currently seeing. I.e., is there a risk that AI-generated content will take clicks, attention, and money away from content that journalists have put time and effort into developing even if it can’t replicate on the ground reporting? Yes, there is a risk of more attention moving from the publisher to search experience.  If a Google generated AI search results solves the problem today that a page on someone’s site would have solved yesterday, that is a lost visitor. On the plus side for publishers, super powerful AI functions are a single API call away, meaning the publisher’s discovery and search experience may also be able to retain quality traffic longer. What do you make of The New York Times’ lawsuit against OpenAI and the wider trend of AI vendors training models on news content generated by human authors and journalists? In the future, I anticipate the government and even the private sector will reign in the wild west approach of anything on internet could be used as training data. Will this case of the New York Times vs. OpenAI be the milestone case for how content creators are compensated by AI companies? I have my doubts, but it certainly is two big names. It emerged after a content licensing agreement failed. Reading between the lines, if OpenAI was able to compensate the New York Times more, the case would have never made it to court. The verbatim regurgitation of another’s content is plagiarism. The New York Times knows this, OpenAI knows this, and even your grade school teacher knows this. I expect OpenAI to pay The New York Times more money before this is over, but I don’t see this case shaping the future for how internet content is licensed to AI training. What do you make of AI news tools like Perplexity AI which offer news summaries with citations? (Do you think these can be useful tools or is there a concern they will take readers away from traditional news sites). Curating is a value add. Sometimes, especially if given reliable and detailed rules, AI can curate as effectively as some humans. AI is 100% changing how we search and research on the internet. I’m not even certain that Perplexity’s search differentiation is the use of AI as Perplexity has amazing design choices. Was not surprised to see Meta roll out a very similar scrolling topics homepage during the launch of Meta AI chat and for SearchGPT to use a similar design for displaying relevant sources. Google search still dominates the market, their use of generative AI in search results demonstrates that generative AI will be a part of the future of the internet search market. How can news publishers use AI to enhance their operations? We use AI in a number of publishing systems across HackerNoon. Before publication, AI recommends headlines based on the story draft and past performance of HackerNoon stories. The humans still write the headlines better 95% of the time, but it’s nice to have the machines generate a few relevant options. We also use AI to better curate stories, like when we had to categorize 50k technology tags into 22 technology categories, it made more sense for an AI to make those 50k assignments than for human editors to do. Do you have any comments on the impact of AI on SEO? More specifically, do you think it’s going to be harder to rank human-written content against AI-driven content in the future? AI content is not source material. Sources will always need to be cited and linked to.  With the rise of AI generated search result summaries and the aggregate number of human to AI interactions increasing daily, it is becoming expected for search experiences to be supplemented by an AI assistant. What would you say to writers and journalists who are entering the industry who are concerned about the future of news publishing as a whole? Don’t be afraid of competing with robots. The demand for authentic human stories is as high as it's ever been. As AI floods the internet with billions of pieces of bad content, mediocre content, acceptable-ish content and even some remarkable content, great storytellers will continue to rise above. Whenever the writer lives/d, there’s barriers to entry to acquiring readers. Most of human history there were no magazines or internet. Whoever had a quality story to tell, found a way to tell their story. If you have stories to write, there are more ways than ever before to acquire readers from around the globe. Are there any other comments you’d like to add? We will always need human originality… because we’re humans, we crave human stories. Also Published as “What is the Role of AI in the Newsroom? We Ask Hackernoon’s CEO” Recent Photo of HackerNoon Founder & CEO David Smooke. Recent Photo of HackerNoon Founder & CEO David Smooke . HackerNoon Founder & CEO David Smooke Tim Keary from Techopedia : Confidence in journalism is at an all time low , and artificial intelligence threatens to destabilize this further. Currently news publishers of all sizes are being forced to decide what role AI plays in the newsroom. Tim Keary from Techopedia all time low Will they accept AI-generated content and headlines, how much AI use needs to be disclosed to readers, and will AI-generated news will take traffic away from human-written journalism? Techopedia reached out to David Smooke, founder and CEO of HackerNoon , a technology publisher with over 45,000 contributing writers and 4 million monthly readers, to find out how his organization is experimenting with AI, and to get his thoughts on how AI should be approached by journalists and news publishers. founder and CEO of HackerNoon The Q&A provides a brief look at how HackerNoon is experimenting with AI in its operations, what the acceptable limits of AI’s role in the newsroom should be, Smooke’s thoughts on the The New York Times vs OpenAI lawsuit, and the future of human-written journalism. Smooke, from Colorado, founded HackerNoon in 2013, back when AI was still effectively confined to the dreams of Hollywood. Comments and formatting have been edited slightly for brevity. Tim Keary : As a journalist and the CEO of a news organization, what role do you think that AI should play in the newsroom? Tim Keary David Smooke : I’m more of  a writer and a product manager than a journalist. HackerNoon publishes all types of technology blog posts, like op eds, tutorials, interviews, columns, research papers, and some journalism. We’re building a community driven content management system, and there are many places where AI can assist writers, readers, and editors, such as through brainstorming new ideas, fixing grammar, or finding your next relevant story. David Smooke HackerNoon HackerNoon Within our text editor , we have a custom ChatGPT layer for rewrites, a handful of image generation models, and leverage AI to generate summaries for the native character count per distribution channel. We use AI to make stories more accessible by making more versions of the story; for example we use Google AI to translate stories into foreign languages and generate audio versions of the blog post. Within our text editor As a consumer of news, when it comes to the newsroom specifically I would like journalists to research their stories with whatever the most advanced and relevant search technology or specific methodology that story calls for, but to never fully trust the AI, and always always verify. More specifically, what level of use is acceptable in your view, and what level of transparency is required? It’s not acceptable for content to be presented as human made when it was made by AI. Platforms should do what they can to indicate where and how AI contributed to the experience.  For example, we use emoji credibility indicators to indicate to the reader if AI assisted in the writing of the story. People on the internet should trust the author is who the site says the author is. emoji credibility indicators emoji credibility indicators AI assisted AI assisted Do you see AI-generated news sites as a threat to the future of human-written journalism? There are side effects from the mass production and mass consumption of AI generated content. Deep fakes create billions of views across social media. Platforms are getting better at detecting them and labeling them, but they are just easier than ever to make. When TUAW recently relaunched with newly AI generated content and accredited them to real humans that used to write there - it did not go over well. Writers don’t want that misattribution, and for blog posts, readers trust the content more if they trust the human on the other side of the screen. TUAW recently relaunched TUAW recently relaunched Many financial websites and tools have been using natural language processing and automation to dish out headlines in seconds because that information is important for investors. It's a speed and convenience thing vs. slower human input, but it's been going on for far longer than the generative AI boom we're currently seeing. I.e., is there a risk that AI-generated content will take clicks, attention, and money away from content that journalists have put time and effort into developing even if it can’t replicate on the ground reporting? Yes, there is a risk of more attention moving from the publisher to search experience.  If a Google generated AI search results solves the problem today that a page on someone’s site would have solved yesterday, that is a lost visitor. On the plus side for publishers, super powerful AI functions are a single API call away, meaning the publisher’s discovery and search experience may also be able to retain quality traffic longer. What do you make of The New York Times’ lawsuit against OpenAI and the wider trend of AI vendors training models on news content generated by human authors and journalists? In the future, I anticipate the government and even the private sector will reign in the wild west approach of anything on internet could be used as training data. Will this case of the New York Times vs. OpenAI be the milestone case for how content creators are compensated by AI companies? I have my doubts, but it certainly is two big names. It emerged after a content licensing agreement failed. Reading between the lines, if OpenAI was able to compensate the New York Times more, the case would have never made it to court. The verbatim regurgitation of another’s content is plagiarism. The New York Times knows this, OpenAI knows this, and even your grade school teacher knows this. I expect OpenAI to pay The New York Times more money before this is over, but I don’t see this case shaping the future for how internet content is licensed to AI training. this case of the New York Times vs. OpenAI this case of the New York Times vs. OpenAI What do you make of AI news tools like Perplexity AI which offer news summaries with citations? (Do you think these can be useful tools or is there a concern they will take readers away from traditional news sites). Curating is a value add. Sometimes, especially if given reliable and detailed rules, AI can curate as effectively as some humans. AI is 100% changing how we search and research on the internet. I’m not even certain that Perplexity’s search differentiation is the use of AI as Perplexity has amazing design choices. Was not surprised to see Meta roll out a very similar scrolling topics homepage during the launch of Meta AI chat and for SearchGPT to use a similar design for displaying relevant sources. Google search still dominates the market, their use of generative AI in search results demonstrates that generative AI will be a part of the future of the internet search market. How can news publishers use AI to enhance their operations? We use AI in a number of publishing systems across HackerNoon. Before publication, AI recommends headlines based on the story draft and past performance of HackerNoon stories. The humans still write the headlines better 95% of the time, but it’s nice to have the machines generate a few relevant options. We also use AI to better curate stories, like when we had to categorize 50k technology tags into 22 technology categories , it made more sense for an AI to make those 50k assignments than for human editors to do. 50k technology tags 50k technology tags 22 technology categories 22 technology categories Do you have any comments on the impact of AI on SEO? More specifically, do you think it’s going to be harder to rank human-written content against AI-driven content in the future? AI content is not source material. Sources will always need to be cited and linked to.  With the rise of AI generated search result summaries and the aggregate number of human to AI interactions increasing daily, it is becoming expected for search experiences to be supplemented by an AI assistant. What would you say to writers and journalists who are entering the industry who are concerned about the future of news publishing as a whole? Don’t be afraid of competing with robots. The demand for authentic human stories is as high as it's ever been. As AI floods the internet with billions of pieces of bad content, mediocre content, acceptable-ish content and even some remarkable content, great storytellers will continue to rise above. Whenever the writer lives/d, there’s barriers to entry to acquiring readers. Most of human history there were no magazines or internet. Whoever had a quality story to tell, found a way to tell their story. If you have stories to write, there are more ways than ever before to acquire readers from around the globe. Are there any other comments you’d like to add? We will always need human originality… because we’re humans, we crave human stories. Also Published as “What is the Role of AI in the Newsroom? We Ask Hackernoon’s CEO” Also Published as “ What is the Role of AI in the Newsroom? We Ask Hackernoon’s CEO ” What is the Role of AI in the Newsroom? We Ask Hackernoon’s CEO

"For Publishers, Super Powerful AI Functions are a Single API Call Away" says HackerNoon Founder/CEO

"ለአሳታሚዎች፣ እጅግ በጣም ኃይለኛ AI Functions ነጠላ የኤፒአይ ጥሪ ነው" ይላል HackerNoon Founder/CEO

"Nəşriyyatçılar üçün Super Güclü Süni İntellekt Funksiyaları Tək API Zəngidir" deyir HackerNoon təsisçisi/CEO

হ্যাকারনুন প্রতিষ্ঠাতা/সিইও বলেছেন "প্রকাশকদের জন্য, সুপার পাওয়ারফুল এআই ফাংশনগুলি একটি একক API কল অ্যাওয়ে"

"Para los editores, las funciones de inteligencia artificial superpoderosas están a una sola llamada de API de distancia", afirma el fundador y director ejecutivo de HackerNoon

Stories, News & Mentions about SINGLE

Single’s Stories on HackerNoon

Single's News & Mentions