8506 Courses

Duration 1 Days 6 CPD hours This course is intended for This overview-level course is ideally suited for professionals seeking an introduction to microservices architecture and its application within a business context. Ideal attendee roles include software developers, system architects, technical managers, and IT professionals who are part of teams transitioning to a microservices approach. It's also an excellent starting point for non-technical roles such as product owners or business analysts who work closely with technical teams and want to better understand and become conversant in the language and principles of microservices. Overview This course combines engaging instructor-led presentations and useful demonstrations with engaging group activities. Throughout the course you'll explore: Understand the Basics of Microservices: Get to know the fundamental principles and characteristics of microservices and how they revolutionize traditional software development approaches. Explore the Design of Microservices: Gain an overview of how microservices are designed based on business requirements and what makes them unique in the software architecture world. Overview of Managing and Scaling Microservices: Get an introduction to how microservices are managed and scaled independently, and understand the significance of these features in your business operations. Familiarize with the Microservices Ecosystem: Learn about the typical patterns, best practices, and common pitfalls in the microservices world, setting a foundation for future learning and implementation. Introduction to Microservices in a Business Context: Acquire a basic understanding of how microservices can be aligned with specific business capabilities, and get a glimpse into how they can coexist with legacy systems in a business setting. Microservices have rapidly emerged as a popular architectural style, breaking down applications into small, independent services that can be developed, deployed, and scaled individually. Microservices offer a robust method to address a variety of projects, such as e-commerce platforms and content management systems, enhancing scalability and boosting productivity. This technology, when employed correctly, can greatly increase software delivery speed and system resilience, making it a crucial skill set for modern technology professionals.Understanding Microservices - A Technical Overview is a one-day course ideally suited for technical professionals seeking an introduction to microservices architecture and its application within a business context. Under the guidance of an industry expert, this engaging class combines lecture-style learning with lively demonstrations, case study review and group discussions.Throughout the course you?ll explore the principles and characteristics that define microservices, how to identify suitable projects for a microservices approach, the factors to consider when designing them, and the strategies to effectively manage and scale them within complex systems. You?ll also learn about the best practices, patterns, and anti-patterns, arming you with the knowledge to make the right architectural choices. This course also explores the real-world implementation of microservices in a business enterprise. We'll discuss how to align the application of microservices with your organization's specific business capabilities, and offer strategies for smoothly integrating this technology within existing legacy systems. Introduction to Microservices Understand what microservices are and their role in modern software development. Introduction to Microservices: what they are and why they matter. Monolithic vs Microservices: highlighting the shift and benefits. Key principles and characteristics of microservices. Identifying suitable applications for microservices transformation. Demo: Analyzing a sample application and identifying potential microservices Architecting and Managing Microservices Learn the basic strategies for scaling and managing microservices. Scaling Microservices: from a single service to hundreds. Key components of a microservices architecture. Introduction to resilience patterns: Circuit-Breakers and Bulkheads. Load management and provisioning in a microservices setup. Understanding the role of cloud services in microservices. Optional Demo: Illustrating how a microservice-based application scales in real-time Designing Microservices Learn the key aspects to consider when designing microservices. Defining microservice boundaries: Deciding the scope of a microservice. Communication patterns in microservices. Understanding Microservice endpoints. Exploring data stores and transaction boundaries in microservices. Overcoming challenges in Microservices design. Demo: Designing microservices for a hypothetical business requirement Implementing Microservices in a Business Enterprise Understand the process and considerations for implementing microservices in an enterprise context. Assessing enterprise readiness for microservices. Building the business case for microservices: strategic advantages and potential challenges. Aligning microservices with business capabilities. Organizational changes: Team structures and processes for microservices. Dealing with Legacy Systems: Strategies for microservices integration. Demo: Exploring a case study of successful microservices implementation in a business enterprise The Microservices Ecosystem Understand the key tools and best practices in the Microservices ecosystem. Understanding the typical Microservices Stack. Monitoring and Logging in Microservices. Introduction to Docker: Containerization of Microservices. Deployment strategies in a Microservices setup. Introduction to Orchestration in Microservices Demo: Containerizing and deploying a simple microservice Microservices Deployment Strategies Understand various ways to safely introduce changes in a microservices environment. The concept of Blue-Green Deployment: changing services without downtime. Canary Releases and Feature Toggles: slowly rolling out changes to users. Database changes in a microservices environment: keeping data consistent. Demo: Examining various deployment strategies Microservices Best Practices and DevOps Learn key strategies to ensure a smooth operation of your microservices setup. The DevOps culture in Microservices: collaboration for efficiency. Defining a Minimum Viable Product in a Microservices setup: building small, delivering fast. Dealing with data in a distributed setup: managing Data Islands. The importance of Continuous Integration/Continuous Delivery in a microservices setup. Governance: Keeping track of your services and their consumers. Demo: Visualizing a simple continuous delivery pipeline Microservices Patterns and Anti-Patterns Learn about common do's and don'ts when working with microservices. Understanding patterns that help with efficient microservices operation. Recognizing and avoiding anti-patterns that can hinder performance. Dealing with common challenges: dependencies between services, managing service boundaries. Demo: Examples of real-world patterns and anti-patterns Simple Overview of OAuth and OpenID for Microservices Introduction to OAuth and OpenID: What they are and why they matter in Microservices. The role of tokens in OAuth 2.0: How they help in securing communications. A simplified look at OpenID Connect: Linking identities across services. Demo

