android Working With Android Notification Channels Google has introduced notification channels [https://developer.android.com/preview/features/notification-channels.html] to Android Oreo. Each notification is now associated with a channel, and the user is granted control over how each channel presents notifications. For developers, channels are a double-edged sword. On the one hand, it is great
rxjava Why Not RxLifecycle? Hello. This is Dan Lew. You may or may not know me as the author of RxLifecycle [https://github.com/trello/RxLifecycle/tree/2.x]. Here’s why I’ve started pulling back from using my creation. Origins When Trello first started using RxJava [https://github.com/ReactiveX/RxJava], we
talk An Introduction to Functional Reactive Programming I gave a talk this year about functional reactive programming (FRP) that attempted to break down what gives FRP its name and why you should care. Here's a write-up of that talk. -------------------------------------------------------------------------------- Introduction Functional reactive programming has been all the rage in the past few years. But
kotlin Convincing the Kotlin compiler that code is safe One of the best features of Kotlin is its built-in null safety in the type system. Try to use a nullable type in a non-null way and the compiler will yell at you. This null safety can occasionally create some tricky situations, though. Code that you know is ironclad turns
kotlin Musings on Kotlin Ranges Here are a few interesting aspects of Kotlin ranges [https://kotlinlang.org/docs/reference/ranges.html], some of which I've found to be less-than-intuitive. Ranging on Empty Pop quiz: What does the following code output? (1..3).forEach(System.out::print) (3..1).forEach(System.out::print) If
kotlin Mutable vals in Kotlin When I first learned Kotlin, the difference between val and var seemed simple: val means immutable and var means mutable. The truth is more nuanced than that: val does not mean immutable, val means read-only. That means that you're not allowed to explicitly write to a val, but
kotlin Why Kotlin? I want to explain why I prefer Kotlin over Java. In short, the many myriad Kotlin features enable more concise and understandable code than Java without sacrificing performance or safety. Kotlin compiles to bytecode, so it can perform just as well as Java. It's got the same compile-time
android Proper Parcelable testing Check out this Parcelable [https://developer.android.com/reference/android/os/Parcelable.html] I've just written: public class Thing implements Parcelable { public static final Parcelable.Creator<Thing> CREATOR = new Parcelable.Creator<Thing>() { public Thing createFromParcel(Parcel in) { throw new RuntimeException("Oops"); } // ...skipping
android Displaying Sync State Early on, we realized that we needed some way to communicate to the user when data isn’t synced with the server yet. Otherwise, you could end up in a frustrating situation where you see a card you created on your device, but no one else can see it and
android Sync is a Two-Way Street Most of what [https://blog.danlew.net/2017/02/14/airplane-mode-enabling-trello-mobile-offline/] I’ve [https://blog.danlew.net/2017/02/26/syncing-changes/] written [https://blog.danlew.net/2017/03/02/sync-failure-handling/] so [https://blog.danlew.net/2017/03/09/the-two-id-problem/] far [https://blog.danlew.net/2017/03/14/offline-attachments/] has been
android Kotlin Puzzler: Whose Line Is It Anyways? Here's a small Kotlin puzzler. What's wrong with the following code (when used on Android)? val map = mapOf("hello" to "goodbye") map.forEach { t, u -> Log.i("tag", t + u) } I'll give you a hint: on
android Offline Attachments When writing offline mode, attachments proved to be a uniquely difficult aspect of syncing. The nature of attachments differ from other data in Trello. Most data in Trello are simple numbers and strings. Files are an entirely different beast; they’re large and unwieldy. File Permissions On Android, when a
android The Two ID Problem I want to call out a surprisingly tricky problem we ran into when developing offline mode: handling identifiers. In Trello, all models have an ID. Each board, list, card, etc. It’s how we define relationships between models as well as how we communicate with the server about them. When
android Sync Failure Handling In the last article [https://blog.danlew.net/2017/02/26/syncing-changes/] we discussed how we sync our changes with the server. Ideally, those HTTP requests would always work - if only we could walk the rosy path of best-case scenarios! Unfortunately, when it comes to network requests, all sorts
android Syncing Changes Going offline meant using our database for all immediate changes to the client. But obviously we later want to sync those changes with the server. The basic idea behind our sync is to store changes made offline as a series of deltas that are later uploaded to the server. In
android Airplane Mode: Enabling Trello Mobile Offline Good news, everyone! The Trello mobile apps now work offline! Offline mode has been the most requested mobile feature for years. It’s frustrating to lose the ability to use Trello when you enter the subway or you’re flying on a plane. Even more importantly, using Trello in an
android Correctly handling bundled Android notifications Bundled notifications on Android are a tricky business. Individual, fire-and-forget notifications are simple. You create a Notification [https://developer.android.com/reference/android/app/Notification.html], send it to NotificationManagerCompat [https://developer.android.com/reference/android/support/v4/app/NotificationManagerCompat.html] , and the system handles the rest. Bundled notifications allow
Code Deliberately All code should have a purpose. There should be just as much code as necessary to execute your goals and no more. Unintentional or unnecessary code raises many difficult questions: What is the purpose of this code? Is this code actually important? Did this code ever work? By contrast, intentional
android The Activity lifecycle vs. the world A common problem people run into with Activities are handling runtime configuration changes [http://developer.android.com/guide/topics/resources/runtime-changes.html]. This situation ought to sound familiar: 1. The user initiates a network request in an Activity. 2. The user rotates the screen. 3. The Activity is destroyed and
android Year in Review (2016) In case you missed it... here is all the public activity I've done in the last year. Articles * RxJava's repeatWhen and retryWhen, explained [https://blog.danlew.net/2016/01/25/rxjavas-repeatwhen-and-retrywhen-explained/] I found repeatWhen and retryWhen to be a couple of the most confusing RxJava operators,
android Trello Android Schema Upgrades For many years, Trello Android has used a simple system for upgrading the database schema: drop the entire database, recreate it, and repopulate the data from the server! While far from ideal, this solution worked because the Trello server was the only source of truth. Any change you made in
android A deep dive into Android View constructors I often see confusion around Android View constructors. Why are there four of them? What does each parameter do? Which constructors do I need to implement? tl;dr If you just want quick, practical advice, here's a few good guidelines: * Use View(Context) for creating Views in code.
rxjava Multicasting in RxJava Multicasting is a key method for reducing duplicated work in RxJava. When you multicast an event, you send the same event to all downstream operators/subscribers. This is useful when you're doing an expensive operation like a network request. You don't want to repeatedly execute identical
speaking How I write tech talks A few people have asked me recently about writing talks, so I thought I'd document my process. I only write technical talks, so keep in mind that some of this advice may not apply for your talk. Goals I have two goals in mind for any talk: 1.
Unlimited vacation policies are inherently unfair Unlimited vacation policies are often painted as a dream benefit that only happens in cushy tech jobs, but I think they're inherently unfair because they're entirely subjective. It's easy to prove that unlimited vacation policies are anything but: no company would allow you to
