Lucas Fugisawa on Kotlin
Lucas Fugisawa on Kotlin
  • Articles
  • Newsletter
  • LinkedIn
  • Kotlin Devs Brasil
  • E-mail

Blog

Your blog category

Blog

Kotlin + gRPC: Tooling, CI/CD, and Architectural Practices

In the previous articles of this series, we explored how to build idiomatic gRPC APIs with Kotlin from schema design using Protobuf to leveraging streams, coroutines, and Kotlin DSL builders. Now it’s time to look beyond the application code. In this article, we’ll have a sneak peek on what it Read more…

By Lucas Fugisawa, 17 hoursMay 7, 2025 ago
Blog

Kotlin + gRPC: Streaming, Deadlines, and Structured Error Handling

In the previous articles of this series, we built a solid foundation: from setting up a gRPC service in Kotlin, to mastering schema design, and writing idiomatic, expressive code with Protobuf and Kotlin DSLs. Now, we’re ready to go beyond the basics into features that power real-time, reactive, and resilient Read more…

By Lucas Fugisawa, 1 weekApril 30, 2025 ago
Blog

Kotlin + gRPC: Nesting, Composition, Validations, and Idiomatic Builder DSL

In the first two articles of this series, we built our first gRPC service in Kotlin and explored the essentials of Protobuf schema design from optional and repeated fields to enums, oneof, maps, and how to evolve your schema safely. In this article, we’ll level up again and explore how Read more…

By Lucas Fugisawa, 2 weeksApril 22, 2025 ago
Blog

Kotlin + gRPC: Enhance Protobuf schema design with Optional, Repeated, Maps, Enums, Oneof and backwards compatibility

In the previous (first) article of this series, we introduced gRPC and Protocol Buffers by building a minimal Kotlin gRPC service: a simple NoteService that allowed creating and retrieving notes. Now that we’ve covered the fundamentals and the codebase setup, it’s time to dig a bit deeper into the backbone Read more…

By Lucas Fugisawa, 3 weeksApril 16, 2025 ago
Blog

Kotlin + gRPC: Build your first service in four steps

This is the first article in a hands-on series where we’ll explore how to build gRPC services using Kotlin. The series is designed to help you understand not only the technical how-to, but also the design choices behind Protocol Buffers and gRPC. We’ll start simple and gradually introduce more advanced concepts as we go. Here is Read more…

By Lucas Fugisawa, 4 weeksApril 11, 2025 ago
Blog

Scope Isolation in Kotlin DSLs with @DslMarker

In the previous article, Taking Kotlin Builders to the Next Level: A Type-Safe DSL Approach, we explored how Kotlin’s type-safe builders allow you to build expressive and concise DSLs. But as soon as your DSL starts nesting structures, something sneaky can happen: receiver conflicts. Let’s take a deeper look at this Read more…

By Lucas Fugisawa, 1 monthApril 5, 2025 ago
Blog

Taking Kotlin Builders to the Next Level: A Type-Safe DSL Approach

You might recall my Simplifying the Builder Pattern article about using Kotlin Data Classes as a simpler version of the Builder pattern. You saw how named parameters and default values removed much of the ceremony you see in a traditional Builder. Now, I want to guide you further. In this Read more…

By Lucas Fugisawa, 3 monthsFebruary 15, 2025 ago
Blog

Kotlin Design Patterns: Using Cool Features To Simplify Other Design Patterns

In the previous chapters, we’ve seen cases where Kotlin’s features can profoundly alter traditional design patterns to a simpler, more concise and expressive solution. In this final article of the series, we’ll explore how Kotlin’s capabilities can help simplify other patterns. The changes and impact shown here can seem to Read more…

By Lucas Fugisawa, 1 yearMarch 3, 2024 ago
Blog

Kotlin Design Patterns: Simplifying the Observer Pattern

The Observer Pattern is a behavioral design pattern where an object (the subject) maintains a list of its dependents (observers), and notifies them automatically of any state changes. This pattern ensures that multiple objects are notified when certain state changes occur. It’s widely used in implementing distributed event handling systems. Read more…

By Lucas Fugisawa, 1 yearFebruary 26, 2024 ago
Blog

Kotlin Design Patterns: Simplifying the Proxy Pattern

The Proxy Pattern is a structural design pattern in object-oriented programming. It provides a surrogate or placeholder for another object to control access to it. This pattern creates a ‘proxy’ object that acts as an intermediary between the client and the real object. This pattern is useful when direct access Read more…

By Lucas Fugisawa, 1 yearFebruary 20, 2024 ago

Posts pagination

1 2 Next
Recent Posts
  • Kotlin + gRPC: Tooling, CI/CD, and Architectural Practices
  • Kotlin + gRPC: Streaming, Deadlines, and Structured Error Handling
  • Kotlin + gRPC: Nesting, Composition, Validations, and Idiomatic Builder DSL
  • Kotlin + gRPC: Enhance Protobuf schema design with Optional, Repeated, Maps, Enums, Oneof and backwards compatibility
  • Kotlin + gRPC: Build your first service in four steps
Recent Comments
No comments to show.
Archives
  • May 2025
  • April 2025
  • February 2025
  • March 2024
  • February 2024
  • January 2024
  • December 2023
Categories
  • Blog
Hestia | Developed by ThemeIsle