Roadmap - Senior Java Developer 2024
Tags: java, roadmap, programming, careerdevelopment
Published: 2023-12-29 15:14:43

The role of a Senior Java Developer has witnessed significant changes over the past years. As technology continues to advance at an unprecedented pace, the responsibilities, skills, and expectations of a Senior engineers have evolved to keep up with the demands of the industry. 

For a Junior or Middle Developer it is often hard to say what steps should be taken to become a Senior. I've spent several days, gathering all the skills one would expect from a Senior Java Developer.

[Interactive roadmap of Senior Java Developer 2024](https://infinite.education/skillset/YEmtMEu3IxSHubbpupfzT6O5)

1. **General IT knowledge** - Senior developer must have a great understanding not only of Java and Spring framework, but also of all the IT landscape: typical design patterns, data transfer protocols, data encoding formats, message brokers, monitoring tools etc. This also includes basic alogrithms, computer knowledge and even math
2. **Core Java** - you expect nothing less than a great understanding of all core features of Java. Not only when to use this or that feature, but also when NOT to use it :)
3. **Java Frameworks and Libraries** - there are lots of different libraries, but I've selected a couple that are de facto industry leaders: Spring Boot, Hibernate, JUnit etc
4. **How JVM works** - knowing programming language is not sufficient for a senior developer. Understanding the principles how a program translates into a computer commands opens a rich set of opportunities for an engineer
5. **How the Internet works** - I would say, 99% of java backend works in internet/intranet environment. No experienced developer could ignore at least basics of internet organization.
6. **Teamwork** - well, it is a "nice-to-have" skills. But let's say frankly - soft skills frequently matters much more that hard skills. Junior developers, please, do never neglect those
7. **User Interface Disign Patterns** - optional skills, but they could become very handy when working in integration with any kind of UI (web site, mobile application etc)

Please give me a feedback what skills you beleive I have missed to include?

