AI is dead, long live AK: Exploring AI vs. Artificial Knowledge

“Artificial Intelligence” (AI) has been explored in Sci-fi for over 150 years sparking the imagination of technologists, futurists, and the general public with the of machines that think, learn, and even surpass human intelligence. However, as we re-enter an era of “AI” being developed, sold and used across industries we start to realise that “AI” is not genuinely “intelligent” in the human sense but is more accurately described as “Artificial Knowledge” (AK).
This distinction underscores AI’s role as an advanced tool for data recall and pattern recognition, rather than an entity possessing autonomous thought or understanding.

With this in mind during this talk, we will explore the following points:

Defining Intelligence vs. Knowledge: Clarifying the fundamental differences between intelligence—encompassing reasoning, emotional understanding, and self-awareness—and knowledge, which involves the storage and retrieval of information.

The limitations of AI: How modern AI systems operate primarily on vast datasets, algorithms, and computational power to provide useful outputs without genuine comprehension.

Case Studies in AK: Examining practical applications where AI excels in data processing, from medical diagnostics to financial forecasting, demonstrating its role as a sophisticated knowledge tool.

The Limitations of Current AI models implementations: Discussing the boundaries of AI capabilities and the ethical implications of misrepresenting AI as intelligent, including issues of trust, accountability, and societal impact.

But ultimately even if we can rebrand “AI” to “AK” and foster a more accurate understanding of its capabilities compared to that of Sci-Fi maybe the battle is already lost. Perhaps we are just too late and the marketing machine can not be stopped. AI is dead, long live AK!

Building a Kotlin Multiplatform Library in 10 Minutes. Why Not?

Day to day we make use of a huge range of libraries when writing code, from the Android software development kit (SDK) to Test libraries, helper classes and everything in between. We also will often need to consume Application Programming Interfaces (APIs) either when talking with third-party systems or just interfacing with our backend application.

Often these APIs don’t have a library, and manually consuming them can be time-consuming, documentation can often be lacking (particularly with internal APIs!) and leaves a lot of ambiguity as to what the API will return, or what parameters it expects.
With OpenAPI, developers can work together to clearly define the API contact and ensure all ambiguity is removed. These specifications can then be used to streamline the process of creating a Kotlin Multiplatform Library to consume and use these APIs.

The session will delve into the fundamentals of OpenAPI and how it serves as a comprehensive standard for API specification.
Attendees will gain insights into the benefits of utilising OpenAPI to define RESTful APIs and how this can significantly expedite the Library development lifecycle.
But let’s not just talk about it, let’s build a Kotlin Multiplatform Library, and use it in an application all within 10 minutes! We will explore the tools and techniques available, and demonstrate how they enable developers to produce robust and efficient libraries without the traditional time-consuming boilerplate coding.

Key takeaways include:

* OpenAPI Essentials: We take a look at the fundamentals of OpenAPI and its role in describing RESTful APIs. Learn how OpenAPI specifications provide a standardised way to define API contracts, enabling seamless communication between different systems.

* Automating Library Generation: Live demo highlighting the simplicity of converting OpenAPI specifications into Kotlin code, automating the generation of a multiplatform library. Discover tools and techniques that streamline the process, allowing you to focus on building features rather than writing boilerplate code.

* Real-world Use Cases: With real-world uses of both OpenAPI and generated libraries we can see just how much better the world can be with clearly defined APIs!

By the end of this talk, you will have all you need to start experimenting with OpenAPI and library generation. While we focus on Kotlin Multiplatform in this talk the knowledge and tools covered can easily be used in a whole range of programming languages!

LinuxOnAndroid - Reviving a 10 year old Android project.

The LinuxOnAndroid project was for many years a massive success, with over a million downloads on the PlayStore and at its height a thriving community of contributors and users. However, due to real-life commitments after a few years, the project had to take a back seat and was left dormant. Now, over 10 years after it all started I took on the challenge of reviving, rebuilding and creating a new Linux on Android.

We take a look at the lessons learned during this revival process, and what changed not just in Android itself but what users expect from a project like this in 2022. With the goal to share the mistakes I made, the issues I came up against and what you can do to make sure that your next project survives and evolves for the next 10 years!

From this talk, you will come away with tips and tricks to help keep your Android projects manageable long term. Help make them survive the tests of time and still be useable even if you need to go years without an update. And of course, have a good laugh at how much everything has changed, IRC anyone?

I have been an Android developer since 2009, extensively involved in open-source communities throughout my developer journey. This talk highlights some of the essential things learnt during that time and the pains of trying to bring back such an "old" project.

This talk was first given at Droidcon Berlin 2022 https://www.droidcon.com/2022/08/01/linuxonandroid-reviving-a-10-year-old-android-project/

Slides for this talk can be found at https://github.com/devwithzachary/presentations/tree/main/linuxonandroid
https://devwithzachary.github.io/presentations/linuxonandroid/deck.html

How we moved SDKs to Kotlin Multiplatform and saved the world (kind of).

This year the Client SDK engineering team made the leap into the world of Kotlin Multiplatform.
With one “simple” goal, to unify the Android, iOS and JS SDK.
We take a dive into why the team wanted to make this move, the history of the SDK and multiplatform efforts up until that point and finally how the new SDK was built!
But more importantly, we will talk about some surprising benefits of moving to Kotlin Multiplatform and how this might be the solution for your next multi-platform project!

The key points you will take away from this talk are:

* History of past codeshare/multiplatform attempts
* How Kotlin Multiplatform was different
* The improvements Kotlin multiplatform made both to the code base and the team as a whole.

This talk is the combination of my own personal experience of Kotlin Multiplatform following its progress over the past 3 years and the group experience of the Client SDK engineering team who built the past codeshare work and implemented the new SDK

The talk was first given at Vonage DevCity in October and then at Android Worldwide's January event.

Slides can be found here https://github.com/devwithzachary/presentations/tree/main/kotlin-multiplatform-saved-the-world
https://devwithzachary.github.io/presentations/kotlin-multiplatform-saved-the-world/deck.html