Duration 4 Days 24 CPD hours This course is intended for This is an introductory-level C++ programming course designed for developers with experience programming in C or other languages. Practical hands-on prior programming experience and knowledge is required. Overview This 'skills-centric' course is about 50% hands-on lab and 50% lecture, designed to train attendees in basic coding with C++, coupling the most current, effective techniques with the soundest industry practices. Our engaging instructors and mentors are highly experienced practitioners who bring years of current 'on-the-job' experience into every classroom. Working in a hands-on learning environment, guided by our expert team, attendees will learn: Writing procedural programs using C++ Using private, public and protected keywords to control access to class members Defining a class in C++ Writing constructors and destructors Writing classes with const and static class members Overloading operators Implementing polymorphic methods in programs Writing programs using file I/O and string streams Using manipulators and stream flags to format output Using the keyword template to write generic functions and classes Writing programs that use generic classes and functions Writing programs that use algorithms and containers of the Standard Library Apply object-oriented design techniques to real-world programming problems Using algorithms and containers of the Standard Library to manipulate string data Understand how C++ protects the programmer from implementation changes in other modules of an application Using try() blocks to trap exceptions Using catch() blocks to handle exceptions Defining exceptions and using throw to trigger them Introduction to C++ Programming / C++ Essentials is a skills-focused, hands-on C++ training course geared for experienced programmers who need to learn C++ coupled with sounds coding skills and best practices for OO development. Students will leave this course armed with the required skills to put foundation-level C++ programming skills right to work in a practical environment. The central concepts of C++ syntax and style are taught in the context of using object-oriented methods to achieve reusability, adaptability and reliability. Emphasis is placed on the features of C++ that support abstract data types, inheritance, and polymorphism. Students will learn to apply the process of data abstraction and class design. Practical aspects of C++ programming including efficiency, performance, testing, and reliability considerations are stressed throughout. Comprehensive hands on exercises are integrated throughout to reinforce learning and develop real competency Moving from C to C++ (Optional) New Compiler Directives Stream Console I/O Explicit Operators Standard Libraries Data Control Capabilities Handling Data New Declaration Features Initialization and Assignment Enumerated Types The bool Type Constant Storage Pointers to Constant Storage Constant Pointers References Constant Reference Arguments Volatile Data Global Data Functions Function Prototypes and Type Checking Default Function Data Types Function Overloading Problems with Function Overloading Name Resolution Promotions and Conversions Call by Value Reference Declarations Call-by-Reference and Reference Types References in Function Return Constant Argument Types Conversion of Parameters Using Default Initializers Providing Default Arguments Inline Functions Operator Overloading Advantages and Pitfalls of Overloading Member Operator Syntax and Examples Class Assignment Operators Class Equality Operators Non-Member Operator Overloading Member and Non-Member Operator Functions Operator Precedence This Pointer Overloading the Assignment Operator Overloading Caveats Creating and Using Objects Creating Automatic Objects Creating Dynamic Objects Calling Object Methods Constructors Initializing Member consts Initializer List Syntax Allocating Resources in Constructor Destructors Block and Function Scope File and Global Scope Class Scope Scope Resolution Operator :: Using Objects as Arguments Objects as Function Return Values Constant Methods Containment Relationships Dynamic Memory Management Advantages of Dynamic Memory Allocation Static, Automatic, and Heap Memory Free Store Allocation with new and delete Handling Memory Allocation Errors Controlling Object Creation Object Copying and Copy Constructor Automatic Copy Constructor Conversion Constructor Streaming I/O Streams and the iostream Library Built-in Stream Objects Stream Manipulators Stream Methods Input/Output Operators Character Input String Streams Formatted I/O File Stream I/O Overloading Stream Operators Persistent Objects Introduction to Object Concepts The Object Programming Paradigm Object-Orientated Programming Definitions Information Hiding and Encapsulation Separating Interface and Implementation Classes and Instances of Objects Overloaded Objects and Polymorphism Declaring and Defining Classes Components of a Class Class Structure Class Declaration Syntax Member Data Built-in Operations Constructors and Initialization Initialization vs. Assignment Class Type Members Member Functions and Member Accessibility Inline Member Functions Friend Functions Static Members Modifying Access with a Friend Class Templates Purpose of Template Classes Constants in Templates Templates and Inheritance Container Classes Use of Libraries Strings in C++ Character Strings The String Class Operators on Strings Member Functions of the String Class Inheritance Inheritance and Reuse Composition vs. Inheritance Inheritance: Centralized Code Inheritance: Maintenance and Revision Public, Private and Protected Members Redefining Behavior in Derived Classes Designing Extensible Software Systems Syntax for Public Inheritance Use of Common Pointers Constructors and Initialization Inherited Copy Constructors Destructors and Inheritance Public, Protected, Private Inheritance Exceptions Types of Exceptions Trapping and Handling Exceptions Triggering Exceptions Handling Memory Allocation Errors C++ Program Structure Organizing C++ Source Files Integrating C and C++ Projects Using C in C++ Reliability Considerations in C++ Projects Function Prototypes Strong Type Checking Constant Types C++ Access Control Techniques Polymorphism in C++ Definition of Polymorphism Calling Overridden Methods Upcasting Accessing Overridden Methods Virtual Methods and Dynamic Binding Virtual Destructors Abstract Base Classes and Pure Virtual Methods Multiple Inheritance Derivation from Multiple Base Classes Base Class Ambiguities Virtual Inheritance Virtual Base Classes Virtual Base Class Information The Standard Template Library STL Containers Parameters Used in Container Classes The Vector Class STL Algorithms Use of Libraries

