Jonathan Lalou's Blog

Archive for the ‘en-US’ Category

Jean-François Lépine, a quality-focused developer at Alineaforce, shared a gripping account at PHP Forum Paris 2022 of a production crash that reshaped his team’s approach to software development. With a background in tools like PHP Metrics, Jean-François offered a candid reflection on the lessons learned from a critical incident two years prior. His presentation emphasized proactive strategies for preventing future failures, blending technical insights with a focus on team culture and process improvement.

Anatomy of a Production Crash

Jean-François began by recounting the harrowing incident that brought their production environment to a halt. Without dwelling on the chaos, he focused on the root causes, such as inadequate monitoring and untested assumptions. By analyzing the failure’s impact, Jean-François highlighted the importance of identifying vulnerabilities early. His narrative underscored how such crises expose gaps in processes, prompting his team to rethink their approach to reliability and resilience.

Building Robust Processes

Drawing from the aftermath, Jean-François detailed the processes his team implemented to prevent recurrence. These included automated monitoring, rigorous incident tracking, and mandatory documentation for every merge request. He emphasized the creation of secondary tickets to address root causes, ensuring issues are resolved systematically. Jean-François noted that while some practices, like immediate alerting, remain a work in progress, others, such as incident resolution protocols, have become ingrained team habits.

Fostering a Culture of Accountability

Jean-François stressed the role of team culture in sustaining these changes. He described how Alineaforce adopted measurable goals, such as increasing documentation coverage to 12% of merge requests, with plans to improve further. By fostering accountability and encouraging proactive communication, the team transformed painful lessons into a framework for continuous improvement. Jean-François’s insights inspired developers to prioritize resilience and collaboration in their workflows.

Links:

• Alineaforce company website
• PHP Metrics on GitHub

In a compelling session at Spring I/O 2023, Badr Nasslahsen, a DevSecOps expert at CyberArk, tackled the critical challenge of securing secrets in Spring Boot applications. With the rise of cloud-native architectures and Kubernetes, secrets like database credentials or API keys have become prime targets for attackers. Badr’s talk, enriched with demos and real-world insights, introduced CyberArk’s Conjur solution and various patterns to eliminate hard-coded credentials, enhance authentication, and streamline secrets management, fostering collaboration between developers and security teams.

The Growing Threat to Application Secrets

Badr opened with alarming statistics: in 2021, software supply chain attacks surged by 650%, with 71% of organizations experiencing such breaches. He cited the 2022 Uber attack, where a PowerShell script with hard-coded credentials enabled attackers to escalate privileges across AWS, Google Suite, and other systems. Using the SALSA threat model, Badr highlighted vulnerabilities like compromised source code (e.g., Okta’s leaked access token) and build processes (e.g., SolarWinds). These examples underscored the need to eliminate hard-coded secrets, which are difficult to rotate, track, or audit, and often exposed inadvertently. Badr advocated for “shifting security left,” integrating security from the design phase to mitigate risks early.

Introducing Application Identity Security

Badr introduced the concept of non-human identities, noting that machine identities (e.g., SSH keys, database credentials) outnumber human identities 45 to 1 in enterprises. These secrets, if compromised, grant attackers access to critical resources. To address this, Badr presented CyberArk’s Conjur, an open-source secrets management solution that authenticates workloads, enforces policies, and rotates credentials. He emphasized the “secret zero problem”—the initial secret needed at application startup—and proposed authenticators like JWT or certificate-based authentication to solve it. Conjur’s attribute-based access control (ABAC) ensures least privilege, enabling scalable, auditable workflows that balance developer autonomy and security requirements.

Patterns for Securing Spring Boot Applications

Through a series of demos using the Spring Pet Clinic application, Badr showcased five patterns for secrets management in Kubernetes. The API pattern integrates Conjur’s SDK, using Spring’s @Value annotations to inject secrets without changing developer workflows. The Secrets Provider pattern updates Kubernetes secrets from Conjur, minimizing code changes but offering less security. The Push-to-File pattern stores secrets in shared memory, updating application YAML files securely. The Summon pattern uses a process wrapper to inject secrets as environment variables, ideal for apps relying on such variables. Finally, the Secretless Broker pattern proxies connections to resources like MySQL, hiding secrets entirely from applications and developers. Badr demonstrated credential rotation with zero downtime using Spring Cloud Kubernetes, ensuring resilience for critical applications.