```
General IT knowledge
	Application maintenance
		Logging
			Async vs sync logging
			What information must be included into logging message
			ELK
		Application Monitoring
			Health check probes
		Crash dump analysis
		Tracing based on service-mesh
		Application Design Patterns
			Monolithic architecture
				Pros and cons of monolithic architecture vs mircoservices
			Event-driven Architecture
			Microservices Architecture
				Service mesh
				Service registry
				Transactional outbox
				Remote procedure invocation
				Messaging pattern
				Circuit Breaker
				Saga pattern
	How OSs work in General
		How random access memory works
		Understanding process concept
		Understanding thread concept
		Understand stack memory concept
		File System
		Linux basic commands
			Linux command: grep
			Linux command: ls
			Linux command: tail
			Linux command: cat
			Linux command: chmod
	Working with data
		Data Formats
			Fixed-length format
			Protocol Buffers
			JSON
			Yaml
			Binary Serialization
			Xml
			CSV
		Web Services
			Authentication
				OpenID
				SAML
				JWT
				OAuth 2.0
			Internet Protocols
				REST
				SOAP
				FTP
		Databases
			Relational Databases
				PostgreSQL
				SQL migrations
				MySQL
				Oracle
				SQL commands: INSERT, UPDATE, DELETE, SELECT
				Using Inner Joins
				User Left Joins
				Sequence
				Stored Procedure
				Understanding SQL plan
				Single-Column Index
					Multi-column Index
					Understanding index direction
					Primary Index
					Cluster index
				Database partitioning
				Auto-increment values
				SQL Transactions
					Transaction Isolation levels
				Aggregate Functions
			Database Normalization
			Database replication
			Database Sharding
			NoSQL Databases
			Column-oriented databases
	Math for Programmers
		Set Theory
		Category theory
		Algebra
			Predicate
			Commutativity
			Distributivity
			Associativity
		Mathematical Logic
		Geometry
			Cartesian Coordinate System
	Application lifecycle
		Version Control Systems
			Git
				Git commit
					Git tagging
					Git stash
					Git stage
				Gitflow
				Git Branching
					Git merge
						Git rebase
						Git squash
				Remote vs local repository
					Git fetch
					Git push
					Git pull
				.gitignore
				Git limitations
		Java build systems
			Maven
			Gradle
			Package dependency
				Dependency scope
			Package managers
				Nexus
			Java application versioning
		Containers
			Docker
				Docker Installation and Setup
				Docker Images
				Docker Containers
				Container Networking
				Docker volumes
				Docker compose
				Docker registry
				Docker container orchestration
				Docker Security
				Docker Monitoring and Logging
			Kubernetes
				Cluster Setup and Configuration
				Containerization
				Pod Management
				Deployment
				Scaling
				Service and networking
				Persistent Storage
				Monitoring and Logging
				Security and Access Control
				Troubleshooting and Debugging
				Cluster Maintenance and Upgrades
			OpenShift
	Code Quality
		SOLID
		Code testing
			Unit Testing
			Functional Testing
			Integration Testing
			Performance Testing
		DRY
		Application maintainability principles
		KISS
	Algorithms
		Binary Search
		Depth-first search algorithm
		Breadth-first algorithm
		Comparison metrics
			Time complexity notations
			Worst time complexity
			Average time complexity
			Memory consumption of algorithm
			Stable sorting
		Quicksort
		Heapsort
		Counting sort
Core Java
	Java syntax
		Keywords
		Control Flow
		Arrays
		Packages and Imports
		Java I/O
		Strings and Regular Expressions
		Object-oriented programming
			Interfaces vs abstract classes
		Exceptions
			Runtime handing of exceptions
			Fatal errors
		Identifiers
		Literals
		Operators
		Types
			Generic types
				Type erasure
				Wildcards in generics
				Heap pollution
			Primitive types
				Boxing and unboxing
				Math number vs programming numbers
					Number overflow
					Number precision
					Decimal vs double
					Errors when working with floating numbers
					Rounding of floating numbers
						Fair rounding problem
					Primitive type memory size
			Reference types
				Anonymous classes
			Raw types
			Casting conversion
				Widening primitive conversion
				Widening and narrowing primitive conve
				Narrowing primitive conversion
				Boxing conversion
				Unboxing conversion
				Widening Reference Conversion
				Narrowing Reference Conversion
		Variables
			final variables
				Understanding the restrictions on using final variables in lambda expressions
				Capturing final variables in lambda expressions
				Optimizations achieved through final variables by the Java compiler
				Using final variables in performance-critical code sections
				Thread safety of final variables
			Variable Naming Conventions
			Variable Memory and Stack/Heap Allocation
				Understanding the memory allocation for variables in the stack and heap
				Knowing the difference between stack-based and heap-based variables
				Managing memory usage and avoiding memory leaks
	Java collections
		List
			ArrayList
			LinkedList
		Queue
			BlockingQueue
			PriorityQueue
			ArrayDeque
		Set
			EnumSet
			HashSet
		Map
			HashMap
			WeakHashMap
			ConcurrentHashMap
			TreeMap
		Array
		Common pitfalls with collections
			How to evade ConcurrentModificationException
			Correct Equals and HashCode implementation
			Adding mutable object to hash-based collection
		Streams
			Performance of streams vs collections
			Lazy evaluation in Streams
	Concurrency
		Understanding what is Process
		Understanding what is Thread
			What happens when thread sleeps
				What is thread interrup
					Interrupt status flag
			What is thread stack
			ThreadLocal variables
		Memory Model
			Happens-before principle
			Atomicity
			Race condition
			Update visibility
			Operations re-ordering
			volatile keyword
			Immutable objects
		Synchronization Patterns
			Understanding the monitor locking
			Synchronized keyword
			Lock
				ReadWriteLock
				ReentrantLock
			Condition interface
			Reentrancy
		Common multhi-thread problems
			Deadlock
			Livelock
			Starvation
		Executors
			ThreadPool
			ForkJoinPool
Java Frameworks and Libraries
	Spring Boot
		Spring Data JPA
		Application properties
			Application profile
		Bean
			Bean lifecycle
			InitializingBean
		Common spring annotations
			@Prototype
			@Configuration
			@ConfigurationProperties
			@Autowire
			@Service
			@Component
			@Transaction
	Apache Commons
	Log4j
	Mockito
	JUnit
	Apache Tomcat
	Java ORMs
		Hibernate
		MyBatis
		Jooq
How JVM works
	Java memory organization
		Heap memory
			Memory Analysis and Profiling
			Memory optimization technics
				Memory optimization: object reuse
				Memory optimization: minimize object creation
				Memory optimization: usage of local variables
				Memory optimization: do not concatenate strings in loops
				Memory optimization: weak references
				Memory optimization: proper resource disposal
			JVM flags to control heap memory sizes
			Structure of JVM heap memory
				Eden Space
				Survivor Spaces
				Tenured Generation
				Permanent Generation
		Method Area
		Stack memory
			Understanding Stack pointer
			Understanding Stack Frame
			Understanding Stack size
			Usage of stack during method invocation
			Usage of stack and recursive calls
				Tail chain optimization
		Garbage collection
			Object reference
				WeakReference
			Memory leak detection
			Object finalization
			Tuning garbage collection
			GC root
			Mark and sweep algorithm
	Class loaders
		Class Loader Hierachy
		Custom Class Loading
		Class Loading Policies
		Class Loader Isolation
		Dynamic Class Loading
	Execution engine
		JIT compiler
			Intermediate Code Generator
			Code Optimizer
				Dead code elimination
				Constant folding and propagation
				Method inlining
				Escape analysis
			Target Code Generator
			JIT profiler
		Interpreter
	Native Method Interface
	Common JVM errors
		ClassNotFoundExcecption
		NoClassDefFoundError
		OutOfMemoryError
		StackOverflowError
How the Internet works
	Transport protocols
		TCP / IP model
			IP Address
			Network port
				Local port
				Remote port
			MAC Address
			Network route
		Proxy mechanism
			Reverse proxy
			Forward proxy
		DNS
			DNS resolve mechanism
			DNS alias
	Basics of HTML
	Browsers
		Browser Caching
		URL
		Request compression
		Understanding the Cookie
	Application protocols
		HTTP protocol
			GET request
			POST request
			PUT request
			HEAD request
			DELETE request
			HTTP header
				Application content header
				Cookie
			Timeout limitation
			Resource usage
			Athentication mechanisms
				Basic Authentication
				Token Authentication
			Long polling
			HTTPS protocol
				SSL/TLS
				Digital signature
				Certificate chain
				mTLS
			SSE
		GraphQL
		WebSockets
		HTTP/2 protocol
	Internet Security
		Same-origin security policy
		Cross-origin resource sharing (CORS)
		Web Application Security Threats
			Arbitrary file inclusion
			Cross-site request forgery
			Cross-site scripting
			Path disclosure
			SQL Injection
			Denial-of-service atack
Teamwork
	Collaboration
	Conflict resolution
	Persuading
	Coordinating
	Creative Thinking
	Active listening
	Responsibility
	Communication skills
	Goal Setting
	Honesty
	Give Feedback
	Empathy
User Interface Disign Patterns
	Model-View-View-Model
	Model-View-Presenter
	Model-View-Controller
```