Duration 5 Days 30 CPD hours This course is intended for In order to be successful in this course you should have incoming hands-on experience with another programming language. This course is not for non-developers or new developers. Possible roles that may attend this course include: Software Developers: Professionals who have been working with other programming languages and want to expand their skillset by learning Java and its object-oriented features. Web Developers: Those who work on web applications and want to enhance their back-end development capabilities with Java. Mobile App Developers: Developers who wish to enter the world of Android app development, where Java is a widely used language for creating mobile applications. Overview This 'skills-centric' course is about 50% hands-on lab and 50% lecture, designed to train attendees in core OO coding and Java development skills, coupling the most current, effective techniques with the soundest industry practices. Our engaging instructors and mentors are highly experienced practitioners who bring years of current 'on-the-job' experience into every classroom. Working in a hands-on learning environment, guided by our expert team, attendees will learn to: Understand what OO programming is and what the advantages of OO are in today's world Work with objects, classes, and OO implementations Understand the basic concepts of OO such as encapsulation, inheritance, polymorphism, and abstraction Understand not only the fundamentals of the Java language, but also its importance, uses, strengths and weaknesses Understand the basics of the Java language and how?it relates to OO programming and the Object Model Learn to use Java exception handling Understand and use classes, inheritance and polymorphism Understand and use collections, generics, autoboxing, and enumerations Become familiar with the concept of functional programming using Lambda Expressions Process large amounts of data using the Stream API introduced in Java 8 Discover the new Date/Time API Use the JDBC API for database access Work with annotations Take advantage of the Java tooling that is available with the programming environment being used in the class Java 8 Features: Lambda Expressions, Method and Constructor references, The Streams API, Collectors, The Optional class Geared for experienced developers, Basic Java Programming for Developers New to OO, this hands-on, workshop-style course will provide you with an immersive learning experience that will expand your skillset and open doors to new opportunities within the ever-growing technology landscape. Mastering Java and its powerful capabilities will provide you with the competitive edge you need to stand out in today's fast-paced development world. Working in a hands-on learning environment led by our expert coach, you?ll thoroughly explore the foundations of the Java platform, essential programming concepts, and advanced topics, ensuring you acquire a strong understanding of the language and its ecosystem. The object-oriented programming principles taught in this course promote code reusability and maintainability, enabling you to streamline development processes and reduce long-term costs. As you progress through the course, you will also gain familiarity with using an IDE, enhancing your development workflow and collaboration with other Java developers, enabling you to integrate seamlessly into new projects and teams. You?ll also gain practical experience in applying the concepts and techniques learned, solidifying your newly acquired skills and facilitating their direct application in real-world scenarios. You?ll exit this course empowered to create robust, scalable, and efficient Java-based applications that drive innovation and growth for your organization The Java Platform The Java Platform Lifecycle of a Java Program Responsibilities of JVM Documentation and Code Reuse Using the JDK Explain the JDK?s file structure Use the command line compiler to compile a Java class Use the command line Java interpreter to run a Java application class The IntelliJ Paradigm Introduce the IntelliJ IDE The Basics of the IntelliJ interface IntelliJ Projects and Modules Creating and running Java applications Writing a Simple Class Write a Java class that does not explicitly extend another class Define instance variables for a Java class Create object instances Primitives vs Object References Implement a main method to create an instance of the defined class Adding Methods to the Class Write a class with accessor methods to read and write instance variables Write a constructor to initialize an instance with data Write a constructor that calls other constructors of the class to benefit from code reuse Use the this keyword to distinguish local variables from instance variables Object-Oriented Programming Real-World Objects Classes and Objects Object Behavior Methods and Messages Inheritance, Abstraction, and Polymorphism Encapsulation Inheritance Method Overriding Polymorphism Essential Java Programming Essential Java Programming Language Statements Arithmetic operators Operators to increment and decrement numbers Comparison operators Logical operators Return type of comparison and logical operators Use for loops Switch Expressions Switch Expressions and yield Using Strings and Text Blocks Create an instance of the String class Test if two strings are equal Get the length of a string Parse a string for its token components Perform a case-insensitive equality test Build up a string using StringBuffer Contrast String, StringBuffer,and StringBuilder Compact Strings Text Blocks Specializing in a Subclass Constructing a class that extends another class Implementing equals and toString Writing constructors that pass initialization data to parent constructor Using instanceof to verify type of an object reference Pattern matching for instanceof Overriding subclass methods Safely casting references to a more refined type Fields and Variables Discuss Block Scoping Rules Distinguish between instance variables and method variables within a method Explain the difference between the terms field and variable List the default values for instance variables Final and Static fields and methods Local Variable type inference Using Arrays Declaring an array reference Allocating an array Initializing the entries in an array Writing methods with a variable number of arguments Records Data Objects in Java Introduce records as carrier of immutable data Defining records Java Packages and Visibility Use the package keyword to define a class within a specific package Discuss levels of accessibility/visibility Using the import keyword to declare references to classes in a specific package Using the standard type naming conventions Visibility in the Java Modular System Correctly executing a Java application class The Java modular system Defining Modules Inheritance and Polymorphism Write a subclass with a method that overrides a method in the superclass Group objects by their common supertype Utilize polymorphism Cast a supertype reference to a valid subtype reference Use the final keyword on methods and classes to prevent overriding Interfaces and Abstract Classes Define supertype contracts using abstract classes Implement concrete classes based on abstract classes Define supertype contracts using interfaces Implement concrete classes based on interfaces Explain advantage of interfaces over abstract classes Explain advantage of abstract classes over interfaces Static, default and private methods in interfaces Sealed classes Introduce Sealed classes The sealed and permits modifiers Sealed Interfaces Exception Handling Introduction to Exception Handling Introduce the Exception architecture Defining a try/catch blocks Checked vs Unchecked exceptions Exceptions Defining your own application exceptions Automatic closure of resources Suppressed exceptions Handling multiple exceptions in one catch Helpful Nullpointers Enhanced try-with-resources Java Developer's Toolbox Developing applications Introduce the wrapper classes Explain Autoboxing and Unboxing Converting String representations of primitive numbers into their primitive types Defining Enumerations Using static imports Deprecating methods Advanced Java Programming Introduction to Generics Generics and Subtyping Bounded Wildcards Generic Methods Legacy Calls To Generics When Generics Should Be Used Lambda Expressions and Functional Interface Understanding the concept of functional programming Writing lambda expressions Understanding functional interfaces Collections Provide an overview of the Collection API Review the different collection implementations (Set, List and Queue) Explore how generics are used with collections Examine iterators for working with collections Using Collections Collection Sorting Comparators Using the Right Collection Lambda expressions in Collections Bonus Topics: Time Permitting Streams Understanding the problem with collections in Java Thinking of program solutions in a declarative way Use the Stream API to process collections of data Understand the difference between intermediate and terminal stream operations Filtering elements from a Stream Finding element(s) within a Stream Collecting the elements from a Stream into a List takeWhile and dropWhile intermediate operations Collectors Using different ways to collect the items from a Stream Grouping elements within a stream Gathering statistics about numeric property of elements in a stream

