Welcome, Kotliners!

This is a group for anyone interested in Kotlin and located in Sydney, Australia. All developers welcome, regardless of their occupation: Android, backend, frontend or anything else. Meet new people, listen to interesting talks and expand your knowledge of this great language.

Join us for the next iteration of the Kotlin meetup at yet another new venue/sponsor Deputy. We are excited to welcome an overseas guest straight from JetBrains, Eugene Petrenko, who's in town for other engagements and offered to give a talk about Kotlin/Native at the meetup.

Native with Kotlin/Native

Have you tried Native with Kotlin/Native? It compiles your Kotlin code for various native platforms, including iOS, Mac, Linux, and Windows. No virtual machine is needed! The native world brings native libraries, C static and dynamic libraries, Apple frameworks, Swift and Objective-C dependencies. Kotlin adds multiplatform libraries to share Kotlin code between different platforms. That is the way to share code between Android and iOS, between backend and frontend, between JVM, JavaScript, C, and Swift/Objective-C. You benefit from both platform libraries and multiplatform pure Kotlin libraries. Join us to learn about native development new Kotlin/Native, code reuse between platforms and multiplatform development fun.

Coroutines to the Rescue!

Asynchronous or non-blocking programming is the new reality. Whether we're creating server-side, desktop or mobile applications, using microservices architecture or not, it provides an experience that is not only fluid from the user's perspective, but scalable when needed. Coroutines is a new feature that was released in Kotlin 1.3 and has similar counterparts in other languages like C# and JavaScript. Let’s understand together what it is all about.

Kotlin meetup is resuming in March this year and this one will be at yet another new venue, provided by Microsoft Reactor. Talks from a long time attendee, first time speaker, Andrew Gallasch, and a Microsoft local, Dave Glover. Should be fun!

Readable, Reusable, Maintainable... and all these words that end in -ible

Kotlin is a very expressive language, allowing a developer to say a lot with little code. In this talk I'll show you how to get the most out of some of my favourite features of the language and how to avoid falling into some common traps.

Building an End-to-End Secure, Scalable IoT Serverless Solution

Learn how to build and run your IoT solutions securely and at scale. We will cover device security with Azure Sphere, distribute intelligence to the edge with Azure IoT Edge, and building real-time serverless solutions with Azure Functions and Azure SignalR.

Last meetup of 2018, can you believe it? This month we welcome a new host and sponsor, Outware Part of Arq Group, and we should have a great programme of talks lined up to send you into the season of office parties.

Kotlin Collections vs Java Streams

The Kotlin Collections API is great for processing complex data structures with readable code. But what’s the performance impact compared to using Java Streams? This talk will cover how to avoid the obvious pitfalls and when to chose readability over performance.

Exploring Kotlin Functions - Let’s have some fun()

The goal of this talk is learning about Kotlin functions and how they differ from the ones in Java. The discussion is around variety of scopes offered by Kotlin functions and variations on how they can be invoked. In addition, we will also take a look at lambdas and reified type parameters.

Time for the next meetup and we're back to the host that started it all (even before we were a separate user group) - Atlassian. The two talks cover a broad spectrum, between just starting out with Kotlin and attempting circuit breaking, something for everyone.

Circuit Breakers with Resilience4J

This short talk is an introduction to Circuit Breakers. We'll use Resilience4J to add a circuit breaker to an example Spring Boot + Kotlin application and then watch its behaviour as errors are encountered.

Data Science and Other Buzzwords

Kotlin continues to conquer new areas of software development, but some are still firmly held by one or two languages. Data science, statistical analysis and machine learning are largely Python domains, but with many performance-focused implementations based on the JVM, Kotlin has a good chance to break into this scene too. The intention of this talk is to give a shallow overview of what you can do today.

Thinking of Changing Career Direction?

Are you working with one technology and contemplating the move to another? Or are you considering pivoting into a whole other 'post-technical' career? Are you feeling nervous because it's uncharted territory? This talk might be for you!

It's already been one year since we started Sydney Kotlin User Group, let that sink in! This will be our first anniversary meetup with two great talks, as always, and some reflection on the past events, so think about some feedback that you can contribute.

Distributed Tracing - Know Your Enemy

Modern web applications consist of multiple services often deployed on hundreds of different machines. This allows them to be scalable, evolve quickly, deploy often. However, these distributed architectures contain new challenges for debugging. Luckily for us, there is a solution - distributed tracing. In this talk, I'll go through the experience of integrating distributed tracing at Canva, the decisions we made and the challenges we faced.

Writing Gradle in Kotlin

This talk covers all you need to know to migrate your Gradle scripts from Groovy to Kotlin. The richer syntax of Kotlin makes your build scripts and utility methods more readable and who really wants to be writing Groovy?

Having resolved April's scheduling woes, the next meetup is now confirmed for May. And what a line-up we have on offer: one special overseas guest and one cancelled talk from last year that never got re-scheduled until now.

Vaadin on Kotlin

We will see how we can migrate a Vaadin App from Java to Kotlin. Step by step we will transform the code of an app to see the difference. What are the easy parts, what looks like a little bit more work?

Kotlin and Bluetooth LE

Exploring how Kotlin can improve the size, simplicity and maintainability of Android Bluetooth LE code, from reducing boilerplate, simplifying control structures, and using coroutines. Creating a solid Bluetooth LE driver in just a few pages of code.

Application Continuum

The Application Continuum is a spectrum of system architecture, showing the evolution of a distributed system starting from a single application and evolving into several applications and services. This tool will help you to make conscious design decisions and potentially reduce the cost of changing code as the system needs to evolve. The continuum is language agnostic and applies to any modern programming language, however, the provided examples will be all in Kotlin. So if you like Kotlin, and enjoy a bit of monolith-vs-microservices discussion, please join us!

