Frontcon Riga - GraphQL Will Do To REST What JSON Did To XML

This document compares REST and gRPC for microservices communication. It discusses how gRPC addresses limitations of REST like inefficient binary encoding and lack of bidirectional streaming. gRPC uses protocol buffers for interface definition and code generation. It supports multiple languages and platforms and uses HTTP/2 for performance. Companies like Google and Netflix use gRPC for its performance advantages. The document provides examples of unary, server streaming, client streaming and bidirectional streaming RPC calls in gRPC. It recommends using gRPC for microservices and client-server applications where performance is important.

Communication between Microservices is inherently unreliable. These integration points may produce cascading failures, slow responses, service outages. We will walk through stability patterns like timeouts, circuit breaker, bulkheads and discuss how they improve stability of Microservices.

This document provides an introduction and overview of REST APIs. It defines REST as an architectural style based on web standards like HTTP that defines resources that are accessed via common operations like GET, PUT, POST, and DELETE. It outlines best practices for REST API design, including using nouns in URIs, plural resource names, GET for retrieval only, HTTP status codes, and versioning. It also covers concepts like filtering, sorting, paging, and common queries.

This presentation outlines the benefits of implementing a Microservice over a monolithic architecture.

Building Cloud-Native App Series - Part 2 of 11 Microservices Architecture Series Event Sourcing & CQRS, Kafka, Rabbit MQ Case Studies (E-Commerce App, Movie Streaming, Ticket Booking, Restaurant, Hospital Management)

This presentation talks about Open Tracing, Jaeger, OpenCensus and their use in the world of Microservices Architecture.

- REST API - JSON API - QueryLanguages - GraphQL - API Application structure - API Documentation

REST web service development guidelines and best practices. An introduction to guidelines and best practices for developing REST API or web services.

Microservices Pattern Language Microservices Software Architecture Governance, Best Practices and Design Pattern Decomposition Patterns Decompose by Business Capability Decompose by Subdomain

This document provides an overview of HTTP and REST APIs. It describes how HTTP allows sending documents over the web using URLs to identify resources and HTTP verbs like GET, PUT, DELETE and POST. It defines common response codes. It explains that REST stands for Representational State Transfer and relies on a stateless, client-server architecture using the HTTP protocol. The key design constraints of REST include having a uniform interface, being resource-based and using representations to manipulate resources with self-descriptive messages. Benefits include statelessness for scalability, cacheability to improve performance, separating clients from servers, and using a layered system with intermediary servers.

Microservices, event-driven architecture, and service orientation were discussed in the document. The key points covered included: 1) Microservices were developed as a reaction to monolithic architectures that had slow evolution due to poor design. 2) Splitting systems into services does not always provide proper decoupling, and can introduce accidental complexity from distributed service integration if not done properly. 3) Asynchronous event-driven communication using messages is preferable to synchronous request-response for loosely coupled microservices, as it avoids many of the issues that arise from distributed transactions.

This document provides an overview of patterns for scalability, availability, and stability in distributed systems. It discusses general recommendations like immutability and referential transparency. It covers scalability trade-offs around performance vs scalability, latency vs throughput, and availability vs consistency. It then describes various patterns for scalability including managing state through partitioning, caching, sharding databases, and using distributed caching. It also covers patterns for managing behavior through event-driven architecture, compute grids, load balancing, and parallel computing. Availability patterns like fail-over, replication, and fault tolerance are discussed. The document provides examples of popular technologies that implement many of these patterns.

Talk about AES-GCM documented and largely unknown limitations. We won’t get into the cryptographic details of the algorithm, so no need to worry about that. I’ll propose some workarounds to the limitations too. There is some basic math involved :)

OpenTelemetry is a set of APIs, SDKs, tooling and integrations that are designed for the creation and management of telemetry data such as traces, metrics, and logs. It aims to enable effective observability by making high-quality, portable telemetry ubiquitous and vendor-agnostic. The OpenTelemetry Collector is an independent process that acts as a "universal agent" to collect, process, and export telemetry data in a highly performant and stable manner, supporting multiple types of telemetry through customizable pipelines consisting of receivers, processors, and exporters.

The monolith to cloud-native, microservices evolution has driven a shift from monitoring to observability. OpenTelemetry, a merger of the OpenTracing and OpenCensus projects, is enabling Observability 2.0. This talk covers the fundamental concepts of observability and then demonstrates how to instrument your applications using the OpenTelemetry libraries.

