Development

A Case for Fast CI

How slow build times lower your team’s productivity, and how to change this.

Migrating Our Web Codebase from Flow to TypeScript

How we migrated our web codebase from Flow to TypeScript.

Fitting Text into a Bounding Frame on iOS

How to use a binary search algorithm to precisely fit multiline text into a bounding frame on iOS.

How to Handle Stacked Pull Requests on GitHub

This blog post describes how to deal with dependent pull requests on GitHub, as well as the git concepts you need to master to understand them.

What Is a Deprecated API on iOS?

A look at Apple's API evolution strategy and the effect of the deployment target and base SDK Xcode project settings.

Introducing Jetpack Compose Support

The Android PDF SDK you know and love now supports Jetpack Compose!

Practical Uses of Object URLs

Showcasing different applications of JavaScript object URLs in the browser.

HTTP Caching 101

...Or, how the cache works on your browser.

Refactoring Git Branches with Interactive Rebase and Autosquash in Android Studio

A primer on using Git's interactive rebase feature, and how to use it within Android Studio to housekeep commits.

How to Save Custom Data in Image Files

Image files hold more than just images, and in this post, you'll learn how to save custom data in them.

What Is Text Shaping and Why Do We Do It?

Some text in some languages requires text shaping to render correctly. This will explain a little about what exactly that is.

Managing CI Pipelines with Terraform

Learn about Terraform and how we use it to manage our Buildkite pipelines.

Swift Render Tests in Practice — Part III

How to automate regenerating and updating reference images for render tests.

Swift Render Tests in Practice - Part II

How to improve test failures with attachments and grouping related test output.

Swift Render Tests in Practice - Part I

How to pragmatically approach render testing for custom drawing code.

Reverse Engineering UIKit to Fix Our Top Crash

This blog post describes the process of reverse engineering UIKit to identify and fix our top crash in PSPDFKit for iOS.

Automating Test Retries

We walk through our experience of dealing with flaky tests by automatically retrying them.

Debugging Image Loading and Cropping Performance on iOS

We talk about using the Image I/O and Core Graphics APIs to improve the image loading and cropping performance in the PSPDFKit iOS SDK.

How We Debugged a Customer Problem with a Signed PDF

This blog post details how the PDF expertise of the PSPDFKit team helped unblock a customer with a tricky PDF problem.

Load Testing PSPDFKit Server

How we figured out what it takes to run PSPDFKit Server.

How We Maintain Our Public Flutter Project Using a Private Monorepo

We describe the process taken to speed up the maintenance, development, and release cycle of our public Flutter project.

Avoiding Primitive Type Saturation in Kotlin

Enough of fun getString(string: String): String – let's make greater use of Kotlin's powerful type system.

CMake Presets in Practice

What CMake presets are and why PSPDFKit hopes to use them more.

Automating Mac Catalyst Distribution with fastlane

We recently automated PDF Viewer for Mac distribution via fastlane. Here’s how you can do the same for your Mac Catalyst app.

Optimizing PDFs for Printers

How to make sure your users get a good experience when your PDF is printed.

Why Should You Care about Manual Testing?

How to approach manual testing pragmatically for quality products you can be proud of.

How a B-Tree Helped Reduce Memory Usage in Our Framework

This blog post describes the approach we took to save around 15 percent of memory in our framework by first identifying bottlenecks, and then changing one of our dictionary implementations to use a specialized data structure known as a B-tree.

A Brief Tour of Multipart Requests

...Or, how your files travel over the internet.

Why PDF Uses Floats and Word Uses EMUs

This post explores and gives examples of the units of length in Word documents.

What Contributes to Slow PDF Rendering?

We briefly cover how PDF rendering works and some reasons why rendering a PDF can be slow.

SwiftUI In Production

We recently shipped a major new feature in SwiftUI while still supporting iOS 12 in our SDK. Here's what we learned.

Server Development on Apple Silicon

