Grootste online IT opleider

Beste klantenservice

Veel e-learning in prijs verlaagd

Na betaling, direct starten

Ontwikkel je van Developer naar Software Architect

€ 825,00
€ 998,25 Incl. BTW

Bestellen namens een bedrijf?

Duur: 78 uur |

Taal: Engels (US) |

Online toegang: 365 dagen |

In Onbeperkt Leren

Gegevens

Wil jij jezelf ontwikkelen van Developer naar Software Architect? Dan is dit ontwikkelpad voor jou! In het ontwikkelpad verken je de rollen van Developer, Database Developer, Full Stack Developer en Software Architect. Je verkent programmeertalen, frameworks en tools zoals Java, Spring Web MVC, JDBC en Redis.

Wanneer je kiest voor dit ontwikkelpad, krijg jij:

  • toegang tot trainingen, livelabs en examens over de rollen van Developer, Database Developer, Full Stack Developer en Software Architect. Daarnaast krijg je toegang tot nog veel meer trainingen, proefexamens, bootcamps, e-books enzovoort.
  • begeleiding van ons Learning & Development team, samen met jou stellen we doelen, maken we een planning en monitoren we je voortgang.
  • mentor asset in diverse trainingen.

Dit ontwikkelpad is ideaal om jouw STAP budget voor in te zetten!

Developer

Je gaat van start met trainingen die jou voorbereiden op de rol van Developer. De nadruk ligt vooral op geavanceerde datastructuren en algoritmen, multithreading en concurrency in Java.

Database Developer

Vervolgens ontdek je welke kennis en vaardigheden je nodig hebt als Database Developer. Hierbij ligt de focus op Java database connectiviteit met behulp van JDBC en Java Persistence API (JPA) met hibernate.

Full Stack Developer

Daarna verdiep je je in de rol van Full Stack Developer via online trainingen, een lab en een examen. Je ontdekt hoe je web applicaties met Spring MVC en microservices met Spring Boot kan bouwen.

Software Architect

Ten slotte verken je de rol van Software Architect. De nadruk ligt in dit onderdeel vooral op het werken met de Redis In-memory data store. Dit is een populaire tool onder softwareontwikkelaars voor het leveren van betere prestaties aan eindgebruikers, dankzij het gebruiksgemak, de uitgebreide functieset en de open-source status. Je sluit dit onderdeel af met lab en een examen

Resultaat

Na het doorlopen van dit ontwikkelpad heb jij voldoende handvatten om aan de slag te gaan als Software Architect. Je deed de volgende kennis en vaardigheden op:

  • Kennis van geavanceerde datastructuren en algoritmen in Java.
  • Implementeren van multithreading en concurrency in Java.
  • Kennis van Java database connectiviteit (JDBC).
  • Gebruik van Java Persistence API en hibernate.
  • Bouwen van web applicaties met Spring MVC en microservices met Spring Boot.
  • Gebruik van de Redis In-memory data store.

Voorkennis

Je beschikt over basiskennis van programmeren en idealiter heb je ervaring met programmeren met Java.

Doelgroep

Softwareontwikkelaar, Webontwikkelaar

Inhoud

Ontwikkel je van Developer naar Software Architect

78 uur

Advanced Data Structures & Algorithms in Java: Working With Binary Trees

A solid understanding of data structures and algorithms is fundamental to writing clean, performant, fast, and robust programs without relying on scarce resources. To capitalize on this, Software Engineers need to recognize the core concepts of basic data structures, their characteristics, and the algorithms behind them.

In this course, you'll identify the basic structure and representation of a binary tree and tree traversal algorithms. You'll learn how binary trees are essentially nodes that have references to their left and right children. You'll explore how nodes of a binary tree can be traversed using depth-first traversal and breadth-first traversal. Finally, you'll recognize the three flavors that exist for depth-first traversal: pre-order, post-order, and in-order traversal.

Advanced Data Structures & Algorithms in Java: Solving Binary Tree Problems

Binary trees are commonly used data structures in programming interviews. It's essential you know how to solve binary tree problems such as counting the number of nodes in a tree, finding the maximum depth of a tree, and mirroring a binary tree using robust, recursive solutions.