Enhancing Kubernetes Security and Auditing

Badr cautioned that Kubernetes secrets, being base64-encoded and unencrypted by default, are insecure without etcd encryption. He introduced KubeScan, an open-source tool to identify risky roles and permissions in clusters. His demos highlighted Conjur’s auditing capabilities, logging access to secrets and enabling security teams to track usage. By centralizing secrets management, Conjur eliminates “security islands” created by disparate tools like AWS Secrets Manager or Azure Key Vault, ensuring compliance and visibility. Badr stressed the need for a federated governance model to manage secrets across diverse technologies, empowering developers while maintaining robust security controls.

Links:

• Badr Nass Lahsen’s GitHub
• Conjur Spring Boot Demos Repository
• Slides

Hashtags: #SecretsManagement #SpringIO2023 #SpringBoot #CyberArk #BadrNassLahsen

Observability pillars—logs, gauges, spans—form the triad illuminating Node.js constellations, where opacity breeds outages. Thomas Hunter II, a Node.js luminary and author of “Distributed Systems with Node.js,” dissects these sentinels, adapting book chapters to unveil their synergies in service scrutiny.

Thomas frames logging as cloud-elevated console.logs: structured JSON extrudes states, severity tiers—error to silly—filter verbosity. Winston orchestrates: transports serialize to stdout/files, Pino accelerates with async flushes. Conventions prescribe correlation IDs, timestamps; aggregators like ELK ingest for faceted searches.

Metrics quantify aggregates: counters tally invocations, histograms bin latencies. Prometheus scrapes via prom-client, Grafana visualizes trends—spikes foretell fractures. Thomas codes a registry: gauge tracks heap, histogram times handlers, alerting deviations.

Tracing reconstructs causal chains: spans encapsulate ops, propagators thread contexts. OpenTelemetry standardizes; Jaeger self-hosts hierarchies, timelines dissect 131ms journeys—Memcache to Yelp. Datadog APM auto-instruments, flame graphs zoom Postgres/AWS latencies.

Instrumentation Patterns and Visualization Nuances

Thomas prototypes: async_hooks namespaces contexts, cls-r tracers bridge async gulfs. Zipkin’s dependency DAGs, Datadog’s y-axis strata—live Lob.com postcard fetches—demystify depths.

Thomas’s blueprint—Winston for persistence, Prometheus for pulses, Jaeger for journeys—equips Node.js artisans to navigate nebulous networks with crystalline clarity.

Links:

• Thomas Hunter II on LinkedIn
• Thomas Hunter II Website
• Distributed Systems with Node.js Book

KotlinConf’23 kicked off with an energizing keynote, marking a much-anticipated return to an in-person format in Amsterdam. Hosted by Hadi Hariri of JetBrains, the session brought together key figures from both JetBrains and Google, including Roman Elizarov, Svetlana Isakova, Egor Tolstoy, and Grace Kloba (VP Engineering for Android Developer Experience at Google), to share exciting updates and future directions for the Kotlin language and its ecosystem. The conference also featured a global reach with KotlinConf Global events in 41 countries. The main announcements from the keynote are also available in a blog post on the Kotlin blog.

The keynote celebrated Kotlin’s impressive growth, with statistics highlighting its widespread adoption, particularly in Android development where it’s the most popular language, used in over 95% of the top 1000 Android apps. A major focus was the upcoming Kotlin 2.0, centered around the new K2 compiler, which promises significant performance improvements, stability, and a foundation for future language evolution. The K2 compiler is nearing completion and is set to be released as Kotlin 2.0. The IntelliJ IDEA plugin will also adopt the K2 frontend, aligning with IntelliJ releases.

The Evolution of Kotlin: K2 Compiler and Language Features

The K2 compiler was a central theme of the keynote, marking a major milestone for Kotlin. This new compiler front-end, which also powers the IDE, is designed to be faster, more stable, and enable the development of new language features and tooling capabilities more rapidly. Kotlin 2.0, built on K2, is expected to bring these benefits to all Kotlin developers, enhancing both compiler performance and IDE responsiveness.