Duration 2 Days 12 CPD hours This course is intended for This course is intended for system and network administrators responsible for installation, setup, configuration, and administration of BIG-IP DNS systems. This course gives networking professionals a functional understanding of the BIG-IP DNS system as it is commonly used. The course covers configuration and ongoing management of the BIG-IP DNS system, and includes a combination of lecture, discussion, and hands-on labs. Module 1: Setting Up the BIG-IP System Introducing the BIG-IP System Initially Setting Up the BIG-IP System Archiving the BIG-IP Configuration Leveraging F5 Support Resources and Tools Provision the BIG-IP System and Confirm Network Configuration Module 2: Introducing the Domain Name System (DNS) and BIG-IP DNS Understanding the Domain Name System (DNS) Reviewing the Name Resolution Process Implementing BIG-IP DNS Using DNS Resolution Diagnostic Tools Module 3: Accelerating DNS Resolution Introducing DNS Resolution with BIG-IP DNS BIG-IP DNS Resolution Decision Flow Configuring BIG-IP DNS Listeners Resolving DNS Queries in the Labs (Lab Zone Records) Load Balancing Queries to a DNS Server Pool Accelerating DNS Resolution with DNS Cache Accelerating DNS Resolution with DNS Express Introducing Wide IPs Using Other Resolution Methods with BIG-IP DNS Integrating BIG-IP DNS into Existing DNS Environments Module 4: Implementing Intelligent DNS Resolutions Introducing Intelligent DNS Resolution Identifying Physical Network Components Identifying Logical Network Components Collecting Metrics for Intelligent Resolution Configuring Data Centers Configuring a BIG-IP DNS System as a Server Configuring a BIG-IP LTM System as a Server Establishing iQuery Communication between BIG-IP Systems Configuring a Non-F5 Server Defining Links and Routers Configuring Wide IP Pools Configuring Wide IPs Managing Object Status Using the Traffic Management Shell (TMSH) Module 5: Using LDNS Probes and Metrics Introducing LDNS Probes and Metrics Types of LDNS Probes Excluding an LDNS from Probing Configuring Probe Metrics Collection Module 6: Load Balancing Intelligent DNS Resolution Introducing Load Balancing on BIG-IP DNS Using Static Load Balancing Methods Round Robin Ratio Global Availability Static Persist Other Static Load Balancing Methods Using Dynamic Load Balancing Methods Round Trip Time Completion Rate CPU Hops Least Connections Packet Rate Kilobytes per Second Other Dynamic Load Balancing Methods Virtual Server Capacity Virtual Server Score Using Quality of Service Load Balancing Persisting DNS Query Responses Configuring GSLB Load Balancing Decision Logs Using Manual Resume Using Topology Load Balancing Module 7: Monitoring Intelligent DNS Resources Exploring Monitors Configuring Monitors Assigning Monitors to Resources Monitoring Best Practices Module 8: Advanced BIG-IP DNS Topics Implementing DNSSEC Setting Limits for Resource Availability Using iRules with Wide IPs Introducing Other Wide IP Types Implementing BIG-IP DNS Sync Groups Module 9: Final Configuration Projects Final Configuration Projects