A short post about the experience of using an M1 MacBook for working on our Server product.

Our Journey to ARM

A recollection of the events that led to PSPDFKit supporting ARM for our server-based products.

How to Identify Browser Bugs

Strategies to adopt for identifying browser bugs, and what to do after spotting one.

Tackling PDF Performance Issues

Digging into the internals of PSPDFKit to improve PDF performance.

The Perils of Large Files in Elixir

A post about dealing with large files in Elixir applications.

Streams of Cocoa: Why It's Still Worth Knowing NSStream

In this post, we'll look at a piece of API that many people rarely touch, if ever: Stream. It’s neither new nor shiny, but it's a powerful tool when you know how to use it.

String Literals, Character Encodings, and Multiplatform C++

How string literals are encoded by Clang and MSVC.

Frontend Performance Enhancements at PSPDFKit

A short article about the principles of performance improvements at PSPDFKit.

Advances in XCFrameworks

With Xcode 12, Apple improved the XCFramework format, which unlocks great new capabilities.

Deflaking CI Tests with xcresults

We’re sharing some techniques for tracking down and fixing flaky Xcode tests on CI.

Keyboard Navigation in SwiftUI

SwiftUI wasn’t built with keyboard support in mind, and it shows. Learn how you can rewrite keyboardShortcut to work with iOS 13 and access the underlying navigation controller to pop views on ⌘-Left Arrow.

Using the SwiftUI ColorPicker on iOS and macOS

While macOS has offered a system-provided color picker since OS X 10.0 Cheetah, iOS developers had to wait a bit longer. Let's take a closer look at the new ColorPicker (SwiftUI) and UIColorPickerViewController (UIKit) controls.

Continuous Integration: From Jenkins to Buildkite

Learn why we moved from Jenkins to Buildkite, what the current most promising services are, and how we evaluated them.

Automating macOS Provisioning with Chef

Learn how to use Chef to automatically provision macOS machines for CI: infrastructure as code

A Primer on JSON Web Tokens

What JWTs are, how they work, and how we use them at PSPDFKit.

Time Travel Debugging for C/C++

A quick look at reverse debugging/time travel debugging for C/C++.

Keeping Up with JavaScript Pointer Events

Events on the web have changed a great deal since the days of the cursor and the mouse. We examine some differences that you should be aware of.

How Updating to Kotlin 1.4 Broke Our Linter Rules

How the update to Android Gradle plugin 4.1 and Kotlin 1.4 can break custom linter rules, and how to fix it.

Managing macOS Hardware: Virtualization or Bare Metal?

We explore the different ways to run macOS in the cloud, comparing virtualization via VMware, Anka, and Orka with running a fleet of bare metal machines on Amazon or MacStadium.

Continuous Integration for Small iOS/macOS Teams

In this new series, we're sharing our approach to macOS continuous integration for smaller teams that can't dedicate an entire team to CI management or aren't willing to invest five-figure sums per year for their setup.

Executable API Documentation with the LLVM Integration Tester and FileCheck

This post covers what executable documentation is and how you can use the LLVM Integration Tester to create it.

Updating Complex Forked Projects

This blog post explains all the steps we take to stay up to date with PDFium at all times.

Caching File Downloads with URLCache in Swift

Apple has a sophisticated caching system in iOS, which is enabled by default. However, documentation around URLCache is quite sparse. Today, we'll look at the behavior of caching when dealing with large files.

Faster Compilation with Ccache 4.0

Ccache is a build cache to achieve faster compilation. With the 4.0 release, it now supports Modules, which makes it possible to accelerate projects that mix Objective-C and Swift.

Presenting Popovers from SwiftUI

Is there a way to present UIKit popovers from toolbar buttons managed by SwiftUI?

Migrating to the New Emscripten LLVM Backend

We share the experience of migrating from the old Fastcomp backend to the new LLVM backend in Emscripten.