Looking beyond Kotlin 2.0, the speakers provided a glimpse into potential future language features that are under consideration. These included:
* Static Extensions: Allowing extension functions to be resolved statically, potentially improving performance and clarity.
* Collection Literals: Introducing a more concise syntax for creating collections, like using square brackets for lists, with efficient implementations.
* Name-Based Destructuring: Offering a more flexible way to destructure objects based on property names rather than just position.
* Context Receivers: A powerful feature for providing contextual information to functions in a more implicit and structured manner. This feature, however, is being approached carefully to ensure it aligns well with Kotlin’s principles.
* Explicit Fields: Providing more control over backing fields for properties.

The team emphasized a careful approach to evolving the language, ensuring new features are well-designed and maintainable. Compiler plugins were also highlighted as an avenue for extending Kotlin’s capabilities.

Kotlin in the Ecosystem: Google’s Investment and Multiplatform Growth

Grace Kloba from Google took the stage to reiterate Google’s strong commitment to Kotlin. She shared insights into Google’s investments in the Kotlin ecosystem, including the development of Kotlin Symbol Processing (KSP) and the continued focus on making Kotlin the default choice for Android development. Google officially supported Kotlin for Android development by early 2017. The Kotlin DSL is now the default for Gradle build scripts in Android Studio, enhancing developer experience with features like semantic highlighting and code completion. Google also actively contributes to the Kotlin Foundation and encourages the community to participate through programs like the Kotlin Foundation Grants Program, which focuses on supporting multiplatform libraries and frameworks.

Kotlin Multiplatform (KMP) was another major highlight, showcasing its growing maturity and adoption. The vision for KMP is to allow developers to share code across various platforms—Android, iOS, desktop, web, and server-side—while retaining the ability to write platform-specific code when needed. The keynote celebrated the increasing number of multiplatform libraries and tools, including KMM Bridge, that simplify KMP development. The future of KMP looks bright, with efforts to further improve the developer experience and expand its capabilities.

Compose Multiplatform and Emerging Technologies

The keynote also showcased the advancements in Compose Multiplatform, JetBrains’ declarative UI framework for building cross-platform user interfaces. A significant announcement was the alpha release of Compose Multiplatform for iOS, enabling developers to write their UI once in Kotlin and deploy it on both Android and iOS, and even desktop and web. This opens up new possibilities for code sharing and faster development cycles for mobile applications.

Finally, the team touched upon Kotlin’s expansion into emerging technologies like WebAssembly (Wasm). JetBrains is developing a new compiler backend for Kotlin targeting WebAssembly with its garbage collection proposal, aiming for high-performance Kotlin code in the browser. Experiments with running Compose applications in the browser using WebAssembly were also mentioned, hinting at a future where Kotlin could offer a unified development experience across an even wider range of platforms. The keynote concluded with an invitation for the community to dive deeper into these topics during the conference and to continue contributing to Kotlin’s vibrant ecosystem.

Links:

• KotlinConf’23 Keynote Highlights Blog Post
• JetBrains Website
• JetBrains on LinkedIn
• Grace Kloba – KotlinConf’23 Speaker

Marine Gandy, a dynamic Drupal advocate, delivered an energetic and entertaining presentation at PHP Forum Paris 2022, unveiling the upcoming Drupal 10 release. Adopting a playful “newsroom” format, Marine shared exclusive insights from her “undercover” investigation within the Drupal community. Her talk blended humor, technical depth, and community spirit, offering a comprehensive look at Drupal 10’s advancements and its evolving ecosystem, captivating both newcomers and seasoned developers.

Drupal 10’s New Features

Marine kicked off with a lively overview of Drupal 10, set for release on December 14, 2022. She highlighted its enhanced support for modern PHP versions and improved compatibility with diverse environments. Marine explained how Drupal 10 builds on its predecessor, introducing streamlined tools and modules to enhance developer productivity. Her animated delivery, complete with sound effects and lighthearted jabs, kept the audience engaged while conveying the technical significance of these updates.

Simplifying Installation and Updates

Focusing on usability, Marine discussed Drupal 10’s efforts to simplify installation and updates, particularly through restructured module handling. She addressed the shift away from traditional distributions, noting that while modules like Drupal Commerce remain integral, their installation process is evolving to be more modular and flexible. Marine emphasized that these changes aim to reduce maintenance overhead, allowing developers to customize setups without relying on rigid distributions, thus enhancing long-term maintainability.

Engaging the Drupal Community

Marine concluded by rallying the Drupal community to embrace Drupal 10’s advancements and contribute to its growth. She encouraged developers to explore the updated ecosystem and provide feedback to refine its features. Her infectious enthusiasm and call for inclusivity, including support for diverse contributors, resonated with attendees, inspiring them to engage with Drupal’s vibrant open-source community and drive its future development.

