218 Programming Fundamentals courses

Duration 3.5 Days 21 CPD hours This course is intended for This course is aimed at students new to the language who may or may not have experience with other programming languages. Overview Learn how Python works and what it's good for. Understand Python's place in the world of programming languages Learn to work with and manipulate strings in Python. Learn to perform math operations with Python. Learn to work with Python sequences: lists, arrays, dictionaries, and sets. Learn to collect user input and output results. Learn flow control processing in Python. Learn to write to and read from files using Python. Learn to write functions in Python. Learn to handle exceptions in Python. Learn to work with dates and times in Python. In this Python training course by Webucator, Inc, students learn to program in Python. PYTHON BASICS * Running Python * Hello, World! * Literals * Python Comments * Data Types * Variables * Writing a Python Module * print() Function * Named Arguments * Collecting User Input * Getting Help FUNCTIONS AND MODULES * Defining Functions * Variable Scope * Global Variables * Function Parameters * Returning Values * Importing Modules MATH * Arithmetic Operators * Modulus and Floor Division * Assignment Operators * Built-in Math Functions * The math Module * The random Module * Seeding PYTHON STRINGS * Quotation Marks and Special Characters * String Indexing * Slicing Strings * Concatenation and Repetition * Common String Methods * String Formatting * Built-in String Functions * ITERABLES: SEQUENCES, DICTIONARIES, AND SETS * Definitions * Sequences * Unpacking Sequences * Dictionaries * The len() Function * Sets * *args and **kwargs FLOW CONTROL * Conditional Statements * The is and is not Operators * Python's Ternary Operator * Loops in Python * The enumerate() Function * Generators * List Comprehensions FILE PROCESSING * Opening Files * The os and os.path Modules EXCEPTION HANDLING * Wildcard except Clauses * Getting Information on Exceptions * The else Clause * The finally Clause * Using Exceptions for Flow Control * Exception Hierarchy * DATES AND TIMES * Understanding Time * The time Module * The datetime Module RUNNING PYTHON SCRIPTS FROM THE COMMAND LINE * The sys Module * sys.argv

This video course will prepare you to take and pass the CompTIA IT Fundamentals (ITF+) certification (FC0-U61) exam confidently by helping you get to grips with all the major domains covered in the certification and enabling you to develop the skills required to set up, configure, and secure desktop PC, mobile, and networking devices.

Duration 2.5 Days 15 CPD hours This course is intended for This course is intended to help participants learn basic principles and techniques of providing PC, mobile, applications, and network support. Overview Upon successful completion of this course, students will have introductory knowledge of computer systems and mobile devices. In this course, students will identify and set up: computer hardware, software, networks, files, wireless devices and discuss safety. IDENTIFYING COMPUTER HARDWARE * Identify Types of Computing Devices * Identify Internal Computer Components * Common Computer Connector Types * Identify Common Peripheral Devices IDENTIFYING COMPUTER SOFTWARE * Compare Functions and Features of Common Operating * Systems * Identify Application Software SETTING UP A BASIC WORKSTATION * Connect Hardware * Install and Configure Operating Systems * Install and Configure Applications * Configure Accessibility Options CONFIGURING NETWORK ACCESS * Network Connection Types * Install and Configure a SOHO Router * Network and Alternative Technologies * Sharing and Storage Methods WORKING WITH FILES, FOLDERS, AND APPLICATIONS * Create Files * Navigate a File Structure * Manage Files and Folders * Compress and Extract Files * Create Screen Captures CONFIGURING AND USING WIRELESS DEVICES * Configuring Wireless Devices * Use Wireless Devices SECURING COMPUTING DEVICES * Identify Security Threats * Apply Security Best Practices * Perform Secure Web Browsing SUPPORTING COMPUTERS AND USERS * Environmental and Safety Concepts * Back Up and Restore Data * Manage Software * Implement Basic Support Measures