In this course, you'll solve some common interview-style problems using binary trees, such as how to use a recursive algorithm to count the number of nodes in a binary tree, calculate the maximum depth of a tree, sum up the values of nodes along a path, and mirror a binary tree. Finally, you'll explore different kinds of binary trees, namely the full binary tree, the complete binary tree, the perfect binary tree, and the balanced binary tree.

Advanced Data Structures & Algorithms in Java: Working with Binary Search Trees

A binary search tree is a unique data structure that allows for highly performant insert and lookup operations because, for every value stored in the tree, there is precisely one position where that value can exist. Knowing how to work with this data structure is an essential tool for your software engineering toolkit.

In this course, you'll explore the various operations that you can perform on a binary search tree. You'll recognize how the binary search tree works for efficient insert and lookup operations and how to implement the code for these operations.

You'll move on to identify the constraints on the nodes of a binary search tree data structure. Finally, you will learn how to write code for various problems that involve binary search trees.

Advanced Data Structures & Algorithms in Java: Sorting & Searching Algorithms

Data structures and algorithms are vital tools in writing robust and performant code. Being trained in the proper use of these tools is the responsibility of all Software Engineers. Using these tools correctly involves recognizing which algorithms to use for which scenarios.

In this course, you'll identify and implement several algorithms to sort data stored in a list. You'll explore the various trade-offs made with sorting algorithms in terms of time and space complexity. You'll recognize the nitty-gritty details of sorting algorithms such as selection sort, bubble sort, insertion sort, and divide and conquer algorithms like merge sort and quick sort.

Finally, you'll learn to use searching algorithms that allow you to quickly look elements up in a sorted list such as binary search, jump search, and interpolation search.

Advanced Data Structures & Algorithms in Java: Working with the Binary Heap

The binary heap, the data structure used to implement a priority queue, is an interesting data structure. Recognizing how best to work with the binary heap is part of creating sturdy and fast software programs.

In this course, you'll explore the binary heap data structure used to implement a priority queue in a performant and efficient manner. You'll recognize how the binary heap is essentially a binary tree that satisfies two additional constraints: the heap property and the shape property.

You'll examine how the binary heap can be represented using an array and how it allows us to implement add, remove, and access operations on a priority queue in an extremely high-performing manner. Finally, you'll learn how the binary heap helps us implement an efficient sort algorithm: the heap sort.

Advanced Data Structures & Algorithms in Java: Working with Graph Algorithms

To effectively work with graphs in your daily software engineering operations, you need to expand your knowledge beyond a basic familiarity. To do this, you need to identify which algorithms are used for which tasks and how to implement these algorithms using the Java programming language.

In this course, you'll identify how graph nodes can be sorted using the topological sort algorithm, which has many real-life applications, such as course scheduling, as well as modeling tasks and dependencies. Next, you'll explore shortest path algorithms, which are used in mapping applications.

You'll move on to identify and implement the shortest path in an unweighted graph. Finally, you'll implement Dijkstra's algorithm to find the shortest path in a weighted graph.

Advanced Data Structures & Algorithms in Java: Getting Started with Graphs

Graph data structures have numerous real-world applications. Recognizing what these applications are and how best to work with graphs in your day-to-day is a must-have skill for any Software Engineer.

In this course, you'll identify what is meant by a graph. You'll examine the typical, real-life applications of graphs and explore how they can be represented in programming languages.

You'll move on to define different types of graphs, such as directed and undirected graphs, connected graphs, trees, and weighted and unweighted graphs.

Next, you'll explore how to write code and perform operations on graphs. Finally, you'll implement graph representations in code using the adjacency matrix representation, the adjacency list, and adjacency set representation.

Multithreading & Concurrency in Java: Introduction to Concurrent Programming

  • Concurrent programming in Java allows you to run multiple

  • sequences of operations at the same time using a variety of objects
  • and mechanisms. In this course, you'll learn about concurrent
  • programming concepts such as threads and processes, including
  • working with multiple tasks, multithreading, and multiprocessing.
  • You'll explore race conditions and concurrency challenges and how
  • to achieve concurrent thread synchronization using locks. Next,
  • you'll look at how semaphores can be used and conditions that may
  • cause deadlocks. You'll examine Java objects that aid in working
  • with multithreaded application, using atomic operations, and the
  • benefits of using thread pools to manage multiple concurrently
  • executing threads. Finally, you'll learn use cases of the Futures
  • object and the Fork/Join framework in terms of executing multiple
  • threads.