Duration 2 Days 12 CPD hours This course is intended for If you are a data analyst, data scientist, or a business analyst who wants to get started with using Python and machine learning techniques to analyze data and predict outcomes, this book is for you. Basic knowledge of computer programming and data analytics is a must. Familiarity with mathematical concepts such as algebra and basic statistics will be useful. Overview By the end of this course, you will have the skills you need to confidently use various machine learning algorithms to perform detailed data analysis and extract meaningful insights from data. This course is designed to give you practical guidance on industry-standard data analysis and machine learning tools in Python, with the help of realistic data. The course will help you understand how you can use pandas and Matplotlib to critically examine a dataset with summary statistics and graphs, and extract the insights you seek to derive. You will continue to build on your knowledge as you learn how to prepare data and feed it to machine learning algorithms, such as regularized logistic regression and random forest, using the scikit-learn package. You?ll discover how to tune the algorithms to provide the best predictions on new and unseen data. As you delve into later sections, you?ll be able to understand the working and output of these algorithms and gain insight into not only the predictive capabilities of the models but also their reasons for making these predictions. Data Exploration and Cleaning Python and the Anaconda Package Management System Different Types of Data Science Problems Loading the Case Study Data with Jupyter and pandas Data Quality Assurance and Exploration Exploring the Financial History Features in the Dataset Activity 1: Exploring Remaining Financial Features in the Dataset Introduction to Scikit-Learn and Model Evaluation Introduction Model Performance Metrics for Binary Classification Activity 2: Performing Logistic Regression with a New Feature and Creating a Precision-Recall Curve Details of Logistic Regression and Feature Exploration Introduction Examining the Relationships between Features and the Response Univariate Feature Selection: What It Does and Doesn't Do Building Cloud-Native Applications Activity 3: Fitting a Logistic Regression Model and Directly Using the Coefficients The Bias-Variance Trade-off Introduction Estimating the Coefficients and Intercepts of Logistic Regression Cross Validation: Choosing the Regularization Parameter and Other Hyperparameters Activity 4: Cross-Validation and Feature Engineering with the Case Study Data Decision Trees and Random Forests Introduction Decision trees Random Forests: Ensembles of Decision Trees Activity 5: Cross-Validation Grid Search with Random Forest Imputation of Missing Data, Financial Analysis, and Delivery to Client Introduction Review of Modeling Results Dealing with Missing Data: Imputation Strategies Activity 6: Deriving Financial Insights Final Thoughts on Delivering the Predictive Model to the Client

