Developer to Software Architect - Part 1 Developer

$398.09 incl. vat


duration: 30 hours |

Language: English (US) |

access duration: 365 days |

In Onbeperkt Leren


In the Developer to Software Architect learning path, you will explore the roles of developer, database developer, full stack developer and software architect. You'll explore programming languages, frameworks, and tools such as Java, Spring Web MVC, JDBC, and Redis.

This is the first part of the Developer to Software Architect learning path. This part focuses on the role of Developer.

The main focus is on advanced data structures and algorithms, multithreading and concurrency in Java.

In this part of the learning path you will find several training courses that prepare you to start working as a Developer.


When you have completed the first part of the learning path, you will have sufficient tools to start working as a Developer. You have knowledge of advanced data structures and algorithms in Java. You can also implement multithreading and concurrency in Java. Finally, you are ready to start with part 2 of this learning path.


You have experience programming with Java.

Target audience

Software Developer, Web Developer


Developer to Software Architect - Part 1 Developer

30 hours

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.

Course options

We offer several optional training products to enhance your learning experience. If you are planning to use our training course in preperation for an official exam then whe highly recommend using these optional training products to ensure an optimal learning experience. Sometimes there is only a practice exam or/and practice lab available.

Optional practice exam (trial exam)

To supplement this training course you may add a special practice exam. This practice exam comprises a number of trial exams which are very similar to the real exam, both in terms of form and content. This is the ultimate way to test whether you are ready for the exam. 

Optional practice lab

To supplement this training course you may add a special practice lab. You perform the tasks on real hardware and/or software applicable to your Lab. The labs are fully hosted in our cloud. The only thing you need to use our practice labs is a web browser. In the LiveLab environment you will find exercises which you can start immediatelyThe lab enviromentconsist of complete networks containing for example, clients, servers,etc. This is the ultimate way to gain extensive hands-on experience. 


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 officiële certificaat van deelname van

Krijg inzicht in uitgebreide voortgangsinformatie van jezelf of je medewerkers

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


Once we have processed your order and payment, we will give you access to your courses. If you still have any questions about our ordering process, please refer to the button below.

read more about the order process

What is included?

Certificate of participation Yes
Monitor Progress Yes
Award Winning E-learning Yes
Mobile ready Yes
Sharing knowledge Unlimited access to our IT professionals community
Study advice Our consultants are here for you to advice about your study career and options
Study materials Certified teachers with in depth knowledge about the subject.
Service World's best service


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

Follow multiple courses? Read more about our Life Long Learning concept

read more

Contact us

Need training advise? Contact us!