Multithreading and Concurrency in Java: Spawning & Launching Threads

  • This is a hands-on course which introduces you to the

  • implementation of concurrency in a Java application. You will
  • become familiar with setting up, configuring and launching multiple
  • concurrent threads. You will implement the join() method to
  • synchronize threads and will explore a variety of thread features
  • including their states, transitions and how they can be
  • interrupted.

Multithreading and Concurrency in Java: Thread Synchronization & Locks

  • In this demo-only course you will cover the basics of

  • synchronization of threads in Java in order to prevent the
  • unpredictability of the race condition. You will get experience
  • with the implementation of synchronized functions and blocks, and
  • also the use of Java lock objects such as the ReentrantLock and
  • StampedLock.

Java Concurrency: Multithreading and Concurrency in Java: Concurrency & the Producer-Consumer Problem

  • The Producer-Consumer problem is a common issue to address when

  • we have concurrent producer and consumer threads working with a
  • bounded buffer. Solving this problem covers a variety of
  • synchronization mechanisms in Java, and this course covers the
  • implementation of synchronization blocks, locks, Condition objects,
  • and Java's built-in data structures.

Multithreading and Concurrency in Java: Objects for Concurrent Programming

  • Java includes a variety of objects and mechanisms to manage

  • concurrently executing threads working on shared resources. In this
  • course, you will get hands-on with a variety of Java objects and
  • mechanisms to manage concurrently executing threads working on
  • shared resources. You will get to implement semaphores, volatile,
  • and atomic variables and concurrent collections, while recognizing
  • their inidividual features and use cases.

Multithreading and Concurrency in Java: Scaling a Multithreaded Application

  • Creating and managing multiple concurrent threads manually can

  • be painstaking, but Java includes objects that make this much
  • simpler. This course will help you gain experience using objects
  • such as Java's ExecutorService and the Fork/Join framework that
  • make it easy to write scalable multithreaded applications. You will
  • get hands on with these objects and will recognize their use cases,
  • features and their limitations.

Final Exam: Developer

Final Exam: Developer will test your knowledge and application of the topics presented throughout the Developer track of the Skillsoft Aspire Developer to App Architect Journey.

JDBC: An Introduction to Java Database Connectivity

  • Before getting your hands dirty with Java Database Connectivity

  • (JDBC), it is important to recognize its purporse and the options
  • it has to offer - and this is exactly what this course provides. It
  • first lays a theoretical foundation in terms of the need for JDBC,
  • the various pieces which come together to let your app connect to a
  • database, as well as their features and use cases. You will cover
  • topics such as JDBC drivers, JDBC objects such as Statement ,
  • ResultSet, and RowSet, and then connect a Java app to a
  • database.

JDBC: Executing Statements

  • Java Database Connectivity (JDBC) offers a number of ways in

  • which SQL queries can be executed using a number of built-in
  • objects. This demo-based course covers the use of the fundamental
  • JDBC objects required to set up and manage database connections
  • from a Java app and to execute queries. You will cover the use of
  • Properties objects to load connection details, and then the use of
  • the Statement and PreparedStatement instances to run SELECT,
  • INSERT, DELETE and UPDATE queries against a database from a Java
  • app.

JDBC: Working with ResultSets & Query Batches

  • ResultSets allow SELECT query results to be processed

  • systematically in a Java app while executing INSERT and UPDATE
  • queries can be handled efficiently with query batches. This is very
  • much a hands-on course and gets into the nitty-gritty of processing
  • large volumes of data using JDBC. You will cover a lot of features
  • of the ResultSet object - from its navigability to its ability to
  • update data. You will also optimize updates by running them in a
  • batch, and cover the implementations of atomic transactions when
  • using JDBC.