Links:

• Drupal official website

Pierre Tondereau, a developer with a passion for exploring new technologies, captivated attendees at PHP Forum Paris 2022 with his engaging exploration of creating PHP extensions using Rust. Drawing from his personal journey of discovering Rust in 2021, Pierre shared a compelling narrative about leveraging this modern language to enhance PHP’s capabilities. His presentation, rooted in a practical experiment, highlighted Rust’s potential to improve security and streamline development, offering a fresh perspective on extending PHP’s functionality.

Why Rust for PHP Extensions?

Pierre began by introducing Rust, a language developed by Mozilla in 2015 to refactor their HTML rendering engine, prioritizing performance and memory safety. Unlike traditional PHP extensions written in C, which demand meticulous memory management to avoid security vulnerabilities, Rust offers robust safety guarantees. Pierre explained how Rust’s design eliminates common issues like null pointer dereferences, making it an appealing choice for PHP developers unfamiliar with C’s complexities. He emphasized that his goal was not to rewrite PHP’s virtual machine but to create a secure, efficient extension using the ext-php-rs crate.

Building and Distributing Extensions

Delving into the technical process, Pierre outlined how the ext-php-rs crate simplifies PHP extension development by abstracting the Zend API. He demonstrated wrapping Rust APIs for PHP userland, using tools like cargo-php to streamline building and installation. Pierre highlighted the crate’s comprehensive coverage, which handled his use case effectively, though he encouraged community feedback to expand its capabilities. By automating distribution, Rust enables developers to integrate extensions seamlessly, enhancing PHP’s ecosystem with minimal friction.

Security and Future Potential

Concluding, Pierre underscored Rust’s security benefits, citing its ability to prevent memory-related vulnerabilities that plague C-based extensions, such as those impacting Google Chrome. He referenced Microsoft’s 2019 shift toward prioritizing security over performance, reinforcing Rust’s relevance. Pierre invited developers to explore his GitHub repository and contribute to ext-php-rs, fostering a collaborative push toward safer, more reliable PHP extensions. His talk inspired attendees to consider Rust as a viable tool for modernizing PHP development.

Links:

• ext-php-rs on GitHub

Lecturer: Ryan Dahl

Ryan Dahl is an American software engineer and entrepreneur, widely recognized as the creator of the Node.js JavaScript runtime, which he released in 2009. Following his initial work on Node.js, he later created the Deno JavaScript/TypeScript runtime to address what he perceived as fundamental architectural issues in Node.js. Mr. Dahl studied mathematics at the University of California, San Diego (UCSD) and pursued algebraic topology at the University of Rochester for graduate school before pivoting to software engineering, which he found more applicable to real life. He currently serves as the Co-Founder and Chief Executive Officer of Deno Land Inc.. His work emphasizes moving away from centralized module systems and toward conservative, browser-like security models.

• Institutional Profile/Professional Page: Ryan Dahl – Wikipedia
• Organization: Deno Land Inc.

Abstract

This article analyzes the strategic architectural and functional changes introduced in Deno 2.0, interpreting them as a move toward enhanced interoperability with the existing Node.js ecosystem and a strong commitment to cloud-native development paradigms. The analysis focuses on key innovations, including dependency management enhancements (package.json auto-discovery and bare specifiers), the introduction of built-in distributed primitives (Deno.KV), and the philosophical shift from optimizing local servers to building optimal global services by restricting programs to distributed cloud primitives.

Context: The Evolution of JavaScript Server Runtimes

The initial philosophy behind the Node.js runtime was to restrict I/O primitives to asynchronous methods, enabling developers to build optimal local servers. However, the proliferation of cloud computing and serverless architectures necessitated a rethinking of runtime design. Deno 2.0 is positioned as an expanded version of this initial philosophy, focusing on restricting programs to distributed Cloud Primitives to facilitate the development of optimal Global Services.

Analysis of Architectural Innovations

Interoperability and Dependency Management

A central focus of Deno 2.0 is improving backwards compatibility and reducing friction for developers migrating from or using npm packages.