With Instana the "Classic" Observability is not the end of the line. Find out what Observability means and how it can help DevOps, Developers, SREs day-by-day.

Everyone wants observability into their system, but find themselves with too many vendors and tools, each with its own API, SDK, agent and collectors. In this talk I will present OpenTelemetry, an ambitious open source project with the promise of a unified framework for collecting observability data. With OpenTelemetry you could instrument your application in a vendor-agnostic way, and then analyze the telemetry data in your backend tool of choice, whether Prometheus, Jaeger, Zipkin, or others. I will cover the current state of the various projects of OpenTelemetry (across programming languages, exporters, receivers, protocols), some of which not even GA yet, and provide useful guidance on how to get started with it.

This document discusses using GraphQL to wrap and secure REST APIs. It describes problems with REST APIs like multiple endpoints, over-fetching and under-fetching data, and versioning issues. GraphQL solves these problems with a single endpoint that returns flexible data structures. The document then provides steps to implement GraphQL, including using schemas to define queries and mutations, retrieving data from existing services and APIs, adding authentication middleware, and building a GraphQL server with Node.js and Apollo.

Your frontend developers are pushing to get started with GraphQL, but you don’t have the backend capacity to migrate your existing REST APIs to GraphQL? Or you want to have a GraphQL API next to your existing endpoints that are based on REST? In this talk I’ll show how to create a Node.js/Express server that wraps existing REST APIs into one single GraphQL endpoint. Code examples: - https://codesandbox.io/s/mfu9e - https://codesandbox.io/s/graphqlrestexpressapolloserver-uydq6

Why GraphQL will become the new standard for accessing external data in your React Native app. I will show how using GraphQL instead of REST services the development process becomes even more declarative as GraphQL will take away the (imperative) hassle of tying data from multiple endpoints together. This will increase the level of complexity in React Native development, while also increasing the performance of the application.

GraphQL is quickly becoming mainstream as one of the best ways to get data into your React application. When we see people modernize their app architecture and move to React, they often want to migrate their API to GraphQL as part of the same effort. But while React is super easy to adopt in a small part of your app at a time, GraphQL can seem like a much larger investment. In this talk, we’ll go over the fastest and most effective ways for React developers to incrementally migrate their existing APIs and backends to GraphQL, then talk about opportunities for improvement in the space. If you’re using React and are interested in GraphQL, but are looking for an extra push to get it up and running at your company, this is the talk for you!

The document discusses React, Relay, and GraphQL. It describes them as a "quite normal component approach" and provides overviews of each technology. For GraphQL, it highlights how GraphQL allows for single requests with nested data and any combinations of backend data sources. For Relay, it explains how Relay correlates components with GraphQL types and fragments to define necessary fields and render instructions. Live demos of a GraphQL server and Relay app are also referenced.

The document discusses building a GraphQL API that fetches data from REST endpoints. It describes using JSON web tokens (JWT) for authentication by passing them in request headers to the REST API. It also discusses using Apollo data sources, which help with caching requests and fetching authentication data from request headers to pass to REST APIs. The document provides examples of building a GraphQL server with Express and Apollo that implements these techniques.

Have you ever used a third party API, and it didn't work the way you wanted? You don't have to live with it! I'll be sharing my experience transforming unruly JSON into the GraphQL API of my dreams. I'll speak about how GraphQL helped me get the data I wanted, and share some strategies for designing schema you'll love. By the end of this talk, you'll understand how GraphQL can improve the quality of your data, and your life.

Have you ever used a third party API, and it didn't work the way you wanted? You don't have to live with it! I'll be sharing my experience transforming unruly JSON into the GraphQL API of my dreams. I'll speak about how GraphQL helped me get the data I wanted, and share some strategies for designing schema you'll love. By the end of this talk, you'll understand how GraphQL can improve the quality of your data, and your life.

GraphQL is convenient for developers because it allows them to ask for exactly what they want and get the data they need without hassle. But running GraphQL in production can be incredibly challenging. Pinpointing the exact source of a GraphQL error is like searching for a needle in a haystack. It requires sifting through layers of data fetching logic, resolver functions and upstream services, hoping to stumble upon the culprit. But OpenTelemetry can help... Recording: https://youtu.be/IkEUJjRBCbo?feature=shared