JDBC: RowSet

  • The JDBC RowSet offers the same functionality as a ResultSet

  • with several useful additional features. This course involves a
  • number of demos covering different RowSet types. You will explore
  • the features of the JdbcRowSet which is a type of connected RowSet
  • and is similar to a ResultSet. You will then cover different
  • flavors of disconnected RowSets - from the CachedRowSet and the
  • WebRowSet to performing offline joins using the JoinRowSet and
  • filtering rows using the FilteredRowSet.

JDBC: Advanced Topics

  • When building Java apps which interact with a database, you may

  • need to work with stored procedures and also large binary objects.
  • The goal of this course is to give you hands-on experience with the
  • handling of binary and text data and working with stored
  • procedures. You will load image and text files from your file
  • system to a database using JDBC, and will then do the reverse
  • operations. You will also create and execute a variety of stored
  • procedures from a Java app.

Java Persistence API: Getting Started With JPA & Hibernate

JPA, or the Java Persistence API, is focused on persistence. Persistence can refer to any mechanism by which Java objects outlive the applications that created them. JPA is not a tool, or a framework, or an actual implementation.

In this course, you'll explore the basic ideas behind object-relational mapping, where entities and relationships expressed in an object-oriented framework are mapped to records and tables in a relational database.

You'll examine the basic features of the JPA and Hibernate frameworks. You'll then practice how to get set up with the MySQL database, the MySQL Workbench, and Apache Maven to manage dependencies in your Java application.

Java Persistence API: Configuring Fields & Performing CRUD Operations

In this course, you'll explore how primary keys can be set up for the tables underlying your entities and how you can manage the configuration of individual columns in your database columns using JPA annotations. You'll learn how to perform create, read, update, and delete operations using the JPA entity manager.

Once you're done with this course, you'll be able to structure your entities and their attributes based exactly on your specifications and perform basic storage and retrieval operations using JPA and Hibernate.

Java Persistence API: Mapping & Configuring Relationships

In this course, you'll explore the various kinds of relationships that you might want to express using JPA annotations and how these relationships map to relational table design. You'll examine unidirectional as well as bidirectional one-to-one, one-to-many, many-to-one, and many-to-many relationships.

Once you're done with this course, you'll be able to model and express real-world relationships between your entities using JPA annotations. Finally, you'll learn how to finely manipulate how you want these relationships configured using underlying database tables.

Java Persistence API: Embedding Collections & Managing Cascade Operations

In this course, you'll explore how nested collections within an outer entity can be mapped using JPA. You'll implement mappings for collections of primitive types, embeddable objects, and collections of entities. You'll examine how JPA and Hibernate handle list, set, and map collections.

Next, you'll relate how specific operations such as entity persistence, update, and removal can be cascaded from parent entities to child entities and illustrate how inheritance relationships in your code can be mapped to database tables.

Once you're done with this course, you'll be able to use nested collections within your entities and also map inheritance relationships in your code to meaningful representations using tables.

Java Persistence API: Executing Queries & Managing the Entity Lifecycle

In this course, you'll explore a variety of ways to execute queries using JPA. You'll run native queries, queries using JPQL, and queries using the Criteria API, which helps avoid syntax errors in your query specification.

Next, you'll examine how you can have entity-specific callback methods that can be invoked at different stages in the entity's lifecycle. When you are done with this course, you'll be able to perform complex queries on your database tables and manage your entity's lifecycle in a very granular manner.

Database Developer

  • Perform Database Developer tasks such as inserting records to a table, formating records for display and adding the JDBC's RowSet class. Then, configure Eclipse to build with Maven, examine update modes, build tables with Entity class and combine JDBC functionality to build collections.
  • This lab provides access to tools typically used by Database Developers, including:
  • - MySQL 5.7
  • - MySQL 8.0.23
  • - Mysql-connector-java-8.0.22
  • - MySQl Workbench 6.3
  • - MySQL Workbench 8
  • This lab is part of the Database Developer track of the Skillsoft Aspire Developer to Softwart Architect journey.

Final Exam: Database Developer

Final Exam: Database Developer will test your knowledge and application of the topics presented throughout the Database Developer track of the Skillsoft Aspire Developer to App Architect Journey.