How We're Improving Accessibility on PSPDFKit for Web

Better keyboard navigation and assistive technology support on the latest versions of our Web SDK.

The Generalized CRUD API of PSPDFKit for Web

An introduction to why and how we designed the brand-new unified CRUD API in PSPDFKit for Web.

An Introduction to LLDB Reproducers

An introduction to an experimental feature in LLDB, Reproducers, that helps reproduce bugs in the debugger itself.

The State of Debugging in WebAssembly

We share our tips and tricks for debugging issues in WebAssembly and look to the future to see what's coming.

Monitoring PSPDFKit Server with Metrics

Using data to draw insightful conclusions.

Binary Frameworks as Swift Packages

What we learned from experimenting with binary frameworks as Swift packages in Xcode 12.

Evaluating the Render Fidelity of PDF.js

We explore various issues with the render fidelity of PDF.js.

Visual Studio Code, C++, and a Docker Container

Our journey of using Visual Studio Code to develop C++ in a remote container.

Using Metal to Apply Image Filters

An overview of how to use Metal to apply filters to images to perform a simple color inversion on the input image.

C++20 in 2020: Modules

An introduction to the C++20 modules feature: what they are, their potential advantages and disadvantages, and how they are used.

Why Is the PDF Format So Well Supported on Apple Platforms?

Apple has a rich history of supporting the PDF file format, but when and how did its relationship with the PDF format begin?

A Better Way to Git Log to Understand Changes in a Big Codebase

How git log information may not be enough when developers need to understand changes in a codebase that has evolved over several years.

The Case for Lists in UICollectionView

Exploring the power and flexibility offered by creating lists using UICollectionView.

The Hidden Trap in Selective Table View and Collection View Reloads

Learn how to properly update cells in a table view or collection view without crashing.

How We Created a Real-Time Collaboration Tool Inside a PDF

This blog post takes a peek under the proverbial PDF hood to find out how we developed Instant Comments.

Direct Calls with Objective-C

Apple introduced the objc_direct attribute in Xcode 12. Learn what it does and how you can use it to your advantage.

How to Use WebAssembly Modules in a Web Worker

A short tutorial showing the use of WebAssembly in a web worker.

Supporting XCFrameworks

What we learned about XCFrameworks while migrating PSPDFKit to this new format.

NULL-Characters in Strings and Tales of Apple Radar

In iOS 11, Smart Punctuation caused data loss. Learn how we fixed the issue and how we are now cleaning up the OS-level workaround.

Generate TypeScript Declarations from a Flow Codebase

A short guide on how to generate TypeScript declarations from a Flow codebase.

Level Up Your Trackpad Support Using UIInteraction

How to make your iOS app work well with scrolling, secondary clicking and dragging on a trackpad or mouse.

Text Selection Regression in Chrome 83

How we noticed a Chrome regression and shipped a workaround in a timely fashion.

Think First, Code Later

A case study on how we design features and APIs for PSPDFKit for Android.

IDEs and Text Editors for Writing C++ Code on a Large Scale

This blog post compares different IDEs and text editors that can be used to write C++ in a big codebase.

Automated Profiling Runs in Instruments

Learn how to automate measurement runs with Instruments.

How to Effectively Measure the Performance of Your Code

This blog post explains why software that performs well is important and how we measure code performance at PSPDFKit.

How to Reduce Flakiness in Automated UI Testing on Android

This blog post discusses tips and best practices on how to reduce flakiness in automated UI testing on Android.

Preventing Surprisingly Large Objective-C Type Encodings

Objective-C stores type encoding in the binary. These encodings can become surprisingly large.

Supporting Pointer Interactions

Apple introduced new pointer events in iOS 13.4 to better support trackpad and mouse devices.

Effective Header Management in C++

How we can reduce build times and clean up our header dependencies with effective header management.

Change Android Themes Instantly Using the Circular Reveal Animation

