Decomposition

Scrum,
basic
functional Kanban
concepts
and
Scrum
of
requirements concurrency
Recomposition 
-essentials:
and threadRoles
clarifying
Beginner:
Analogy-based
and
management
requirements - OOD
estimations 
responsibilities,
Defining,
with technical
principles:
Story
Artifacts,
Instantiating, based
leader;
Encapsulation,
estimations 
Beginner:
Ceremonies
Starting and
Polymorphism,
Interaction - Knowledge of
Good:
Abstraction
Good:
the
Good:
between
-Qualities relationships
aware of the
Delphi
(One-to-One,
Scrum
Threads
software method
vs
(cohesion,
Like
Cone
One-to-Many)
Kanban:
Race toofdo,
conditions Self estimate,
Activity requirements
coupling)
Uncertainty 
applicability
Thread
elicitation - Y/NStates vs.
Understanding Grade
Beginner:
Source
normalization
SAFe - Inheritance
of
(Scaled
and
Beginner:
techniques;
Basic Transitions
BPMN
Aggregation
Estimation
Agile
Beginner:
Using wait(),
Simple
- non-functional
elements HTML
Errors 
-Good:
Framework)
Spring
notify(),
elements
requirements;
Beginner: basic MVC andand
notations
Good:
-Diseconomies
Beginner:
Distributed Transaction of
Engineering Management -architecture
notifyAll()
basic
on
Smells
Good:
-diagram
styling.
assumptions
class
GoFone and
Catalog
Design
foruse vs
Scale 
properties:
The
teams
Understanding
synchronization
Using
constrains
case
and has
javascript
diagrams
possible ACID,
the
re-
Process planning (SDLC) Start
Patterns
Challenges
isolation
basic
coordination Yes events: with
levels,
knowledge and Beginner
base
Request
for
-- product
factorings
Beginner:
timer, security
modifying flow
signal, in
Estimation Estimating
optimistic/pessi
in
collaboration
principles.
Spring
Good:
object Architectural
Java MVC Size, None
champion
JEE
Knowledge
SOAP:
message
Patterns: platform
definitionof
Efforts,
mistic
Test
-Knowledge Schedule
locking
Driven
Requirements attributes.
components
basic
Define
Intermediate
Layered software
knowledge Webofof&
refactoring
-Documenting
Development
Good:
advanced
quality
structure,
Manifest
techniques:
Service Optimizing attributes
file the
thread
events:
Architecture,
presenting
Database
The
Feature one timer,
is Design
Driven
Software requirements engineering Knowledge
Accessing
management
Good:
-behavior
Deployment
operations, Moving of
andlink None
error,
MVC,
estimates
by
capable
Development signal,
IoC to (ear,
pass
Design advanced
requests/respon
techniques:
Beginner:
Implementing
Strong:
interaction
packaging
Features
return
End types
events:
-REST
Denormalizing
Java
security SOLIDcertification
-se/request
Synchronizing
complex
diagrams
war,
Between
Define
Beginner:
receive
principles
principles
tracking
jar) layout
Objects
Service
message, a
OOD Strong:
concept
Strong:
practices
header
block
Ability
using
-changes
Bean Yes ofto and
code
create
different
in
validation:
Composing Beginner
Endpoint
Beginner:
Servlets
escalation,
Using and
Historical JSPs
DB design Strong:
Deployment
tools.
Binding
with
service
approaches.
requirements;
Strong:
concept,
Methods
Build
Java
fundamental Yesasimplerequest
Lock,
using
Foundationbuld-in Beginner
signal,
Strong:
Beginner:
Data
Strong: to link,
Refine
Modeling -Working
process
parameters
Semaphore,
JAX-RS
Implementing
Beginner:
constraints
service
Classes
knowledge
terminate
-specification business
BPMN
Simplifying
-Principles
Able to
with
panning
with
(JFC) toand
rules,
(Basics)
ofJAX-
write None
-Your
different
Planning
Strong:
method
CountDownLatc
XML
-their
Basic
Spring
Conditional
WS
Swing Being Estimates
handling
types
ablefor
building
overview and
to
Security Swimlanes
Beginner:
Object
simple
Political
Beginner:
Multidimentiona
garbage
testing Yes Oriented
queries None
Knowledge
parameters
h,
and
context;
terminology
select
blocks
Expressions
WSDL
Good:
concept CyclicBarrier,
connections
- Writing proper
essentials
Read/update of and
Design
Construction ---databases
Influences
Messaging
lEvaluating
collectors
threat
Work
Exchanger,
Good:
to
basic
approaches
Beginner:
Good:
Servlet
Usage
data serverwith
requirements
principles
from
Patterns and
of
simple
modeling on
team
usingfor
JSP
script
of via
DB
select
Estimates
Models
-development
Soft/Weak/Phan
performance
practices
session,
Phaser
JAX-RS
javascript.
of
documenting Object-
services- cookies
2.0 and the
Good:
Core
Advanced
Filters
task
JDBC
Enterprise
statements ESB
and
or Swing
service
Programming language Functional
JMS
Relational
tom
Security
Request
Threadsafe
features
Creating
process
oriented
architecture
Dependency Yes
Use cases
references Point Beginner
Combine
functionality
Contract
techniques.
The
task
JPA/Hibernate
Architecture Application
-validating
Tables, First and
vs
Refactoring Analysis
JMS
Database
Checking
Development
interception
Collection
-JAX-RS
complex
application
Injection
refactoring and AMQP
CSS
withand to None
it's
Code
Java2D
Events
Using
Applications
relationships, benefits
- Being First
service
able to
Concurrency concepts
Systems
application
lifecycle.
Use
Classes:
annotations
implement
requirements;
components
Spring/JEE
patterns
approaches: Controllers (not None
Framework
task
configure
-limited
keys, to Invoke
Architecture
constraints
-Good:
-resource
as
ConcurrentHash
complex
Bean
Red
pros
Strong: NoSQL
a REST
assisting to) layout.
validation
green
and in
cons
Desktop applications Using
Synchronous
mapping
Qualities
understanding
Good:
databases Yes JavaBeans Beginner
utilization
provider
Map,
@PathParam,
Implementing
development
Good:
essentials
refactoring
Implement
Limitations
Know and with
ofin
apply of
Web UI -Components
Services
between
Beginner:
Capable
-message,
VisualVM
Resolving
CopyOnWriteArr
@QueryParam, -Cloud
Joins
Yes
Distributed toJava
types views Beginner
complex
SRS
Service
WSDL
design
JSP
Creating
class
and documents,
Documents
andout
service user
Table
Web Component Applications understanding
Understanding
develop
databases
Figuring
with
ayList,
@CookieParam,
javascript
questionnaires
Classification
Strong: the None
request,
Generate
guidelines
JSP
tasks
models Standard
(Human code Tag
MapReduce
applications
memory
ViewResolver
ConcurrentLinke
@MatrixParam,
routine
for
SOA
Java
Re-factor
response
from customers, leaks
that
Architecture
Community
WSDL jobs
that
legacy
flows
Java Enterprise Essentials Library
Tasks)
Good:
Good:
basic
uses (JSTL)
knowledge
one of None
interface
dQueue
@Context,
implement
technical
Models
Process
applications
Beginner:
Routing
JAX-WS
-Compensation Able towith vision
MVC Framework -JMS/AMQP
of
Handling
Organize
@HeaderParam
objects.
documents,
State
overview is able
work and to write
Threadetc. None
Re-factor
Code
messages:
Annotations
Strong:
tasks
configure
the convention
complex ofFixed
SOAP Web Services HDFS
implementation
exceptions
Pooling
Beginner:
JAX-RS
Stateless
JSR
large
practices
router,
SOAP and
proposal
scalewith
Content
Content-
Messaging and None
Declarative
Business
JPA/Hibernate
queries,
programming rule
usage and of
REST Web Services Beginner:
Configuring
Executors
-Participation
Handlers
Strong:
Services
approval
applications
based
Architecture
programmatic
task
usage unit testing
router
in the andinfor
process None
triggers,
Hadoop
Strong:
Automated
Spring
ExecutorService
concept;
HATEOAS
Deep
Standardized MVC stored build
Messaging AOP
code
Beginner:
Validating
Enable
security
Execute
application
procedures, with
review
SOAP
sub-Spring None
Integration
concept
-Testing
Fork/Join
principle
understanding
Service
(types
-sessions
messages
attachments writing Spring
of
fundamental unit
Contract
AOP,of
process
-cursors
Good:
JMS/AMQP Working activity
with
SOA Building
MVC
Framework
test
Handling
browser's
aspect,
concepts
Message
support
Fault
transactions
-application
on of with
the
Application
base
pointcut,
policy:
Understanding
of None
BPMN Workflows Ability
other
chosen
exceptions
compatibility,
Strong:
advice)/AOP
Good:
group to
work work
tool; with None
transformation
Handling
throwing/catchi
with
sessions,
with HDFS andand
locks
frameworks
build
Strong:
memory
Service
with
Utilize
version
Connection
throwing tool:
EJB tools ant,
control;
customfor
ESB ng
JPA/Hibernate
and
programmaticall
(Spring,
maven, exception
transactions
EJB)
gradle None
Asynchronous
Monitoring
Good:
Strong:
management,
Versioning
Interceptors
-code
options
exceptions
-BPMN2 basic quality
Detachmentthe Lock,
DB yAchieving
Request
Phaser,
Scaling
performance
Approaches
Spring
check
operations;
Configuration
framework
and -Combining
Organizing Executor,
JAX-RS
inof
Merging and
(one
results
Advanced
Quality
Good:
Processing
Fork/Join
building
application
and
SOA: versions.JUnit
SQL Security/Securin
automatic
-Strong:
of): Deployment
Yes
jBPM5,
Working mode
with Beginner
multiple
knowledge
Attributes
CI
Spring
Testing
tests
JAX-RS
gHTML5
Performance, concept:
EJB and
2.0queries
inof
pros
and
-Securing
Good:
(one
Activity,
Java
-JMS/AMQP Checkstyle,
usage of the
SOAP
Oracle
Persistence
of ESB
DB access programming
and
internationalizati
Concurrent
Bean
knowledge.
Security,
applications
-PMD, - cons
Knowledge
validation
Service
FindBugs
configuring infor None
environment:
frameworks):
Business
Query
aggregations Process
Language
Big data Hadoop
Development
on
Applications
one
Securing
Management
Running
repository;
Authentication of mock JAX-RS
code of None
CXF/Metro/Axis2
-Management, Constructing
Managing
scheduled
Using
Catching
frameworks
REST
Establishing
review locales
patterns
withanbuilds
SOA
code
Verification -Criteria
and
etc
Strong:
Hadoop
(night
Spring
exception -
importing API
builds)
Integration
and
and
review
exporting
authorization
Strong:
Queries antipatterns
SOA tools
Code quality -intergation
infrastructure
Creating
thrown
testing
Governance Dynamic
Yes by jobsSQL
with:on Beginner
(Crucible,
sources;
Managing
Securing
--Strong: Working
Data Weband
with
Automated testing CI
JasperReports,
thread
-GitLab,
monitoring
Services tool (for
Yes etc) the
branching, ex: Beginner
Process
Inheritance
manipulation
Strong:
Jenkins, Hudson, in
Document
Advanced
Strong:
Use
tagging,
ESB SonarQube views
merging
Configuration Management versioning:
JPA/Hibernate
using
Advanced
TeamCity)
-(PDF/Excel)
Concurrency
for
changes Webcode
updatable
services
quality
from
-support
views Working
technologies
Able to multiple
createwith to
Product builds and continuous integration Concepts
tesing
inspection
specific with
branch; SOAP None
-versions
Locks
work
the
UI Query with
Ant/Maven of the
Managing versions -execution
same applying
Yesprocess, Beginner
Hadoop:
project
-Strong:Testingnew
patches, Pig,
Web
deploy
Strong:
performance
Hive
description file
applications
OOD
reverting
-version
Audit Metrics
entity
-optimization
(build.xml/pom.
Integration
Cyclomatic
changes;
Configure
-changes
xml)Systemwith
testing
with
catalog
Complexity
workflow
Eveners
(information engine
databases
Strong:
-to work
Multi-tenancyin
schema) usage
Strong:
-indeveloping
clustered
Hibernate mode and
Continuous
implementing
Communicating
integration: best
versions
With Other control
practices
infrastructure;
BPMN Processes
-and
creating
Services policy
Use
tagging,
versioning:
JPA/Hibernate
using SonarQube
merging
updatable
TeamCity)
-changes
for Web
codeservices
quality
from
-support
views
Able Working multiple
towith with
create
tesing
inspection
specific
versions
Locks SOAP
branch;
of the
-UIQuery
the Ant/Maven
-same applying
process,
-execution
project
Strong:Testingnew
patches,
deploy
Strong: Web
performance
description
applications file
OOD
reverting
-version Metrics
Audit
optimization entity
(build.xml/pom.
-Cyclomatic
Integration
changes;
Configure
changes
-testing
xml) with
Systemwith
catalog
Complexity
workflow
Eveners
(information engine
databases
Strong:
-to work in
Multi-tenancy
schema)
Strong: usage
-indeveloping
clustered
Hibernatemodeand
Continuous
implementing
Communicating
integration: best
versions
With Othercontrol
practices
infrastructure;
BPMN Processes
-and
creating
Servicespolicy
documents.
Using Send and
Receive Tasks
 Like to Self
