What a senior back-end developer should know in 2016

I've been developing software for a decade now and quite often feel overwhelmed by the sheer amount of must-know-s someone needs to possess by common consent to earn the right to be called a professional. I think almost everyone can fail an interview if being asked the wrong questions, regardless of experience. 

I've spent half an hour assembling the following lists. I'm too lazy to elaborate the items here (mostly I just mention some related keywords) or structure them properly, but I think the gist comes through. The items also highly vary in importance and required level of depth. Of course it depends on your field, mine is the Enterprise Java (lately Scala) world. E.g. I've never needed to implement a binary tree in my career, but subjectively consider it somewhat "important". I also simply drop in DDD, but it takes years to master (as opposed to getting sufficiently familiar with HTTP). 

So, here we go

• Knowing at least one language inside-out
• Good software development principles:
• separation of concerns, polymorphism, SOLID principles, encapsulation, loose coupling, high cohesion
• understanding the concept of good quality code and the capacity to produce it - very vague definition, yet the most important. It has nothing to do with frameworks/technologies/most of the things listed below
• OO fundamentals. Design patterns, SOLID principles
• FP fundamentals - it's just getting into the mainstream, but hopefully sooner or later will be ubiquitous
• Algorithms and data structures ( graph theory, O(n), binary trees, tail recursion, ...)
• Concurrency, thread safety, parallel computation. Deadlock, livelock, threads, thread-pools, locks, synchronization primitives, CSP, Actor model, Dataflow (Functional Reactive Programming)
• JVM memory model
• Monitoring tools (JMX, JProfiler, ...)
• Dynamic vs static typing, pros and cons
• DI frameworks (the concept and at least one, e.g. Spring)
• App servers (like JBoss. The concept at least and pros/cons against lightweight solutions)
• Build tools (Ant, Maven, Sbt, Leiningen, depends on the language)
• Testing
• TDD, BDD, mocks, stubs, load tests, unit testing patterns, integrations tests, acceptance-level tests, non-functional tests, property-based tests, ...
• Databases
• Relational
• Working proficiency with SQL
• Transactions (local vs distributed), ACID, dirty reads, transaction isolation levels, etc
• optimistic/pessimistic locking
• NoSQL - when to use which, pros, cons, etc
• ORM tools
• Middleware
• HTTP protocol
• Network protocols (TCP, UDP, SSL, ...)
• Messaging - Enterprise Integration Patterns, JMS or some alternative, ActiveMQ or some alternative
• REST
• SOAP (not so relevant any more)
• Synchronous vs asynch communication. When to use which, benefits and pitfalls.
• Markup languages - xml, json, yaml, ...
• Small-scale architecture 
• packaging, layering principles, cohesion, coupling, static code quality metrics, MVC, UML, Hexagonal Architecture
• Patterns: pipeline, circuit-breaker, ...
• Big-scale  architecture
• SOA, microservices vs monoliths
• Scalability (vertical, horizontal, functional decomposition)
• CAP theorem
• Domain-Driven Design
• HTML, DOM, Javascript
• Continuous Integration/Delivery tools
• Deployment tools (Ansible, Capistrano, ...)
• Cloud - e.g. AWS
• Project management methodologies (Scrum, Kanban, ...)
• OSs
• Networks

I'm sure I missed some pretty obvious ones...