This presentation was at the Japanese Perl Association Seminar #1 in Akihabara on April 21st, 2009.
It covers ideas for how to have establish good habits one by one, and strategies to get them to stick.
The document discusses motivating developers to follow agile practices when transitioning from legacy software development. It notes that simply adopting new technologies does not ensure good practices are followed and that the underlying issue is developing discipline among the development team. It suggests upgrading the team from legacy to agile practices through focusing initially on basic disciplines like source control, testing and continuous integration.
This document outlines good programming practices for students to follow such as practicing and failing to improve, working in teams to solve problems, always coding to improve skills, debugging errors gracefully, and testing programs thoroughly. It recommends writing code on paper first, timing tasks, using functions and comments, handling exceptions, and getting feedback from others. Students should practice these techniques to write clean, well-structured code and solve problems effectively.
This document provides an introduction to coding standards for Java. It discusses why coding standards are important for consistency, readability, and maintainability. It outlines the key components of a Java source file and comments. It also covers naming conventions, formatting, and best practices for variables, methods, classes, and comments. Finally, it introduces static code analysis tools like PMD and AppPerfect that can analyze Java code and enforce coding standards and best practices.
The document outlines coding conventions and best practices for C# programming, including recommendations for naming conventions, indentation, spacing, commenting, exception handling, and other programming practices. It was compiled from various sources including Microsoft guidelines to help improve code readability and maintainability. Adhering to consistent coding standards can reduce software maintenance costs by making code easier for others to understand and maintain.
This document outlines the syllabus and session 1 objectives for an introductory Photoshop course. The course will run from January 15th to February 5th, 2013 on Tuesdays from 7-9:30 PM. Session 1 will cover introducing Photoshop, the workspace, using tools and layers, and include class exercises on working with layers and tools. The instructor's contact information is provided.
The document discusses various coding best practices and conventions for writing good quality code, including naming conventions, formatting guidelines, and general programming practices. Some key points covered include using descriptive names, consistent indentation and spacing, single responsibility per method, error handling, and separating concerns between layers.
This document provides an introduction to using Adobe Photoshop. It discusses what Photoshop is, how it can be used for publications, websites, and video/digital materials. It also covers starting Photoshop, the interface including menus and tools, understanding layers and how to work with layers, common file formats like JPEG and TIFF, creating image archives, and image resolution. The document serves as a beginner's guide for getting familiar with the Photoshop environment and basic image editing and manipulation tasks.
This document provides a list of over 200 seminar topics related to computer science, electronics, IT, mechanical engineering, electrical engineering, civil engineering, applied electronics, chemical engineering, biomedical engineering, and MBA projects. The topics are divided into categories such as computer science projects, electronics projects, IT projects, and so on. Each topic includes a brief 1-2 sentence description. Contact information is provided at the bottom for requesting full reports on any of the topics.
The document discusses motivating developers to follow agile practices when transitioning from legacy software development. It notes that simply adopting new technologies does not ensure good practices are followed and that the underlying issue is developing discipline among the development team. It suggests upgrading the team from legacy to agile practices through focusing initially on basic disciplines like source control, testing and continuous integration.
This document outlines good programming practices for students to follow such as practicing and failing to improve, working in teams to solve problems, always coding to improve skills, debugging errors gracefully, and testing programs thoroughly. It recommends writing code on paper first, timing tasks, using functions and comments, handling exceptions, and getting feedback from others. Students should practice these techniques to write clean, well-structured code and solve problems effectively.
This document provides an introduction to coding standards for Java. It discusses why coding standards are important for consistency, readability, and maintainability. It outlines the key components of a Java source file and comments. It also covers naming conventions, formatting, and best practices for variables, methods, classes, and comments. Finally, it introduces static code analysis tools like PMD and AppPerfect that can analyze Java code and enforce coding standards and best practices.
The document outlines coding conventions and best practices for C# programming, including recommendations for naming conventions, indentation, spacing, commenting, exception handling, and other programming practices. It was compiled from various sources including Microsoft guidelines to help improve code readability and maintainability. Adhering to consistent coding standards can reduce software maintenance costs by making code easier for others to understand and maintain.
This document outlines the syllabus and session 1 objectives for an introductory Photoshop course. The course will run from January 15th to February 5th, 2013 on Tuesdays from 7-9:30 PM. Session 1 will cover introducing Photoshop, the workspace, using tools and layers, and include class exercises on working with layers and tools. The instructor's contact information is provided.
The document discusses various coding best practices and conventions for writing good quality code, including naming conventions, formatting guidelines, and general programming practices. Some key points covered include using descriptive names, consistent indentation and spacing, single responsibility per method, error handling, and separating concerns between layers.
This document provides an introduction to using Adobe Photoshop. It discusses what Photoshop is, how it can be used for publications, websites, and video/digital materials. It also covers starting Photoshop, the interface including menus and tools, understanding layers and how to work with layers, common file formats like JPEG and TIFF, creating image archives, and image resolution. The document serves as a beginner's guide for getting familiar with the Photoshop environment and basic image editing and manipulation tasks.
This document provides a list of over 200 seminar topics related to computer science, electronics, IT, mechanical engineering, electrical engineering, civil engineering, applied electronics, chemical engineering, biomedical engineering, and MBA projects. The topics are divided into categories such as computer science projects, electronics projects, IT projects, and so on. Each topic includes a brief 1-2 sentence description. Contact information is provided at the bottom for requesting full reports on any of the topics.
This document summarizes Peter Scott's talk "Mind Like Water: The Path to Perl Bliss" given at OSCON in Portland, OR in July 2006. The talk discusses different programmer personalities like the Perl Parser, Impatient Coder, Glory Hunter, and Good Samaritan. It emphasizes the importance of balancing these personalities within oneself and on a team. The talk also provides excerpts of wisdom from expert Perl programmers like Dominus, Damian Conway, brian d foy, and chromatic about practices like testing, learning from others, and experimenting regularly.
Here are the slides from my tutorial on Scripting Recipes for Testers. In it I share a number of reusable scripts and some tips I learned writing them to help testers do their job better.
The scripts themselves can be found on my site (http://adam.goucher.ca) under the category 'GLSEC2008'
Test Driven Development With YUI Test (Ajax Experience 2008)Nicholas Zakas
This document discusses test-driven development (TDD) using the YUI Test framework. It introduces TDD principles like writing tests before code and iterating through failing tests, passing tests, and refactoring. It then covers key aspects of YUI Test like writing unit tests, simulating events, handling asynchronous code, and hooking into the test runner. The document provides examples and recommendations for effectively using TDD and YUI Test in web development.
PHX Session #3 - "It Works on My Machine!" Closing the Loop Between Developme...Steve Lange
The document discusses closing the loop between development and testing. It emphasizes that quality is a shared responsibility of both developers and testers. Effective communication between these teams is important, and automation can help reduce manual testing effort. The document argues that by working together and applying lessons learned through each iteration, development and testing teams can improve their process and deliver high quality software.
This document discusses program design for larger AI programming projects. It recommends designing programs that are simple, flexible, modular, and easy to follow to reduce bugs and ease maintenance. Specific design techniques mentioned include breaking programs into smaller intuitive modules and files, using descriptive names, and creating algorithms as step-by-step procedures to solve problems.
Dynamic Languages In The Enterprise (4developers march 2009)Ivo Jansch
Slightly more generic version of my 'Enterprise PHP' talk, adjusted for the 4developers conference's 'dedicated languages' track that features developers with different backgrounds.
Session #3: "It Works on My Machine!" Closing the Loop Between Development & ...Steve Lange
This document discusses closing the loop between development and testing. It addresses whose responsibility it is to find and fix bugs, and how teams should communicate about bug status. The document advocates that quality is a shared responsibility of both developers and testers. It also promotes automating testing where possible to reduce manual effort and ensure bugs found are reproducible.
The document discusses techniques for automatically testing web applications in Perl, including using modules like Test::Simple, Test::WWW::Mechanize, and HTTP::Recorder. It emphasizes that testing should be integrated into the development workflow from the start and designed in a way that facilitates testing, in order to gradually improve software quality. Examples are provided for creating basic tests with Test::Simple and testing websites by programmatically interacting with them.
This document outlines an agenda for presenting on software testing. It discusses the importance of testing code, different types of tests like unit tests, integration tests and acceptance tests. It also introduces the PHPUnit testing framework and how to write tests in PHPUnit. Specific techniques like test doubles and test-driven development are explained. Frameworks for testing code in Zend and CakePHP are also briefly mentioned.
Given that the database, as the canonical repository of data, is the most important part of many applications, why is it that we don't write database unit tests? This talk promotes the practice of implementing tests to directly test the schema, storage, and functionality of databases.
A few tips on how to go to the next level in PHP web application development. Tells about SCM, code convention, code testing, DRY, etc. Targeted towards the new PHPers who have worked for around 6-12 months.
How the JDeveloper team test JDeveloper at UKOUG'08kingsfleet
The document discusses how the Oracle JDeveloper team tests JDeveloper. It covers their use of automation, tools like Abbot and Selenium for testing. Some key points include that they do not have 100% test coverage but focus on testing critical areas. They discuss what to automate like builds and common workflows. Abbot is used for testing Swing components while Selenium is used for browser-based testing. Screenshots and logs are captured when tests fail to aid in debugging.
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.
Enterprise PHP Development - ZendCon 2008Ivo Jansch
The document discusses best practices for enterprise PHP development. It outlines 10 steps for building PHP applications in an enterprise setting: 1) assemble a skilled team, 2) define requirements, 3) design architecture, 4) select tools, 5) use a framework as a foundation, 6) employ design patterns, 7) implement thorough testing, 8) optimize performance through acceleration and caching, 9) properly deploy code to production environments, and 10) monitor and debug applications after deployment. The document uses metaphors of building construction with bricks to illustrate PHP development concepts.
The document discusses 7 sins of software engineers in high energy physics (HEP) projects. It describes each sin with an observation, problem it causes, and proposed solution. The sins are: being too reliant on tools, writing code before designing, flawed processes, reinventing wheels, making software functional but not usable, documentation paralysis, and resistance to change. The document advocates automating work, designing before coding, minimal necessary processes, reusing code, prioritizing usability, automatically generating documentation, and adapting to change.
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 enterprise PHP development. It begins by noting how PHP usage has changed over time from personal projects in 1998 to powering large websites, banks, and insurance companies today. It then addresses whether PHP is "enterprise ready" and discusses improved metaphors for PHP beyond toys or LEGO bricks. The remainder of the document outlines 10 steps for enterprise PHP development, including establishing requirements, designing architecture and tools, using frameworks, implementing design patterns, and emphasizing testing.
Rails Is From Mars Ruby Is From Venus Presentation 1railsconf
The document provides advice on learning Ruby and developing a good relationship between Ruby and Rails. It encourages developers to learn Ruby more deeply in order to write better code. It discusses Ruby idioms and best practices, and how to write code that is readable, expressive and considers Ruby's preferences while respecting Rails' conventions and opinions. The document emphasizes that understanding performance issues requires knowing where the slow parts are, and that code quality should take priority over premature optimization.
AI 101: An Introduction to the Basics and Impact of Artificial IntelligenceIndexBug
Imagine a world where machines not only perform tasks but also learn, adapt, and make decisions. This is the promise of Artificial Intelligence (AI), a technology that's not just enhancing our lives but revolutionizing entire industries.
This document summarizes Peter Scott's talk "Mind Like Water: The Path to Perl Bliss" given at OSCON in Portland, OR in July 2006. The talk discusses different programmer personalities like the Perl Parser, Impatient Coder, Glory Hunter, and Good Samaritan. It emphasizes the importance of balancing these personalities within oneself and on a team. The talk also provides excerpts of wisdom from expert Perl programmers like Dominus, Damian Conway, brian d foy, and chromatic about practices like testing, learning from others, and experimenting regularly.
Here are the slides from my tutorial on Scripting Recipes for Testers. In it I share a number of reusable scripts and some tips I learned writing them to help testers do their job better.
The scripts themselves can be found on my site (http://adam.goucher.ca) under the category 'GLSEC2008'
Test Driven Development With YUI Test (Ajax Experience 2008)Nicholas Zakas
This document discusses test-driven development (TDD) using the YUI Test framework. It introduces TDD principles like writing tests before code and iterating through failing tests, passing tests, and refactoring. It then covers key aspects of YUI Test like writing unit tests, simulating events, handling asynchronous code, and hooking into the test runner. The document provides examples and recommendations for effectively using TDD and YUI Test in web development.
PHX Session #3 - "It Works on My Machine!" Closing the Loop Between Developme...Steve Lange
The document discusses closing the loop between development and testing. It emphasizes that quality is a shared responsibility of both developers and testers. Effective communication between these teams is important, and automation can help reduce manual testing effort. The document argues that by working together and applying lessons learned through each iteration, development and testing teams can improve their process and deliver high quality software.
This document discusses program design for larger AI programming projects. It recommends designing programs that are simple, flexible, modular, and easy to follow to reduce bugs and ease maintenance. Specific design techniques mentioned include breaking programs into smaller intuitive modules and files, using descriptive names, and creating algorithms as step-by-step procedures to solve problems.
Dynamic Languages In The Enterprise (4developers march 2009)Ivo Jansch
Slightly more generic version of my 'Enterprise PHP' talk, adjusted for the 4developers conference's 'dedicated languages' track that features developers with different backgrounds.
Session #3: "It Works on My Machine!" Closing the Loop Between Development & ...Steve Lange
This document discusses closing the loop between development and testing. It addresses whose responsibility it is to find and fix bugs, and how teams should communicate about bug status. The document advocates that quality is a shared responsibility of both developers and testers. It also promotes automating testing where possible to reduce manual effort and ensure bugs found are reproducible.
The document discusses techniques for automatically testing web applications in Perl, including using modules like Test::Simple, Test::WWW::Mechanize, and HTTP::Recorder. It emphasizes that testing should be integrated into the development workflow from the start and designed in a way that facilitates testing, in order to gradually improve software quality. Examples are provided for creating basic tests with Test::Simple and testing websites by programmatically interacting with them.
This document outlines an agenda for presenting on software testing. It discusses the importance of testing code, different types of tests like unit tests, integration tests and acceptance tests. It also introduces the PHPUnit testing framework and how to write tests in PHPUnit. Specific techniques like test doubles and test-driven development are explained. Frameworks for testing code in Zend and CakePHP are also briefly mentioned.
Given that the database, as the canonical repository of data, is the most important part of many applications, why is it that we don't write database unit tests? This talk promotes the practice of implementing tests to directly test the schema, storage, and functionality of databases.
A few tips on how to go to the next level in PHP web application development. Tells about SCM, code convention, code testing, DRY, etc. Targeted towards the new PHPers who have worked for around 6-12 months.
How the JDeveloper team test JDeveloper at UKOUG'08kingsfleet
The document discusses how the Oracle JDeveloper team tests JDeveloper. It covers their use of automation, tools like Abbot and Selenium for testing. Some key points include that they do not have 100% test coverage but focus on testing critical areas. They discuss what to automate like builds and common workflows. Abbot is used for testing Swing components while Selenium is used for browser-based testing. Screenshots and logs are captured when tests fail to aid in debugging.
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.
Enterprise PHP Development - ZendCon 2008Ivo Jansch
The document discusses best practices for enterprise PHP development. It outlines 10 steps for building PHP applications in an enterprise setting: 1) assemble a skilled team, 2) define requirements, 3) design architecture, 4) select tools, 5) use a framework as a foundation, 6) employ design patterns, 7) implement thorough testing, 8) optimize performance through acceleration and caching, 9) properly deploy code to production environments, and 10) monitor and debug applications after deployment. The document uses metaphors of building construction with bricks to illustrate PHP development concepts.
The document discusses 7 sins of software engineers in high energy physics (HEP) projects. It describes each sin with an observation, problem it causes, and proposed solution. The sins are: being too reliant on tools, writing code before designing, flawed processes, reinventing wheels, making software functional but not usable, documentation paralysis, and resistance to change. The document advocates automating work, designing before coding, minimal necessary processes, reusing code, prioritizing usability, automatically generating documentation, and adapting to change.
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 enterprise PHP development. It begins by noting how PHP usage has changed over time from personal projects in 1998 to powering large websites, banks, and insurance companies today. It then addresses whether PHP is "enterprise ready" and discusses improved metaphors for PHP beyond toys or LEGO bricks. The remainder of the document outlines 10 steps for enterprise PHP development, including establishing requirements, designing architecture and tools, using frameworks, implementing design patterns, and emphasizing testing.
Rails Is From Mars Ruby Is From Venus Presentation 1railsconf
The document provides advice on learning Ruby and developing a good relationship between Ruby and Rails. It encourages developers to learn Ruby more deeply in order to write better code. It discusses Ruby idioms and best practices, and how to write code that is readable, expressive and considers Ruby's preferences while respecting Rails' conventions and opinions. The document emphasizes that understanding performance issues requires knowing where the slow parts are, and that code quality should take priority over premature optimization.
AI 101: An Introduction to the Basics and Impact of Artificial IntelligenceIndexBug
Imagine a world where machines not only perform tasks but also learn, adapt, and make decisions. This is the promise of Artificial Intelligence (AI), a technology that's not just enhancing our lives but revolutionizing entire industries.
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.
Have you ever been confused by the myriad of choices offered by AWS for hosting a website or an API?
Lambda, Elastic Beanstalk, Lightsail, Amplify, S3 (and more!) can each host websites + APIs. But which one should we choose?
Which one is cheapest? Which one is fastest? Which one will scale to meet our needs?
Join me in this session as we dive into each AWS hosting service to determine which one is best for your scenario and explain why!
Unlock the Future of Search with MongoDB Atlas_ Vector Search Unleashed.pdfMalak Abu Hammad
Discover how MongoDB Atlas and vector search technology can revolutionize your application's search capabilities. This comprehensive presentation covers:
* What is Vector Search?
* Importance and benefits of vector search
* Practical use cases across various industries
* Step-by-step implementation guide
* Live demos with code snippets
* Enhancing LLM capabilities with vector search
* Best practices and optimization strategies
Perfect for developers, AI enthusiasts, and tech leaders. Learn how to leverage MongoDB Atlas to deliver highly relevant, context-aware search results, transforming your data retrieval process. Stay ahead in tech innovation and maximize the potential of your applications.
#MongoDB #VectorSearch #AI #SemanticSearch #TechInnovation #DataScience #LLM #MachineLearning #SearchTechnology
HCL Notes und Domino Lizenzkostenreduzierung in der Welt von DLAUpanagenda
Webinar Recording: https://www.panagenda.com/webinars/hcl-notes-und-domino-lizenzkostenreduzierung-in-der-welt-von-dlau/
DLAU und die Lizenzen nach dem CCB- und CCX-Modell sind für viele in der HCL-Community seit letztem Jahr ein heißes Thema. Als Notes- oder Domino-Kunde haben Sie vielleicht mit unerwartet hohen Benutzerzahlen und Lizenzgebühren zu kämpfen. Sie fragen sich vielleicht, wie diese neue Art der Lizenzierung funktioniert und welchen Nutzen sie Ihnen bringt. Vor allem wollen Sie sicherlich Ihr Budget einhalten und Kosten sparen, wo immer möglich. Das verstehen wir und wir möchten Ihnen dabei helfen!
Wir erklären Ihnen, wie Sie häufige Konfigurationsprobleme lösen können, die dazu führen können, dass mehr Benutzer gezählt werden als nötig, und wie Sie überflüssige oder ungenutzte Konten identifizieren und entfernen können, um Geld zu sparen. Es gibt auch einige Ansätze, die zu unnötigen Ausgaben führen können, z. B. wenn ein Personendokument anstelle eines Mail-Ins für geteilte Mailboxen verwendet wird. Wir zeigen Ihnen solche Fälle und deren Lösungen. Und natürlich erklären wir Ihnen das neue Lizenzmodell.
Nehmen Sie an diesem Webinar teil, bei dem HCL-Ambassador Marc Thomas und Gastredner Franz Walder Ihnen diese neue Welt näherbringen. Es vermittelt Ihnen die Tools und das Know-how, um den Überblick zu bewahren. Sie werden in der Lage sein, Ihre Kosten durch eine optimierte Domino-Konfiguration zu reduzieren und auch in Zukunft gering zu halten.
Diese Themen werden behandelt
- Reduzierung der Lizenzkosten durch Auffinden und Beheben von Fehlkonfigurationen und überflüssigen Konten
- Wie funktionieren CCB- und CCX-Lizenzen wirklich?
- Verstehen des DLAU-Tools und wie man es am besten nutzt
- Tipps für häufige Problembereiche, wie z. B. Team-Postfächer, Funktions-/Testbenutzer usw.
- Praxisbeispiele und Best Practices zum sofortigen Umsetzen
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.
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.
UiPath Test Automation using UiPath Test Suite series, part 6DianaGray10
Welcome to UiPath Test Automation using UiPath Test Suite series part 6. In this session, we will cover Test Automation with generative AI and Open AI.
UiPath Test Automation with generative AI and Open AI webinar offers an in-depth exploration of leveraging cutting-edge technologies for test automation within the UiPath platform. Attendees will delve into the integration of generative AI, a test automation solution, with Open AI advanced natural language processing capabilities.
Throughout the session, participants will discover how this synergy empowers testers to automate repetitive tasks, enhance testing accuracy, and expedite the software testing life cycle. Topics covered include the seamless integration process, practical use cases, and the benefits of harnessing AI-driven automation for UiPath testing initiatives. By attending this webinar, testers, and automation professionals can gain valuable insights into harnessing the power of AI to optimize their test automation workflows within the UiPath ecosystem, ultimately driving efficiency and quality in software development processes.
What will you get from this session?
1. Insights into integrating generative AI.
2. Understanding how this integration enhances test automation within the UiPath platform
3. Practical demonstrations
4. Exploration of real-world use cases illustrating the benefits of AI-driven test automation for UiPath
Topics covered:
What is generative AI
Test Automation with generative AI and Open AI.
UiPath integration with generative AI
Speaker:
Deepak Rai, Automation Practice Lead, Boundaryless Group and UiPath MVP
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.
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.
Let's Integrate MuleSoft RPA, COMPOSER, APM with AWS IDP along with Slackshyamraj55
Discover the seamless integration of RPA (Robotic Process Automation), COMPOSER, and APM with AWS IDP enhanced with Slack notifications. Explore how these technologies converge to streamline workflows, optimize performance, and ensure secure access, all while leveraging the power of AWS IDP and real-time communication via Slack notifications.
Ocean lotus Threat actors project by John Sitima 2024 (1).pptxSitimaJohn
Ocean Lotus cyber threat actors represent a sophisticated, persistent, and politically motivated group that poses a significant risk to organizations and individuals in the Southeast Asian region. Their continuous evolution and adaptability underscore the need for robust cybersecurity measures and international cooperation to identify and mitigate the threats posed by such advanced persistent threat groups.
Webinar: Designing a schema for a Data WarehouseFederico Razzoli
Are you new to data warehouses (DWH)? Do you need to check whether your data warehouse follows the best practices for a good design? In both cases, this webinar is for you.
A data warehouse is a central relational database that contains all measurements about a business or an organisation. This data comes from a variety of heterogeneous data sources, which includes databases of any type that back the applications used by the company, data files exported by some applications, or APIs provided by internal or external services.
But designing a data warehouse correctly is a hard task, which requires gathering information about the business processes that need to be analysed in the first place. These processes must be translated into so-called star schemas, which means, denormalised databases where each table represents a dimension or facts.
We will discuss these topics:
- How to gather information about a business;
- Understanding dictionaries and how to identify business entities;
- Dimensions and facts;
- Setting a table granularity;
- Types of facts;
- Types of dimensions;
- Snowflakes and how to avoid them;
- Expanding existing dimensions and facts.
In the rapidly evolving landscape of technologies, XML continues to play a vital role in structuring, storing, and transporting data across diverse systems. The recent advancements in artificial intelligence (AI) present new methodologies for enhancing XML development workflows, introducing efficiency, automation, and intelligent capabilities. This presentation will outline the scope and perspective of utilizing AI in XML development. The potential benefits and the possible pitfalls will be highlighted, providing a balanced view of the subject.
We will explore the capabilities of AI in understanding XML markup languages and autonomously creating structured XML content. Additionally, we will examine the capacity of AI to enrich plain text with appropriate XML markup. Practical examples and methodological guidelines will be provided to elucidate how AI can be effectively prompted to interpret and generate accurate XML markup.
Further emphasis will be placed on the role of AI in developing XSLT, or schemas such as XSD and Schematron. We will address the techniques and strategies adopted to create prompts for generating code, explaining code, or refactoring the code, and the results achieved.
The discussion will extend to how AI can be used to transform XML content. In particular, the focus will be on the use of AI XPath extension functions in XSLT, Schematron, Schematron Quick Fixes, or for XML content refactoring.
The presentation aims to deliver a comprehensive overview of AI usage in XML development, providing attendees with the necessary knowledge to make informed decisions. Whether you’re at the early stages of adopting AI or considering integrating it in advanced XML development, this presentation will cover all levels of expertise.
By highlighting the potential advantages and challenges of integrating AI with XML development tools and languages, the presentation seeks to inspire thoughtful conversation around the future of XML development. We’ll not only delve into the technical aspects of AI-powered XML development but also discuss practical implications and possible future directions.
2. Better Programming Practices
About Me
• Jay Shirley, jshirley@gmail.com
• On IRC (a lot), irc.perl.org as ‘jshirley’
• IT Director, National Auto Sport
• Co-Founder of www.coldhardcode.com
• Opinionated
3. Better Programming Practices
Better
• Useful techniques for better applications
• Best is for Knuth, we build applications
5. Better Programming Practices
Step 1: You’re Wrong
• Hopefully just the first time
• Better to be wrong and learn, than to
never learn.
6. Better Programming Practices
Step 2: Learn
• Accept you will not be right the first time
• Still give a lot of thought
• Make your second attempt stick
7. Better Programming Practices
Step 3: Be Happy
• Don’t be perfect
• Perfect your technique
• Be Happy (Or at least your boss will be)
8. Better Programming Practices
Design
• Goals!
• Understand your role
• Don’t over-extend
• Don’t let others, either.
9. Better Programming Practices
Testing
• Is not a goal
• Don’t design tests, design API then test
• Coverage is not a valuable metric of
completeness or progression
11. Better Programming Practices
It’s about the API
• Make it simple on yourself
• Expose flaws in tests
• Impress your boss
12. Better Programming Practices
These are good
• We can all agree: Design, Test, Refactor
• But we never do them.
• Habits!
13. Better Programming Practices
Establishing Habits
• Make mole hills out of mountains
• Make it easier to do the right thing
• Make it harder to do the wrong thing
14. Better Programming Practices
How to get habits
• Make things easier as time goes on
• Make things better as time goes on
• Make people happier as time goes on
• It’s about the future
23. Better Programming Practices
Web != Desktop
• You control the environment
• You control the deployment
• Slow? Scalability! Add another server.
• Apple would kill to have this
24. Better Programming Practices
Better Applications
• Your software is only as good as its tools
• Don’t reinvent wheels
26. Better Programming Practices
Simple Syntax
my $foo = $request->params->{foo};
my $bar = $request->params->{bar};
27. Better Programming Practices
good code, type
my $data = $request->params;
my $foo = $data->{foo};
my $bar = $data->{bar};
28. Better Programming Practices
Type Less is not
my $s=($api?$api->params:$request-
>params)||$request->params;
${“__PACKAGE__::$_”}=($s->{$_})
for keys%$s;
30. Better Programming Practices
good code, type
my $data = {map{$_=>$request-
>params->{$_}}@keys
my $foo = $data->{foo};
my $bar = $data->{bar};
31. Better Programming Practices
Test::Class
• This is the best test package
• Don’t take my word for it, chromatic and
Ovid have written a ton on it at http://
modernperlbooks.com/
33. Better Programming Practices
Why?
• Package based testing
• Wrap each package in a Test:: package
• More flexible than .t files (code reuse)
• Better configuration for testing
38. Better Programming Practices
Use what you need
• Too many OO-API modules on CPAN
• Moose does most of it
• Don’t need it all, just ‘use Mouse;’
39. Better Programming Practices
Use Config
• Configure everything you can think of
• You’ll figure out how to do it easily
• The more you do it, the easier it is
• (MooseX::SimpleConfig)
40. Better Programming Practices
Favorite Recipe Ever
with 'MooseX::SimpleConfig';
with 'MooseX::Getopt';
has +configfile = (
default =
(
grep { defined $_ and -f $_ }
@places_to_look
)[0]||””
);
41. Better Programming Practices
To Recap
• Write less code (Base classes)
• Test where it matters
• Use Moose (Write less code)
• Config!
45. Better Programming Practices
Not Invented Here
• Moose is better than what you would
write
• It is written by many people
• It has a huge test suite
• You can do more with Moose
46. Better Programming Practices
Slow?
• Moose is not slow
• Moose is slower
• Mostly Startup
• Linear Scalability (constant time)
• Use more hardware
47. Better Programming Practices
Incremental
• Add where needed
• Refactor when the time is right
• “Progressive Enhancement”
48. Better Programming Practices
Immediate
• Type Checking
• (Yes, it still is Perl)
• ‘ArrayRef[MyObject]’ works in Moose
49. Better Programming Practices
A Word of Caution
• Everything will look like a Role
• That’s normal
• Resist the temptation, then build a role.
Editor's Notes
Best is theoretical, it is something that cannot truly be reached because you can’t ever really know. It is an impossible goal, so lets just be better.
We can build applications better, we know this because we can look at how other people do things.
Even people who do things better than others can still be better. I know this because I’ve known people with very good practices still complain about shortcomings. Whether it is lacking test coverage, QA, staging, there is usually something missing and sometimes the complaints turn to whine.
Well, we’re developers. We fix problems, right? So just fix it.
When you look backwards, there are a lot of moments where you can point out flaws. Either your own or others, but this is very important. When you do this, you can learn and try to think of ways to do things better. Better yet, look at what other people have done. This is where the Perl Community (p5 porters, CPAN) really shines, they have all these tools built for you. Let them make the mistakes, and you learn.
After acknowledging your failures, the next step is to analyze your next attempt at a problem. This is where studying other people works, but you have to get rid of the Not Invented Here attitude.
Dropping all that, accepting your own limitations and doing better will make you happy. It will make you happy because you’re not trying to pick up a mountain. You’re simply enhancing something you’ve always done. If you start jogging, you don’t run a marathon. Start running a half kilometer at a time and work your way up. Perfect your technique, tempo, strategies. This all falls into 3 concepts of what constitutes “Software Development”.
The first, very easy and very vague.
The best way to enhance your strategy is to do an initial look at design. Design is 100% about goals. Defining your goals in your design step means your implementation will be complete, and hopefully robust.
Another aspect of design is figuring out your role in the project. If you’re not a frontend guy, don’t venture into that territory. It’s hard to let go of some control, but you really can’t do it all. Design what falls in your realm, set those goals, and let other do the same.
Testing is equally important, but testing happens iteratively and as time goes on your code progresses in maturity; your tests will increase in quality and coverage. A test without a design isn’t going to do much more than tell you what you already know.
Another point is to not get fixated on code coverage., At least during iterative development phases, it is better to work on testing your API and not focus on code coverage. The reason is simple, in the beginning of a project a percentage of the code initially written will not be there at the end. This is refactoring.
Yes, you will have to refactor code.
This is why you have to accept your flaws, because your code is flawed. The first invention of any solution isn’t the right one, but that’s ok because software development doesn’t have manufacturing costs associated with it. Enjoy deleting lots of code, do it often, just make sure you use something you can commit to frequently, preferably in branches (like git or svk).
By building a solid and comprehensive API that is both simple to use, and makes sense, you’ll increase productivity and reduce bugs (less code rewriting) -- both things will make your boss much happier.
In the charged world of Ruby vs Python vs Perl, or vi vs emacs, it is nice to have something to agree on. I hope we all can agree on these principles here.
It’s very hard to say “No, you never refactor code.” or “Testing isn’t good!”
It’s also very hard to do any of this in your own projects, and even harder to make them habits. That’s really the big problem here, since all of these points have been talked to death.
So, habits.
A lot of the burden falls on whoever maintains the development environment. For inspiration, look at the CPAN world. When a module goes to CPAN, you have Smokers (CPAN Testers) and a variety of other tools (such as Kwalitee) that help you write better code.
These are -voluntary- tools built by others that you can use for your stuff. Email yourself statistics. Nag yourself, and you’ll want to do better. Setup a smoker, setup email reports and even kwalitee. Use custom perl critic specs. The CPAN world has better supportive tools than most software companies. At your company: change this! You can. Use CPAN as an inspiration, setup a smoker and a custom CPAN repository for your companies packages.
You are the master of your own destiny, and when you establish a habit it becomes easy to drop if there isn’t an eventual reward if it is harder to maintain the habits otherwise. Having tools that help you keep them, such as Smokers and custom CPAN paths, aren’t enough.
The real eventual reward for good development practices is doing your job in less time. That means you can write more fun code, or just read RSS feeds. At the very least, you can justify a raise easier.
So, in practice, setup tools that nag you (Smokers, CPAN overlays, etc). Use iterative testing strategies to get better APIs, then ultimately write less code and do more.
This is very general, though, and each environment is different. The hardest step is really the testing, and that’s because people either fixate on coverage metrics or some other detail.
To make it easier, understand what your goal is. Testing is very different based on what you are testing. Schema classes are based on unit testing, figuring out what works and what doesn’t. What relationships need work, what is missing from your API (that is what your schema class really is)
When you test an application, like a web application, you are testing workflow. The difference here is that your unit tests prove the underlying things work. Workflow tests make sure things like email verification works.
[Catalyst Example]
Tests are not to prove it works. Tests are to prove it doesn’t break, and that your API does what it should.
The difference is in coverage, for the first step cover your API. After that work on complete code coverage
Tests do not require more time to finish your project, unless you release really buggy software. I’ll buy a beer to anybody who can prove otherwise, unless you work for the Internet Explorer team.
The next phase of testing after API testing and then basic coverage tests is going to be your acceptance tests.
I like to think of these mostly as workflow tests make sure things like email verification works, so people can sign up.
At this step, it is about aligning to specifications, the design goals and end-user acceptance (also good to count number of “clicks” and test for that)
If the test is hard to write, it is hard for the user to use. Except you only have to write the test once.
So, testing is really about incrementing the scope of what you look at. And first focusing on the API. The API is what you design, so testing and design go hand in hand.
The first step of design is a rough idea of what you are after. Think of clay modeling, you don’t start with a finalized product, you shape it from rough forms. Software is, fortunately, nothing like that -- we can throw away and replace without looking at the full form.
So, think about what you want. Come up with a nice API for it, and then start filling in the methods will practical code. If a method sucks, get rid of it. Your tests will help you while you flesh this out to figure out what you want. Something I usually do is write out an “Ideal syntax sketch” that just pretends all my API functions work. Often times this turns into my first API test.
Now, after you get a rough idea of how your API should look you can think about backend implementations. This is far too similar to computer science courses where you code the methods giving the example, for this, I’m sorry. But it is a good way to do things.
Fortunately, you can cheat. This is where you find CPAN modules that do the work, or some other algorithm on Google. CPAN is better, because you can steal the tests, too.
So when you have your methods built in, your tests cover the API and you can handle (via unit tests) all the individual points of a project it is time to put everything together and build a real application.
In terms of cooking, lower the heat and start simmering. This is the boring work, everything is done and you’re assembling it. Hopefully, every project gets more boring since you can rely on code reuse from previous projects. By having everything in tested methods, you’ll know what things can and cannot do.
Also, if a method needs to be changed you can do that. With the API tests, nothing will break, unless your test is broken. It’s fluid, easily changed and very, very robust.
The other thing, is that a lot of computer science ideas come from an age where desktops were the real applications, and web applications were simply scripts.
I’m guessing that all but a few here are working on web applications that rival very large desktop applications.
Good thing, because often times we don’t know how good we have it. We control everything. We know what hardware, and however much we want to complain about how certain browsers make our lives difficult, imagine trying to support a desktop application on unknown hardware, with a lot of other variables. I’ve done it. It’s terrible.
Web applications are easier, even considering how hard Microsoft makes it. So, stop thinking about software in terms of a desktop application. We control everything, and even Microsoft provides free virtual PC images of all versions of IE.
Release early, release often, don’t fear change because you have the tests to make it safe.
So, the key to a solid application is to remember your environment, don’t overstep your goals, test as you go and finally, use the tools available. Definitely smoke servers and sandbox development environments. These tools will help you so much.
And, please, don’t reinvent wheels. CPAN has most things out there, and the hardest part is finding out the right module, since there are usually 5. Getting involved in the community helps, but looking at the unit tests of the modules is a really good litmus test for how good a module is, and how attentive an author is to the packages.
To move into Perl specific areas, lets go over what makes better Perl. Applying my previous concepts, a bit part of that is looking at what is out on CPAN now and making the best usage of it.
For now, lets break this into two categories. The first is testing.
A lot of times you see code that is highly repetitive, like fetching parameters out of a request or something. Even if this code is simple, if you find yourself typing the same chain of commands it isn’t very good.
So, simplify it. Store a reference. You can spend the couple of bytes for the scalar reference to the hash. It saves you typing, and cleans up code.
Just because your creating shorthand syntax, doesn’t mean it should turn into Golf. It’s the exact opposite, really. You’re typing less by creating more variables and then saving yourself a lot of trouble later.
Don’t use stupid obscure code like this. Even if you can write it, you shouldn’t.
That code example would die with strict turned on, as it should. Always code with warnings and strict turned on. If you don’t, you don’t know what your code is doing. People seem to have forgotten that back when C was the highest level language, you had to initialize all your variables or you got random data in them.
Don’t introduce entropy into your programs, use strict to keep things sane.
Then, if you get another source of input, you only have to change one type. This is a contrived example, but I’ve had similar things come up in practice. Being able to normalize your data into a very easy to query structure will save you in the long run. The key there is easy to query, you don’t have to obfuscate things.
And for testing, use Test::Class if you don’t already have a testing system you know and love. Ovid has written a lot on using Test::Class at modernperlbooks.com, it is easy to follow and very very useful.
I completed 3 different projects, with the intention of using Test::Class and better testing policies. I failed miserably up until the end of the final project.
This involved me talking to people at length, and finally figuring out the “right way”. The big thing is that you do have to change the way you write your code slightly, but more importantly really change the way you think about your tests. They’re not encapsulated as tiny bite sized morsels, because then you end up with no good way to share your code between tests. Test::Class helps this, by applying some structure and a development pattern.
It takes a few times to learn how to do it right. Ovid and Chromatic probably forgot that, but it’s ok to fail -- just take a moment after you fail to figure out why.
With the learning curve on doing these tests right, it may not be obvious why you should use it. There are a lot of benefits, and it really is worth it.
You won’t have the problem of copy and pasting code from one .t file to another.
Test packages make more sense, you can mix and match them. You can extend them, and override them. Your tests will come together quicker, better and generally be friendlier.
Base classes are also somewhat related to Test::Class. You save your test data in an upstream class. Base classes are a very simple concept, and Perl supports multiple inheritance (in that a package can have two or more parent classes).
So, you can easily get away with writing less code and doing more by using base classes. It does take different ways of thinking about the code you write though.
Building base classes is, in some ways, a puzzle game. If you like this sort of thing, you’ll have fun. If not, it is yak shaving. Either way, it is better to do it. One thing is really thinking about the real differences.
Base classes are great, but it will take a bit of practice to get used to building good classes. In my RESTful Catalyst applications, I have many packages that consist of nothing more than configuration blocks and an inheritance line.
The base class is very complex, works with configuration, but it covers all the use cases I have and to use it I just inherit from it, and muck with config. It is very, very fast to develop with. I also can get away with rigorous testing of just the base class and feel confident it works.
When I introduce new functionality, I start first with my existing tests and work from there, since the new stuff tends to be very complicated it is better to have a scratch pad.
I’m a big fan of Moose, but this isn’t a Moose talk. This is about writing better code, and I believe that Moose does that (and more).
Just as a simple introduction, Moose is syntactic sugar over Class::MOP. Class::MOP is an API into Perl’s OO capabilities.
Effectively, it is just a layer on top of what Perl gives you that does fantastic things to your code. I’m not going to go into all the fantastic things, because then it would be a Moose talk.
Instead, I’m going to talk about what you need to write better Perl code. A big problem is that if you think of Moose (or any OO-API package that is on CPAN) as nothing more than accessor generators and mutators, you’re doing it wrong.
Moose handles much more. Introspection, reflection, method modifiers, mutable classes, immutable classes. It has an API into the meta definitions.
But that’s a lot, and you may not need it. If you don’t, there is a minimal set of features that is called ‘Mouse’. You can use that, and speed things up and still write better code.
One thing that Moose makes really easy is configuration. This is done through the idea of ‘Roles’. Roles are a very complex subject that requires a Moose talk, and this isn’t a Moose talk, so I’m just going to say that Roles are a way of mixing in functionality. The main difference can be thought of as “A class IS A” and “A role DOES”. It’s an action.
Configuration is an action, and there is a fantastic role on CPAN that makes it all happen.
I configure most things in my application, and one thing is that I tend to have config files in different locations. Sometimes I like to override things by having a “appname_local” configuration file that gets loaded if it exists, but that I instruct git or svn to ignore.
This lets me do that, by just populating a list of locations to look for a file. While it doesn’t merge multiple files (which would be awesome), it is the next best thing right now.
So here you can have multiple paths for configuration, and then they set the accessors you have generated.
So go read up on the pod for MooseX::SimpleConfig and start using it, it’s on CPAN.