This blog post investigates how to achieve nice animations when changing themes.

Optimizing PDF File Size

When editing PDFs, they often grow in size, but that doesn't have to be the case. Here's how we optionally optimize for size.

Our Approach to Testing a Large-Scale C++ Codebase

This blog post outlines the frameworks and techniques PSPDFKit uses to test its large-scale C++ codebase.

Investigating the Performance Overhead of C++ Exceptions

C++ exceptions have their place, but using an alternative is recommended for general program flow control.

Compiler-Based Lock Checking in C++

A short introduction to compiler-based lock checking in C++ with Clang using Thread Safety Analysis

The State of Progressive Web Apps in 2020

Examining new developments in the PWA landscape that affect mobile and desktop browsers.

The C++ Lifetime Profile: How It Plans to Make C++ Code Safer

This blog post explains what the C++ Lifetime Profile is and how it intends to make the language safer and help avoid memory management problems.

Moving a Git Repository into Its Submodule

How we improved our Git repository setup by moving our PDF Viewer for iOS repository into our PSPDFKit repository.

Adopting UIAppearance in Custom Views

Learn how to support styling your own custom views using UIAppearance.

Filtering Tests in Android

A look at the android.support.test.filters library and what it provides you with.

The Functional Side of std::optional with C++20

std::optional is already really useful, and it's about to get better with C++20.

Open Links in Safari, Not Safari View Controller

Why we changed our default for opening web links from SFSafariViewController to the Safari app.

Our Journey from Genymotion to the Android Emulator

How we migrated our Genymotion-based CI to an AVD.

WebAssembly and Emscripten Chat with Alon Zakai

A chat with Alon Zakai, co-creator of WebAssembly and creator of Emscripten.

Introduction to C++ for Swift Developers

An introduction to the C++ language for Swift developers, with an overview of reasons to use C++ and a look at differences and similarities between the languages.

Adopting Dark Mode on iOS and Ensuring Backward Compatibility

A comprehensive overview of adopting Dark Mode in an iOS app, along with a few tips to make the process of development easier.

How We Improved Keyboard Navigation Accessibility in Our Android SDK

A look at the steps we took to start improving the accessibility of our Android SDK.

Making C++ Talk to Other Languages with SWIG

Using SWIG to generate interfaces to talk to a C++ backend.

Docker import/export vs. load/save

A blog post that explains the difference between the Docker import/export and load/save commands.

The Android Drag-and-Drop Framework in Practice

Using the Android drag-and-drop framework — from theory to implementation.

Understanding the Gradle Build System

In this article, we'll explore the Gradle build system, how it works, and why it is the new standard for building Android projects.

Challenges of Using Emojis with C++

In this article, we discuss the challenges of implementing your own custom emoji support in a cross-platform way.

What Is an Intent?

An overview of intents, their uses, and pitfalls to consider.

Dealing with Large Memory Requirements on Android

This article provides tips for optimizing memory usage of your apps.

NDK Debugging

A set of tips for debugging native NDK code in Android apps.

How Do I Fix NetworkOnMainThreadException?

A post detailing what NetworkOnMainThreadException is and how to prevent it.

The Role of PSPDFKit as a PDF Processor

How we fit into the PDF landscape.

Performance Evaluation of Linked Lists

Today we'll delve into the performance evaluation of linked lists, a controversial topic among many experienced developers, and try to understand why they trigger a warning in the Error Prone report.

React Redux's New Features

An overview of React Redux's seven new features in action.

How to Await an Async Event Handler Delegate in UWP

Asynchronous programming is hard, and the WinRT interface poses further issues. Learn how to implement a deferral to wait on a user action before completing additional work.

Smoother Interactions on the Web: getCoalescedEvents()

How to use the getCoalescedEvents() method of the PointerEvent API to improve the precision of drawing apps or of any web application.

Making a Resource Thread-Safe with Locks

We discuss how to ensure thread safety and synchronization via locking.