Duration 1.625 Days 9.75 CPD hours This course is intended for This course is designed for any business professional that leads or works on teams that identify and develop business solutions. Overview Upon successful completion of this course, students will understand the fundamentals of design thinking and be able to apply principles, methodologies and frameworks and apply them to projects. In this course, students are introduced to design thinking and its application to developing new products, services and the organization of businesses. Design thinking is a human-centric, interdisciplinary approach towards innovation. Understand Design ThinkingWhat is Process Awareness and why is it Key?How to Develop a Good Problem StatementHow to Discover User Needs How to Build Empathy with the User How to Generate IdeasHow to Select Ideas How to Create a Good PrototypeLearn from Failure Additional course details: Nexus Humans Design Thinking for Innovative Problem Solving training program is a workshop that presents an invigorating mix of sessions, lessons, and masterclasses meticulously crafted to propel your learning expedition forward. This immersive bootcamp-style experience boasts interactive lectures, hands-on labs, and collaborative hackathons, all strategically designed to fortify fundamental concepts. Guided by seasoned coaches, each session offers priceless insights and practical skills crucial for honing your expertise. Whether you're stepping into the realm of professional skills or a seasoned professional, this comprehensive course ensures you're equipped with the knowledge and prowess necessary for success. While we feel this is the best course for the Design Thinking for Innovative Problem Solving course and one of our Top 10 we encourage you to read the course outline to make sure it is the right content for you. Additionally, private sessions, closed classes or dedicated events are available both live online and at our training centres in Dublin and London, as well as at your offices anywhere in the UK, Ireland or across EMEA.