The document compares PHP and Ruby, and the web frameworks CakePHP and Ruby on Rails. It discusses the key features and differences between PHP and Ruby, and demonstrates how a simple blog application can be created from scratch in under a minute using Ruby on Rails with no coding required, compared to the additional coding needed in CakePHP. The document argues that Ruby on Rails is more productive and fully-featured compared to CakePHP.

The document discusses Tracy Lee's presentation on reactive programming with RxJS. It provides an agenda for topics to be covered, including reactive programming in standards, frameworks and libraries, how to think reactively, what RxJS is, and how reactive programming makes development easier. Key points mentioned are promises and observables in standards, reactive programming support in Angular, React, Vue, and D3, treating all applications and data as event-driven and represented as sets of values over time, and that RxJS is the most popular library for reactive programming that provides observables as a way to react to and handle events.

This document discusses transitioning a web application from a REST API to a GraphQL API. It covers why the company adopted GraphQL to address over-fetching and under-fetching issues, choosing the Apollo GraphQL client library, and a staged approach to transitioning including creating a GraphQL server, isolated GraphQL components, and updating legacy stores with component queries. It also provides tips on handling caching keys, response headers, mobile REST clients, server rendering, and taking a staged approach to the transition.

The document discusses problems the author encountered with a third-party REST API and how GraphQL helped solve these issues. Some of the key problems included components being too tightly coupled to the API response, sending unnecessary data to clients, and inability to change data sources without rewriting the app. GraphQL provided instant documentation, allowed fetching related data in one query instead of multiple requests, encouraged better app structure, and provided more resilience to changing data sources. The author recommends GraphQL for applications that need to serve multiple clients, combine multiple data sources, or enforce better coding practices.

This document summarizes and compares several GraphQL libraries for Java: graphql-java, graphql-java-kickstart, and dgs-framework. It discusses their features for defining schemas and types, handling data fetching and caching, performing mutations, handling errors, testing functionality, and code generation capabilities. Overall, dgs-framework requires the least amount of boilerplate code, supports testing and code generation more fully, and is designed specifically for use within Spring Boot applications.

The document discusses building effective APIs with GraphQL and Absinthe. It covers topics such as preventing overfetching with GraphQL queries, implementing efficient pagination with Relay Cursor Connections, inserting and mutating data with mutations, real-time capabilities with subscriptions, handling errors, versioning schema with deprecations, limiting query complexity, and tools for building GraphQL APIs like GraphiQL and GraphQL Playground. The document provides learning resources and links for documentation, books, and example projects using Absinthe for GraphQL APIs in Elixir.

It is a basic presentation which can help you understand the basic concepts about Graphql and how it can be used to resolve the frontend integration of projects and help in reducing the data fetching time This presentation also explains the core features of Graphql and why It is a great alternative for REST APIs along with the procedure with which we can integrate it into our projects

Presented at React Alicante 2022, Spain https://reactalicante.es/ Type systems like TypeScript are the next thing when developing JavaScript applications. They make sure that your props are passed in the correct form and shape throughout your application. Together with GraphQLs query language based on types, you can create the web application of the future!

Your frontend developers are pushing to get started with GraphQL, but you don’t have the backend capacity to migrate your existing REST APIs to GraphQL? Or you want to have a GraphQL API next to your existing endpoints that are based on REST, without having to rewrite all your controllers? In this talk I’ll show how to wrap existing REST APIs into one single GraphQL endpoint on both the client and server side. This allows you to access the power of GraphQL without having to change any of your existing code or connect to a database.

Since the introduction of React a few years ago, a lot has been changed. Were React used to be a library with just a limited amount of features, it now can handle complex use-cases like state management or lazy-loading with just its APIs. This talk will show how these new features can help you develop in React with fewer packages and above all, less code.

What comes to you if you want to have some fun with GraphQL? Join us for the meetup in Munich and enjoy the interesting talk about ‚GraphQL vs. (the) REST ‘. In this session our colleagues Tsvetan Nikolov (Senior Developer at coliquio) and Tom Sedlmeier (Senior Developer at coliquio) will discuss the basic concepts and how to use them. We will present you GraphQL on the backend and on the client side with Apollo.

GraphQL and microservices architectures are perfectly compatible. You can use GraphQL as a data layer for these microservices and combine data from all these services into one universal API. This way, you can break the core of your services into different microservices while still providing one endpoint that your clients can interact with. In this talk, we dive into GraphQL, microservices in Node.js, and why they are the perfect combination. Find the code example here https://github.com/stepzen-dev/stepzen-datalayer-microservices