The Spring Web MVC Framework: Getting Started

"The Spring MVC framework helps build web applications robustly and intuitively using the model-view-controller design pattern. Working with this framework helps produce flexible, loosely-coupled, three-tiered architecture web applications.

In this course, you'll explore the Spring framework and the basic design principle of inversion of control, which is achieved in Spring using dependency injection. You'll also examine the model-view-controller design pattern, identifying the core components, interactions, technologies, and architectural elements that comprise Spring MVC. You'll discuss the range of modules that Spring offers for data access, web applications, messaging, and security. Next, you'll work with Maven web apps on Eclipse and Tomcat and Spring MVC apps using Eclipse and XML. Finally, you'll learn how to configure view resolvers for logical view names and Spring beans using annotations."

The Spring Web MVC Framework: Handling Requests & Errors

"The Spring MVC web framework is a Java framework that includes all the standard features of a core Spring framework but utilizes the model-view-controller design pattern. Working with this framework, you can produce robust, flexible, loosely-coupled, three-tiered web applications.

In this course, you'll explore the basic tiers in a Spring MVC application. You'll configure applications with multiple controllers, multiple views, and simulate the classic 3-tier structure of a web application. You'll also learn how to deal with request parameters, dynamic URL paths, and exceptions thrown in your application.

Some of the tasks you will complete in this course include deploying WAR files, configuring multiple pages and controllers in your app, designing tiers and separating them into different packages, and extracting, accessing, injecting, and configuring request parameters."

The Spring Web MVC Framework: Working With Forms & Files

  • The Spring MVC web framework incorporates all the standard Java

  • features of a core Spring framework, including the ability to work
  • with form elements in JSTL. In this course, you'll explore how you
  • can set up form elements in your web user interface using JSTL
  • tags. Next, you'll learn how to configure the validation of your
  • form fields using built-in validator annotations. Finally, you'll
  • learn how to upload files to your application using various methods
  • along with how to download files from your application.

The Spring Web MVC Framework: Building Web Applications & REST APIs

The Spring MVC framework helps build web applications robustly and intuitively using the model-view-controller design pattern, while also incorporating all the standard Java features of a core Spring framework. Working with this framework helps produce flexible, loosely-coupled, three-tiered architecture web applications.

In this course, you'll use several features of this framework, combining their use to build a simple web application. You'll learn how to connect this web application to a MySQL server database, which will be used to store your data. Next, you'll use JDBC templates to query this database and then set up login and register pages on your app. Finally, you'll perform create, read, update, and delete operations using Spring MVC.

Spring Boot Microservices: Getting Started

Setting up a new Spring Boot application is simple, and with the use of starter templates, the parent POM, and auto-configurations, running a Spring Boot application is also easy. In this course, you'll explore the Spring Boot framework and features of Spring Boot and the basic design principle of inversion of control achieved in Spring using dependency injection.

Next, you'll learn how to run an embedded web server in a simple Spring Boot application, set up a new Spring Boot project using the Spring Initializr and Spring Tools Suite, and configure properties for your Spring Boot application.

Spring Boot Microservices: Asynchronous Methods, Schedulers, & Forms

Spring Boot has some exciting features to offer. It's not difficult to run asynchronous tasks using Spring Boot; all it needs are a few annotations to set up.

In this course, you'll learn how to configure your applications to run scheduled tasks at a fixed rate and fixed delay. You'll also set up forms using the Thymeleaf template engine and perform built-in validation on the form fields.

Next, you'll learn how to configure handler mappings in Spring MVC for request paths, extract request parameters and path variables, and run asynchronous and scheduled operations in Spring Boot. Finally, you'll learn how to perform validation of user-specified form inputs.

Spring Boot Microservices: Building RESTful API Services

Building a RESTful API service to perform create, read, update, and delete (CRUD) operations is an integral part of building microservices with Spring Boot.

In this course, you'll learn how to build a RESTful API service to perform CRUD operations. You'll use Advanced REST Client to test your API service, and wire up a MySQL database using JPA, Spring Data, and Hibernate. You'll then add a front end to your application using the Thymeleaf template engine.

