Principles we apply to improve our CI efficiency.
A tale of how reading an error message more carefully allowed us to work around an issue with our tooling.
An overview of a particular margin collapsing scenario I discovered while working on headers and footers support for PDF Generation.
A dive into details of how we replicated the system magnifying glass on iOS.
How to test an Office to PDF conversion result that one would deem great and others would deem poor.
A blog post explaining how we built rate limiting for test requests in PSPDFKit API.
We tried rewriting a part of our PSPDFKit Catalog example project in SwiftUI. Here's what we learned.
In this blog post, I'll show the quickest possible way to summarize a PDF document using machine learning and a natural language processing model called BART.
Some real-life examples of how we use property testing in PSPDFKit Server testing.
What I learned while working on cross-platform mobile frameworks.
The second part of a series of posts about doing good code reviews, with tips from the code writer's side.
Loading .obj files with .mtl using Three.js in Android.
A short story about scaling performance based on a support ticket.
Learn how to evaluate and select the best PDF generator API for your use case.
A short peek at the CD pipeline powering our PSPDFKit API product.
A dive into the PDF and DOCX formats to understand the advantages of each.
How to present the UI as popovers on iPhone when using SwiftUI.
An article with tips about how to do effective code reviews that have an impact on the quality of a codebase.
A few lessons we learned about API design for modern Android.
A step-by-step tutorial explaining how to download multiple files from a server with a single request.
How to successfully establish and verify SSL connections against a PostgreSQL server from an Elixir application.
Transfer Android's TextView autosizing capability to EditTexts
What does the -ffast-math optimization really do, and when is it safe to use it?
How slow build times lower your team’s productivity, and how to change this.
How we migrated our web codebase from Flow to TypeScript.
How to use a binary search algorithm to precisely fit multiline text into a bounding frame on iOS.
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.
A look at Apple's API evolution strategy and the effect of the deployment target and base SDK Xcode project settings.
The Android PDF SDK you know and love now supports Jetpack Compose!
...Or, how the cache works on your browser.
A primer on using Git's interactive rebase feature, and how to use it within Android Studio to housekeep commits.
Image files hold more than just images, and in this post, you'll learn how to save custom data in them.
Some text in some languages requires text shaping to render correctly. This will explain a little about what exactly that is.
Learn about Terraform and how we use it to manage our Buildkite pipelines.
How to automate regenerating and updating reference images for render tests.
How to improve test failures with attachments and grouping related test output.
How to pragmatically approach render testing for custom drawing code.
This blog post describes the process of reverse engineering UIKit to identify and fix our top crash in PSPDFKit for iOS.
We walk through our experience of dealing with flaky tests by automatically retrying them.
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.
This blog post details how the PDF expertise of the PSPDFKit team helped unblock a customer with a tricky PDF problem.
How we figured out what it takes to run PSPDFKit Server.
We describe the process taken to speed up the maintenance, development, and release cycle of our public Flutter project.
Enough of fun getString(string: String): String – let's make greater use of Kotlin's powerful type system.
What CMake presets are and why PSPDFKit hopes to use them more.
We recently automated PDF Viewer for Mac distribution via fastlane. Here’s how you can do the same for your Mac Catalyst app.
How to make sure your users get a good experience when your PDF is printed.
How to approach manual testing pragmatically for quality products you can be proud of.
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.
...Or, how your files travel over the internet.
This post explores and gives examples of the units of length in Word documents.
We briefly cover how PDF rendering works and some reasons why rendering a PDF can be slow.
We recently shipped a major new feature in SwiftUI while still supporting iOS 12 in our SDK. Here's what we learned.
A short post about the experience of using an M1 MacBook for working on our Server product.
A recollection of the events that led to PSPDFKit supporting ARM for our server-based products.
Strategies to adopt for identifying browser bugs, and what to do after spotting one.
Digging into the internals of PSPDFKit to improve PDF performance.
A post about dealing with large files in Elixir applications.
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.
How string literals are encoded by Clang and MSVC.
A short article about the principles of performance improvements at PSPDFKit.
With Xcode 12, Apple improved the XCFramework format, which unlocks great new capabilities.
We’re sharing some techniques for tracking down and fixing flaky Xcode tests on CI.
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.
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.
Learn why we moved from Jenkins to Buildkite, what the current most promising services are, and how we evaluated them.
Learn how to use Chef to automatically provision macOS machines for CI: infrastructure as code
What JWTs are, how they work, and how we use them at PSPDFKit.
A quick look at reverse debugging/time travel debugging for C/C++.
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 the update to Android Gradle plugin 4.1 and Kotlin 1.4 can break custom linter rules, and how to fix it.
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.
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.
This post covers what executable documentation is and how you can use the LLVM Integration Tester to create it.
This blog post explains all the steps we take to stay up to date with PDFium at all times.
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.
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.
Is there a way to present UIKit popovers from toolbar buttons managed by SwiftUI?
We share the experience of migrating from the old Fastcomp backend to the new LLVM backend in Emscripten.
Better keyboard navigation and assistive technology support on the latest versions of our Web SDK.
An introduction to why and how we designed the brand-new unified CRUD API in PSPDFKit for Web.
An introduction to an experimental feature in LLDB, Reproducers, that helps reproduce bugs in the debugger itself.
We share our tips and tricks for debugging issues in WebAssembly and look to the future to see what's coming.
Using data to draw insightful conclusions.
What we learned from experimenting with binary frameworks as Swift packages in Xcode 12.
We explore various issues with the render fidelity of PDF.js.
Our journey of using Visual Studio Code to develop C++ in a remote container.
An overview of how to use Metal to apply filters to images to perform a simple color inversion on the input image.
An introduction to the C++20 modules feature: what they are, their potential advantages and disadvantages, and how they are used.
Apple has a rich history of supporting the PDF file format, but when and how did its relationship with the PDF format begin?
How git log information may not be enough when developers need to understand changes in a codebase that has evolved over several years.
Exploring the power and flexibility offered by creating lists using UICollectionView.
Learn how to properly update cells in a table view or collection view without crashing.
This blog post takes a peek under the proverbial PDF hood to find out how we developed Instant Comments.
Apple introduced the objc_direct attribute in Xcode 12. Learn what it does and how you can use it to your advantage.
A short tutorial showing the use of WebAssembly in a web worker.
What we learned about XCFrameworks while migrating PSPDFKit to this new format.
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.
A short guide on how to generate TypeScript declarations from a Flow codebase.
How to make your iOS app work well with scrolling, secondary clicking and dragging on a trackpad or mouse.
How we noticed a Chrome regression and shipped a workaround in a timely fashion.
A case study on how we design features and APIs for PSPDFKit for Android.
This blog post compares different IDEs and text editors that can be used to write C++ in a big codebase.
Learn how to automate measurement runs with Instruments.
This blog post explains why software that performs well is important and how we measure code performance at PSPDFKit.
This blog post discusses tips and best practices on how to reduce flakiness in automated UI testing on Android.
Objective-C stores type encoding in the binary. These encodings can become surprisingly large.
Apple introduced new pointer events in iOS 13.4 to better support trackpad and mouse devices.
How we can reduce build times and clean up our header dependencies with effective header management.
This blog post investigates how to achieve nice animations when changing themes.
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.
This blog post outlines the frameworks and techniques PSPDFKit uses to test its large-scale C++ codebase.
C++ exceptions have their place, but using an alternative is recommended for general program flow control.
A short introduction to compiler-based lock checking in C++ with Clang using Thread Safety Analysis
Examining new developments in the PWA landscape that affect mobile and desktop browsers.
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.
How we improved our Git repository setup by moving our PDF Viewer for iOS repository into our PSPDFKit repository.
Learn how to support styling your own custom views using UIAppearance.
A look at the android.support.test.filters library and what it provides you with.
std::optional is already really useful, and it's about to get better with C++20.
Why we changed our default for opening web links from SFSafariViewController to the Safari app.
How we migrated our Genymotion-based CI to an AVD.
A chat with Alon Zakai, co-creator of WebAssembly and creator of Emscripten.
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.
A comprehensive overview of adopting Dark Mode in an iOS app, along with a few tips to make the process of development easier.
A look at the steps we took to start improving the accessibility of our Android SDK.
Using SWIG to generate interfaces to talk to a C++ backend.
A blog post that explains the difference between the Docker import/export and load/save commands.
Using the Android drag-and-drop framework — from theory to implementation.
In this article, we'll explore the Gradle build system, how it works, and why it is the new standard for building Android projects.
In this article, we discuss the challenges of implementing your own custom emoji support in a cross-platform way.
An overview of intents, their uses, and pitfalls to consider.
This article provides tips for optimizing memory usage of your apps.
A set of tips for debugging native NDK code in Android apps.
A post detailing what NetworkOnMainThreadException is and how to prevent it.
How we fit into the PDF landscape.
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.
An overview of React Redux's seven new features in action.
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.
How to use the getCoalescedEvents() method of the PointerEvent API to improve the precision of drawing apps or of any web application.
We discuss how to ensure thread safety and synchronization via locking.
Move semantics in C++ make your code more efficient, but sometimes a move is not performed. In this blog post, we explore why.
Tips for working with the soft keyboard on Android.
A quick crash course on how to swizzle correctly, and how to do it in Swift 5.1
How and what metadata can be stored in a PDF, and how to programmatically work with this information.
An overview of how to use a fragment to retain objects during a configuration change.
A look at some issues with Android's nullability annotations and how to fix them.
Here's how to get the most out of Apple's Worldwide Developer Conference.
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.
A post about existing Android dimensions, their purpose, and common conversion rules.
An overview of Gradle's task configuration avoidance APIs and how they are used by the Android build system.
How to include native C++ in your UWP app and call into it from C#.
This blog post explains what Android App Bundles are and how to upload them to Google Play.
Bookmarks vs. outline elements: Not everything is what it seems.
A monorepo? Isn't that just a weird Facebook and Google thing? Why is PSPDFKit using a monorepo?
A look at Kotlin coroutines and how they compare to other solutions for concurrency.
A quick look at both the benefits and downsides of using the iOS system document browser in your applications.
How to debug memory usage in an Emscripten app.
How I combined Apache PDFBox, Docker, and Make to streamline my tax return workflow.
This article explains how to enable Java 8 features in an Android app and gives an overview of the available Java 8 features.
A brief excursion into the Java type system, nullability, and remedies for the billion-dollar mistake.
We talk about our experience in implementing the new sharing flow.
How to use Android's ViewModel class to retain complex objects across configuration changes.
Will PSPDFKit for iOS move to Swift? In this post, we weigh the pros and cons.
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.
An overview of configuration changes on Android.
We present spaced repetition as a learning technique that can help you be more efficient at work.
This article goes into what's involved when incrementally or fully saving a PDF, and why it matters.
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.
An introduction to Android Debug Bridge (adb) and an overview of some tricks.
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.
Tips and best practices for code refactoring.
An overview of how to make sure your activity state is saved.
Tips, tricks, and techniques for documenting your code the correct way.
A brief introduction to Universal Windows development for iOS developers.
An introduction to implementing bottom navigation in your app with a simple example that incorporates synced page switching as well.
How to use Visual Studio Code for C++ development.
This article discusses the basics of Android reverse engineering using the Apktool, smali, and Java decompilers.
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.
This post surveys the Ruby landscape in 2018 to evaluate the current state-of-the-art of generating PDFs with Ruby.
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.
Don't lose your logs. Increase your logcat buffer!
We take a look at how images are stored in a PDF and discuss some important things to know about them.
In this blog post, we'll look at an example of how to generate PDFs with Elixir.
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.
A look at the different ways that we measure and try to improve performance at PSPDFKit.
A look at how we generate our screenshots for the iOS App Store.
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.
We evaluate the encoding and decoding performance of HEIC.
Rendering tests using Robolectric with a custom bitmap shadow.
An overview of the internal structure of a PDF.
A recap of how we integrated drag-and-drop support into our Document Editor in iOS.
An overview of the experimental Kotlin Contracts API.
PDFs hold information you may not know about. Discover different forms of metadata and where to look for them.
How to use a flexible path API to draw complex shapes with borders.
In this blog post, we’ll look at an example of how we can run multiple instances of a service with Docker Compose.
The benefits of using clang-tidy and how to get started setting it up in Jenkins.
If you're going to fall down a rabbit hole anyway, you might as well enjoy it!
How to improve Dynamic Type support in your app and bring it to the next level.
In this blog post, we will look at some simple solutions that we use at PSPDFKit to make our modals more inclusive and accessible.
Explore the extensibility capabilities of LLDB, a debugger for Swift, C, C++, and Objective-C code.
PSPDFKit for Web and Progressive Web Applications: an open source example and guide.
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.
How we handle changelogs at PSPDFKit and the tools we built to help us with this.
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.
Tips for choosing good class names.
A tutorial on how to parse XML documents in Elixir.
Password-based security for PDF documents.
We show how a developer can use Edge DevTools to debug a WebView in a UWP app.
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.
We discuss some of the benefits of switching to a standing desk.
How to use database transactions and Ecto.Multi in Elixir
A short introduction to Immutable.js and how lazy operations improve performance and readability of your code.
There are better ways to write CMake scripts.
How we added simple spelling and grammar checks to our website build process to catch some common mistakes.
A short review of Flutter from a mobile developer’s standpoint.
Tutorial on how to set up a back-pressure queuing system in Elixir with sbroker.
Another take on writing your project's Gradle build files in pure Kotlin code.
A WebAssembly Benchmark for browser vendors to test a real-world production application.
How PSPDFKit is smart about choosing thumbnail sizes.
We take a look at some of the things you should keep in mind when designing an Android library.
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 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.
An overview of how to render PDF previews.
An overview of how Auto Layout has changed in recent years and how to best use it.
How to create asynchronous stacktraces in Android Studio and IntelliJ.
We explain iOS 11's Smart Punctuation and discuss how it affects string handling in your app.
An explanation of what appearance streams actually are, along with their gotchas.
An explanation of why RxJava is both asynchronous and blocking.
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.
Debugging in real time with Android Studio.
We share some tips on how to navigate a new codebase.
In this article, we have look at using result types to model failable computations in the Djinni IDL.
We explain how to integrate Middleman and webpack to boost your frontend productivity.
We look at SQLite’s FTS extension and how you can use it to add high performance search to your app.
Forms provide a simple yet flexible way to gather data from users.
`UICollectionView` is now at the heart of every document. This blog post talks about why and how we rewrote our view hierarchy.
Kotlin provides the ability to extend any class with new functionality, and we can use this to expand the PSPDFKit API.
How to handle rendering large amounts of bitmaps and maintain a slick UX while doing it.
Four simple yet effective solutions we currently employ in PSPDFKit for Web to reduce WebAssembly startup time.
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.
The best shortcuts for Android Studio. The most famous and the most underrated.
ABI? Module stability? What does binary stability mean, and how will it affect you?
Useful tricks for beginners to start writing better code with Kotlin.
Annotations allow users to add custom content on PDF pages.
The difficulties of extracting text from a PDF and how PSPDFKit can help.
Utilizing the new Drag and Drop feature in iOS 11, and how we integrated it to enhance the user experience.
Android view animations powered by RxJava 2.
Tips and tricks for adding support for the iPhone X in PSPDFKit.
How apps can use iOS Data Protection to secure their files.
What is WebAssembly, and what does it mean for the web?
Picking smart defaults with security in mind when playing videos on Android.
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.
Low-level drawing and animation on Android using Canvas and powerful Shader classes.
Improving an app’s User Experience made easy by adding animations powered by Lottie.
Automating CSS testing and documentation with Hound and Webdriver
What Right to Left Support Actually Means and How We Implemented It
Tips and tricks how to write readable, concise, and beautiful code using the Kotlin language and RxJava.
We implement a simple vector-based freehand drawing with React using SVG.
How PSPDFKit uses an agile approach for design work
This is a story about fixing a bug, even when all the tools go kaput.
Pitfalls when developing a Share or an Action Extension
Best Practices on Developing a Today Widget
How to dramatically shorten your build times with distcc.
How to enable Android's demo mode using a quick setting tile
State restoration is an important part of the Android framework, but we might encounter problems with it when implementing MVP architecture.
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.
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.
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.
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.
Apple recognizes that real-time collaboration is necessary and so do we. Here's how PSPDFKit is upgrading your ability to work with teams.
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.
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.
Our Guides received a large update – now with Kotlin usage examples.