GoodDevs at WASM IO 2023

Practice makes perfect. That’s why our team is continuously learning and making the best use of the resources available to improve and constantly evolve. Today, part of our cross-platform team had the chance to attend the biggest WebAssembly event in Europe. Motivated by Marcos Cárceles, the cross-platform team Engineering Manager, Antonio, Trujy, Mauro, and Pedro went to Barcelona to enhance their Web Assembly skills. If you want to know how it went, keep reading!

The conference started with awesome talks. WASM is an exciting ecosystem growing daily thanks to developers from many different programming languages like Swift, Rust, C++, Python, etc. For this event, Tyler McMullen opened the conference with a talk about WASM’s history, current state, and future outside of the browser. Covering technical details and community effects that make this not just viable but super valuable. And how it all ties together into a future that gives us the freedom to run code where and how we want to.

For our team, this talk was really interesting. WebAssembly is the technology our cross-platform team uses to be able to reuse the Swift code written for years to be able to make GoodNotes the best note-taking and PDF markup app. Thanks to WebAssembly, our team can reuse thousands of lines of code almost for free and focus on shipping the best possible product instead of duplicating a massive, already-written codebase.

This was just the beginning, and it was an amazing talk. Later this day talks like “Wasmer Things: An Upside-Down Guide to WebAssembly” by Edoardo Vacci or “Mobile app development with WebAssembly GC” by Vivek Sekhar completely got our attention. Low-level details related to how WASM works under the hood or WasmGC works were among the best. Digging deep down into the tech stack we use helps us identify improvement areas in our codebase to build a better product.

Vivek Sekhar’s lightning talk about WebAssembly GC was one of the best surprises this event gave us. If using WASM GC, we can improve our performance by efficiently supporting high-level managed languages to WebAssembly, via struct and array types that enable language compilers targeting Wasm to integrate with a garbage collector in the host VM be a really nice improvement for us.

Right after having lunch, another talk got our attention. This time because of the special mention to Yuta Saito! Yuta joined our team more than one year ago and contributed to our project with awesome technical improvements. We are lucky to have Yuta on our team and also glad to see how he’s also an important reference developer for other engineers.

The first day was about to end when we noticed there was an excellent lighting talk about to start! “Rust and WebAssembly threads on production: a field report” by Roberto Vidal. An amazing talk about how Roberto and the rest of the team built them, what they tried, what worked, and what is yet to work! As you may expect, WebAssembly threads unlock a game-changing primitive for the Web and other targets. Workloads that require shared memory and parallelization can finally leverage the full power of the underlying platform.

Ready for the second day, our team woke up willing to listen to awesome talks. Checking the agenda there were promising talks. From new toolchains to cloud computing or even blockchain!

There was a special talk we wanted to mention. If you work with WASM, you know what we are talking about. If you have never heard about WASM, the fact that we specially mention this talk may be shocking. “WebAssembly debugging demystified” by Nisanthan Nanthakumar. A thorough review of the DWARF debug file format and the tools available to be able to include breakpoints, evaluate expressions and inspect our code. Believe it or not, debugging WASM binaries while executing the binary on a browser was not straightforward for us. Since we started the project, the team has not been able to inspect variables or evaluate expressions with the tooling provided by standard browsers like Google Chrome. However, this talk gave us information about some tooling we can use to inspect the WASM binaries and check in detail the memory allocated.

Before ending the day and the conference, our front-end team decided to get out of their comfort zone and learn about something different and experimental for them: Grain and Lunatic. Lunatic is a runtime for building distributed, highly concurrent systems with WebAssembly, and Grain is a programming language that makes getting up and running with WebAssembly a breeze. This talk was about the ins and outs of Lunatic, from its process spawning model to how it can run untrusted code and ultimately build a full application that can withstand enormous amounts of traffic.

The event ended on Friday afternoon, and it was time to return home. We had an awesome time at WASM IO! Our team works remotely, and having the chance to see each other on-site in events like this is something we love. However, this is not it! After the conference, we have to check some details and some notes we took to see how we can improve our usage of this technology. This is a list of tools and projects we want to check in detail we’ve found interesting:

• Twiggy: A WASM binary size profiler.
• wasm-snip: Optimize the binary size by replacing unused functions with a nop version.
• wasm-gc: Promising Google Project we want to try as soon as it is available.
• Docker + WASM: Docker support for WASM.
• Javy: Running JS into WASM.
• WABT: Tooling to be able to work with wasm files.
• Kowasm: Fullstack development with Kotlin and WASM.

This article was written by:
Pedro, Mauro, Antonio, and Trujy part of the cross-platform team at GoodNotes.