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
- 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
- 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 :)
- 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
- 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
- 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.
- 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
- 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
Top comments (15)
For me, the most "senior" thing you need to do, is to change mindset from "I don't know" to "I don't know YET". Then most of the things will come eventually.
Also it is important to understand, that seniority doesn't mean to learn a lot of things fast (and thus rather briefly), but mostly comes with experience (meanwhile you will learn a lot of new things).
One skill I find much more important that for example deep understanding to JVM or knowing dozes of frameworks - business analysis. Or at least part of it. To be able to transform the requirements into solutions. And be able to think about it, uncover blind spots in the design, forsee the edge cases, propose solutions and communicate them with team and sooner or later also with the customer himself. I believe this differs (senior) software engineers from mere coders. In the emerging world of AI being good at this seems more important than ever.
Fully agree about "YET" part :) It is especially visible in situtation: "I cannot do it" vs "I cannot do it YET"
Thanks for this very detailed list.
I just want to that say learning Scala or even Kotlin can be a great way to understand the new features that are being incorporated in the latest Java versions. Myself, I didn't understand functional interfaces (Function, BiFunction, Predicate and the others) completely until I learned Scala, even though I don't use Scala at work. Other examples: pattern matching or sealed classes have been in Scala since the very beginning.
Avoid mutability as much as possible leads to much more maintainable programs.
The vavr library allows ro write Java as if it was Scala.
Yes, knowing functional languages is definetely a huge step forward for any programmer. But when we are talking about widely spread enterprise Java developers, their code based is often written on java (sometimes even older than 1.8). Large companies (especially those whose main business not IT) are histent to add Kotlin to their stack, since starting from that point they would need to hire more expensive programmers, knowing both Kotlin and Java
If you need to stay in Java, you can use libraries like Lombok, Immutable, vavr or Guava. Guava should be a must, in my opinion. Specially if you still have to use Java 8.
I like the tree of topics, however, I find the word "Senior" as very subjective in the industry nowadays.
Nevertheless, I have been looking for something like this tree of concepts for a long time.
Thank you
Well, yes, seniority highly depends on the particular work place. But in general, I'd like to believe that Senior is someone who could not only execute tasks and set goals on development of hte current project in technical direction. Decide which technologies should be used, how to do features and so on. One cannot make such decisions without having enough outlook
I like it. Cool
Thank you!
Thanks for the enlightening the key features.
Thank you!
Модель was in Russian on the list
The same as геометрия
Ops, exported from platform, which has translations for some skills. My bad, fixed.
where is message broker and cache?(kafka, redis)