When C++ Doesn't Move

Move semantics in C++ make your code more efficient, but sometimes a move is not performed. In this blog post, we explore why.

The Soft Keyboard on Android

Tips for working with the soft keyboard on Android.

Swizzling in Swift

A quick crash course on how to swizzle correctly, and how to do it in Swift 5.1

Working with PDF Metadata in Swift

How and what metadata can be stored in a PDF, and how to programmatically work with this information.

Retaining Objects Using a Fragment

An overview of how to use a fragment to retain objects during a configuration change.

Problems with Nullability Annotations

A look at some issues with Android's nullability annotations and how to fix them.

WWDC for First-Timers, 2019 Edition

Here's how to get the most out of Apple's Worldwide Developer Conference.

How Xcode Indexing Works and How You Can Fix IDE Problems with Your Projects

This post provides an overview of how the code assistance feature in Xcode works and how you can debug code assistance problems in your projects.

Understanding Android Dimensions

A post about existing Android dimensions, their purpose, and common conversion rules.

Gradle Task Configuration Avoidance in Android Builds

An overview of Gradle's task configuration avoidance APIs and how they are used by the Android build system.

How to Use Native C++ in UWP

How to include native C++ in your UWP app and call into it from C#.

How to Use Android App Bundles

This blog post explains what Android App Bundles are and how to upload them to Google Play.

Understanding the Difference between Bookmarks and the Outline in a PDF

Bookmarks vs. outline elements: Not everything is what it seems.

The Many Benefits of Using a Monorepo

A monorepo? Isn't that just a weird Facebook and Google thing? Why is PSPDFKit using a monorepo?

Kotlin Coroutines

A look at Kotlin coroutines and how they compare to other solutions for concurrency.

The Bittersweet iOS Document Browser

A quick look at both the benefits and downsides of using the iOS system document browser in your applications.

Debug Emscripten with the Tracing API

How to debug memory usage in an Emscripten app.

Preparing My Tax Return with Apache PDFBox, Docker, and Make

How I combined Apache PDFBox, Docker, and Make to streamline my tax return workflow.

Java 8 in Android Apps

This article explains how to enable Java 8 features in an Android app and gives an overview of the available Java 8 features.

Handling Nullability in Your Code

A brief excursion into the Java type system, nullability, and remedies for the billion-dollar mistake.

Embracing the Limits of UIActivityViewController

We talk about our experience in implementing the new sharing flow.

Using ViewModels to Retain State on Android

How to use Android's ViewModel class to retain complex objects across configuration changes.

PSPDFKit and Swift

Will PSPDFKit for iOS move to Swift? In this post, we weigh the pros and cons.

Adding Logging to Crash Reports

Understanding crash reports is often difficult without extra context. Learn how we attach application logs to crash reports via Google's Firebase Crashlytics in the free PDF Viewer for iOS app.

What Are Configuration Changes?

An overview of configuration changes on Android.

How Spaced Repetition Helps You Learn New Things

We present spaced repetition as a learning technique that can help you be more efficient at work.

Incremental and Full Save in PDFs

This article goes into what's involved when incrementally or fully saving a PDF, and why it matters.

Sharing Business Logic Using React Native

Not only can React Native be used to provide the UI for your application, but it is also a convenient way to share business logic.

Android Debug Bridge Tricks and Tips

An introduction to Android Debug Bridge (adb) and an overview of some tricks.

How to Test REST API Clients in Android Apps

This article shows how we built simple and flexible integration tests for PSPDFKit Instant that are using a custom abstraction layer on top of an OkHttp mocked web server.

What Is Ninja Refactoring, and When Should You Consider Doing It?

Tips and best practices for code refactoring.

Saving the Activity State

An overview of how to make sure your activity state is saved.

Writing and Maintaining Good Code Documentation

Tips, tricks, and techniques for documenting your code the correct way.

UWP for iOS Developers

