Kotlin/Native requires that C libraries are compiled with a specific verison of GCC.
You can use the GCC used by Kotlin/Native itself. These Gradle tasks will help with this.
// build.gradle.kts
import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTarget
import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
For work I have an Intel Core i5 MacBook. With the Docker Desktop license changes I looked into minikube and Multipass but both failed when I got on our VPN with Cisco AnyConnect due to bridged networking in hyperkit (see links at bottom).
I realized I would be happy SSHing into a local Linux VM but passed on VirtualBox to avoid depending on legacy system extensions. I landed on libvirt for the VM, then realized I could remove libvirt from the equation to finally end up at this quick, simple setup for an Ubuntu VM on macOS with QEMU.
First, install QEMU (see https://wiki.qemu.org/Hosts/Mac for other o
| class UploadFilesUseCase( | |
| private val schedulerProvider: SchedulerProvider, | |
| private val httpManager: HttpManager | |
| ) { | |
| private var operation: Completable? = null | |
| fun uploadFiles(): Completable = synchronized(this) { | |
| operation | |
| ?: (doUploadFiles() |
| import kotlinx.coroutines.FlowPreview | |
| import kotlinx.coroutines.Job | |
| import kotlinx.coroutines.cancelAndJoin | |
| import kotlinx.coroutines.coroutineScope | |
| import kotlinx.coroutines.flow.Flow | |
| import kotlinx.coroutines.flow.collect | |
| import kotlinx.coroutines.flow.flow | |
| import kotlinx.coroutines.launch | |
| /** |
State machines are everywhere in interactive systems, but they're rarely defined clearly and explicitly. Given some big blob of code including implicit state machines, which transitions are possible and under what conditions? What effects take place on what transitions?
There are existing design patterns for state machines, but all the patterns I've seen complect side effects with the structure of the state machine itself. Instances of these patterns are difficult to test without mocking, and they end up with more dependencies. Worse, the classic patterns compose poorly: hierarchical state machines are typically not straightforward extensions. The functional programming world has solutions, but they don't transpose neatly enough to be broadly usable in mainstream languages.
Here I present a composable pattern for pure state machiness with effects,
The native UI toolkits on Android and iOS are frustratingly imperative. Unfortunately, there has been little architecture evolution (unlike the web). However, nothing(ish) is stopping us from bolting something "nice" on top. By nice I mean single-atom-state purely functional reactive composable UI components. In this post, I'll explain what this title means, the inspiration behind the design of the framework, an example component, and dive a little into the framework's implementation.
Right now, there only exists a Kotlin (Android) implementation, but a Swift port will be relatively straightforward and will happen soon.
| // add this to the general build.gradle, not in the subproject's build.gradle | |
| // improved version of Xavier's tip http://tools.android.com/tech-docs/new-build-system/tips#TOC-Improving-Build-Server-performance. | |
| // usage example default, preDex will be enabled: gradle clean build | |
| // usage example disabling preDex: gradle clean build -PpreDexEnable=false | |
| // preDexEnable parameter's value can be set as property of Continuous Integration build config | |
| // this is the main difference from Xavier's workaround where he doing only hasProperty check | |
| project.ext { | |
| if (project.hasProperty('preDexEnable')) { |
| def toCamelCase(String string) { | |
| String result = "" | |
| string.findAll("[^\\W]+") { String word -> | |
| result += word.capitalize() | |
| } | |
| return result | |
| } | |
| afterEvaluate { project -> | |
| Configuration runtimeConfiguration = project.configurations.getByName('compile') |
(by @andrestaltz)
If you prefer to watch video tutorials with live-coding, then check out this series I recorded with the same contents as in this article: Egghead.io - Introduction to Reactive Programming.
| apply plugin: "java" | |
| apply plugin: "eclipse" | |
| apply plugin: "maven" | |
| apply plugin: "findbugs" | |
| apply plugin: "pmd" | |
| def defaultEncoding = 'UTF-8' | |
| [compileJava, compileTestJava]*.options*.encoding = defaultEncoding | |
| sourceCompatibility = 1.7 |