Duration 2 Days 12 CPD hours This course is intended for Software Test Engineers and Test Leaders with minimum two years of experience. Specialists who have experience in software testing and want to deepen both their theoretical and practical knowledge. Overview Please refer to Overview. Practical training that you will learn how to apply additional tools in your work which will help you to optimize it. You will be able to analyze requirements better and to prioritize your tasks. Requirements analysis Effective approaches in requirements analyze What does 'Good Requirement' mean? Change Management Subsystems and actors Practice - Analysis of an actual functional specification Applicable Models and Priorities Specifications of the extraordinary models software projects Prioritizing the tasks of the test team Practice case - Iteration and sprint specifications Test planning Test design approaches Applicable techniques Practice cases with different techniques Defects management Defect status management Applicable metrics Best practices Practical examples of extraordinary applications Additional course details: Nexus Humans Modern approaches and practical tips in software testing training program is a workshop that presents an invigorating mix of sessions, lessons, and masterclasses meticulously crafted to propel your learning expedition forward. This immersive bootcamp-style experience boasts interactive lectures, hands-on labs, and collaborative hackathons, all strategically designed to fortify fundamental concepts. Guided by seasoned coaches, each session offers priceless insights and practical skills crucial for honing your expertise. Whether you're stepping into the realm of professional skills or a seasoned professional, this comprehensive course ensures you're equipped with the knowledge and prowess necessary for success. While we feel this is the best course for the Modern approaches and practical tips in software testing course and one of our Top 10 we encourage you to read the course outline to make sure it is the right content for you. Additionally, private sessions, closed classes or dedicated events are available both live online and at our training centres in Dublin and London, as well as at your offices anywhere in the UK, Ireland or across EMEA.

Duration 2 Days 12 CPD hours This course is intended for This course is designed for the Business Analyst professional who is involved with testing the functionality of technology projects. Overview Develop an understanding about basic concepts associated with User Acceptance TestingSee how UAT applies to the Software Development Lifecycle (SDLC)Recognize benefits of improved quality of deployed software using User Acceptance TestingIdentify the key roles, activities and deliverables which make up User Acceptance Testing Use a Business Use Case to define scenarios for testingCreate a UAT test plan and write UAT test cases with associated test dataUnderstand the process for testing functional and non-functional requirementsIdentify the challenges of testing vendor-supplied applications This course looks at the issues which drive the need for a UAT process & describes the components of the process. It is designed to help Business Analysts to develop an understanding of their role, the process, and the deliverables associated with UAT. Day 1 Software Testing - the Basics Understanding the Tester?s Terminology The UAT Planning Process Day 2 UAT Test Coverage Creating & Executing the UAT Test Cases Verifying the Test Results Testing Vendor-Supplied Applications Additional course details: Nexus Humans BA29 - User Acceptance Testing for Business Analysts training program is a workshop that presents an invigorating mix of sessions, lessons, and masterclasses meticulously crafted to propel your learning expedition forward. This immersive bootcamp-style experience boasts interactive lectures, hands-on labs, and collaborative hackathons, all strategically designed to fortify fundamental concepts. Guided by seasoned coaches, each session offers priceless insights and practical skills crucial for honing your expertise. Whether you're stepping into the realm of professional skills or a seasoned professional, this comprehensive course ensures you're equipped with the knowledge and prowess necessary for success. While we feel this is the best course for the BA29 - User Acceptance Testing for Business Analysts course and one of our Top 10 we encourage you to read the course outline to make sure it is the right content for you. Additionally, private sessions, closed classes or dedicated events are available both live online and at our training centres in Dublin and London, as well as at your offices anywhere in the UK, Ireland or across EMEA.

