The document provides a list of 10 things that are commonly done wrong in Talend jobs and provides tips to fix them. The top issues include jobs that are too large, joblets that take on too much responsibility, not looking at the code to debug errors, lack of versioning, meaningless naming conventions, modifying context variables, keeping unnecessary variables, not using pre/post jobs, complex tMaps with many inputs, and jumping straight into the job without pre/post jobs. The tips recommend breaking large jobs into smaller units, limiting joblets to defined inputs/outputs, examining code with errors, implementing source control and versioning, following a naming standard, using global maps instead of contexts, removing unused variables, separating concerns across multiple
The document discusses six programming practices recommended by Kevlin Henney for programmers to follow when working on code. The practices are:
1. Make roots of class hierarchies fully abstract to avoid issues with concrete base classes and increase stability.
2. Inherit for subtyping only to promote understandability and substitutability.
3. Include only what is needed in header files to reduce build time and dependencies.
4. Consider duplicate code a programming error to eliminate bugs and reduce code size.
5. Use self-contained objects to take advantage of C++ features and separation of concerns.
6. Details on the remaining three practices will be covered in the next article.
The document discusses best practices for writing clear and maintainable C++ code. It summarizes the first six of twelve recommendations: 1) make class roots fully abstract, 2) inherit only for subtyping, 3) include only necessary files, 4) avoid duplicate code, 5) use self-contained objects, and 6) make acquisition and release of resources symmetric. The remaining recommendations continue the theme of avoiding unnecessary complexity and exposure to risk.
War of the Machines: PVS-Studio vs. TensorFlowPVS-Studio
The document summarizes the analysis of the TensorFlow machine learning library using the PVS-Studio static code analyzer. Some key findings include:
1. PVS-Studio found 64 instances of false positives related to the DCHECK debugging macro that were suppressed. Explanations of how to address false positives were provided.
2. Various PVS-Studio settings like disabling diagnostics rules and excluding automatically generated files helped filter the analysis output.
3. Genuine errors found include a null pointer dereference that could lead to undefined behavior and a redundant null check.
Ever find a module that does 98% of what you need it to do, and there's no way to make it do that last 2%? Ever need to fix a bug in a module you've run into, but you're the only one who's ever had this problem? You need a patch.
Phase 2 Senior Developer Joshua Turton will cover the hows and whys of patching a module. You will learn:
When is a patch appropriate?
How to edit the module's code and what branch to edit against
How to generate a patch with git, both on the command line and in a GUI
How to report an issue in the module issue queue
How to name your patch file according to drupal's standards
How to use drush make to apply your patch automatically.
What to do if your patch is accepted or rejected
And most importantly: Why you SHOULD contribute your patch, and not be shy!
This presentation is aimed right at the beginner level developer, who is interested in getting involved in Drupal's open-source community, but is intimidated by the complexities and scale of the issue queue and module building. Middle to advanced level developers should also find the session interesting, particularly if they have not gotten involved in the issue queues themselves.
The document provides an introduction and overview of using Google Mock (gmock) for testing in C++. It discusses key concepts like the system under test (SUT), test doubles, mocks, stubs, and fragile tests. It then provides a tutorial example of defining a mock class for a Turtle interface to allow testing code that depends on drawing functions without executing the real drawing implementation.
Developers provide a build intended to fix two critical bugs, but testing finds issues. One critical bug remains unfixed, and three new minor bugs were introduced. Due to time pressure, full testing is not completed and an untested build is reluctantly released, missing known issues. The following day, problems are likely to arise from the rushed release made on a Friday.
Graylog Engineering - Design Your ArchitectureGraylog
This document provides a technical overview of the Graylog data processing engine in 9 sections. It describes the key components, including the transport layer which uses an append-only journal to prevent message loss, a high speed processing chain using ring buffers, a REST API that allows building custom front ends, an embedded Elasticsearch cluster for fast writing, and an index aliasing system to seamlessly switch between indexes. The goal is to provide the fastest machine data processing through an optimized architecture and attention to small performance details.
C# coding standards, good programming principles & refactoringEyob Lube
The document discusses C# coding standards and principles of good programming. It covers topics such as the importance of coding standards, principles like KISS and SOLID, general naming conventions, and refactoring code for better design. Specific points made include that coding standards create consistency, enable quicker understanding of code, and facilitate collaboration. The SOLID principles of single responsibility, open/closed, Liskov substitution, interface segregation and dependency inversion are explained. Meaningful naming is also emphasized, with examples of how intention-revealing names can greatly improve readability and maintainability of code.
The document discusses six programming practices recommended by Kevlin Henney for programmers to follow when working on code. The practices are:
1. Make roots of class hierarchies fully abstract to avoid issues with concrete base classes and increase stability.
2. Inherit for subtyping only to promote understandability and substitutability.
3. Include only what is needed in header files to reduce build time and dependencies.
4. Consider duplicate code a programming error to eliminate bugs and reduce code size.
5. Use self-contained objects to take advantage of C++ features and separation of concerns.
6. Details on the remaining three practices will be covered in the next article.
The document discusses best practices for writing clear and maintainable C++ code. It summarizes the first six of twelve recommendations: 1) make class roots fully abstract, 2) inherit only for subtyping, 3) include only necessary files, 4) avoid duplicate code, 5) use self-contained objects, and 6) make acquisition and release of resources symmetric. The remaining recommendations continue the theme of avoiding unnecessary complexity and exposure to risk.
War of the Machines: PVS-Studio vs. TensorFlowPVS-Studio
The document summarizes the analysis of the TensorFlow machine learning library using the PVS-Studio static code analyzer. Some key findings include:
1. PVS-Studio found 64 instances of false positives related to the DCHECK debugging macro that were suppressed. Explanations of how to address false positives were provided.
2. Various PVS-Studio settings like disabling diagnostics rules and excluding automatically generated files helped filter the analysis output.
3. Genuine errors found include a null pointer dereference that could lead to undefined behavior and a redundant null check.
Ever find a module that does 98% of what you need it to do, and there's no way to make it do that last 2%? Ever need to fix a bug in a module you've run into, but you're the only one who's ever had this problem? You need a patch.
Phase 2 Senior Developer Joshua Turton will cover the hows and whys of patching a module. You will learn:
When is a patch appropriate?
How to edit the module's code and what branch to edit against
How to generate a patch with git, both on the command line and in a GUI
How to report an issue in the module issue queue
How to name your patch file according to drupal's standards
How to use drush make to apply your patch automatically.
What to do if your patch is accepted or rejected
And most importantly: Why you SHOULD contribute your patch, and not be shy!
This presentation is aimed right at the beginner level developer, who is interested in getting involved in Drupal's open-source community, but is intimidated by the complexities and scale of the issue queue and module building. Middle to advanced level developers should also find the session interesting, particularly if they have not gotten involved in the issue queues themselves.
The document provides an introduction and overview of using Google Mock (gmock) for testing in C++. It discusses key concepts like the system under test (SUT), test doubles, mocks, stubs, and fragile tests. It then provides a tutorial example of defining a mock class for a Turtle interface to allow testing code that depends on drawing functions without executing the real drawing implementation.
Developers provide a build intended to fix two critical bugs, but testing finds issues. One critical bug remains unfixed, and three new minor bugs were introduced. Due to time pressure, full testing is not completed and an untested build is reluctantly released, missing known issues. The following day, problems are likely to arise from the rushed release made on a Friday.
Graylog Engineering - Design Your ArchitectureGraylog
This document provides a technical overview of the Graylog data processing engine in 9 sections. It describes the key components, including the transport layer which uses an append-only journal to prevent message loss, a high speed processing chain using ring buffers, a REST API that allows building custom front ends, an embedded Elasticsearch cluster for fast writing, and an index aliasing system to seamlessly switch between indexes. The goal is to provide the fastest machine data processing through an optimized architecture and attention to small performance details.
C# coding standards, good programming principles & refactoringEyob Lube
The document discusses C# coding standards and principles of good programming. It covers topics such as the importance of coding standards, principles like KISS and SOLID, general naming conventions, and refactoring code for better design. Specific points made include that coding standards create consistency, enable quicker understanding of code, and facilitate collaboration. The SOLID principles of single responsibility, open/closed, Liskov substitution, interface segregation and dependency inversion are explained. Meaningful naming is also emphasized, with examples of how intention-revealing names can greatly improve readability and maintainability of code.
This document provides an introduction to using Matlab for computational PhD work. It discusses tips for better use of Matlab like version control, bibliographies, file organization, and debugging. It also recommends learning software engineering best practices like code reviews. The talk introduces concepts like workspaces, functions vs scripts, data types, and sharing data between workspaces. Debugging, numeric types, data classes and structure arrays vs tables in Matlab are also covered.
The document discusses 10 things you should never do with PL/SQL, but then argues you should always do the opposite. It recommends asking for help when stuck, taking breaks to avoid burnout, sharing knowledge with others, questioning experts, properly encapsulating code, allowing peer code reviews, designing for maintainability, and planning for future changes. Overall it emphasizes teamwork, self-care, knowledge sharing, and creating sustainable code over time.
Functional programming is the most extreme programmingsamthemonad
Functional Programming is the most Extreme form of Programming according to the document. It introduces Functional Programming concepts and compares them to Object Oriented Programming. It argues that FP is better aligned with Extreme Programming principles like YAGNI and KISS. OOP can introduce unnecessary complexity and tight coupling between components, whereas FP avoids this through purity and avoiding side effects and mutable state.
A collection of FIVE presentations given at the recent ATLUG Day of Champions event. The Impact of Mobile on Human Perception explore the changes that mobile is driving on user expectations of software. Lotus Notes: Live Long and Prosper look at trends in technology to predict the future for Notes applications. Three short (4-minute) presentations then give ideas and best practices on a range of techniques that can be used to prepare Notes applications for that future.
This document provides an introduction to using STATA for econometric analysis. It discusses contacting the instructor, an overview of topics to be covered including data management and Monte Carlo simulations, references useful STATA books and resources, and demonstrates some basic STATA commands through examples using sample datasets. The document emphasizes using do-files to record commands instead of just the command line for reproducibility and organization of analysis.
This guide provides a refresher on basic computer programming concepts without using a specific programming language. It defines key terms like variables, which represent values that can change throughout a program, and statements, which are the smallest standalone elements a computer can understand. It also explains functions and methods as named sets of instructions that can be reused, and parameters as values passed into functions. Finally, it outlines different data types like integers, doubles, strings, and booleans that variables can take on to store different kinds of values.
ChainRules.jl provides extensible, AD engine-agnostic custom differentiation rules for Julia. It defines rules for Julia's standard libraries that can be used by various AD engines like Zygote and ReverseDiff. ChainRules.jl is made up of three key packages - ChainRulesCore defines the system for creating rules, ChainRules defines rules for Julia, and ChainRulesTestUtils tests rule definitions. Polymorphism in Julia poses challenges for AD rules, such as ensuring tangents have the proper structure. Future work includes better support for selective differentiation.
This document discusses structural design patterns from the Gang of Four (GoF) patterns book. It introduces proxies, decorators, adapters, façades, and composites patterns. Proxies provide a placeholder for another object to control access. Decorators dynamically add/remove responsibilities to objects. Adapters allow incompatible interfaces to work together. Façades provide a simplified interface to a subsystem. Composites represent part-whole hierarchies to access all parts uniformly. Bridge and flyweight patterns were not covered due to dependencies on other patterns. The document emphasizes introducing extra levels of indirection to solve problems and favoring composition over inheritance.
q Name collisions between classes or constants are more annoying than they are common. Using identifier prefixes or nesting names inside a struct is a step in the right direction, but only a small step. C++ namespaces introduce named, extensible scopes with all the right collision avoidance properties. In choosing a good name for a namespace, pick something stable. Don't use department names, company names or domain names.
The document provides coding guidelines and conventions for naming variables, functions, classes, files and other constructs in C++. It recommends using meaningful names that indicate purpose, starting class names with uppercase letters, and using prefixes for boolean and other functions. The document also discusses organizing code into libraries and header files, using references instead of pointers, following standards to minimize bugs, and additional references for coding best practices.
The document discusses various approaches to addressing the "impedance mismatch" that occurs when integrating semantic technologies like topic maps with other applications and programming languages. It evaluates approaches like using JSPs directly, writing a custom domain model, generating a domain model from the ontology, and using generic portlet components. While each approach has tradeoffs between flexibility, complexity, and development effort, the document suggests that further work is needed to fully address the impedance mismatch problem between semantic technologies and applications. It invites feedback on the proposed approaches.
This document discusses refactoring techniques to improve code quality based on the book "Refactoring: Improving the Design of Existing Code". It provides examples of code smells that indicate areas for refactoring such as duplicate code, long parameter lists, unused code, and poor class/variable names. Various refactoring techniques are presented such as extract method, move method, encapsulate field, and introduce foreign method that can help address these code smells and improve code design.
White Paper for OMG! Identifying and Refactoring Common SQL...Jeff Jacobs
The document discusses common SQL anti-patterns that lead to poor database performance. It identifies issues like overuse of inline views, unnecessary outer joins, and updating primary keys. The document proposes techniques called the "OMG Method" to refactor SQL and fix performance problems, such as replacing IN with EXISTS, using subquery factoring with WITH, and properly applying index hints. The goal is to help developers write more efficient SQL without requiring advanced privileges.
This document discusses refactoring code through careful modifications that do not change functionality. It emphasizes that refactoring requires rigorous unit testing to be done correctly. Successful refactoring can be achieved through uninterrupted work, pair programming, or test-driven development with an automated testing framework. Tests should be written early and often to catch errors introduced during refactoring. The minimum requirement for testing is assert statements, which provide an easy way to start testing without complex tools. Overall, the document stresses that refactoring is best approached as a disciplined process guided by thorough automated testing.
MATLAB is a software package for numerical computation. The document provides a brief introduction to MATLAB, including how to build arrays and matrices, reference elements of arrays, and some basic commands. It summarizes MATLAB's niche as numerical computation for non-experts in engineering, science, and applied mathematics.
Hipster FP code harder to maintain because it actively removes domain knowledge Philip Schwarz
Carlo Pescio wrote a very interesting paper called 'Programming as if the Domain (and Performance) Mattered' https://drive.google.com/file/d/0B59Tysg-nEQZUkdRT2lfUVM3cVk.
The paper is centred on a programming approach that is a common FP solution to the 'Water collected between towers' coding challenge. This slide deck contains some excerpts from the first few pages of the paper. Download for better quality.
TOPS Technologies provides PHP training in Ahmedabad, for MCA Students PHP live project training as per GTU project guidelines. Get more info @ http://www.tops-int.com/, 903 Samedh Complex, Next to Associated Petrol Pump, CG Road, Ahmedabad 380009.
This document provides an overview of a talk on advanced Zemax Programming Language (ZPL) macro programming. It introduces the speakers and describes the structure of the talk, which will cover what ZPL is, examples of using ZPL for specific tasks like calculating ray angles of incidence across a pupil, and tips for writing macros. The document outlines several example macros that will be discussed in detail during the talk, including automating repetitive tasks and creating custom operands. It encourages participants to provide feedback and suggestions for additional topics.
The document discusses optimizing Perl code for easy maintenance. It suggests limiting the programming vocabulary to simpler and more common constructs to make the code easier to read, understand and debug. Specifically, it recommends always using strict and warnings, formatting code consistently with Perltidy, writing code for future readers rather than just oneself, following common conventions when possible, and avoiding obscure, complex or magical language features. It provides examples of features that should generally be avoided, such as formats, punctuation variables and indirect object syntax, to optimize Perl code for long-term maintainability.
Generative AI Deep Dive: Advancing from Proof of Concept to ProductionAggregage
Join Maher Hanafi, VP of Engineering at Betterworks, in this new session where he'll share a practical framework to transform Gen AI prototypes into impactful products! He'll delve into the complexities of data collection and management, model selection and optimization, and ensuring security, scalability, and responsible use.
This document provides an introduction to using Matlab for computational PhD work. It discusses tips for better use of Matlab like version control, bibliographies, file organization, and debugging. It also recommends learning software engineering best practices like code reviews. The talk introduces concepts like workspaces, functions vs scripts, data types, and sharing data between workspaces. Debugging, numeric types, data classes and structure arrays vs tables in Matlab are also covered.
The document discusses 10 things you should never do with PL/SQL, but then argues you should always do the opposite. It recommends asking for help when stuck, taking breaks to avoid burnout, sharing knowledge with others, questioning experts, properly encapsulating code, allowing peer code reviews, designing for maintainability, and planning for future changes. Overall it emphasizes teamwork, self-care, knowledge sharing, and creating sustainable code over time.
Functional programming is the most extreme programmingsamthemonad
Functional Programming is the most Extreme form of Programming according to the document. It introduces Functional Programming concepts and compares them to Object Oriented Programming. It argues that FP is better aligned with Extreme Programming principles like YAGNI and KISS. OOP can introduce unnecessary complexity and tight coupling between components, whereas FP avoids this through purity and avoiding side effects and mutable state.
A collection of FIVE presentations given at the recent ATLUG Day of Champions event. The Impact of Mobile on Human Perception explore the changes that mobile is driving on user expectations of software. Lotus Notes: Live Long and Prosper look at trends in technology to predict the future for Notes applications. Three short (4-minute) presentations then give ideas and best practices on a range of techniques that can be used to prepare Notes applications for that future.
This document provides an introduction to using STATA for econometric analysis. It discusses contacting the instructor, an overview of topics to be covered including data management and Monte Carlo simulations, references useful STATA books and resources, and demonstrates some basic STATA commands through examples using sample datasets. The document emphasizes using do-files to record commands instead of just the command line for reproducibility and organization of analysis.
This guide provides a refresher on basic computer programming concepts without using a specific programming language. It defines key terms like variables, which represent values that can change throughout a program, and statements, which are the smallest standalone elements a computer can understand. It also explains functions and methods as named sets of instructions that can be reused, and parameters as values passed into functions. Finally, it outlines different data types like integers, doubles, strings, and booleans that variables can take on to store different kinds of values.
ChainRules.jl provides extensible, AD engine-agnostic custom differentiation rules for Julia. It defines rules for Julia's standard libraries that can be used by various AD engines like Zygote and ReverseDiff. ChainRules.jl is made up of three key packages - ChainRulesCore defines the system for creating rules, ChainRules defines rules for Julia, and ChainRulesTestUtils tests rule definitions. Polymorphism in Julia poses challenges for AD rules, such as ensuring tangents have the proper structure. Future work includes better support for selective differentiation.
This document discusses structural design patterns from the Gang of Four (GoF) patterns book. It introduces proxies, decorators, adapters, façades, and composites patterns. Proxies provide a placeholder for another object to control access. Decorators dynamically add/remove responsibilities to objects. Adapters allow incompatible interfaces to work together. Façades provide a simplified interface to a subsystem. Composites represent part-whole hierarchies to access all parts uniformly. Bridge and flyweight patterns were not covered due to dependencies on other patterns. The document emphasizes introducing extra levels of indirection to solve problems and favoring composition over inheritance.
q Name collisions between classes or constants are more annoying than they are common. Using identifier prefixes or nesting names inside a struct is a step in the right direction, but only a small step. C++ namespaces introduce named, extensible scopes with all the right collision avoidance properties. In choosing a good name for a namespace, pick something stable. Don't use department names, company names or domain names.
The document provides coding guidelines and conventions for naming variables, functions, classes, files and other constructs in C++. It recommends using meaningful names that indicate purpose, starting class names with uppercase letters, and using prefixes for boolean and other functions. The document also discusses organizing code into libraries and header files, using references instead of pointers, following standards to minimize bugs, and additional references for coding best practices.
The document discusses various approaches to addressing the "impedance mismatch" that occurs when integrating semantic technologies like topic maps with other applications and programming languages. It evaluates approaches like using JSPs directly, writing a custom domain model, generating a domain model from the ontology, and using generic portlet components. While each approach has tradeoffs between flexibility, complexity, and development effort, the document suggests that further work is needed to fully address the impedance mismatch problem between semantic technologies and applications. It invites feedback on the proposed approaches.
This document discusses refactoring techniques to improve code quality based on the book "Refactoring: Improving the Design of Existing Code". It provides examples of code smells that indicate areas for refactoring such as duplicate code, long parameter lists, unused code, and poor class/variable names. Various refactoring techniques are presented such as extract method, move method, encapsulate field, and introduce foreign method that can help address these code smells and improve code design.
White Paper for OMG! Identifying and Refactoring Common SQL...Jeff Jacobs
The document discusses common SQL anti-patterns that lead to poor database performance. It identifies issues like overuse of inline views, unnecessary outer joins, and updating primary keys. The document proposes techniques called the "OMG Method" to refactor SQL and fix performance problems, such as replacing IN with EXISTS, using subquery factoring with WITH, and properly applying index hints. The goal is to help developers write more efficient SQL without requiring advanced privileges.
This document discusses refactoring code through careful modifications that do not change functionality. It emphasizes that refactoring requires rigorous unit testing to be done correctly. Successful refactoring can be achieved through uninterrupted work, pair programming, or test-driven development with an automated testing framework. Tests should be written early and often to catch errors introduced during refactoring. The minimum requirement for testing is assert statements, which provide an easy way to start testing without complex tools. Overall, the document stresses that refactoring is best approached as a disciplined process guided by thorough automated testing.
MATLAB is a software package for numerical computation. The document provides a brief introduction to MATLAB, including how to build arrays and matrices, reference elements of arrays, and some basic commands. It summarizes MATLAB's niche as numerical computation for non-experts in engineering, science, and applied mathematics.
Hipster FP code harder to maintain because it actively removes domain knowledge Philip Schwarz
Carlo Pescio wrote a very interesting paper called 'Programming as if the Domain (and Performance) Mattered' https://drive.google.com/file/d/0B59Tysg-nEQZUkdRT2lfUVM3cVk.
The paper is centred on a programming approach that is a common FP solution to the 'Water collected between towers' coding challenge. This slide deck contains some excerpts from the first few pages of the paper. Download for better quality.
TOPS Technologies provides PHP training in Ahmedabad, for MCA Students PHP live project training as per GTU project guidelines. Get more info @ http://www.tops-int.com/, 903 Samedh Complex, Next to Associated Petrol Pump, CG Road, Ahmedabad 380009.
This document provides an overview of a talk on advanced Zemax Programming Language (ZPL) macro programming. It introduces the speakers and describes the structure of the talk, which will cover what ZPL is, examples of using ZPL for specific tasks like calculating ray angles of incidence across a pupil, and tips for writing macros. The document outlines several example macros that will be discussed in detail during the talk, including automating repetitive tasks and creating custom operands. It encourages participants to provide feedback and suggestions for additional topics.
The document discusses optimizing Perl code for easy maintenance. It suggests limiting the programming vocabulary to simpler and more common constructs to make the code easier to read, understand and debug. Specifically, it recommends always using strict and warnings, formatting code consistently with Perltidy, writing code for future readers rather than just oneself, following common conventions when possible, and avoiding obscure, complex or magical language features. It provides examples of features that should generally be avoided, such as formats, punctuation variables and indirect object syntax, to optimize Perl code for long-term maintainability.
Similar to 10 things you're doing wrong in Talend (20)
Generative AI Deep Dive: Advancing from Proof of Concept to ProductionAggregage
Join Maher Hanafi, VP of Engineering at Betterworks, in this new session where he'll share a practical framework to transform Gen AI prototypes into impactful products! He'll delve into the complexities of data collection and management, model selection and optimization, and ensuring security, scalability, and responsible use.
Sudheer Mechineni, Head of Application Frameworks, Standard Chartered Bank
Discover how Standard Chartered Bank harnessed the power of Neo4j to transform complex data access challenges into a dynamic, scalable graph database solution. This keynote will cover their journey from initial adoption to deploying a fully automated, enterprise-grade causal cluster, highlighting key strategies for modelling organisational changes and ensuring robust disaster recovery. Learn how these innovations have not only enhanced Standard Chartered Bank’s data infrastructure but also positioned them as pioneers in the banking sector’s adoption of graph technology.
Why You Should Replace Windows 11 with Nitrux Linux 3.5.0 for enhanced perfor...SOFTTECHHUB
The choice of an operating system plays a pivotal role in shaping our computing experience. For decades, Microsoft's Windows has dominated the market, offering a familiar and widely adopted platform for personal and professional use. However, as technological advancements continue to push the boundaries of innovation, alternative operating systems have emerged, challenging the status quo and offering users a fresh perspective on computing.
One such alternative that has garnered significant attention and acclaim is Nitrux Linux 3.5.0, a sleek, powerful, and user-friendly Linux distribution that promises to redefine the way we interact with our devices. With its focus on performance, security, and customization, Nitrux Linux presents a compelling case for those seeking to break free from the constraints of proprietary software and embrace the freedom and flexibility of open-source computing.
Communications Mining Series - Zero to Hero - Session 1DianaGray10
This session provides introduction to UiPath Communication Mining, importance and platform overview. You will acquire a good understand of the phases in Communication Mining as we go over the platform with you. Topics covered:
• Communication Mining Overview
• Why is it important?
• How can it help today’s business and the benefits
• Phases in Communication Mining
• Demo on Platform overview
• Q/A
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.
Cosa hanno in comune un mattoncino Lego e la backdoor XZ?Speck&Tech
ABSTRACT: A prima vista, un mattoncino Lego e la backdoor XZ potrebbero avere in comune il fatto di essere entrambi blocchi di costruzione, o dipendenze di progetti creativi e software. La realtà è che un mattoncino Lego e il caso della backdoor XZ hanno molto di più di tutto ciò in comune.
Partecipate alla presentazione per immergervi in una storia di interoperabilità, standard e formati aperti, per poi discutere del ruolo importante che i contributori hanno in una comunità open source sostenibile.
BIO: Sostenitrice del software libero e dei formati standard e aperti. È stata un membro attivo dei progetti Fedora e openSUSE e ha co-fondato l'Associazione LibreItalia dove è stata coinvolta in diversi eventi, migrazioni e formazione relativi a LibreOffice. In precedenza ha lavorato a migrazioni e corsi di formazione su LibreOffice per diverse amministrazioni pubbliche e privati. Da gennaio 2020 lavora in SUSE come Software Release Engineer per Uyuni e SUSE Manager e quando non segue la sua passione per i computer e per Geeko coltiva la sua curiosità per l'astronomia (da cui deriva il suo nickname deneb_alpha).
GraphSummit Singapore | The Future of Agility: Supercharging Digital Transfor...Neo4j
Leonard Jayamohan, Partner & Generative AI Lead, Deloitte
This keynote will reveal how Deloitte leverages Neo4j’s graph power for groundbreaking digital twin solutions, achieving a staggering 100x performance boost. Discover the essential role knowledge graphs play in successful generative AI implementations. Plus, get an exclusive look at an innovative Neo4j + Generative AI solution Deloitte is developing in-house.
UiPath Test Automation using UiPath Test Suite series, part 5DianaGray10
Welcome to UiPath Test Automation using UiPath Test Suite series part 5. In this session, we will cover CI/CD with devops.
Topics covered:
CI/CD with in UiPath
End-to-end overview of CI/CD pipeline with Azure devops
Speaker:
Lyndsey Byblow, Test Suite Sales Engineer @ UiPath, Inc.
Unlocking Productivity: Leveraging the Potential of Copilot in Microsoft 365, a presentation by Christoforos Vlachos, Senior Solutions Manager – Modern Workplace, Uni Systems
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.
GraphSummit Singapore | The Art of the Possible with Graph - Q2 2024Neo4j
Neha Bajwa, Vice President of Product Marketing, Neo4j
Join us as we explore breakthrough innovations enabled by interconnected data and AI. Discover firsthand how organizations use relationships in data to uncover contextual insights and solve our most pressing challenges – from optimizing supply chains, detecting fraud, and improving customer experiences to accelerating drug discoveries.
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!
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.
“Building and Scaling AI Applications with the Nx AI Manager,” a Presentation...
10 things you're doing wrong in Talend
1. 10 THINGS YOU’RE
DOING WRONG IN
By Sam Hopper
Lead Technical Architect
and the Data Engineers at
And pro tips for how to fix them
2. We’ve asked our team of Talend experts to compile
this top ten list of their biggest bugbears when it
comes to jobs they see in the wild.
Here it is!
4. 10. Size does matter
Kicking off our list is a common problem – the size of individual Talend
jobs.
Whilst it is often convenient to contain all similar logic and data in a
single job, you can soon run into problems when building or deploying a
huge job, not to mention trying to debug a niggling nasty in the midst of
all those tMaps!
5. 10. Size does matter
Also, big jobs often contain big sub-jobs (those blue-shaded blocks that
flows form into), and you will eventually come up against a Java error
telling you some code is “exceeding the 65535 bytes limit”.
This is a fundamental limitation of Java that limits the size of a method’s
code, and Talend generates a method for each sub-job.
6. 10. Size does matter
Our best advice is to break down big jobs into smaller, more manageable
(and testable) units, which can then be combined together using your
favourite orchestration technique.
PRO TIP
7. 9. Joblets that take on too much
responsibility
Joblets are great! They provide a simple way to encapsulate standard
routines and reuse code across jobs, whilst maintaining some transparency
into their inner workings.
However, problems can arise when joblets are given tasks that operate
outside the scope of the code itself, such as reading and writing files,
databases, etc.
Leave me alone!
8. 9. Joblets that take on too much
responsibility
This usage will require additional complexities when reusing joblets across
different jobs and contexts, and can lead to unexpected side effects and
uncertain testability.
9. 9. Joblets that take on too much
responsibility
PRO TIP
We have found that you can get the best from joblets when treating them
as the equivalent of pure functions, limiting their score to only the inputs
and outputs defined by the joblet’s connections and variables.
Thank you!
10. 8. “I’m not a coder, so I’m not looking at
the code”
11. 8. “I’m not a coder, so I’m not looking at
the code”
Ever seen a NullPointerException? If you’re a Talend engineer, then of course
you have! However, this kind of run-time error can be tricky to pin down, especially
if it lives in the heart of a busy tMap.
Inexperienced Talend engineers will often spend hours picking apart a job to find
the source of this kind of bug, when a faster method is available.
12. 8. “I’m not a coder, so I’m not looking at
the code”
If you’ve worked with Talend for a while, or if you have Java experience, you will
recognise the stack trace, the nested list of exceptions that are bubbled up through
the job as it falls over.
You can pick out the line number of the first error in the list (sometimes it’s not the
first, but it’ll be near the top), switch to the job’s code view and go to that line
(ctrl+L).
ctrl L
13. 8. “I’m not a coder, so I’m not looking at
the code”
Even if the resulting splodge of Java code doesn’t mean much,
Eclipse (the technology that Talend Studio is built on) will
helpfully point out where the problem is, and in the case of a
tMap it’s then clear which mapping or variable is at fault.
PRO TIP
14. 7. No version of this makes sense
Talend, Git (and SVN) and Nexus all provide great methods to control,
increment, freeze and roll back versions of code – so why don’t people
use them?!
Too often we encounter a Talend project that uses just a single, master
branch in source control, has all the jobs and metadata still on version 0.1
in Studio, and no clear policy on deployment to Nexus.
15. 7. No version of this makes sense
Without versioning, you’ll miss out on being able to clearly track changes
across common artefacts, struggle to trace back through the history of
part of a project, and maybe get into a pickle when rolling back
deployed code.
I seem to be in a
pickle
16. 7. No version of this makes sense
It’s too huge a topic to go into here, but our advice is to learn how your
source control system works.
Git is a fantastic bit of software once you know what it can do, and come
up with a workable policy for versioning projects sources and artefacts.
PRO TIP
18. 6. What’s in a name?
Whilst we’re on the topic of not having policies for things, what about
naming? A busy project gets in a mess really quickly if there’s no
coherent approach to the naming of jobs, context groups/variables, and
other metadata items.
You will be
called…dog1.pet
19. 6. What’s in a name?
It can be daunting to approach the topic of naming conventions, as we’ve
all seen policy documents that would put Tolstoy to shame, but it doesn’t
need to be exhaustive.
Just putting together a one-pager to cover the basics, and making sure
all engineers can find, read and understand it, will go a long way.
The strongest of all warriors
are these two — proper
naming conventions and
commenting on your code
20. 6. What’s in a name?
Also, while you’re about it, think about routinely renaming components
and flows within jobs to give them more meaningful names. Few of us
would disagree that tFileInputDelimited405 is not quite as clear and
informative LoadCustomerCSV, so why don’t we do it more? And renaming
flows, particularly those leading into tMaps, will make everyday chores a
breeze!
You will be called…
Bugeyes Uglydog
PRO TIP
21. 5. Don’t touch the contexts!
So often we see context variables being updated at different points in a
job – it’s so easy to do as they’re right there at context.whatever, with the
right data type and everything.
But then how can you refer back to the original parameter values? And
what if you then want to pass the original context into a child job, or log
it to a permanent record?
CONTEXTS
22. 5. Don’t touch the contexts!
If you need a place to store and update variables within a job, the
globalMap is your friend. Just be careful to cast the correct type when
reading values back, or you may get Java errors. For example, if you put
an integer into the map, make sure you read it back as
((Integer)globalMap.get(“my_variable”)), as auto-generated code will often
put (String) as the cast by default.
PRO TIP
23. 4. But I like all these columns, don’t make me
choose!
Something that adds to the unnecessary complexity and memory requirements of a
job is all those columns that are pulled from the database or read from the file and
not needed. Add to that, all the rows of data which get read from sources, only to be
filtered out or discarded much later in the job, and no wonder the DevOps team keep
complaining there’s no memory left on the job server!
24. 4. But I like all these columns, don’t make me
choose!
We find that a good practice is to only read the columns and rows from the source that the job will actually need.
That does mean you may need to override the metadata schema and choose your own set of columns (although
that can, and often should, then be tracked and controlled as a generic schema), and while you’re about it, maybe
throw a WHERE clause into that tDbInput’s SQL statement.
If that’s sometimes impossible, or impractical to do, then at least drop in a tFilterColumns and/or tFilterRow at the
earliest possible point in the flow.
PRO TIP
25. 3. Hey, lets keep all these variables, just in case
Context groups are great – just sprinkle them liberally on a job and you
suddenly have access to all the variables you’ll ever need. But it can soon
get to the point where, especially for smaller jobs, you find that most of
them are irrelevant. There can be also cases where the purpose of
certain context groups overlap leading to uncertainty about which
variable should actually be set to achieve a given result.
?
26. 3. Hey, lets keep all these variables, just in case
A good approach is first to keep context groups small and focussed – limit the scope to a specific
purpose, such as managing a database connection.
Combine this with a clear naming convention, and you’ll reduce the risk of overlapping other sets of
variables. Also, feel free to throw away variables you don’t need when adding a group to a job – if
you only need to know the S3 bucket name then do away with the other variables! They can always be
added back in later if needed.
PRO TIP
27. 2. Jumping straight in
By missing out a tPrejob and tPostjob, you’re missing out on some simple
but effective flow control and error handling. These orchestration
components give developers the opportunity to specify code to run at the
start and end of the job.
28. 2. Jumping straight in
It could be argued that you can achieve the same effect by controlling
flow with onSubjobOk triggers, but code linked to tPrejob and tPostjob is
executed separately from the main flow, and, importantly, the tPostJob
code in particular will execute even if there’s an exception in the code
above.
PRO TIP
I got you,
bruh!
30. 1. Mutant tMap spiders
Too many lookup inputs in a tMap, often coming in from all points of the
compass, can make a Talend job look like something pulled from a
shower drain. And just as nice to deal with.
Add to this a multitude of variables, joins and mappings, and your
humble tMap will quickly go from looking busy and important to a pile
of unmanageable spaghetti.
31. 1. Mutant tMap spiders
A common solution, and one we advocate, is to enforce a separation of concerns between several
serial tMaps, rather than doing everything at once.
Maybe have one tMap to transform to a standard schema, one for data type clean-up, one to bring in
some reference tables, etc.
Bear in mind though that there’s a performance overhead that comes with each tMap, so don’t go
overboard and have 67 all in a line!
PRO TIP
32. Conclusion
At the end of the day, each job, sub-job, and
component should be a well-defined, well-scoped,
readable, manageable and testable unit of code.
That’s the dream, anyway!
33. Special thanks to
Kevin, Wael, Ian, Duncan, Hemal,
Andreas and Harsha
Huge thanks to the Datalytyx Data Engineering
team for their help in writing this.