Finally, you'll build RESTful microservices in Spring Boot, integrate with a relational database to store your data, set up a front end for your application, and add caching for common requests.

Spring Boot Microservices: Advanced Microservices & Securing Web Applications

Spring Boot microservices are capable of a plethora of functions, but like all web applications, these must be secured. In this course, you'll start by building Spring Boot microservices to configure your application to send emails. Then, you'll use interceptors to pre-process requests and responses to and from your application and integrate it with the Twilio platform to send text messages and make phone calls.

Next, you'll learn to integrate with external services, such as JavaMailSender and the Twilio platform, within your Spring Boot application. Lastly, you'll learn how to secure your application using in-memory users and users stored in a database using Spring Security.

Full Stack Developer

  • Perform Full Stack Developer tasks such as specifying application context programmatically and with an XML file, and adding paths and links for a RESTful app. Then, add and validate forms, and import classes using the Data Access layer.
  • This lab provides access to tools typically used by Journeyman Developers, including:
  • - Eclipse 4.17.0
  • - Apache Tomcat 9
  • This lab is part of the Full Stack Developer track of the Skillsoft Aspire Developer to Softwart Architect journey.

Final Exam: Full Stack Developer

Final Exam: Full Stack Developer will test your knowledge and application of the topics presented throughout the Full Stack Developer track of the Skillsoft Aspire Developer to Software Architect Journey.

The Redis In-memory Data Store: An Introduction to Redis

  • Redis is an in-memory, key-value store with many use cases. It

  • is a popular tool among software developers for delivering improved
  • performance to end-users due to its ease of use, rich feature set,
  • and open source status. In this course, you'll explore the various
  • use cases, features, and limitations of the Redis in-memory store.
  • You'll examine the different data types, structures, and client
  • connections supported in Redis. Next, you'll learn how to install
  • Redis and to set up an instance of the Redis server. You'll then
  • learn to carry out basic Redis operations involving string and
  • numeric data, such as create, read, update, and delete (CRUD)
  • operations and key expiration setting.

The Redis In-memory Data Store: Data Structures

  • Redis offers a variety of data structures and collections which

  • enable developers to deliver several types of high-performing
  • applications to end-users. In this course, you'll learn how to work
  • with Redis's different data structures, namely lists, hashes, and
  • sets. You'll then learn to perform various set operations, such as
  • union, intersection, and set difference. Next, you'll distinguish
  • sorted sets from regular sets and learn how to work with them.
  • You'll then examine the benefits and limitations of HyperLogLog
  • structures and how to use these in Redis. Upon completing this
  • course, you'll be able to compare and work with each of these
  • structures and recognize their use cases.

The Redis In-memory Data Store: Messaging & Streaming

  • Redis is primarily an in-memory, key-value store, but has many

  • additional use cases. In this course, you'll explore the use cases
  • of Redis that go beyond its use as a database or cache,
  • specifically its application in messaging and streaming. You'll
  • start by setting up communications between Redis clients using the
  • Publish/Subscribe paradigm and the Redis CLI. Next, you'll learn
  • how to set up Redis streams and retrieve data from them using the
  • XREAD command. Finally, you'll use the stream data structure in
  • Redis to record information and communicate messages to a group of
  • consumer processes.

The Redis In-memory Data Store: Working With Redis Clients

Once the primary functions of Redis are implemented, several advanced features can optimize processes further and enable you to work with Python apps. In this course, you'll explore some of these advanced features and how they apply to pipelines, transactions, and locks. You'll learn how to work with these features using both the Redis CLI and Python clients. You'll start by learning how to use both Pub/Sub and pipelines in a Python app with a Redis client. You'll then learn how to define and execute transactions in Redis and use the watch feature.

You'll move on to learn how to apply optimizations using features and techniques, such as the pipe mode feature and server-assisted client-side caching. Finally, you'll learn how to use Redis keys and locks to synchronize access to shared Redis resources.

The Redis In-memory Data Store: Administering a Redis Server

Once a Redis server is in place, there are several essential tasks involved in managing it. In this course, you'll explore how to carry out some of these critical tasks, namely assigning user permissions, establishing replacement servers, and setting cache replacement policies.