A brief introduction to Universal Windows development for iOS developers.

Using the Bottom Navigation View in Android

An introduction to implementing bottom navigation in your app with a simple example that incorporates synced page switching as well.

Visual Studio Code for C++

How to use Visual Studio Code for C++ development.

Inspecting APK Files

This article discusses the basics of Android reverse engineering using the Apktool, smali, and Java decompilers.

Self-Sizing Table View Cells in Practice

A look at self-sizing table view cells for apps supporting iOS 10, 11, and 12, covering three implementation approaches and some pitfalls I encountered supporting these across our UI in PSPDFKit.

Generating PDFs with Ruby: 2018 Edition

This post surveys the Ruby landscape in 2018 to evaluate the current state-of-the-art of generating PDFs with Ruby.

External Storage Permissions on Android

An exploration of how permissions work, starting from a high level and working down to the lower lever managed by FUSE, the native Android module that interacts with the file system.

How to Increase the Logcat Buffer Size

Don't lose your logs. Increase your logcat buffer!

Understanding Images in PDF

We take a look at how images are stored in a PDF and discuss some important things to know about them.

How to Generate PDFs with Elixir

In this blog post, we'll look at an example of how to generate PDFs with Elixir.

Tips and Tricks for Contributing to the Swift Language

This post describes the process for contributing code to the Swift programming language, including how to propose changes to the language, write a pull request, address feedback, and make your code part of the next version of the language.

Using Signposts for Performance Tuning on iOS

A look at the different ways that we measure and try to improve performance at PSPDFKit.

Creating an Efficient App Store Screenshot Workflow

A look at how we generate our screenshots for the iOS App Store.

Time Management

A discussion of how managing time by incorporating productivity techniques, making lists, planning your days, and finding ways to utilize downtime can help with your workflow.

iOS HEIC Performance

We evaluate the encoding and decoding performance of HEIC.

Rendering Tests Using Robolectric

Rendering tests using Robolectric with a custom bitmap shadow.

PDF Syntax 101

An overview of the internal structure of a PDF.

Challenges of Adopting Drag and Drop

A recap of how we integrated drag-and-drop support into our Document Editor in iOS.

What Are Kotlin Contracts and How Are They Useful?

An overview of the experimental Kotlin Contracts API.

What’s Hiding in Your PDF?

PDFs hold information you may not know about. Discover different forms of metadata and where to look for them.

Using Paths to Draw Shapes with Borders

How to use a flexible path API to draw complex shapes with borders.

How to Use Docker Compose to Run Multiple Instances of a Service in Development

In this blog post, we’ll look at an example of how we can run multiple instances of a service with Docker Compose.

Using Clang-Tidy and Integrating It in Jenkins

The benefits of using clang-tidy and how to get started setting it up in Jenkins.

Refactoring Large Codebases: Tips and Tricks

If you're going to fall down a rabbit hole anyway, you might as well enjoy it!

Improving Dynamic Type Support

How to improve Dynamic Type support in your app and bring it to the next level.

Building Accessible Modals with React

In this blog post, we will look at some simple solutions that we use at PSPDFKit to make our modals more inclusive and accessible.

How to Extend LLDB to Provide a Better Debugging Experience

Explore the extensibility capabilities of LLDB, a debugger for Swift, C, C++, and Objective-C code.

PWA - Progressive Web Applications

PSPDFKit for Web and Progressive Web Applications: an open source example and guide.

Marzipan: Porting iOS Apps to the Mac

With macOS Mojave, Apple is adding support to bring apps written in UIKit to macOS without the requirement of having to rewrite the UI in AppKit. This is not yet officially supported — this post will explore what we can expect in 2019 and how you can use Marzipan today.

The Challenges of Changelogs

How we handle changelogs at PSPDFKit and the tools we built to help us with this.

Naming Is Hard - Difficulties of Naming Variables