GraphQL and microservices architectures are perfectly compatible. You can use GraphQL as a data layer for these microservices and combine data from all these services into one universal API. This way, you can break the core of your services into different microservices while still providing one endpoint that your clients can interact with. Before diving into GraphQL, let's explore what microservices are and why it can be helpful to add GraphQL.

This document discusses state management in React using Context and Hooks. It introduces Context as a way to pass data through the component tree without drilling props. Hooks like useContext, useReducer, and custom hooks are demonstrated as ways to consume Context values and update state. The document compares Context to other state management solutions and recommends Context is best for global state while local component state may still be handled with useState.

This document outlines Roy Derks' workshop on authentication in GraphQL. The workshop includes an introduction to JSON Web Tokens (JWTs) and OAuth flows, as well as demonstrations of handling authentication via the GraphQL context, resolvers, and schema. It also covers encoding and decoding JWTs using a secret. The workshop concludes with exercises for attendees to practice these authentication concepts in breakout rooms.

Type systems like TypeScript are the next thing when developing JavaScript applications. They make sure that your props are passed in the correct form and shape throughout your application. Together with GraphQLs query language based on types, you can create the web application of the future! The code can be found here https://github.com/royderks/ts-react-graphql

This document discusses strategies for testing GraphQL applications from the initial development phases through integration and end-to-end testing. Key aspects that can be tested include GraphQL schemas through importing and mocking the schema, resolvers which are pure functions that are easy to test in isolation, integration through schema mocking and resolver testing with server mocking, and client-side testing by mocking the GraphQL client. End-to-end testing involves testing against real servers, and load testing can also be done to test performance. The document emphasizes that testing GraphQL applications involves static type checking, unit tests, integration tests, end-to-end tests, and load testing.

Type systems like TypeScript are the next thing when developing JavaScript applications. They make sure that your props are passed in the correct form and shape throughout your application. Together with GraphQLs query language based on types, you can create the web application of the future!

Did you knew the City of Amsterdam has developed over 125 open-source projects? Also, many of those are build using JavaScript and are using other open-source packages and tools included in the JavaScript ecosystem. The City of Amsterdam is pioneering the field of open-source development by local governments worldwide. But how do we incorporate Open Standards into our projects, choose which packages to use, maintain our repositories and keep our codebase reliable?

State-management could make your application feel bloated, especially when handled on a large-scale. The React core team has been working hard to add features to take this trouble away. By using the new Context and Hooks feature I'll show how to handle state-management for large scale applications.

ReasonML is based on the OCaml programming language and was created at Facebook, by the same creator as React! It shares a lot of features, but with the benefits of a statically typed functional programming language. ReasonML compiles to JavaScript and can therefore be used to create strongly typed React applications.

Boilerplates are often used to kickstart the development process of a JavaScript application. However, this leads to a lot of copied code that isn't needed for most projects, while developers aren't exactly knowing what they are doing.

This document summarizes an introductory workshop on JavaScript ES6/7/8 features. It discusses what ES stands for and how versioning works. Key topics that will be covered in the workshop include importing modules, arrow functions, spread/rest operators, classes, let & constants, template literals, object literals, destructuring, and more. Links are provided for code examples on CodePen to demonstrate each feature. The document also discusses how newer JavaScript features like promises and async/await help solve issues like "callback hell" from previous versions.

Have you noticed the OpenSSF Scorecard badges on the official Dart and Flutter repos? It's Google's way of showing that they care about security. Practices such as pinning dependencies, branch protection, required reviews, continuous integration tests etc. are measured to provide a score and accompanying badge. You can do the same for your projects, and this presentation will show you how, with an emphasis on the unique challenges that come up when working with Dart and Flutter. The session will provide a walkthrough of the steps involved in securing a first repository, and then what it takes to repeat that process across an organization with multiple repos. It will also look at the ongoing maintenance involved once scorecards have been implemented, and how aspects of that maintenance can be better automated to minimize toil.

Kief Morris rethinks the infrastructure code delivery lifecycle, advocating for a shift towards composable infrastructure systems. We should shift to designing around deployable components rather than code modules, use more useful levels of abstraction, and drive design and deployment from applications rather than bottom-up, monolithic architecture and delivery.

