The document discusses best practices for designing application programming interfaces (APIs). It covers why API design is important, characteristics of a good API, the API design process, and principles for class, method, and exception design. The key aspects discussed are making APIs easy to learn and use, minimizing the potential for misuse, ensuring APIs are robust and flexible over time, and throwing exceptions only for true errors rather than as part of normal control flow.
Anupam Jha has over 10 years of experience as an Automation Test Engineer and Senior Consultant. He has expertise in test automation using Selenium WebDriver, HP UFT, Cucumber, and Appium. He has worked on projects in e-commerce, banking, and other domains. Currently, he is an Automation Test Lead implementing continuous integration using Jenkins.
What all things to consider for a good career in javaJanBask Training
This shortage has created a huge demand for the right Java developers. Existing Java developers also need to brush up their knowledge and skills to gain benefit from this increasing demand.
https://www.janbasktraining.com/online-java-training
Well not quite, but they can detect them. This talk will explore Microsoft Cognitive Services in Azure. We'll take a look at the offerings overall, and then take a deeper look into specifics such as Sentiment analysis, Computer vision (image recognition) and Emotion detection.
The document summarizes Developers Nepal Meetup #4, which focused on testing. It describes presentations on service orchestration with Consul, remote work challenges/opportunities, and lessons for junior developers. A panel discussion on automated testing featured senior engineers debating the importance of tests. Attendees provided positive feedback, saying they would attend and recommend future meetups.
This document introduces TejaSoft, an Indian company specialized in providing optimization services for embedded Java applications. The company was founded in 2004 and has experience in areas like JavaME, Android, and desktop Java technologies. TejaSoft has a team of senior consultants and developers with deep expertise in Java who aim to improve code quality, performance, size and reliability through activities like architecture reviews, profiling, testing and refactoring. They have worked with various clients on projects involving embedded systems and Java.
The document discusses various code quality metrics that can be used to understand software quality, including defects density, unit test density, code and test coverage, cyclomatic complexity, fan-in and fan-out, and WTFs per minute. While metrics can help identify issues, they cannot determine the precise cause. Metrics should be used carefully to avoid incentivizing behaviors like hiding bugs. Maintaining pride in craftsmanship is important for quality.
This document contains the resume of Akash Chopra, an automation test engineer with over 2.5 years of experience working for Tata Consultancy Services. He has extensive experience developing automation frameworks and test scripts using tools like Selenium, QTP, Ranorex Studio, and ALM. He has worked on several projects for JP Morgan Chase automating tests for applications in banking, investments, and online trading.
Anupam Jha has over 10 years of experience as an Automation Test Engineer and Senior Consultant. He has expertise in test automation using Selenium WebDriver, HP UFT, Cucumber, and Appium. He has worked on projects in e-commerce, banking, and other domains. Currently, he is an Automation Test Lead implementing continuous integration using Jenkins.
What all things to consider for a good career in javaJanBask Training
This shortage has created a huge demand for the right Java developers. Existing Java developers also need to brush up their knowledge and skills to gain benefit from this increasing demand.
https://www.janbasktraining.com/online-java-training
Well not quite, but they can detect them. This talk will explore Microsoft Cognitive Services in Azure. We'll take a look at the offerings overall, and then take a deeper look into specifics such as Sentiment analysis, Computer vision (image recognition) and Emotion detection.
The document summarizes Developers Nepal Meetup #4, which focused on testing. It describes presentations on service orchestration with Consul, remote work challenges/opportunities, and lessons for junior developers. A panel discussion on automated testing featured senior engineers debating the importance of tests. Attendees provided positive feedback, saying they would attend and recommend future meetups.
This document introduces TejaSoft, an Indian company specialized in providing optimization services for embedded Java applications. The company was founded in 2004 and has experience in areas like JavaME, Android, and desktop Java technologies. TejaSoft has a team of senior consultants and developers with deep expertise in Java who aim to improve code quality, performance, size and reliability through activities like architecture reviews, profiling, testing and refactoring. They have worked with various clients on projects involving embedded systems and Java.
The document discusses various code quality metrics that can be used to understand software quality, including defects density, unit test density, code and test coverage, cyclomatic complexity, fan-in and fan-out, and WTFs per minute. While metrics can help identify issues, they cannot determine the precise cause. Metrics should be used carefully to avoid incentivizing behaviors like hiding bugs. Maintaining pride in craftsmanship is important for quality.
This document contains the resume of Akash Chopra, an automation test engineer with over 2.5 years of experience working for Tata Consultancy Services. He has extensive experience developing automation frameworks and test scripts using tools like Selenium, QTP, Ranorex Studio, and ALM. He has worked on several projects for JP Morgan Chase automating tests for applications in banking, investments, and online trading.
How To Design A Good A P I And Why It Matters G O O G L Eguestbe92f4
This document discusses best practices for designing application programming interfaces (APIs). It outlines that APIs can be a company's greatest asset or liability depending on their quality. The author then provides guidelines for designing good APIs, including gathering requirements, writing code that uses the API early, keeping APIs small and focused, minimizing mutability, and properly documenting the API. The document is an outline for a presentation or paper on API design.
This document discusses guidelines for designing good APIs. It covers the importance of API design, characteristics of a good API, the API design process, general principles like minimizing mutability and accessibility, class design considerations like immutable classes, method design best practices like failing fast and avoiding long parameter lists, exception design, and refactoring existing APIs. The overall goal is to create APIs that are easy to learn, use, read and extend while preventing misuse.
Sap web dynpro – practices for better functionalityanjalirao366
This document discusses best practices for developing functionality in SAP WebDynpro applications. It recommends separating reusable logic from component controllers into helper classes and business classes to improve code organization. It also suggests creating lightweight user interfaces with standard naming conventions and context elements to reduce complexity. The document advises using simple functions and standard naming conventions for populating context and storing simple data types in attributes to improve context reading and writing.
This document discusses guidelines for developing application programming interfaces (APIs). It defines an API as an interface that allows software applications to communicate with each other. The document outlines properties an API should have like being easy to use and learn. It provides guidelines for APIs such as having a single responsibility, using proper naming conventions, adding documentation, and considering performance. It also discusses API maintenance, C/C++ specific issues, anti-patterns to avoid, and concludes that the best API is no API.
Refactoring involves restructuring existing code without changing its external behavior in order to improve aspects like readability, structure, and performance. It is done through a series of small, behavior-preserving changes. Refactoring can save time by improving code quality, allowing easier prototyping and changes when specifications are unclear, and helping to establish a clear overall project structure. It is important that refactoring does not break any existing functionality and keeps a consistent application programming interface.
The document discusses how to build a reusable eLearning framework using APIs. It notes that APIs can provide significant cost and time savings through standardization, shorter development cycles, improved quality, and better risk management. When creating an API, planning and collaboration are important. The API should have intuitive methods and properties to allow code to ignore implementation details. The first steps are to identify commonly repeated tasks and code from existing projects to determine what to include in the API.
MuleSoft Surat Meetup#39 - Pragmatic API Led ConnectivityJitendra Bafna
This document provides an overview of a MuleSoft meetup on API-led connectivity. It includes introductions of the organizers and agenda. The agenda discusses designing RESTful reusable APIs, how API-led fits into architecture, and an example use case. It also covers when system APIs may be useful, such as to address security issues, improve error handling, reduce complexity, and improve third party APIs. The document emphasizes that core or business APIs are the essential layer and other layers like system or process APIs are optimizations that need only be built if necessary.
Refactoring involves restructuring existing code without changing its external behavior through small, behavior-preserving transformations. It improves code readability, maintainability, and quality over time. Refactoring is useful for prototyping with unclear specs, gaining project overview on large codebases, and improving poorly designed code. It can save significant time versus rewriting from scratch by allowing work to progress iteratively while preserving existing functionality and APIs. Examples demonstrate how refactoring authentication and database code improved structure without affecting existing features or tests.
This is a presentation inspired (heavily) by that of Joshu Bloch's presentation on "How to design a good API and its importance". I tried to simplify on API importance and tried to generify how to conceive it. No point referring to that presentation explicitly as I am mentioning it here and mentioned it at the start and end of the presentation as I made it in BASIS SoftExpo 2012
This document summarizes a presentation on how to improve APIs by focusing on the developer experience. The presentation outlines four simple rules for better APIs: 1) Give developers reasons to build on the API, 2) Make developers successful faster, 3) Don't violate developers' trust, and 4) Listen to developers. It discusses common frustrations developers have such as a lack of purpose or documentation, difficulty getting started, and lack of support. The presentation urges API providers to put themselves in developers' shoes and treat them and their APIs as products to improve adoption.
The document provides guidance on API design best practices. It recommends that APIs should be easy to use, consistent, follow standards, and have good documentation. APIs should do one thing well and be testable. Red flags include inability to find functionality or come up with good names. The document also discusses REST principles and levels, and provides opinions on improving the BringIt API, such as versioning, using HTTP verbs, and standardizing naming conventions.
How to Become an SAP ABAP Developer? Career Scope, Salary, Skills, Future Tre...Aspire Techsoft Academy
If you want to become a good programmer, you are in the right place. here, you will see some tips for making a programmer. In today's world, I want to tell you some good tips to become a good programmer.
Continuous coding allows you to notice mistakes in your designing, error handling, and threading, and then acquire those related skills to improve yourself. The top developers in the universe don’t just write strong code but have important ethereal traits. After working with maximum developers, you have been identifying the qualities that set a good programmer apart from the people.
API Specifications and Best Practices | MuleSoft Mysore Meetup #4MysoreMuleSoftMeetup
API Specifications and Best Practices | MuleSoft Mysore Meetup #4
What is RAML?
API Specification vs. API Fragment
Various Fragment types and their usage
Speaker:- Abhishek Bathwal
Organizers:- Shubham Chaurasia, Giridhar Meka
This document discusses principles for effective API design. It defines an API as providing a way for developers to interact with and consume a service. It outlines six principles for API design: design first, choose the right runtime, define contracts, monitor usage, continuously improve, and socialize APIs. The principles emphasize designing for developers and specific use cases, ensuring scalability and reliability of the runtime, and engaging with developers through documentation and community. Well-designed APIs that follow these principles can become valuable products and ecosystems, while mediocre APIs that don't engage stakeholders may fail to meet business objectives.
Trouble with Performance Debugging? Not Anymore with Choreo, the AI-Assisted ...WSO2
This slide deck explores how Choreo, a low-code integration Platform-as-a-Service, provides AI-assisted performance debugging.
Read the full article here: https://wso2.com/choreo/resources/performant-code-for-everyone-writing-better-code-with-ai-powered-performance-feedback/
This document outlines an agenda for a presentation on API Specification (RAML) Best Practices. The presentation will cover what RAML is, how to use different fragment types like data types, libraries, security schemes and resource types, best practices for modularization and naming standards, and examples of strict validation. It includes an introduction of the speaker, safe harbor statement, and information on providing feedback. The presentation will also include a demo and references for further reading.
[WSO2 API Day Chicago 2019] Sustainable Competitive Advantage WSO2
Sustainable competitive advantage, while once a necessary part of any strategy, is now increasingly obsolete for most firms. The new path to winning means capturing opportunities quickly and exploiting them decisively. It's all about learning to thrive in a transient advantage economy. Transient advantage is the central thesis of Rita McGrath's recent book on competitive advantage. These principles are especially relevant for agile companies that pursue digital-first business models. Quinnox has adopted this philosophy for its clients and its own business where we believe enterprise integration driven by API's is the bridge to digital transformation, speed to market, and frequency to market.
This document discusses the benefits of building APIs first before developing user interfaces. It argues that taking an "API-first" approach allows software to more easily become a platform that others can integrate with. Some key points made include:
- Building APIs first is more work upfront but pays off by enabling integrations and new interfaces like mobile apps.
- The process needs to break features into API endpoints before considering the user interface.
- APIs should support multiple "actors" like users, integrations and bots rather than tying all data to individual user accounts.
- Thinking about how features may evolve and allowing for future possibilities, like multiple related objects rather than a single one, helps future-proof APIs.
Crafting a Cloud Native API Platform to Accelerate Your Platform Maturity - B...Nordic APIs
A presentation given by Budhaditya Bhattacharya, Developer Advocate at Tyk, at our 2024 Austin API Summit, March 12-13.
Session Description: APIs and microservices are powering domain-driven design architectures and have become the fabric of modern cloud-native applications. However, focusing on technology isn't enough - there is a need for a synergy between people, processes, and tools.
Based on the CNCF platform maturity model, we will look to bridge the gap between an org's current and desired platform maturity level when creating cloud-native API platforms. We'll discuss:
1. The platform team model - team topologies and key roles for developing internal API platforms
2. Processes like platform discovery, jobs-to-be-done analysis, and continuous feedback loops to understand and meet developer needs
3. Applying a "platform as a product" mindset to measure and communicate platform success
4. Architecting for discoverability, security, observability and integration capabilities 5. The role of technologies like service meshes, API gateway, identity management, internal developer portals and OpenAPI specifications
Monitoring and Managing Anomaly Detection on OpenShift.pdfTosin Akinosho
Monitoring and Managing Anomaly Detection on OpenShift
Overview
Dive into the world of anomaly detection on edge devices with our comprehensive hands-on tutorial. This SlideShare presentation will guide you through the entire process, from data collection and model training to edge deployment and real-time monitoring. Perfect for those looking to implement robust anomaly detection systems on resource-constrained IoT/edge devices.
Key Topics Covered
1. Introduction to Anomaly Detection
- Understand the fundamentals of anomaly detection and its importance in identifying unusual behavior or failures in systems.
2. Understanding Edge (IoT)
- Learn about edge computing and IoT, and how they enable real-time data processing and decision-making at the source.
3. What is ArgoCD?
- Discover ArgoCD, a declarative, GitOps continuous delivery tool for Kubernetes, and its role in deploying applications on edge devices.
4. Deployment Using ArgoCD for Edge Devices
- Step-by-step guide on deploying anomaly detection models on edge devices using ArgoCD.
5. Introduction to Apache Kafka and S3
- Explore Apache Kafka for real-time data streaming and Amazon S3 for scalable storage solutions.
6. Viewing Kafka Messages in the Data Lake
- Learn how to view and analyze Kafka messages stored in a data lake for better insights.
7. What is Prometheus?
- Get to know Prometheus, an open-source monitoring and alerting toolkit, and its application in monitoring edge devices.
8. Monitoring Application Metrics with Prometheus
- Detailed instructions on setting up Prometheus to monitor the performance and health of your anomaly detection system.
9. What is Camel K?
- Introduction to Camel K, a lightweight integration framework built on Apache Camel, designed for Kubernetes.
10. Configuring Camel K Integrations for Data Pipelines
- Learn how to configure Camel K for seamless data pipeline integrations in your anomaly detection workflow.
11. What is a Jupyter Notebook?
- Overview of Jupyter Notebooks, an open-source web application for creating and sharing documents with live code, equations, visualizations, and narrative text.
12. Jupyter Notebooks with Code Examples
- Hands-on examples and code snippets in Jupyter Notebooks to help you implement and test anomaly detection models.
Generating privacy-protected synthetic data using Secludy and MilvusZilliz
During this demo, the founders of Secludy will demonstrate how their system utilizes Milvus to store and manipulate embeddings for generating privacy-protected synthetic data. Their approach not only maintains the confidentiality of the original data but also enhances the utility and scalability of LLMs under privacy constraints. Attendees, including machine learning engineers, data scientists, and data managers, will witness first-hand how Secludy's integration with Milvus empowers organizations to harness the power of LLMs securely and efficiently.
How To Design A Good A P I And Why It Matters G O O G L Eguestbe92f4
This document discusses best practices for designing application programming interfaces (APIs). It outlines that APIs can be a company's greatest asset or liability depending on their quality. The author then provides guidelines for designing good APIs, including gathering requirements, writing code that uses the API early, keeping APIs small and focused, minimizing mutability, and properly documenting the API. The document is an outline for a presentation or paper on API design.
This document discusses guidelines for designing good APIs. It covers the importance of API design, characteristics of a good API, the API design process, general principles like minimizing mutability and accessibility, class design considerations like immutable classes, method design best practices like failing fast and avoiding long parameter lists, exception design, and refactoring existing APIs. The overall goal is to create APIs that are easy to learn, use, read and extend while preventing misuse.
Sap web dynpro – practices for better functionalityanjalirao366
This document discusses best practices for developing functionality in SAP WebDynpro applications. It recommends separating reusable logic from component controllers into helper classes and business classes to improve code organization. It also suggests creating lightweight user interfaces with standard naming conventions and context elements to reduce complexity. The document advises using simple functions and standard naming conventions for populating context and storing simple data types in attributes to improve context reading and writing.
This document discusses guidelines for developing application programming interfaces (APIs). It defines an API as an interface that allows software applications to communicate with each other. The document outlines properties an API should have like being easy to use and learn. It provides guidelines for APIs such as having a single responsibility, using proper naming conventions, adding documentation, and considering performance. It also discusses API maintenance, C/C++ specific issues, anti-patterns to avoid, and concludes that the best API is no API.
Refactoring involves restructuring existing code without changing its external behavior in order to improve aspects like readability, structure, and performance. It is done through a series of small, behavior-preserving changes. Refactoring can save time by improving code quality, allowing easier prototyping and changes when specifications are unclear, and helping to establish a clear overall project structure. It is important that refactoring does not break any existing functionality and keeps a consistent application programming interface.
The document discusses how to build a reusable eLearning framework using APIs. It notes that APIs can provide significant cost and time savings through standardization, shorter development cycles, improved quality, and better risk management. When creating an API, planning and collaboration are important. The API should have intuitive methods and properties to allow code to ignore implementation details. The first steps are to identify commonly repeated tasks and code from existing projects to determine what to include in the API.
MuleSoft Surat Meetup#39 - Pragmatic API Led ConnectivityJitendra Bafna
This document provides an overview of a MuleSoft meetup on API-led connectivity. It includes introductions of the organizers and agenda. The agenda discusses designing RESTful reusable APIs, how API-led fits into architecture, and an example use case. It also covers when system APIs may be useful, such as to address security issues, improve error handling, reduce complexity, and improve third party APIs. The document emphasizes that core or business APIs are the essential layer and other layers like system or process APIs are optimizations that need only be built if necessary.
Refactoring involves restructuring existing code without changing its external behavior through small, behavior-preserving transformations. It improves code readability, maintainability, and quality over time. Refactoring is useful for prototyping with unclear specs, gaining project overview on large codebases, and improving poorly designed code. It can save significant time versus rewriting from scratch by allowing work to progress iteratively while preserving existing functionality and APIs. Examples demonstrate how refactoring authentication and database code improved structure without affecting existing features or tests.
This is a presentation inspired (heavily) by that of Joshu Bloch's presentation on "How to design a good API and its importance". I tried to simplify on API importance and tried to generify how to conceive it. No point referring to that presentation explicitly as I am mentioning it here and mentioned it at the start and end of the presentation as I made it in BASIS SoftExpo 2012
This document summarizes a presentation on how to improve APIs by focusing on the developer experience. The presentation outlines four simple rules for better APIs: 1) Give developers reasons to build on the API, 2) Make developers successful faster, 3) Don't violate developers' trust, and 4) Listen to developers. It discusses common frustrations developers have such as a lack of purpose or documentation, difficulty getting started, and lack of support. The presentation urges API providers to put themselves in developers' shoes and treat them and their APIs as products to improve adoption.
The document provides guidance on API design best practices. It recommends that APIs should be easy to use, consistent, follow standards, and have good documentation. APIs should do one thing well and be testable. Red flags include inability to find functionality or come up with good names. The document also discusses REST principles and levels, and provides opinions on improving the BringIt API, such as versioning, using HTTP verbs, and standardizing naming conventions.
How to Become an SAP ABAP Developer? Career Scope, Salary, Skills, Future Tre...Aspire Techsoft Academy
If you want to become a good programmer, you are in the right place. here, you will see some tips for making a programmer. In today's world, I want to tell you some good tips to become a good programmer.
Continuous coding allows you to notice mistakes in your designing, error handling, and threading, and then acquire those related skills to improve yourself. The top developers in the universe don’t just write strong code but have important ethereal traits. After working with maximum developers, you have been identifying the qualities that set a good programmer apart from the people.
API Specifications and Best Practices | MuleSoft Mysore Meetup #4MysoreMuleSoftMeetup
API Specifications and Best Practices | MuleSoft Mysore Meetup #4
What is RAML?
API Specification vs. API Fragment
Various Fragment types and their usage
Speaker:- Abhishek Bathwal
Organizers:- Shubham Chaurasia, Giridhar Meka
This document discusses principles for effective API design. It defines an API as providing a way for developers to interact with and consume a service. It outlines six principles for API design: design first, choose the right runtime, define contracts, monitor usage, continuously improve, and socialize APIs. The principles emphasize designing for developers and specific use cases, ensuring scalability and reliability of the runtime, and engaging with developers through documentation and community. Well-designed APIs that follow these principles can become valuable products and ecosystems, while mediocre APIs that don't engage stakeholders may fail to meet business objectives.
Trouble with Performance Debugging? Not Anymore with Choreo, the AI-Assisted ...WSO2
This slide deck explores how Choreo, a low-code integration Platform-as-a-Service, provides AI-assisted performance debugging.
Read the full article here: https://wso2.com/choreo/resources/performant-code-for-everyone-writing-better-code-with-ai-powered-performance-feedback/
This document outlines an agenda for a presentation on API Specification (RAML) Best Practices. The presentation will cover what RAML is, how to use different fragment types like data types, libraries, security schemes and resource types, best practices for modularization and naming standards, and examples of strict validation. It includes an introduction of the speaker, safe harbor statement, and information on providing feedback. The presentation will also include a demo and references for further reading.
[WSO2 API Day Chicago 2019] Sustainable Competitive Advantage WSO2
Sustainable competitive advantage, while once a necessary part of any strategy, is now increasingly obsolete for most firms. The new path to winning means capturing opportunities quickly and exploiting them decisively. It's all about learning to thrive in a transient advantage economy. Transient advantage is the central thesis of Rita McGrath's recent book on competitive advantage. These principles are especially relevant for agile companies that pursue digital-first business models. Quinnox has adopted this philosophy for its clients and its own business where we believe enterprise integration driven by API's is the bridge to digital transformation, speed to market, and frequency to market.
This document discusses the benefits of building APIs first before developing user interfaces. It argues that taking an "API-first" approach allows software to more easily become a platform that others can integrate with. Some key points made include:
- Building APIs first is more work upfront but pays off by enabling integrations and new interfaces like mobile apps.
- The process needs to break features into API endpoints before considering the user interface.
- APIs should support multiple "actors" like users, integrations and bots rather than tying all data to individual user accounts.
- Thinking about how features may evolve and allowing for future possibilities, like multiple related objects rather than a single one, helps future-proof APIs.
Crafting a Cloud Native API Platform to Accelerate Your Platform Maturity - B...Nordic APIs
A presentation given by Budhaditya Bhattacharya, Developer Advocate at Tyk, at our 2024 Austin API Summit, March 12-13.
Session Description: APIs and microservices are powering domain-driven design architectures and have become the fabric of modern cloud-native applications. However, focusing on technology isn't enough - there is a need for a synergy between people, processes, and tools.
Based on the CNCF platform maturity model, we will look to bridge the gap between an org's current and desired platform maturity level when creating cloud-native API platforms. We'll discuss:
1. The platform team model - team topologies and key roles for developing internal API platforms
2. Processes like platform discovery, jobs-to-be-done analysis, and continuous feedback loops to understand and meet developer needs
3. Applying a "platform as a product" mindset to measure and communicate platform success
4. Architecting for discoverability, security, observability and integration capabilities 5. The role of technologies like service meshes, API gateway, identity management, internal developer portals and OpenAPI specifications
Monitoring and Managing Anomaly Detection on OpenShift.pdfTosin Akinosho
Monitoring and Managing Anomaly Detection on OpenShift
Overview
Dive into the world of anomaly detection on edge devices with our comprehensive hands-on tutorial. This SlideShare presentation will guide you through the entire process, from data collection and model training to edge deployment and real-time monitoring. Perfect for those looking to implement robust anomaly detection systems on resource-constrained IoT/edge devices.
Key Topics Covered
1. Introduction to Anomaly Detection
- Understand the fundamentals of anomaly detection and its importance in identifying unusual behavior or failures in systems.
2. Understanding Edge (IoT)
- Learn about edge computing and IoT, and how they enable real-time data processing and decision-making at the source.
3. What is ArgoCD?
- Discover ArgoCD, a declarative, GitOps continuous delivery tool for Kubernetes, and its role in deploying applications on edge devices.
4. Deployment Using ArgoCD for Edge Devices
- Step-by-step guide on deploying anomaly detection models on edge devices using ArgoCD.
5. Introduction to Apache Kafka and S3
- Explore Apache Kafka for real-time data streaming and Amazon S3 for scalable storage solutions.
6. Viewing Kafka Messages in the Data Lake
- Learn how to view and analyze Kafka messages stored in a data lake for better insights.
7. What is Prometheus?
- Get to know Prometheus, an open-source monitoring and alerting toolkit, and its application in monitoring edge devices.
8. Monitoring Application Metrics with Prometheus
- Detailed instructions on setting up Prometheus to monitor the performance and health of your anomaly detection system.
9. What is Camel K?
- Introduction to Camel K, a lightweight integration framework built on Apache Camel, designed for Kubernetes.
10. Configuring Camel K Integrations for Data Pipelines
- Learn how to configure Camel K for seamless data pipeline integrations in your anomaly detection workflow.
11. What is a Jupyter Notebook?
- Overview of Jupyter Notebooks, an open-source web application for creating and sharing documents with live code, equations, visualizations, and narrative text.
12. Jupyter Notebooks with Code Examples
- Hands-on examples and code snippets in Jupyter Notebooks to help you implement and test anomaly detection models.
Generating privacy-protected synthetic data using Secludy and MilvusZilliz
During this demo, the founders of Secludy will demonstrate how their system utilizes Milvus to store and manipulate embeddings for generating privacy-protected synthetic data. Their approach not only maintains the confidentiality of the original data but also enhances the utility and scalability of LLMs under privacy constraints. Attendees, including machine learning engineers, data scientists, and data managers, will witness first-hand how Secludy's integration with Milvus empowers organizations to harness the power of LLMs securely and efficiently.
How to Get CNIC Information System with Paksim Ga.pptxdanishmna97
Pakdata Cf is a groundbreaking system designed to streamline and facilitate access to CNIC information. This innovative platform leverages advanced technology to provide users with efficient and secure access to their CNIC details.
Programming Foundation Models with DSPy - Meetup SlidesZilliz
Prompting language models is hard, while programming language models is easy. In this talk, I will discuss the state-of-the-art framework DSPy for programming foundation models with its powerful optimizers and runtime constraint system.
Your One-Stop Shop for Python Success: Top 10 US Python Development Providersakankshawande
Simplify your search for a reliable Python development partner! This list presents the top 10 trusted US providers offering comprehensive Python development services, ensuring your project's success from conception to completion.
Threats to mobile devices are more prevalent and increasing in scope and complexity. Users of mobile devices desire to take full advantage of the features
available on those devices, but many of the features provide convenience and capability but sacrifice security. This best practices guide outlines steps the users can take to better protect personal devices and information.
Ivanti’s Patch Tuesday breakdown goes beyond patching your applications and brings you the intelligence and guidance needed to prioritize where to focus your attention first. Catch early analysis on our Ivanti blog, then join industry expert Chris Goettl for the Patch Tuesday Webinar Event. There we’ll do a deep dive into each of the bulletins and give guidance on the risks associated with the newly-identified vulnerabilities.
Building Production Ready Search Pipelines with Spark and MilvusZilliz
Spark is the widely used ETL tool for processing, indexing and ingesting data to serving stack for search. Milvus is the production-ready open-source vector database. In this talk we will show how to use Spark to process unstructured data to extract vector representations, and push the vectors to Milvus vector database for search serving.
Full-RAG: A modern architecture for hyper-personalizationZilliz
Mike Del Balso, CEO & Co-Founder at Tecton, presents "Full RAG," a novel approach to AI recommendation systems, aiming to push beyond the limitations of traditional models through a deep integration of contextual insights and real-time data, leveraging the Retrieval-Augmented Generation architecture. This talk will outline Full RAG's potential to significantly enhance personalization, address engineering challenges such as data management and model training, and introduce data enrichment with reranking as a key solution. Attendees will gain crucial insights into the importance of hyperpersonalization in AI, the capabilities of Full RAG for advanced personalization, and strategies for managing complex data integrations for deploying cutting-edge AI solutions.
Best 20 SEO Techniques To Improve Website Visibility In SERPPixlogix Infotech
Boost your website's visibility with proven SEO techniques! Our latest blog dives into essential strategies to enhance your online presence, increase traffic, and rank higher on search engines. From keyword optimization to quality content creation, learn how to make your site stand out in the crowded digital landscape. Discover actionable tips and expert insights to elevate your SEO game.
Things to Consider When Choosing a Website Developer for your Website | FODUUFODUU
Choosing the right website developer is crucial for your business. This article covers essential factors to consider, including experience, portfolio, technical skills, communication, pricing, reputation & reviews, cost and budget considerations and post-launch support. Make an informed decision to ensure your website meets your business goals.
For the full video of this presentation, please visit: https://www.edge-ai-vision.com/2024/06/building-and-scaling-ai-applications-with-the-nx-ai-manager-a-presentation-from-network-optix/
Robin van Emden, Senior Director of Data Science at Network Optix, presents the “Building and Scaling AI Applications with the Nx AI Manager,” tutorial at the May 2024 Embedded Vision Summit.
In this presentation, van Emden covers the basics of scaling edge AI solutions using the Nx tool kit. He emphasizes the process of developing AI models and deploying them globally. He also showcases the conversion of AI models and the creation of effective edge AI pipelines, with a focus on pre-processing, model conversion, selecting the appropriate inference engine for the target hardware and post-processing.
van Emden shows how Nx can simplify the developer’s life and facilitate a rapid transition from concept to production-ready applications.He provides valuable insights into developing scalable and efficient edge AI solutions, with a strong focus on practical implementation.
OpenID AuthZEN Interop Read Out - AuthorizationDavid Brossard
During Identiverse 2024 and EIC 2024, members of the OpenID AuthZEN WG got together and demoed their authorization endpoints conforming to the AuthZEN API
Essentials of Automations: The Art of Triggers and Actions in FMESafe Software
In this second installment of our Essentials of Automations webinar series, we’ll explore the landscape of triggers and actions, guiding you through the nuances of authoring and adapting workspaces for seamless automations. Gain an understanding of the full spectrum of triggers and actions available in FME, empowering you to enhance your workspaces for efficient automation.
We’ll kick things off by showcasing the most commonly used event-based triggers, introducing you to various automation workflows like manual triggers, schedules, directory watchers, and more. Plus, see how these elements play out in real scenarios.
Whether you’re tweaking your current setup or building from the ground up, this session will arm you with the tools and insights needed to transform your FME usage into a powerhouse of productivity. Join us to discover effective strategies that simplify complex processes, enhancing your productivity and transforming your data management practices with FME. Let’s turn complexity into clarity and make your workspaces work wonders!
CAKE: Sharing Slices of Confidential Data on BlockchainClaudio Di Ciccio
Presented at the CAiSE 2024 Forum, Intelligent Information Systems, June 6th, Limassol, Cyprus.
Synopsis: Cooperative information systems typically involve various entities in a collaborative process within a distributed environment. Blockchain technology offers a mechanism for automating such processes, even when only partial trust exists among participants. The data stored on the blockchain is replicated across all nodes in the network, ensuring accessibility to all participants. While this aspect facilitates traceability, integrity, and persistence, it poses challenges for adopting public blockchains in enterprise settings due to confidentiality issues. In this paper, we present a software tool named Control Access via Key Encryption (CAKE), designed to ensure data confidentiality in scenarios involving public blockchains. After outlining its core components and functionalities, we showcase the application of CAKE in the context of a real-world cyber-security project within the logistics domain.
Paper: https://doi.org/10.1007/978-3-031-61000-4_16
CAKE: Sharing Slices of Confidential Data on Blockchain
Keynoteof A P I
1. How to Design a Good
API and Why it Matters
Joshua Bloch
Principal Software Engineer
1 _How to Design a Good API and Why it Matters
2. Why is API Design Important?
• APIs can be among a company's greatest assets
_ Customers invest heavily: buying, writing, learning
_ Cost to stop using an API can be prohibitive
_ Successful public APIs capture customers
• Can also be among company's greatest liabilities
_ Bad APIs result in unending stream of support calls
• Public APIs are forever - one chance to get it right
2 _
How to Design a Good API and Why it Matters
3. Why is API Design Important to You?
• If you program, you are an API designer
_ Good code is modular–each module has an API
• Useful modules tend to get reused
_ Once module has users, can’t change API at will
_ Good reusable modules are corporate assets
• Thinking in terms of APIs improves code quality
3 _
How to Design a Good API and Why it Matters
4. Characteristics of a Good API
• Easy to learn
• Easy to use, even without documentation
• Hard to misuse
• Easy to read and maintain code that uses it
• Sufficiently powerful to satisfy requirements
• Easy to extend
• Appropriate to audience
4 _
How to Design a Good API and Why it Matters
5. Outline
I. The Process of API Design
II. General Principles
III. Class Design
IV. Method Design
V. Exception Design
VI. Refactoring API Designs
5 _
How to Design a Good API and Why it Matters
6. I. The Process of API Design
6 _
How to Design a Good API and Why it Matters
7. Gather Requirements–with a Healthy
Degree of Skepticism
• Often you'll get proposed solutions instead
_ Better solutions may exist
• Your job is to extract true requirements
_ Should take the form of use-cases
• Can be easier and more rewarding to build
something more general
Good
7 _
How to Design a Good API and Why it Matters
8. Start with Short Spec–1 Page is Ideal
• At this stage, agility trumps completeness
• Bounce spec off as many people as possible
_ Listen to their input and take it seriously
• If you keep the spec short, it’s easy to modify
• Flesh it out as you gain confidence
_ This necessarily involves coding
8 _How to Design a Good API and Why it Matters
9. Write to Your API Early and Often
• Start before you've implemented the API
_ Saves you doing implementation you'll throw away
• Start before you've even specified it properly
_ Saves you from writing specs you'll throw away
• Continue writing to API as you flesh it out
_ Prevents nasty surprises
_ Code lives on as examples, unit tests
9 _How to Design a Good API and Why it Matters
10. Writing to SPI is Even More Important
• Service Provider Interface (SPI)
_ Plug-in interface enabling multiple implementations
_ Example: Java Cryptography Extension (JCE)
• Write multiple plug-ins before release
_ If you write one, it probably won't support another
_ If you write two, it will support more with difficulty
_ If you write three, it will work fine
• Will Tracz calls this “The Rule of Threes”
(Confessions of a Used Program Salesman, Addison-Wesley, 1995)
Bad
10 _How to Design a Good API and Why it Matters
11. Maintain Realistic Expectations
• Most API designs are over-constrained
_ You won't be able to please everyone
_ Aim to displease everyone equally
• Expect to make mistakes
_ A few years of real-world use will flush them out
_ Expect to evolve API
11 _How to Design a Good API and Why it Matters
13. API Should Do One Thing and Do it Well
• Functionality should be easy to explain
_ If it's hard to name, that's generally a bad sign
_ Good names drive development
_ Be amenable to splitting and merging modules
13 _How to Design a Good API and Why it Matters
14. API Should Be As Small As Possible But
No Smaller
• API should satisfy its requirements
• When in doubt leave it out
_ Functionality, classes, methods, parameters, etc.
_ You can always add, but you can never remove
• Conceptual weight more important than bulk
• Look for a good power-to-weight ratio
14 _
How to Design a Good API and Why it Matters
15. Implementation Should Not Impact API
• Implementation details
_ Confuse users
_ Inhibit freedom to change implementation
• Be aware of what is an implementation detail
_ Do not overspecify the behavior of methods
_ For example: do not specify hash functions
_ All tuning parameters are suspect
• Don't let implementation details “leak” into API
_ On-disk and on-the-wire formats, exceptions
15 _
How to Design a Good API and Why it Matters
16. Minimize Accessibility of Everything
• Make classes and members as private as possible
• Public classes should have no public fields
(with the exception of constants)
• This maximizes information hiding
• Allows modules to be used, understood, built,
tested, and debugged independently
16 _How to Design a Good API and Why it Matters
17. Names Matter–API is a Little Language
• Names Should Be Largely Self-Explanatory
_ Avoid cryptic abbreviations
• Be consistent–same word means same thing
_ Throughout API, (Across APIs on the platform)
• Be regular–strive for symmetry
• Code should read like prose
if (car.speed() > 2 * SPEED_LIMIT)
generateAlert("Watch out for cops!");
17 _How to Design a Good API and Why it Matters
18. Documentation Matters
Reuse is something that is far easier to say than
to do. Doing it requires both good design and
very good documentation. Even when we see
good design, which is still infrequently, we won't
see the components reused without good
documentation.
- D. L. Parnas, _Software Aging. Proceedings
of 16th International Conference Software
Engineering, 1994
18 _
How to Design a Good API and Why it Matters
19. Document Religiously
• Document every class, interface, method,
constructor, parameter, and exception
_ Class: what an instance represents
_ Method: contract between method and its client
_ Preconditions, postconditions, side-effects
_ Parameter: indicate units, form, ownership
• Document state space very carefully
19 _
How to Design a Good API and Why it Matters
20. Consider Performance Consequences of
API Design Decisions
• Bad decisions can limit performance
_ Making type mutable
_ Providing constructor instead of static factory
_ Using implementation type instead of interface
• Do not warp API to gain performance
_ Underlying performance issue will get fixed,
but headaches will be with you forever
_ Good design usually coincides with good performance
20 _
How to Design a Good API and Why it Matters
21. Effects of API Design Decisions on
Performance are Real and Permanent
• Component.getSize() returns Dimension
• Dimension is mutable
• Each getSize call must allocate Dimension
• Causes millions of needless object allocations
• Alternative added in 1.2; old client code still slow
21 _
How to Design a Good API and Why it Matters
22. API Must Coexist Peacefully with Platform
• Do what is customary
_ Obey standard naming conventions
_ Avoid obsolete parameter and return types
_ Mimic patterns in core APIs and language
• Take advantage of API-friendly features
_ Generics, varargs, enums, default arguments
• Know and avoid API traps and pitfalls
_ Finalizers, public static final arrays
22 _How to Design a Good API and Why it Matters
24. Minimize Mutability
• Classes should be immutable unless there’s a
good reason to do otherwise
_ Advantages: simple, thread-safe, reusable
_ Disadvantage: separate object for each value
• If mutable, keep state-space small, well-defined
_ Make clear when it's legal to call which method
Bad: Date, Calendar
Good: TimerTask
24 _How to Design a Good API and Why it Matters
25. Subclass Only Where It Makes Sense
• Subclassing implies substitutability (Liskov)
_ Subclass only when is-a relationship exists
_ Otherwise, use composition
• Public classes should not subclass other public
classes for ease of implementation
Bad: Properties extends Hashtable
Stack extends Vector
Good: Set extends Collection
25 _
How to Design a Good API and Why it Matters
26. Design and Document for Inheritance
or Else Prohibit it
• Inheritance violates encapsulation (Snyder, ‘86)
_ Subclass sensitive to implementation details of
superclass
• If you allow subclassing, document self-use
_ How do methods use one another?
• Conservative policy: all concrete classes final
Bad: Many concrete classes in J2SE libraries
Good: AbstractSet, AbstractMap
26 _
How to Design a Good API and Why it Matters
28. Don't Make the Client Do Anything the
Module Could Do
• Reduce need for boilerplate code
_ Generally done via cut-and-paste
_ Ugly, annoying, and error-prone
import org.w3c.dom.*;
import java.io.*;
import javax.xml.transform.*;
import javax.xml.transform.dom.*;
import javax.xml.transform.stream.*;
// DOM code to write an XML document to a specified output stream.
private static final void writeDoc(Document doc, OutputStream out)throws IOException{
try {
Transformer t = TransformerFactory.newInstance().newTransformer();
t.setOutputProperty(OutputKeys.DOCTYPE_SYSTEM, doc.getDoctype().getSystemId());
t.transform(new DOMSource(doc), new StreamResult(out));
} catch(TransformerException e) {
throw new AssertionError(e); // Can’t happen!
}
}
28 _
How to Design a Good API and Why it Matters
29. Don't Violate the Principle of Least
Astonishment
• User of API should not be surprised by behavior
_ It's worth extra implementation effort
_ It's even worth reduced performance
public class Thread implements Runnable {
// Tests whether current thread has been interrupted.
// Clears the interrupted status of current thread.
public static boolean interrupted();
}
29 _How to Design a Good API and Why it Matters
30. Fail Fast–Report Errors as Soon as
Possible After They Occur
• Compile time is best - static typing, generics
• At runtime, first bad method invocation is best
_ Method should be failure-atomic
// A Properties instance maps strings to strings
public class Properties extends Hashtable {
public Object put(Object key, Object value);
// Throws ClassCastException if this properties
// contains any keys or values that are not strings
public void save(OutputStream out, String comments);
}
30 _
How to Design a Good API and Why it Matters
31. Provide Programmatic Access to All
Data Available in String Form
• Otherwise, clients will parse strings
_ Painful for clients
_ Worse, turns string format into de facto API
public class Throwable {
public void printStackTrace(PrintStream s);
public StackTraceElement[] getStackTrace(); // Since 1.4
}
public final class StackTraceElement {
public String getFileName();
public int getLineNumber();
public String getClassName();
public String getMethodName();
public boolean isNativeMethod();
}
31 _
How to Design a Good API and Why it Matters
32. Overload With Care
• Avoid ambiguous overloadings
_ Multiple overloadings applicable to same actuals
_ Conservative: no two with same number of args
• Just because you can doesn't mean you should
_ Often better to use a different name
• If you must provide ambiguous overloadings,
ensure same behavior for same arguments
public TreeSet(Collection c); // Ignores order
public TreeSet(SortedSet s); // Respects order
32 _
How to Design a Good API and Why it Matters
33. Use Appropriate Parameter and Return Types
• Favor interface types over classes for input
_ Provides flexibility, performance
• Use most specific possible input parameter type
_ Moves error from runtime to compile time
• Don't use string if a better type exists
_ Strings are cumbersome, error-prone, and slow
• Don't use floating point for monetary values
_ Binary floating point causes inexact results!
• Use double (64 bits) rather than float (32 bits)
_ Precision loss is real, performance loss negligible
33 _How to Design a Good API and Why it Matters
34. Use Consistent Parameter Ordering
Across Methods
• Especially important if parameter types identical
#include <string.h>
char *strcpy (char *dest, char *src);
void bcopy (void *src, void *dst, int n);
java.util.Collections – first parameter always
collection to be modified or queried
java.util.concurrent – time always specified as
long delay, TimeUnit unit
34 _
How to Design a Good API and Why it Matters
35. Avoid Long Parameter Lists
• Three or fewer parameters is ideal
_ More and users will have to refer to docs
• Long lists of identically typed params harmful
_ Programmers transpose parameters by mistake
_ Programs still compile, run, but misbehave!
• Two techniques for shortening parameter lists
_ Break up method
_ Create helper class to hold parameters
// Eleven parameters including four consecutive ints
HWND CreateWindow(LPCTSTR lpClassName, LPCTSTR lpWindowName,
DWORD dwStyle, int x, int y, int nWidth, int nHeight,
HWND hWndParent, HMENU hMenu, HINSTANCE hInstance,
LPVOID lpParam);
35 _
How to Design a Good API and Why it Matters
36. Avoid Return Values that Demand
Exceptional Processing
• return zero-length array or empty collection, not null
package java.awt.image;
public interface BufferedImageOp {
// Returns the rendering hints for this operation,
// or null if no hints have been set.
public RenderingHints getRenderingHints();
}
36 _
How to Design a Good API and Why it Matters
38. Throw Exceptions to Indicate
Exceptional Conditions
• Don’t force client to use exceptions for control flow
private byte[] a = new byte[BUF_SIZE];
void processBuffer (ByteBuffer buf) {
try {
while (true) {
buf.get(a);
processBytes(tmp, BUF_SIZE);
}
} catch (BufferUnderflowException e) {
int remaining = buf.remaining();
buf.get(a, 0, remaining);
processBytes(bufArray, remaining);
}
}
• Conversely, don’t fail silently
ThreadGroup.enumerate(Thread[] list)
38 _
How to Design a Good API and Why it Matters
39. Favor Unchecked Exceptions
• Checked – client must take recovery action
• Unchecked – programming error
• Overuse of checked exceptions causes boilerplate
try {
Foo f = (Foo) super.clone();
....
} catch (CloneNotSupportedException e) {
// This can't happen, since we’re Cloneable
throw new AssertionError();
}
39 _
How to Design a Good API and Why it Matters
40. Include Failure-Capture Information in
Exceptions
• Allows diagnosis and repair or recovery
• For unchecked exceptions, message suffices
• For checked exceptions, provide accessors
40 _How to Design a Good API and Why it Matters
41. VI. Refactoring API Designs
41 _
How to Design a Good API and Why it Matters
42. 1. Sublist Operations in Vector
public class Vector {
public int indexOf(Object elem, int index);
public int lastIndexOf(Object elem, int index);
...
}
• Not very powerful - supports only search
• Hard too use without documentation
42 _How to Design a Good API and Why it Matters
43. Sublist Operations Refactored
public interface List {
List subList(int fromIndex, int toIndex);
...
}
• Extremely powerful - supports all operations
• Use of interface reduces conceptual weight
_ High power-to-weight ratio
• Easy to use without documentation
43 _
How to Design a Good API and Why it Matters
44. 2. Thread-Local Variables
// Broken - inappropriate use of String as capability.
// Keys constitute a shared global namespace.
public class ThreadLocal {
private ThreadLocal() { } // Non-instantiable
// Sets current thread’s value for named variable.
public static void set(String key, Object value);
// Returns current thread’s value for named variable.
public static Object get(String key);
}
44 _
How to Design a Good API and Why it Matters
45. Thread-Local Variables Refactored (1)
public class ThreadLocal {
private ThreadLocal() { } // Noninstantiable
public static class Key { Key() { } }
// Generates a unique, unforgeable key
public static Key getKey() { return new Key(); }
public static void set(Key key, Object value);
public static Object get(Key key);
}
• Works, but requires boilerplate code to use
static ThreadLocal.Key serialNumberKey = ThreadLocal.getKey();
ThreadLocal.set(serialNumberKey, nextSerialNumber());
System.out.println(ThreadLocal.get(serialNumberKey));
45 _How to Design a Good API and Why it Matters
46. Thread-Local Variables Refactored (2)
public class ThreadLocal {
public ThreadLocal() { }
public void set(Object value);
public Object get();
}
• Removes clutter from API and client code
static ThreadLocal serialNumber = new ThreadLocal();
serialNumber.set(nextSerialNumber());
System.out.println(serialNumber.get());
46 _How to Design a Good API and Why it Matters
47. Conclusion
• API design is a noble and rewarding craft
_ Improves the lot of programmers, end-users,
companies
• This talk covered some heuristics of the craft
_ Don't adhere to them slavishly, but...
_ Don't violate them without good reason
• API design is tough
_ Not a solitary activity
_ Perfection is unachievable, but try anyway
47 _
How to Design a Good API and Why it Matters