• package.json Auto-Discovery: Deno 2.0 introduces automatic detection and configuration based on an existing package.json file, significantly streamlining the process of using npm packages.
• Bare Specifiers: The update adds support for bare specifiers (e.g., import { serve } from 'std/http'), enabling modules to be imported without requiring a fully qualified URL, which improves code readability and familiarity for many developers.
• Import Maps: The use of import maps is highlighted as a solution to address critical issues in the JavaScript ecosystem, specifically the pervasive problem of duplicate dependencies and the issue of disappearing or unmaintained dependencies.
• deno: Specifiers and Registry: Built-in support for deno: specifiers on the deno.land/x registry provides a recommended and streamlined path for publishing reusable code, promoting internal consistency.

The Shift to Distributed Primitives

The most significant philosophical shift in Deno 2.0 is the direct integration of distributed systems primitives into the runtime. This moves beyond the I/O layer (like Node.js) to address the needs of modern globally distributed applications.

• Deno.KV (Key-Value Store): This innovation introduces a built-in, globally distributed key-value store. It is designed to be a durable, globally replicated, and transactionally correct database, providing developers with a default persistence layer that is natively integrated and prepared to scale. The concept aims to force optimization by offering a scalable default for state management.
• Other Cloud Primitives: Other features are under development to support global services, including persistent caches, background workers, and object storage.

Consequences and Implications

The Deno 2.0 feature set represents a concerted effort to optimize JavaScript for the serverless and edge computing landscape. By including distributed primitives like Deno.KV, Deno is reducing the boilerplate and external configuration traditionally required to build a scalable, production-ready backend. The expanded backward compatibility features indicate a pragmatic approach to ecosystem adoption, balancing Deno’s core security and design principles with the practical necessity of using existing npm modules.

This new model reflects an emerging computing abstraction, articulated by the analogy: “bash is to JavaScript as elf is to wasm“. This suggests that JavaScript, running in modern, standards-compliant runtimes, is moving into a “post-Unix future,” becoming the universal scripting and service layer that replaces traditional shell scripting and native binaries in the cloud environment.

Conclusion

Deno 2.0’s innovations solidify its role as a forward-thinking JavaScript runtime designed explicitly for the era of global, distributed services. The focus on integrated cloud primitives and improved interoperability addresses key challenges in modern backend development, pushing the JavaScript ecosystem toward more opinionated, secure, and globally performant architectures. The movement, which includes collaboration in standards bodies like the Web-interoperable Runtimes Community Group (WinterCG), indicates a broad industry consensus on the need for a unified, standards-based approach to server-side JavaScript.

Relevant links and hashtags

• Lecture Video: Deno 2.0 – Ryan Dahl, Node Congress 2023
• Lecturer Professional Links:
  • Organization: Deno Land Inc.
  • Professional Profile: Ryan Dahl – Wikipedia

Hashtags: #Deno20 #JavaScriptRuntime #CloudNative #GlobalServices #DenoKV #WebInteroperability #NodeCongress

Amidst the clamor of high-stakes deployments, where milliseconds dictate user satisfaction and fiscal prudence, refining Node.js execution emerges as a paramount pursuit. Yonatan Kra, software architect at Vonage and avid runner, recounts a pivotal incident—a customer’s frantic call amid a faltering microservice, where a lone sluggish routine ballooned latencies from instants to eternities. This anecdote catalyzes his compendium of runtime enhancements, gleaned from battle-tested optimizations.

Yonatan initiates with diagnostic imperatives: Chrome DevTools’ performance tab chronicles timelines, flagging CPU-intensive spans. A contrived endpoint—filtering arrays via nested loops—exemplifies: record traces reveal 2-3 second overruns, dissected via flame charts into redundant iterations. Remedies abound: hoist computations outside loops, leveraging const for immutables; Array.prototype.filter supplants bespoke sieves, slashing cycles by orders.

Garbage collection looms large; Yonatan probes heap snapshots, unveiling undisposed allocations. An interval emitter appending to external arrays evades reclamation, manifesting as persistent blue bars—unfreed parcels. Mitigation: nullify references post-use, invoking gc() in debug modes for verification; gray hues signal success, affirming leak abatement.

Profiling Memory and Function Bottlenecks

Memory profiling extends to production shadows: –inspect flags remote sessions, timeline instrumentation captures allocations sans pauses. Yonatan demos: API invocations spawn specials, uncollected until array clears, transforming azure spikes to ephemeral grays. For functions, Postman sequences gauge holistically—from ingress to egress—isolating laggards for surgical tweaks.