Widya Salim and Victor Ma will outline the causal impact analysis, framework, and key learnings used to quantify the impact of reducing Twitter's network latency.

Java Servlet programs

This presentation explores the practical application of image description techniques. Familiar guidelines will be demonstrated in practice, and descriptions will be developed “live”! If you have learned a lot about the theory of image description techniques but want to feel more confident putting them into practice, this is the presentation for you. There will be useful, actionable information for everyone, whether you are working with authors, colleagues, alone, or leveraging AI as a collaborator. Link to presentation recording and transcript: https://bnctechforum.ca/sessions/details-of-description-part-ii-describing-images-in-practice/ Presented by BookNet Canada on June 25, 2024, with support from the Department of Canadian Heritage.

Profile portofolio

The integration of programming into civil engineering is transforming the industry. We can design complex infrastructure projects and analyse large datasets. Imagine revolutionizing the way we build our cities and infrastructure, all by the power of coding. Programming skills are no longer just a bonus—they’re a game changer in this era. Technology is revolutionizing civil engineering by integrating advanced tools and techniques. Programming allows for the automation of repetitive tasks, enhancing the accuracy of designs, simulations, and analyses. With the advent of artificial intelligence and machine learning, engineers can now predict structural behaviors under various conditions, optimize material usage, and improve project planning.

Stream processing is a crucial component of modern data infrastructure, but constructing an efficient and scalable stream processing system can be challenging. Decoupling compute and storage architecture has emerged as an effective solution to these challenges, but it can introduce high latency issues, especially when dealing with complex continuous queries that necessitate managing extra-large internal states. In this talk, we focus on addressing the high latency issues associated with S3 storage in stream processing systems that employ a decoupled compute and storage architecture. We delve into the root causes of latency in this context and explore various techniques to minimize the impact of S3 latency on stream processing performance. Our proposed approach is to implement a tiered storage mechanism that leverages a blend of high-performance and low-cost storage tiers to reduce data movement between the compute and storage layers while maintaining efficient processing. Throughout the talk, we will present experimental results that demonstrate the effectiveness of our approach in mitigating the impact of S3 latency on stream processing. By the end of the talk, attendees will have gained insights into how to optimize their stream processing systems for reduced latency and improved cost-efficiency.

Password Rotation in 2024 is still Relevant

If you’ve ever had to analyze a map or GPS data, chances are you’ve encountered and even worked with coordinate systems. As historical data continually updates through GPS, understanding coordinate systems is increasingly crucial. However, not everyone knows why they exist or how to effectively use them for data-driven insights. During this webinar, you’ll learn exactly what coordinate systems are and how you can use FME to maintain and transform your data’s coordinate systems in an easy-to-digest way, accurately representing the geographical space that it exists within. During this webinar, you will have the chance to: - Enhance Your Understanding: Gain a clear overview of what coordinate systems are and their value - Learn Practical Applications: Why we need datams and projections, plus units between coordinate systems - Maximize with FME: Understand how FME handles coordinate systems, including a brief summary of the 3 main reprojectors - Custom Coordinate Systems: Learn how to work with FME and coordinate systems beyond what is natively supported - Look Ahead: Gain insights into where FME is headed with coordinate systems in the future Don’t miss the opportunity to improve the value you receive from your coordinate system data, ultimately allowing you to streamline your data analysis and maximize your time. See you there!

An invited talk given by Mark Billinghurst on Research Directions for Cross Reality Interfaces. This was given on July 2nd 2024 as part of the 2024 Summer School on Cross Reality in Hagenberg, Austria (July 1st - 7th)