Duration 5 Days 30 CPD hours This course is intended for This intermediate course is designed for anyone who works on WebSphere related applications and projects, including administrators, IBM Business Partners, independent software vendors (ISVs), and consultants. Overview The objectives for this course are as follows:Use IBM Support Assistant to organize and analyze problem artifactsUse problem determination techniques to identify common problemsApply problem investigation approaches such as analysis and isolationGather diagnostic data problem artifacts by using administrative toolsTroubleshoot JVM-related problems such as hung threads, out of memory issues, and crashesUse IBM Support Assistant to run tools that analyze diagnostic dataIdentify and troubleshoot common problems with database connectionsConfigure and tune database connection poolsTroubleshoot WebSphere security problems associated with authentication, authorization, SSL, and Java 2 policiesIdentify and resolve Java EE application deployment problemsTroubleshoot HTTP request flow problems from web server to web containerIdentify and resolve application server startup failuresTroubleshoot problems associated with WebSphere default messaging and SI busTroubleshoot WebSphere installation problemsUse Intelligent Management features to configure health policies and tasksCommunicate effectively with IBM support teams This course teaches you how to manage WebSphere Application Server problems more skillfully within your organization by using problem determination tools and techniques. Outline Course introduction Overview of WebSphere Application Server systems and components Using the IBM Support Assistant Team Server 5.0 Exercise: Using the IBM Support Assistant Team Server 5.0 Problem determination methods Gathering diagnostic data Exercise: Gathering diagnostic data Introduction to JVM-related problems Exercise: Introduction to configuring garbage collection policies How to troubleshoot hangs Exercise: Troubleshooting hung threads How to troubleshoot crashes Exercise: Troubleshooting crashes Introduction to WebSphere out-of-memory problems Exercise: Troubleshooting an out-of-memory condition Introduction to database connection problems Exercise: Troubleshooting database connection problems Tuning and connection pool management problems Exercise: Troubleshooting a connection leak WebSphere security configuration problems Exercise: Troubleshooting security problems Application deployment problems Server start failures Exercise: Troubleshooting server start failures Request flow and web container problems Exercise: Troubleshooting request flow and web container problems Default messaging provider problem determination Exercise: Troubleshooting WebSphere default messaging WebSphere installation problems when using IBM Installation Manager Intelligent Management problem determination and problem determination tools Exercise: Configuring health management policies Course summary

Duration 5 Days 30 CPD hours This course is intended for This class is designed for experienced BizTalk Server Developers who have at least one year of hands-on experience developing BizTalk Server applications. Overview In this 5-day course, you will learn how to apply best practices and design patterns to build smarter BizTalk Server applications. Furthermore, this course provides extensive coverage of BizTalk Server's extensibility, including such topics as: custom functoids, custom pipeline components, and invoking external .NET methods. This course is designed specifically for experienced BizTalk Server developers and focuses on best practices & pattern-based design while pulling back the curtain on some of BizTalk Server's eccentricities. Review of BizTalk Server Fundamentals The BizTalk Server Architecture Inner Workings of the Messaging Engine Messaging Engine Deep Dive Two-way Messaging Without Orchestrations Designing and Testing Schemas Schema Design Enabling Unit Testing for BizTalk Projects Data Translation and Transformation Custom Data Transformation Creating Custom Pipeline Components Working with Message Interchanges Debatching Message Interchanges Advanced Concepts of WCF Adapters Connecting to External Systems Using WCF LOB Adapters in BizTalk Server Publishing and Consuming WCF and RESTful Services Overview of Service Integration Using WCF Implementing WCF Services Preprocessing Messages with IIS Modules Consuming Services Advanced Orchestration Communication Patterns Orchestration Engine Deep Dive Splitting and Aggregating Messages using Orchestrations Orchestration Communication Bridging the Synchronous/Asynchronous Gap Across Multiple Channels Correlating Messages in Orchestration Instances Building Convoy Orchestrations Handling Orchestration Faults and Exceptions Exception Handling in Orchestrations Implementing Transactions and Compensation Creating Transactional Processes Designing Custom Tracking Models for BizTalk Applications Introduction to Business Activity Monitoring Enabling Business Activity Monitoring Extending BAM Beyond BizTalk Building Declarative Logic Using the Business Rules Engine Concepts of Declarative Logic Fundamentals of BizTalk BRE Integrating Policies with BizTalk Advanced Concepts of the Business Rules Engine Advanced Business Rule Concepts Working with Advanced Facts Integrating Across Business Boundaries Using Parties, Roles, and EDI Port Binding Option Review Role-Based Integration What is EDI? Enabling EDI-Based Messaging