Introduction to Arrow

Funktionale and Kategory have merged into Arrow, consolidating two of the most popular FP libraries in the Kotlin space into one powerhouse. This talk is an introduction to some FP concepts, how the libraries work, what features they bring to the table and where you might use them in your code.

The beginning of this month marked the first ever KotlinConf in San Francisco and we'll use the last meetup of the year to recap some of the more interesting talks from the conference. Simon Gerber from Tyro will also give a talk about his fancy parser combinators.

KotlinConf 2017 Recap

Summary of the better talks, the more interesting themes, some conversations with other Kotliners and overall impressions about the first ever Kotlin conference in San Francisco. Think of it as your guide to what recorded talks to watch first.

Welcome back for another meetup! This month we're borrowing Manuel Chakravarty from the Haskell and Swift communities to discuss the benefits of having strong types, and one of our co-organisers, Mitchell Tilbrook, is going to explain what decompiled Kotlin code looks like. Come along and meet other fellow Kotliners in your area.

A Type is Worth a Thousand Tests

In this talk, I will explain the advantages of a strong commitment to a sophisticated type system. I will illustrate the impact on language and program design through a series of examples, drawn from my experience of developing one of the first Swift-based applications published in the Mac App Store and illustrated by walking through key design issues in a simple iOS app. I will discuss why type-driven design benefits from functional programming principles, and also, how it allows us to write less tests without a loss of confidence in our code.

Kotlin Backstage

Kotlin offers a more modern language design over Java, while still being fully interoperable: data classes, properties, delegation, inline functions, string interpolation and much more. But what does all this syntactic surger translate to? In this talk, we will take a look at some of the bytecode that Kotlin generates to support our sweet tooth.

We're helping organise the next YOW! Night in Sydney and it's a must-attend for anyone interested in Kotlin. Here's your chance to meet Svetlana Isakova, a developer and author who actually works on the language and wrote a book on it.

You Can Do Better With Kotlin

This YOW! Night is devoted to the Kotlin programming language. It’s a modern language that gives more power in everyday routines and is gaining popularity amongst the Java developer community.

Kotlin code generally looks cleaner and nicer, and it’s much easier to work with when you have less verbosity or code duplication. But what’s even more important, is that Kotlin is 100% compatible with all existing Java frameworks, and has good tooling (it’s from JetBrains after all).

Our agenda for the night consists of three parts:

Introduction to the language

Introduction to Kotlin Coroutines

Practical sides of Java interop

At first, we'll discuss what makes Kotlin so attractive to developers and cover the most important features of the language. Then, we'll talk about coroutines, a new powerful feature, that changes your habits of writing asynchronous code. The last part is aimed mainly at people who already have some experience with Kotlin and dives into some internals of mixing Java and Kotlin code in one project.

We're back with the first regular meetup for Sydney Kotlin User Group! While sharing the venue with NDC Sydney 2017 this time around, we're also sharing one of their speakers - Hadi Hariri - whose talk will be sandwiched between his 'Introduction to Kotlin' and 'Advanced Kotlin' full-day workshops for the conference. Two other talks are sourced from the local Android and JVM communities.

Asynchronous Programming with Kotlin

Kotlin’s approach to asynchronous programming is about giving developers the freedom to choose what fits best. By leveraging the conventions of the language and its ability to be somewhat extended by using simple functions, Kotlin provides an asynchronous model by implementing coroutines, and provides a series of out of the box functionality such as yield, async/await as part of the standard library. In this session we’re going to see how all of this works and how Kotlin even provides us the ability to implement our own asynchronous functionality.

We are organising the first ever Kotlin Night in Australia! But the good news don't end there, this will also be the start of regular meetups for Sydney Kotlin User Group. Come along and meet other fellow Kotliners in your area.

Fantastic DSLs and Where to Find Them

Kotlin is a very rich language. Unlike many other languages, it allows building another language inside itself. For example, mimic HTML syntax or construct completely typed SQL query. But Kotlin’s power isn’t limited to simple DSLs. With some Kotlin-fu, it’s possible to write a DSL that allows working on untyped data structures in a typed manner. In this talk, we’ll go through different ways to define a DSL in Kotlin, from very simple to fantastically powerful.

A 100% Kotlin on Android

In this talk we will look at the lessons learned from writing an Android app completely in Kotlin. We will look at the advantages and disadvantages of using Kotlin and how it plays with other technologies used, like RxJava & Realm.

The interest in Kotlin has been growing steadily for the past couple of years, so having done a few talks as part of the Android meetup, we decided to host a separate event dedicated entirely to Kotlin. Luckily for us, the VP of Developer Advocacy at JetBrains is coming to town and we invited him to give a talk. Come along if you’re interested in Kotlin, there will be interesting talks, pizza, beer and some giveaways.

A Deeper Dive into Kotlin

In this talk we're going to dive a bit deeper into some powerful aspects of Kotlin that provide us with great functionality. We're going to cover topics such as delegation, higher-order extension functions, inline and reified functions, and some other features that allow us to create DSL for using in our applications. In addition we'll look at some of the new things coming out in Kotlin 1.1, and in particular Coroutines, Type Aliases, Local Delegation Properties and Inline Properties.

Asynchronous Vert.x Applications in Kotlin

Looking at web development, Spring seems to be the star of most Kotlin articles and tutorials. This talk will explore an asynchronous alternative that is Vert.x and evaluate its production readiness. We’ll do that by writing a simple (but working) web API, with some neat Kotlin features to boot, and figure out what the benefits of using this framework are.