Duration 5 Days 30 CPD hours This course is intended for This is a basic-level programming course designed for attendees with prior development experience in another language, such as COBOL, 4GL, Mainframe or other non-object oriented languages. This course is not geared for non-developers. 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 within 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 Work with the Modular system (Project Jigsaw) Understand and use classes, inheritance and polymorphism Understand and use collections, generics, autoboxing, and enumerations Process large amount of data using Lambda expressions and the Stream API Abstract, static and private methods in interfaces Take advantage of the Java tooling that is available with the programming environment being used in the class Java 11 features covered: Using the Local Variable Type in Lambda expressions; Updates made to the String API This course provides hands-on Java 11 training for developers who have little or no prior working knowledge of object-oriented programming languages such as C, COBOL, and 4GL. You will learn the best practices for writing great object-oriented programs in Java 11, using sound development techniques, new improved features for better performance, and new capabilities for addressing rapid application development. Special emphasis is placed on object oriented concepts and best practices. A FIRST LOOK * The Java Platform * Using the JDK * The Eclipse Paradigm GETTING STARTED WITH JAVA * Writing a Simple Class * Adding Methods to the Class OO CONCEPTS * Object-Oriented Programming * Inheritance, Abstraction, and Polymorphism ESSENTIAL JAVA PROGRAMMING * Language Statements * Using Strings * Specializing in a Subclass * Fields and Variables * Using Arrays * Local-Variable Type Inference * Java Packages and Visibility OBJECT ORIENTED DEVELOPMENT * Inheritance and Polymorphism * Interfaces and Abstract Classes * Introduction to Exception Handling * Exceptions JAVA DEVELOPER'S TOOLBOXÿ * Utility Classes * Java Date/Time ADVANCED JAVA PROGRAMMING * Introduction to Generics * Lambda Expressions and Functional Interface WORKING WITH COLLECTIONS * Collections * Using Collections STREAM APIÿ * Streams * Collectors THE JAVA MODULE SYSTEM * Introduction to the Module System TIME PERMITTING * Formatting Strings * Introduction to Annotations * Java 12 and beyond ADDITIONAL COURSE DETAILS: Nexus Humans Basic Java 11 and OO Programming for Developers New to OO (TT2120-J11) 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 Basic Java 11 and OO Programming for Developers New to OO (TT2120-J11) 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 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 4 Days 24 CPD hours This course is intended for This is an introductory-level Java programming course, designed for experienced developers who wish to get up and running with Java, or who need to reinforce sound Java coding practices, immediately. Overview Working in a hands-on learning environment, guided by our expert team, attendees will learn to: 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 features Work with the Modular system (Project Jigsaw) Understand and use classes, inheritance and polymorphism Understand and use collections, generics, autoboxing, and enumerations Process large amount of data using Lambda expressions and the Stream API Abstract, static and private methods in interfaces Take advantage of the Java tooling that is available with the programming environment being used in the class Specific Java 11 features covered: Using the Local Variable Type in Lambda expressions; Updates made to the String AP Time Permitting: Quick look ahead - Java 12, Java 13, Java 14 and Beyond If you're an experienced OO developer (coming from a C# or C++ background, etc.) who needs to transition to programming in Java, this fast-paced, hands-on course will get you there quickly. Fast Track to Java Programming for OO Experienced Developers is a four-day, lab-intensive class where you'll quickly be immersed in working with the latest Java 11 programming techniques, using best practices for writing solid, robust (and well-written!) modern object-oriented applications. In addition to learning excellent, current coding skills in Java, you'll explore the new improved features for better performance and new capabilities for addressing rapid application development that Java 11 brings to the table. This course includes several key aspects that were introduced in Java 9, Java 10, and Java 11 including the Java Modular System, Local Variable Type Inference, and several API updates. This course also includes a Quick Look at what?s next in Java ? Java 12, Java 13, Java 14 and beyond. THE JAVA PLATFORM * Java Platforms * Lifecycle of a Java Program * Responsibilities of JVM * Documentation and Code Reuse USING THE JDK * Setting Up Environment * Locating Class Files * Compiling Package Classes * Source and Class Files * Java Applications THE ECLIPSE PARADIGM * Workbench and Workspace * Views * Editors * Perspectives * Projects WRITING A SIMPLE CLASS * Classes in Java * Class Modifiers and Types * Class Instance Variables * Primitives vs. Object References * Creating Objects ADDING METHODS TO THE CLASS * Passing Parameters into Methods * Returning a Value from a Method * Overloaded Methods * Constructors * Optimizing Constructor Usage LANGUAGE STATEMENTS * Operators * Comparison and Logical Operators * Looping * Continue and Break Statements * The switch Statement * The for-each() Loop USING STRINGS * 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 SPECIALIZING IN A SUBCLASS * Extending a Class * Casting * The Object Class * Default Constructor * Implicit Constructor Chaining FIELDS AND VARIABLES * Instance vs. Local Variables: * Usage Differences * Data Types * Default Values * Block Scoping Rules * Final and Static Fields * Static Methods USING ARRAYS * Arrays * Accessing the Array * Multidimensional Arrays * Copying Arrays * Variable Arguments LOCAL-VARIABLE TYPE INFERENCE * Type inference * Infering Types of Local Variables * The var Reserved Type name * Benefits of Using var * Backward Compatibility JAVA PACKAGES AND VISIBILITY * Class Location of Packages * The Package Keyword * Importing Classes * Executing Programs * Visibility in the Modular System * Java Naming Conventions INHERITANCE AND POLYMORPHISM * Polymorphism: The Subclasses * Upcasting vs. Downcasting * Calling Superclass Methods from Subclass * The final Keyword INTERFACES AND ABSTRACT CLASSES * Separating Capability from Implementation * Abstract Classes * Implementing an Interface * Abstract Classes vs. Interfaces INTRODUCTION TO EXCEPTION HANDLING * Exception Architecture * Throwing Exceptions * Checked vs. Unchecked Exceptions EXCEPTIONS * Handling Multiple Exceptions * Automatic Closure of Resources * Creating Your Own Exceptions UTILITY CLASSES * Wrapper Classes * Autoboxing/Unboxing * Enumeration Syntax * Using Static imports INTRODUCTION TO GENERICS * Generics and Subtyping * Bounded Wildcards * Generic Methods * Legacy Calls to Generics * When Generics Should Be Used LAMBDA EXPRESSIONS AND FUNCTIONAL INTERFACE * Lambda Expression Syntax * Functional Interfaces * Type Inference in Java 8 * Method references COLLECTIONS * Characterizing Collections * Collection Interface Hierarchy * The Set, List and Queue Interfaces * Map Interfaces USING COLLECTIONS * Collection Sorting * Comparators * Using the Right Collection * Lambda expressions in Collections STREAMS * Processing Collections of data * The Stream interface * Reduction and Parallelism * Filtering collection data * Sorting Collection data * Map collection data * Find elements in Stream * Numeric Streams * Create infinite Streams * Sources for using Streams COLLECTORS * Creating Collections from a Stream * Group elements in the Stream * Multi-level grouping of elements * Partitioning Streams INTRODUCTION TO THE MODULE SYSTEM * Introduce Project Jigsaw * Classpath and Encapsulation * The JDK internal APIs * Java 9 Platform modules * Defining application modules * Define module dependencies * Implicit dependencies * Implied Readability * Exporting packages JAVA DATE/TIME * The Date and Calendar classes * Introduce the new Date/Time API * LocalDate, LocalDateTime, etc. * Formatting Dates * Working with time zones * Manipulate date/time values JAVA 12 AND BEYOND * Provide an overview of changes since Java 11 * Introduce Preview Features * Records (Java 14) * Switch Expressions (Java 12, Java 13, Java 14) * Text Blocks (Java 13, Java 14) * Helpful NullPointerExceptions (Java 14) * Pattern Matching for instanceof (Java 14) ADDITIONAL COURSE DETAILS: Nexus Humans Fast Track to Core Java Programming for Object Oriented Developers (TT2104-J11) 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 Fast Track to Core Java Programming for Object Oriented Developers (TT2104-J11) 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 4 Days 24 CPD hours This course is intended for This course is appropriate for anyone who wants to create applications or modules to automate and simplify common tasks with Perl. Overview Working within in an engaging, hands-on learning environment, guided by our expert web development, PHP practitioner, students will learn to: Create a working script that gets input from the command line, the keyboard, or a file Use arrays to store and process data from files Create formatted reports Use regular expressions Use the appropriate types of variables and data structures Refactor duplicate code into subroutines and modules What is available in the standard library Use shortcuts and defaults, and what they replace Introduction to Perl Programming Essentials is an Introductory-level practical, hands-on Perl scripting training course that guides the students from the basics of writing and running Perl scripts to using more advanced features such as file operations, report writing, the use of regular expressions, working with binary data files, and using the extensive functionality of the standard Perl library. Students will immediately be able to use Perl to complete tasks in the real world. SESSION: AN OVERVIEW OF PERL * What is Perl? * Perl is compiled and interpreted * Perl Advantages and Disadvantages * Downloading and Installing Perl * Which version of Perl * Getting Help SESSION: CREATING AND RUNNING PERL PROGRAMS * Structure of a Perl program * Running a Perl script * Checking syntax and warnings * Execution of scripts under Unix and Windows SESSION: BASIC DATA AND I/O * Numeric and Text literals * Math operators and expressions * Scalar variables * Default values * Writing to standard output * Command line arguments * Reading from the standard input SESSION: LOGIC AND LOOPS * About flow control * The if statement and Boolean values * Using unless and elsif * Statement modifiers * warn() and die() * The conditional construct * Using while loop and its variants * Using the for loop * Exiting from loops SESSION: LISTS AND ARRAYS * The list data type * Accessing array elements * Creating arrays * List interpolation * Arrays and memory * Counting elements * Iterating through an array * List evaluation * Slices and ranges SESSION: READING AND WRITING TEXT FILES * File I/O Overview * Opening a file * Reading text files * Writing to a text file * Arrays and file I/O * Using the <> operator SESSION: LIST FUNCTIONS * Growing and shrinking arrays * The split() function * Splitting on whitespace * Assigning to literal lists * The join() function * The sort() function * Alternate sort keys * Reversing an array SESSION: FORMATTING OUTPUT * Using sprintf() and printf() * Report formatting overview * Defining report formats * The write() function * Advanced filehandle magic SESSION: HASHES * Hash overview * Creating hashes * Hash attributes * Traversing a hash * Testing for existence of elements * Deleting hash elements SESSION: REFERENCES * What is a reference? * The two ways to create references * References to existing data * References to anonymous data * Dereferencing scalar, array, and ash references * Dereferencing elements of arrays and hashes * Multidimensional arrays and other data structures SESSION: TEXT AND REGULAR EXPRESSIONS * String length * The substr() function * The index() and rindex() functions * String replication * Pattern matching and substitution * Regular expressions SESSION: RAW FILE AND DATA ACCESS * Opening and closing raw (binary) files * Reading raw data * Using seek() and tell() * Writing raw data * Raw data manipulation with pack() and unpack() SESSION: SUBROUTINES AND VARIABLE SCOPE * Understanding packages * Package and Lexical variables * Localizing builtin variables * Declaring and calling subroutines * Calling subroutines * Passing parameters and returning values SESSION: WORKING WITH THE OPERATING SYSTEM * Determining current OS * Environment variables * Running external programs * User identification * Trapping signals * File test operators * Working with files * Time of day SESSION: SHORTCUTS AND DEFAULTS * Understanding $_ * shift() with no array specified * Text file processing * Using grep() and Using map() * Command-line options for file processing SESSION: DATA WRANGLING * Quoting in Perl * Evaluating arrays * Understanding qw( ) * Getting more out of the <> operator * Read ranges of lines * Using m//g in scalar context * The /o modifier * Working with embedded newlines * Making REs more readable * Perl data conversion SESSION: USING THE PERL LIBRARY * The Perl library * Old-style library files * Perl modules * Modules bundled with Perl * A selection of modules * Getting modules from ActiveState * Getting modules from CPAN * Using Getopt::Long SESSION: SOME USEFUL TOOLS * Sending and receiving files with Net::FTP * Using File::Find to search for files and directories * Grabbing a Web page * Some good places to find scripts * Perl man pages for more information * Zipping and unzipping files

Package Details: * Number of Courses: 30 Courses * Accreditation: CPD Quality Standards * Free Certificates: * PDF: 30 * Hardcopy: 30 (Delivery Charge Applicable) * Courses Access: Lifetime Instalment Payment Available Basic Programming (C, Java, Python, SQL) * Course 01: Diploma in Computer Programming * Course 02: C# Programming - Beginner to Advanced * Course 03: Master JavaScript with Data Visualization * Course 04: SQL Programming Masterclass * Course 05: Python Programming for Everybody * Course 06: Javascript Programming for Beginners * Course 07: jQuery: JavaScript and AJAX Coding Bible Structural Programming * Course 01: Kotlin Programming : Android Coding * Course 02: Sensors * Course 03: Remote Sensing in ArcGIS * Course 04: Linux Shell Scripting * Course 05: Bash Scripting, Linux and Shell Programming * Course 06: Coding with Scratch * Course 07: CSS Coding Data Driven Programming * Course 01: Quick Data Science Approach from Scratch * Course 02: Secure Programming of Web Applications * Course 03: A-Frame Web VR Programming * Course 04: Complete AutoLISP Programming AutoCAD Programming * Course 01: AutoCAD Programming using C# with Windows Forms * Course 02: AutoCAD Programming using VB.NET with Windows Forms Programming for Computer Building * Course 01: Building Your Own Computer * Course 02: Neuro-linguistic Programming (NLP) Diploma Programming for Security * Course 01: Cyber Security Incident Handling and Incident Response * Course 02: Computer Networks Security * Course 03: IT Asset Department IT Soft Skills * Course 01: Functional Skills IT * Course 02: CompTIA Healthcare IT Technician * Course 03: Basic Google Data Studio * Course 04: Data Analytics with Tableau * Course 05: Recovering from a Job Loss in Technology Computer Programming Fundamental Course This Computer Programming Fundamental bundles' curriculum has been designed by Computer Programming Fundamental experts with years of Computer Programming Fundamental experience behind them. The Computer Programming Fundamental course is extremely dynamic and well-paced to help you understand Computer Programming Fundamental with ease. You'll discover how to master Computer Programming Fundamental skills while exploring relevant and essential topics. CPD 310 CPD hours / points Accredited by CPD Quality Standards WHO IS THIS COURSE FOR? Computer Programming Fundamental Course REQUIREMENTS Computer Programming Fundamental Course CAREER PATH Computer Programming Fundamental Course

Duration 2 Days 12 CPD hours This course is intended for Business Analysts, Technical Managers, and Programmers Overview This intensive training course helps students learn the practical aspects of the R programming language. The course is supplemented by many hands-on labs which allow attendees to immediately apply their theoretical knowledge in practice. Over the past few years, R has been steadily gaining popularity with business analysts, statisticians and data scientists as a tool of choice for conducting statistical analysis of data as well as supervised and unsupervised machine learning. WHAT IS R * ? What is R? * ? Positioning of R in the Data Science Space * ? The Legal Aspects * ? Microsoft R Open * ? R Integrated Development Environments * ? Running R * ? Running RStudio * ? Getting Help * ? General Notes on R Commands and Statements * ? Assignment Operators * ? R Core Data Structures * ? Assignment Example * ? R Objects and Workspace * ? Printing Objects * ? Arithmetic Operators * ? Logical Operators * ? System Date and Time * ? Operations * ? User-defined Functions * ? Control Statements * ? Conditional Execution * ? Repetitive Execution * ? Repetitive execution * ? Built-in Functions * ? Summary INTRODUCTION TO FUNCTIONAL PROGRAMMING WITH R * ? What is Functional Programming (FP)? * ? Terminology: Higher-Order Functions * ? A Short List of Languages that Support FP * ? Functional Programming in R * ? Vector and Matrix Arithmetic * ? Vector Arithmetic Example * ? More Examples of FP in R * ? Summary MANAGING YOUR ENVIRONMENT * ? Getting and Setting the Working Directory * ? Getting the List of Files in a Directory * ? The R Home Directory * ? Executing External R commands * ? Loading External Scripts in RStudio * ? Listing Objects in Workspace * ? Removing Objects in Workspace * ? Saving Your Workspace in R * ? Saving Your Workspace in RStudio * ? Saving Your Workspace in R GUI * ? Loading Your Workspace * ? Diverting Output to a File * ? Batch (Unattended) Processing * ? Controlling Global Options * ? Summary R TYPE SYSTEM AND STRUCTURES * ? The R Data Types * ? System Date and Time * ? Formatting Date and Time * ? Using the mode() Function * ? R Data Structures * ? What is the Type of My Data Structure? * ? Creating Vectors * ? Logical Vectors * ? Character Vectors * ? Factorization * ? Multi-Mode Vectors * ? The Length of the Vector * ? Getting Vector Elements * ? Lists * ? A List with Element Names * ? Extracting List Elements * ? Adding to a List * ? Matrix Data Structure * ? Creating Matrices * ? Creating Matrices with cbind() and rbind() * ? Working with Data Frames * ? Matrices vs Data Frames * ? A Data Frame Sample * ? Creating a Data Frame * ? Accessing Data Cells * ? Getting Info About a Data Frame * ? Selecting Columns in Data Frames * ? Selecting Rows in Data Frames * ? Getting a Subset of a Data Frame * ? Sorting (ordering) Data in Data Frames by Attribute(s) * ? Editing Data Frames * ? The str() Function * ? Type Conversion (Coercion) * ? The summary() Function * ? Checking an Object's Type * ? Summary EXTENDING R * ? The Base R Packages * ? Loading Packages * ? What is the Difference between Package and Library? * ? Extending R * ? The CRAN Web Site * ? Extending R in R GUI * ? Extending R in RStudio * ? Installing and Removing Packages from Command-Line * ? Summary READ-WRITE AND IMPORT-EXPORT OPERATIONS IN R * ? Reading Data from a File into a Vector * ? Example of Reading Data from a File into A Vector * ? Writing Data to a File * ? Example of Writing Data to a File * ? Reading Data into A Data Frame * ? Writing CSV Files * ? Importing Data into R * ? Exporting Data from R * ? Summary STATISTICAL COMPUTING FEATURES IN R * ? Statistical Computing Features * ? Descriptive Statistics * ? Basic Statistical Functions * ? Examples of Using Basic Statistical Functions * ? Non-uniformity of a Probability Distribution * ? Writing Your Own skew and kurtosis Functions * ? Generating Normally Distributed Random Numbers * ? Generating Uniformly Distributed Random Numbers * ? Using the summary() Function * ? Math Functions Used in Data Analysis * ? Examples of Using Math Functions * ? Correlations * ? Correlation Example * ? Testing Correlation Coefficient for Significance * ? The cor.test() Function * ? The cor.test() Example * ? Regression Analysis * ? Types of Regression * ? Simple Linear Regression Model * ? Least-Squares Method (LSM) * ? LSM Assumptions * ? Fitting Linear Regression Models in R * ? Example of Using lm() * ? Confidence Intervals for Model Parameters * ? Example of Using lm() with a Data Frame * ? Regression Models in Excel * ? Multiple Regression Analysis * ? Summary DATA MANIPULATION AND TRANSFORMATION IN R * ? Applying Functions to Matrices and Data Frames * ? The apply() Function * ? Using apply() * ? Using apply() with a User-Defined Function * ? apply() Variants * ? Using tapply() * ? Adding a Column to a Data Frame * ? Dropping A Column in a Data Frame * ? The attach() and detach() Functions * ? Sampling * ? Using sample() for Generating Labels * ? Set Operations * ? Example of Using Set Operations * ? The dplyr Package * ? Object Masking (Shadowing) Considerations * ? Getting More Information on dplyr in RStudio * ? The search() or searchpaths() Functions * ? Handling Large Data Sets in R with the data.table Package * ? The fread() and fwrite() functions from the data.table Package * ? Using the Data Table Structure * ? Summary DATA VISUALIZATION IN R * ? Data Visualization * ? Data Visualization in R * ? The ggplot2 Data Visualization Package * ? Creating Bar Plots in R * ? Creating Horizontal Bar Plots * ? Using barplot() with Matrices * ? Using barplot() with Matrices Example * ? Customizing Plots * ? Histograms in R * ? Building Histograms with hist() * ? Example of using hist() * ? Pie Charts in R * ? Examples of using pie() * ? Generic X-Y Plotting * ? Examples of the plot() function * ? Dot Plots in R * ? Saving Your Work * ? Supported Export Options * ? Plots in RStudio * ? Saving a Plot as an Image * ? Summary USING R EFFICIENTLY * ? Object Memory Allocation Considerations * ? Garbage Collection * ? Finding Out About Loaded Packages * ? Using the conflicts() Function * ? Getting Information About the Object Source Package with the pryr Package * ? Using the where() Function from the pryr Package * ? Timing Your Code * ? Timing Your Code with system.time() * ? Timing Your Code with System.time() * ? Sleeping a Program * ? Handling Large Data Sets in R with the data.table Package * ? Passing System-Level Parameters to R * ? Summary LAB EXERCISES * Lab 1 - Getting Started with R * Lab 2 - Learning the R Type System and Structures * Lab 3 - Read and Write Operations in R * Lab 4 - Data Import and Export in R * Lab 5 - k-Nearest Neighbors Algorithm * Lab 6 - Creating Your Own Statistical Functions * Lab 7 - Simple Linear Regression * Lab 8 - Monte-Carlo Simulation (Method) * Lab 9 - Data Processing with R * Lab 10 - Using R Graphics Package * Lab 11 - Using R Efficiently

Duration 3 Days 18 CPD hours This course is intended for Java Fundamentals is designed for tech enthusiasts who are familiar with some programming languages and want a quick introduction to the most important principles of Java. Overview After completing this course, you will be able to: Create and run Java programs Use data types, data structures, and control flow in your code Implement best practices while creating objects Work with constructors and inheritance Understand advanced data structures to organize and store data Employ generics for stronger check-types during compilation Learn to handle exceptions in your code Since its inception, Java has stormed the programming world. Its features and functionalities provide developers with the tools needed to write robust cross-platform applications. Java Fundamentals introduces you to these tools and functionalities that will enable you to create Java programs. The course begins with an introduction to the language, its philosophy, and evolution over time, until the latest release. You'll learn how the javac/java tools work and what Java packages are - the way a Java program is usually organized. Once you are comfortable with this, you'll be introduced to advanced concepts of the language, such as control flow keywords. You'll explore object-oriented programming and the part it plays in making Java what it is. In the concluding lessons, you'll be familiarized with classes, typecasting, and interfaces, and understand the use of data structures, arrays, strings, handling exceptions, and creating generics. INTRODUCTION TO JAVA * The Java Ecosystem * Our First Java Application * Packages VARIABLES, DATA TYPES, AND OPERATORS * Variables and Data Types * Integral Data Types * Type casting CONTROL FLOW * Conditional Statements * Looping Constructs OBJECT-ORIENTED PROGRAMMING * Object-Oriented Principles * Classes and Objects * Constructors * The this Keyword * Inheritance * Overloading * Constructor Overloading * Polymorphism and Overriding * Annotations * References OOP IN DEPTH * Interfaces * Typecasting * The Object Class * Autoboxing and Unboxing * Abstract Classes and Methods DATA STRUCTURES, ARRAYS, AND STRINGS * Data Structures and Algorithms * Strings THE JAVA COLLECTIONS FRAMEWORK AND GENERICS * Reading Data from Files * The Java Collections Framework * Generics * Collection ADVANCED DATA STRUCTURES IN JAVA * Implementing a Custom Linked List * Implementing Binary Search Tree * Enumerations * Set and Uniqueness in Set EXCEPTION HANDLING * Motivation behind Exceptions * Exception Sources * Exception Mechanics * Best Practices