The presentation showcases the diverse real-world applications of Fused Deposition Modeling (FDM) across multiple industries: 1. **Manufacturing**: FDM is utilized in manufacturing for rapid prototyping, creating custom tools and fixtures, and producing functional end-use parts. Companies leverage its cost-effectiveness and flexibility to streamline production processes. 2. **Medical**: In the medical field, FDM is used to create patient-specific anatomical models, surgical guides, and prosthetics. Its ability to produce precise and biocompatible parts supports advancements in personalized healthcare solutions. 3. **Education**: FDM plays a crucial role in education by enabling students to learn about design and engineering through hands-on 3D printing projects. It promotes innovation and practical skill development in STEM disciplines. 4. **Science**: Researchers use FDM to prototype equipment for scientific experiments, build custom laboratory tools, and create models for visualization and testing purposes. It facilitates rapid iteration and customization in scientific endeavors. 5. **Automotive**: Automotive manufacturers employ FDM for prototyping vehicle components, tooling for assembly lines, and customized parts. It speeds up the design validation process and enhances efficiency in automotive engineering. 6. **Consumer Electronics**: FDM is utilized in consumer electronics for designing and prototyping product enclosures, casings, and internal components. It enables rapid iteration and customization to meet evolving consumer demands. 7. **Robotics**: Robotics engineers leverage FDM to prototype robot parts, create lightweight and durable components, and customize robot designs for specific applications. It supports innovation and optimization in robotic systems. 8. **Aerospace**: In aerospace, FDM is used to manufacture lightweight parts, complex geometries, and prototypes of aircraft components. It contributes to cost reduction, faster production cycles, and weight savings in aerospace engineering. 9. **Architecture**: Architects utilize FDM for creating detailed architectural models, prototypes of building components, and intricate designs. It aids in visualizing concepts, testing structural integrity, and communicating design ideas effectively. Each industry example demonstrates how FDM enhances innovation, accelerates product development, and addresses specific challenges through advanced manufacturing capabilities.

Everything that I found interesting last month about the irresponsible use of machine intelligence

Slide of the tutorial entitled "Paradigm Shifts in User Modeling: A Journey from Historical Foundations to Emerging Trends" held at UMAP'24: 32nd ACM Conference on User Modeling, Adaptation and Personalization (July 1, 2024 | Cagliari, Italy)

This presentation, delivered at the Postgres Bangalore (PGBLR) Meetup-2 on June 29th, 2024, dives deep into connection pooling for PostgreSQL databases. Aakash M, a PostgreSQL Tech Lead at Mydbops, explores the challenges of managing numerous connections and explains how connection pooling optimizes performance and resource utilization. Key Takeaways: * Understand why connection pooling is essential for high-traffic applications * Explore various connection poolers available for PostgreSQL, including pgbouncer * Learn the configuration options and functionalities of pgbouncer * Discover best practices for monitoring and troubleshooting connection pooling setups * Gain insights into real-world use cases and considerations for production environments This presentation is ideal for: * Database administrators (DBAs) * Developers working with PostgreSQL * DevOps engineers * Anyone interested in optimizing PostgreSQL performance Contact info@mydbops.com for PostgreSQL Managed, Consulting and Remote DBA Services

Your comprehensive guide to RPA in healthcare for 2024. Explore the benefits, use cases, and emerging trends of robotic process automation. Understand the challenges and prepare for the future of healthcare automation

Blockchain technology is transforming industries and reshaping the way we conduct business, manage data, and secure transactions. Whether you're new to blockchain or looking to deepen your knowledge, our guidebook, "Blockchain for Dummies", is your ultimate resource.

Recent advancements in the NIST-JARVIS infrastructure: JARVIS-Overview, JARVIS-DFT, AtomGPT, ALIGNN, JARVIS-Leaderboard

Are you interested in dipping your toes in the cloud native observability waters, but as an engineer you are not sure where to get started with tracing problems through your microservices and application landscapes on Kubernetes? Then this is the session for you, where we take you on your first steps in an active open-source project that offers a buffet of languages, challenges, and opportunities for getting started with telemetry data. The project is called openTelemetry, but before diving into the specifics, we’ll start with de-mystifying key concepts and terms such as observability, telemetry, instrumentation, cardinality, percentile to lay a foundation. After understanding the nuts and bolts of observability and distributed traces, we’ll explore the openTelemetry community; its Special Interest Groups (SIGs), repositories, and how to become not only an end-user, but possibly a contributor.We will wrap up with an overview of the components in this project, such as the Collector, the OpenTelemetry protocol (OTLP), its APIs, and its SDKs. Attendees will leave with an understanding of key observability concepts, become grounded in distributed tracing terminology, be aware of the components of openTelemetry, and know how to take their first steps to an open-source contribution! Key Takeaways: Open source, vendor neutral instrumentation is an exciting new reality as the industry standardizes on openTelemetry for observability. OpenTelemetry is on a mission to enable effective observability by making high-quality, portable telemetry ubiquitous. The world of observability and monitoring today has a steep learning curve and in order to achieve ubiquity, the project would benefit from growing our contributor community.

CIO Council Cal Poly Humboldt September 22, 2023