You'll start by learning how to use ACL commands to set user permissions for new users and continue to assign permissions using ACL categories. Next, you'll learn how to duplicate a copy of a Redis server, before setting up a replica of your server and establishing a master-slave relationship between the server and its replica. Finally, you'll learn how to set up a Redis server to function as a cache by applying the least-recently-used (LRU) or least-frequently-used (LFU) cache replacement policies.

Software Architect

  • Perform Software Architect tasks such as seting up your Redis environment and building and using lists, hash lists, and ordered lists. Then work with multiple Redis databases and Redis streams, and manipulate Redis from Python.
  • - Eclipse 4.17.0
  • - Apache Tomcat 9
  • - Redis Server 4.0.0
  • This lab is part of the Software Architect track of the Skillsoft Aspire Developer to Software Architect journey.

Final Exam: Software Architect

Final Exam: Software Architect will test your knowledge and application of the topics presented throughout the Software Architect track of the Skillsoft Aspire Developer to Software Architect Journey.

Opties bij cursus

Wij bieden, naast de training, in sommige gevallen ook diverse extra leermiddelen aan. Wanneer u zich gaat voorbereiden op een officieel examen dan raden wij aan om ook de extra leermiddelen te gebruiken die beschikbaar zijn bij deze training. Het kan voorkomen dat bij sommige cursussen alleen een examentraining en/of LiveLab beschikbaar is.

Examentraining (proefexamens)

In aanvulling op deze training kunt u een speciale examentraining aanschaffen. De examentraining bevat verschillende proefexamens die het echte examen dicht benaderen. Zowel qua vorm als qua inhoud. Dit is de ultieme manier om te testen of u klaar bent voor het examen. 

LiveLab

Als extra mogelijkheid bij deze training kunt u een LiveLab toevoegen. U voert de opdrachten uit op de echte hardware en/of software die van toepassing zijn op uw Lab. De LiveLabs worden volledig door ons gehost in de cloud. U heeft zelf dus alleen een browser nodig om gebruik te maken van de LiveLabs. In de LiveLab omgeving vindt u de opdrachten waarmee u direct kunt starten. De labomgevingen bestaan uit complete netwerken met bijvoorbeeld clients, servers, routers etc. Dit is de ultieme manier om uitgebreide praktijkervaring op te doen.

Waarom Icttrainingen.nl?

Via ons opleidingsconcept bespaar je tot 80% op trainingen

Start met leren wanneer je wilt. Je bepaalt zelf het gewenste tempo

Spar met medecursisten en profileer je als autoriteit in je vakgebied.

Ontvang na succesvolle afronding van je cursus het certificaat van deelname van Icttrainingen.nl

Krijg inzicht in uitgebreide voortgangsinformatie van jezelf of je medewerkers

Kennis opdoen met interactieve e-learning en uitgebreide praktijkopdrachten door gecertificeerde docenten

Bestelproces

Zodra wij uw order en betaling hebben verwerkt, zetten wij uw trainingen klaar en kunt u aan de slag. Heeft u toch nog vragen over ons orderproces kunt u onderstaande button raadplegen.

lees meer over het orderproces

hoe werkt aanvragen met STAP

Wat is inbegrepen?

Certificaat van deelname ja
Voortgangsbewaking ja
Award Winning E-learning ja
Geschikt voor mobiel ja
Kennis delen Onbeperkte toegang tot onze community met IT professionals
Studieadvies Onze consultants zijn beschikbaar om je te voorzien van studieadvies
Studiemateriaal Gecertificeerde docenten met uitgebreide kennis over de onderwerpen
Service Service via chat, telefoon, e-mail (razendsnel)

Platform

Na bestelling van je training krijg je toegang tot ons innovatieve leerplatform. Hier vind je al je gekochte (of gevolgde) trainingen, kan je eventueel cursisten aanmaken en krijg je toegang tot uitgebreide voortgangsinformatie.

Life Long Learning

Meerdere cursussen volgen? Misschien is ons Life Long Learning concept wel wat voor u

lees meer

Neem contact op

Studieadvies nodig? Neem contact op!


Contact