Is naming a variable so hard? According to Martin Fowler, it is. In this blog post, I'll try to shed some light on what naming entails and why it's a challenge.

Naming Classes - Why It Matters, and How to Do It Well

Tips for choosing good class names.

How to Parse XML Documents in Elixir

A tutorial on how to parse XML documents in Elixir.

Protecting PDF Documents

Password-based security for PDF documents.

Debugging WebView in UWP Apps with Edge DevTools

We show how a developer can use Edge DevTools to debug a WebView in a UWP app.

RxJava for Multi-Level Data Retrieval

RxJava can be useful for many things, and in this post, we’ll have a look at how to use it to add offline support to your app.

Switching to a Standing Desk

We discuss some of the benefits of switching to a standing desk.

Database Transactions with Ecto

How to use database transactions and Ecto.Multi in Elixir

Immutable.js and Lazy Evaluation

A short introduction to Immutable.js and how lazy operations improve performance and readability of your code.

Modern CMake Tips

There are better ways to write CMake scripts.

Adding Spellchecking to Your Tests

How we added simple spelling and grammar checks to our website build process to catch some common mistakes.

How I Got Started with Flutter

A short review of Flutter from a mobile developer’s standpoint.

How to Build a Back-Pressure Queuing System in Elixir with sbroker

Tutorial on how to set up a back-pressure queuing system in Elixir with sbroker.

An Introduction to Stimulus.js

In this article, we'll look at the Stimulus JavaScript framework and how it can help bring some order to a website's frontend codebase.

Moving Your Gradle Build Scripts to Kotlin

Another take on writing your project's Gradle build files in pure Kotlin code.

A Real-World WebAssembly Benchmark

A WebAssembly Benchmark for browser vendors to test a real-world production application.

Smart Grid Sizing

How PSPDFKit is smart about choosing thumbnail sizes.

Tips for Designing an Android Library

We take a look at some of the things you should keep in mind when designing an Android library.

Reviewbot

Reviewbot posts GitHub pull requests that are ready to be reviewed into Slack. How does it know when a pull request is ready? We have a special label in our repositories, named `READY TO REVIEW`.

Line Annotations in PDF

Line annotations are one of the most frequently used annotation types, and they are ideal for things like drawing attention to important areas of your document, diagramming the process flow, and decoration.

Rendering PDF Previews

An overview of how to render PDF previews.

Advances in Auto Layout

An overview of how Auto Layout has changed in recent years and how to best use it.

Async Stacktraces in Android Studio

How to create asynchronous stacktraces in Android Studio and IntelliJ.

Smart Punctuation on iOS 11

We explain iOS 11's Smart Punctuation and discuss how it affects string handling in your app.

What Are Appearance Streams?

An explanation of what appearance streams actually are, along with their gotchas.

RxJava Is Async yet Blocking

An explanation of why RxJava is both asynchronous and blocking.

How to Manage Multiple System Configurations Using Docker Compose

This blog post is a short introduction to Docker Compose and will explain how we use it to manage different system configurations that are built off the same base configuration.

The Subtle Art of Real-Time Debugging With Android Studio

Debugging in real time with Android Studio.

Hints for Beginners Navigating Around New Code

We share some tips on how to navigate a new codebase.

Failable Methods with Djinni

In this article, we have look at using result types to model failable computations in the Djinni IDL.

Using webpack with Middleman

We explain how to integrate Middleman and webpack to boost your frontend productivity.

Leveraging SQLite Full-Text Search on iOS

We look at SQLite’s FTS extension and how you can use it to add high performance search to your app.

Forms in PDF

Forms provide a simple yet flexible way to gather data from users.

UICollectionView All the Things!

`UICollectionView` is now at the heart of every document. This blog post talks about why and how we rewrote our view hierarchy.

Using Kotlin to Make the PSPDFKit API Even Better

Kotlin provides the ability to extend any class with new functionality, and we can use this to expand the PSPDFKit API.

