Final Exam: Developer

Intermediate
  • 1 Video | 30m 32s
  • Includes Assessment
  • Earns a Badge
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.

WHAT YOU WILL LEARN

  • calculate the maximum depth of a binary tree
    compare the graceful and immediate shutdown of an ExecutorService instance
    contrast the algorithms for shortest path in unweighted and weighted graphs
    create a task to be executed within a Java thread by implementing the Runnable interface
    define a producer task that can run concurrently with a consumer using a shared queue
    define a task to be executed within a Java thread by implementing the Runnable interface
    define the adjacency list representation of a graph
    define the insertion sort algorithms
    define the quick sort algorithm
    define the structure and components of a graph
    describe a multi-threaded approach to tackling multiple tasks
    describe how a binary heap data structure functions
    describe how a graph can be represented as an adjacency matrix
    describe how an ExecutorService instance can be shut down while still allowing submitted tasks to run
    describe how lookup works in a binary search tree
    describe the binary search algorithm
    describe the original binary tree and its mirror
    describe the selection sort algorithm
    distinguish between the graceful and immediate shutdown of an ExecutorService instance
    enable atomic operations on integer variables using an AtomicInteger object
    explain depth-first, in-order traversal in a binary tree
    explain depth-first, post-order traversal in a binary tree
    explain depth-first, pre-order traversal in a binary tree
    explain how insertion works in a binary search tree
    explain the array implementation of a binary heap
    explain the bubble sort algorithm
    explain the common operations to be performed on a priority queue
    explain the shortest path algorithm for unweighted graphs
    explain weighted graphs and their use cases
    explain what is meant by the topological sorting of graph nodes
  • identify a sequential execution plan as well as its limitations
    identify the behavior of producer and consumer threads when working with a shared bounded buffer
    identify use cases for semaphores and describe how they can be used
    identify when the shortest path to a node needs to be updated
    implement semaphores in a multi-threaded Java application where each thread is treated equally
    implement the mirroring of a binary tree
    introduce a ReentrantLock in your program to enable exclusive access to a shared resource
    perform operations on an adjacency matrix graph
    recall the conditions under which concurrent threads could encounter a deadlock in Java
    recognize directed and undirected graphs and their use cases
    recognize how the maximum depth of a binary tree is calculated
    recognize how the recursive algorithm to count nodes works
    recognize how to insert and to remove works on a binary heap
    recognize the behavior of producer and consumer threads when working with a shared bounded buffer
    recognize the characteristics of binary trees
    recognize the conditions under which concurrent threads may become deadlocked and how this can be prevented
    recognize the effect of the start() method in kicking off Java threads
    recognize the effects of updates to shared variables in a multi-threaded Java applications
    recognize the options available to monitor the execution of a task using a Future object
    recognize the situations where a race condition could occur in Java
    recognize the trade-offs involved in choosing sorting algorithms
    summarize breadth-first traversal in a binary tree
    summarize depth-first traversal in a binary tree
    summarize the heapify operation on a binary heap
    use semaphores in a multi-threaded Java application where different threads require varying levels of permits to access a shared resource
    use the join() method to synchronize one thread with the execution of another
    use the tryLock() method of a ReentrantLock to prevent a potentially long wait for a resource
    write code to implement bubble sort
    write code to implement insertion sort
    write code to implement the count nodes algorithm

IN THIS COURSE

  • Playable
    1. 
    Developer
    33s
    UP NEXT

EARN A DIGITAL BADGE WHEN YOU COMPLETE THIS COURSE

Skillsoft is providing you the opportunity to earn a digital badge upon successful completion of this course, which can be shared on any social network or business platform

Digital badges are yours to keep, forever.

YOU MIGHT ALSO LIKE

Likes 4 Likes 4  
Likes 0 Likes 0  
Likes 0 Likes 0