Skill work with, estimate,
Y/N Grade
Programming languages
Java Yes Beginner
Groovy None
Scala None
HTML Yes Beginner
CSS Yes Beginner
JavaScript None
DB Access
JDBC Yes Beginner
JPA None
Hibernate None
iBatis None
Spring JDBC Template None
MVC frameworks
Spring MVC None
Grails None
JSF None
JSP None
Servlets None
JSTL None
Apache Struts None
GWT None
IoC
Spring IoC None
EJB None
Google Guice None
Web Services
JAX-WS (SOAP Services frameworks) None
JAX-RS (Restful Servies frameworks) None
Integration
JMS None
Workflow engine (jBPM/Activity/other) None
Drools None
ESB None
AOP
AspectJ None
Spring AOP None
Desktop
Java Swing Yes Beginner
SWT (Standard Widget Toolkit) None
WEB UI
Ext JS None
jQuery None
Angular JS None
Seach engines
Lucene None
Solr None
ElasticSearch None
BI & Reporting engines
JasperReport None
BIRT None
Crystal Report None
Pentaho None
ETL None
OLAP None
Continuous Integration
Jenkins/Hudson None
TeamCity None
CruiseControl None
QuickBuild None
XML Transformation
XSLT None
xPath None
Code Quality
Firebug Yes Beginner
Checkstyle None
PMD None
SonarQube None
Code Review Tools
Crucible None
Gerrit None
Review Board None
Automated testing
JUnit Yes Beginner
DBUnit None
Mocking library None
JMeter None
Selenium None
Big Data
Hadoop None
Apache Spark None
Kafka None
Thrift None
Application Servers & Servlet Containers
JBoss None
WebSphere None
WebLogic None
Glassfish None
Tomcat None
RDBMS
MS SQL Server Yes Beginner
MySQL Yes Beginner
Oracle None
PostgreSQL None
Source Controls
SVN Yes Beginner
Git Yes Beginner
TFS None
Mercurial None
Perforce None
Methodologies
Waterfall Yes Beginner
Agile Yes Beginner
SCRUM Yes Beginner
Extreme Programming None
TDD None
Kanban None
Platform Specific Development
Android Yes Beginner
iOS None
Build & Dependency Management Tools
Ant None
Ivy None
Maven None
Gradle None
Other skills and tools
Linux None
SaaS None
SOA None