Rendering PDFs on Android

How to handle rendering large amounts of bitmaps and maintain a slick UX while doing it.

Optimizing WebAssembly Startup Time

Four simple yet effective solutions we currently employ in PSPDFKit for Web to reduce WebAssembly startup time.

How to Run Your Phoenix Application with Docker

We’re taking a look at how to run Elixir applications within a Docker container, and how that can simplify the setup of development and deployment environments.

Android Studio Shortcuts: How to Boost Your Productivity

The best shortcuts for Android Studio. The most famous and the most underrated.

Binary Frameworks in Swift

ABI? Module stability? What does binary stability mean, and how will it affect you?

Simple Kotlin Tips for Beginners

Useful tricks for beginners to start writing better code with Kotlin.

What Are Annotations?

Annotations allow users to add custom content on PDF pages.

Extracting Text from a PDF

The difficulties of extracting text from a PDF and how PSPDFKit can help.

Adopting Drag and Drop on iOS

Utilizing the new Drag and Drop feature in iOS 11, and how we integrated it to enhance the user experience.

Make Android Animations Reactive with VanGogh

Android view animations powered by RxJava 2.

Challenges of Supporting iPhone X

Tips and tricks for adding support for the iPhone X in PSPDFKit.

How to Use iOS Data Protection

How apps can use iOS Data Protection to secure their files.

Native View Controllers and React Native - It Just Works™

WebAssembly: A New Hope

What is WebAssembly, and what does it mean for the web?

Secure Media Playback on Android

Picking smart defaults with security in mind when playing videos on Android.

User Breakpoints in Xcode

User breakpoints are a not very well known feature in Xcode but they are very powerful and can improve your debugging experience and show issues more prominent.

Linting and Code Formatting at PSPDFKit

How we do code formatting in C++/Objective-C/Java/JavaScript

50 Shaders of Android: Drawing on Canvas

Low-level drawing and animation on Android using Canvas and powerful Shader classes.

Creating Better User Experiences with Animations and Lottie

Improving an app’s User Experience made easy by adding animations powered by Lottie.

How We Test and Generate Interactive CSS Documentation

Automating CSS testing and documentation with Hound and Webdriver

Internationalization - Right to Left Support for Mobile Apps

What Right to Left Support Actually Means and How We Implemented It

Writing Concise Code with Kotlin and RxJava

Tips and tricks how to write readable, concise, and beautiful code using the Kotlin language and RxJava.

How to Build Free-Hand Drawing Using React

We implement a simple vector based free-hand drawing with React using SVG.

Everybody Designs: An Agile Approach to Design

How PSPDFKit uses an agile approach for design work

Running Tests with Clang's AddressSanitizer

Clang has powerful sanitizers that are incredibly useful, so we collected our experiences using them between iOS, Android, and our C++ core to help you through some gotchas.

Android animations powered by RxJava

The purpose of this post is to show you how to combine RxJava features with animations on Android to create a great user interface without a lot of nested code.

PSPDFKit 💖 React Native

Debugging a specific instance with scripted breakpoints

When debugging an issue that is somewhere deep inside your code, you easily end up debugging a class that has lots of living instances. Sometimes, you are only interested in a very particular one. This can become very tedious work.

Writing Good Bug Reports

At PSPDFKit, we work every day to read through developers' bug reports. In fact, we forward many of them to the engineers at Apple. While this post is Apple-centric, many details can be applied to any sort of bug reporting.

Spicing up status messages

At PSPDFKit, we likely spend just as much time polishing the UI as we do implementing PDF features or tweaking the performance. Here's a look at how one of our developers explored improving our status messages.

Just a simple bookmark

When books became digital, bookmarks became more complicated. Instead of stuffing a piece of paper in a book, you now had to store a digital marker, which is not always as simple as it looks.

Kotlin-Ready Online Guides

Our Guides received a large update – now with Kotlin usage examples.