Yonatan dispels myths: performance isn’t arcane sorcery but empirical iteration—profile relentlessly, optimize judiciously. His zeal, born of crises, equips Node.js stewards to forge nimble, leak-free realms, where clouds yield dividends and users endure no stutter.

Links:

• Yonatan Kra on LinkedIn
• Vonage Website
• Yonatan Kra Blog

Anne-Laure de Boissieu, a backend developer at Bedrock, delivered a heartfelt presentation at PHP Forum Paris 2022 on transforming code reviews into positive, constructive experiences. As a member of the Duchess France network and an organizer of the Mixit conference, Anne-Laure shared personal anecdotes and practical strategies to make code reviews less daunting and more collaborative, drawing from her experience at Bedrock and her passion for community engagement.

Reframing Code Reviews as Collaboration

Anne-Laure began by addressing the emotional challenges of code reviews, recounting instances where feedback felt personal or discouraging. She argued that code reviews should be a collaborative process, not a source of suffering. By adopting a constructive mindset, developers can focus on improving code quality rather than defending their work. Anne-Laure emphasized the importance of clear communication, citing her own experiences at Bedrock, where supportive feedback helped her grow as a developer.

Best Practices for Effective Reviews

Drawing from Bedrock’s workflow, Anne-Laure shared actionable best practices for code reviews. She advocated for assigning a “buddy” to new developers for initial reviews, conducting verbal feedback sessions to reduce misunderstandings, and addressing complex feedback in person. Referencing Amélie’s talk on onboarding, she highlighted small tasks, like adding a name to a list, to familiarize newcomers with workflows. These practices, Anne-Laure argued, create a supportive environment that fosters learning and aligns with team standards.

Building a Positive Review Culture

Anne-Laure emphasized that human interactions are key to successful code reviews. She cautioned against piling up written comments, which can escalate tensions, and encouraged direct discussions to resolve issues. By sharing her journey from feeling hurt by feedback to valuing constructive critiques, Anne-Laure inspired developers to approach reviews with empathy and openness. Her insights underscored the role of team dynamics in creating a culture where reviews enhance collaboration and professional growth.

Links:

• Bedrock company website
• Duchess France website

Stéphane Hulard, CTO at Chstudio, delivered a compelling session at PHP Forum Paris 2022 on using OpenAPI to validate API documentation. With four years of experience maintaining a PHP-based project, Stéphane shared a practical approach to ensuring documentation aligns with implementation. His talk emphasized the synergy between testing and documentation, offering developers a workflow to enhance collaboration and maintainability in API-driven projects.

The Role of OpenAPI in Documentation

Stéphane introduced OpenAPI as a standardized format for describing APIs, enabling both human-readable documentation and automated testing. He explained how OpenAPI specifications serve as a contract between backend and frontend teams, ensuring consistency. By documenting a single API endpoint, developers can validate its behavior through automated tests, creating a virtuous cycle of reliable documentation and robust code. Stéphane emphasized starting small, documenting one endpoint at a time to build momentum.

Implementing Documentation-Driven Testing

Delving into technical details, Stéphane demonstrated how to integrate OpenAPI with PHP projects, using tools to generate and validate API requests. He shared code examples from Chstudio’s workflow, illustrating how tests derived from OpenAPI specs catch discrepancies early. This approach, akin to Test-Driven Development (TDD), ensures that documentation remains accurate as the codebase evolves. Stéphane highlighted the importance of enriching test suites with edge cases to uncover potential bugs, enhancing overall API reliability.

Enhancing Collaboration Across Teams

Stéphane underscored OpenAPI’s role in fostering collaboration between backend and frontend developers. By defining API contracts upfront, teams can make informed design decisions, reducing miscommunication. He described Chstudio’s experience with a monolithic repository, where OpenAPI facilitated smoother interactions despite the absence of microservices. Stéphane’s approach, which he termed Documentation-Driven Design (DDD), aligns development and documentation efforts, ensuring both are prioritized from the project’s outset.

Encouraging Community Contributions

Concluding, Stéphane invited developers to contribute to open-source OpenAPI tools, emphasizing their accessibility for PHP projects. He encouraged attendees to adopt incremental documentation practices, noting that even partial coverage yields significant benefits. By sharing Chstudio’s workflow, Stéphane inspired developers to integrate OpenAPI into their projects, fostering a culture of disciplined documentation and testing.

Links:

• Chstudio company website